HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/portable/portable.c

114,308 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 0d42a3c41aa6ccdbda76b016df825fad2759375e

Lines 1–1000 of 2,720

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <linux/loop.h>
#include <sched.h>
#include <unistd.h>
 
#include "sd-bus.h"
#include "sd-messages.h"
#include "sd-varlink.h"
 
#include "bus-common-errors.h"
#include "bus-error.h"
#include "bus-locator.h"
#include "chase.h"
#include "conf-files.h"
#include "copy.h"
#include "cryptsetup-util.h"
#include "data-fd-util.h"
#include "dirent-util.h"
#include "discover-image.h"
#include "dissect-image.h"
#include "env-file.h"
#include "env-util.h"
#include "errno-util.h"
#include "escape.h"
#include "extension-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "glyph-util.h"
#include "image-policy.h"
#include "install.h"
#include "iovec-util.h"
#include "libmount-util.h"
#include "log-context.h"
#include "log.h"
#include "loop-util.h"
#include "mkdir.h"
#include "namespace-util.h"
#include "nsresource.h"
#include "os-util.h"
#include "path-lookup.h"
#include "path-util.h"
#include "pidref.h"
#include "portable.h"
#include "portable-util.h"
#include "process-util.h"
#include "rm-rf.h"
#include "selinux-util.h"
#include "set.h"
#include "socket-util.h"
#include "sort-util.h"
#include "string-table.h"
#include "strv.h"
#include "tmpfile-util.h"
#include "uid-classification.h"
#include "unit-name.h"
#include "vpick.h"
 
/* Markers used in the first line of our 20-portable.conf unit file drop-in to determine, that a) the unit file was
 * dropped there by the portable service logic and b) for which image it was dropped there. */
#define PORTABLE_DROPIN_MARKER_BEGIN "# Drop-in created for image '"
#define PORTABLE_DROPIN_MARKER_END "', do not edit."
 
static bool prefix_match(const char *unit, const char *prefix) {
        const char *p;
 
        p = startswith(unit, prefix);
        if (!p)
                return false;
 
        /* Only respect prefixes followed by dash or dot or when there's a complete match */
        return IN_SET(*p, '-', '.', '@', 0);
}
 
static bool unit_match(const char *unit, char **matches) {
        const char *dot;
 
        dot = strrchr(unit, '.');
        if (!dot)
                return false;
 
        if (!STR_IN_SET(dot, ".service", ".socket", ".target", ".timer", ".path"))
                return false;
 
        /* Empty match expression means: everything */
        if (strv_isempty(matches))
                return true;
 
        /* Otherwise, at least one needs to match */
        STRV_FOREACH(i, matches)
                if (prefix_match(unit, *i))
                        return true;
 
        return false;
}
 
static PortableMetadata *portable_metadata_new(const char *name, const char *path, const char *selinux_label, int fd) {
        PortableMetadata *m;
 
        m = malloc0(offsetof(PortableMetadata, name) + strlen(name) + 1);
        if (!m)
                return NULL;
 
        /* In case of a layered attach, we want to remember which image the unit came from */
        if (path) {
                m->image_path = strdup(path);
                if (!m->image_path)
                        return mfree(m);
        }
 
        /* The metadata file might have SELinux labels, we need to carry them and reapply them */
        if (!isempty(selinux_label)) {
                m->selinux_label = strdup(selinux_label);
                if (!m->selinux_label) {
                        free(m->image_path);
                        return mfree(m);
                }
        }
 
        strcpy(m->name, name);
        m->fd = fd;
 
        return TAKE_PTR(m);
}
 
PortableMetadata *portable_metadata_unref(PortableMetadata *i) {
        if (!i)
                return NULL;
 
        safe_close(i->fd);
        free(i->source);
        free(i->image_path);
        free(i->selinux_label);
 
        return mfree(i);
}
 
static int compare_metadata(PortableMetadata *const *x, PortableMetadata *const *y) {
        assert(x);
        assert(y);
 
        return strcmp((*x)->name, (*y)->name);
}
 
int portable_metadata_hashmap_to_sorted_array(Hashmap *unit_files, PortableMetadata ***ret) {
 
        _cleanup_free_ PortableMetadata **sorted = NULL;
        PortableMetadata *item;
        size_t k = 0;
 
        assert(ret);
 
        sorted = new(PortableMetadata*, hashmap_size(unit_files));
        if (!sorted)
                return -ENOMEM;
 
        HASHMAP_FOREACH(item, unit_files)
                sorted[k++] = item;
 
        assert(k == hashmap_size(unit_files));
 
        typesafe_qsort(sorted, k, compare_metadata);
 
        *ret = TAKE_PTR(sorted);
        return 0;
}
 
static int send_one_fd_iov_with_data_fd(
                int socket_fd,
                const struct iovec *iov,
                size_t iovlen,
                int fd) {
 
        _cleanup_close_ int data_fd = -EBADF;
 
        assert(iov || iovlen == 0);
        assert(socket_fd >= 0);
        assert(fd >= 0);
 
        data_fd = copy_data_fd(fd);
        if (data_fd < 0)
                return data_fd;
 
        return send_one_fd_iov(socket_fd, data_fd, iov, iovlen, 0);
}
 
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(portable_metadata_hash_ops, char, string_hash_func, string_compare_func,
                                              PortableMetadata, portable_metadata_unref);
 
static int receive_portable_metadata(
                int socket_fd,
                const char *path,
                PortableMetadata **ret_os_release,
                Hashmap **ret_unit_files) {
 
        _cleanup_(portable_metadata_unrefp) PortableMetadata* os_release = NULL;
        _cleanup_(hashmap_freep) Hashmap *unit_files = NULL;
        int r;
 
        assert(socket_fd >= 0);
        assert(path);
        assert(ret_os_release);
        assert(ret_unit_files);
 
        unit_files = hashmap_new(&portable_metadata_hash_ops);
        if (!unit_files)
                return -ENOMEM;
 
        for (;;) {
                _cleanup_(portable_metadata_unrefp) PortableMetadata *add = NULL;
                _cleanup_close_ int fd = -EBADF;
                /* We use NAME_MAX space for the SELinux label here. The kernel currently enforces no limit,
                 * but according to suggestions from the SELinux people this will change and it will probably
                 * be identical to NAME_MAX. For now we use that, but this should be updated one day when the
                 * final limit is known. */
                char iov_buffer[PATH_MAX + NAME_MAX + 2 + 1]; /* One extra byte for the trailing NUL we add below. */
                struct iovec iov = IOVEC_MAKE(iov_buffer, sizeof(iov_buffer) - 1);
 
                ssize_t n = receive_one_fd_iov(socket_fd, &iov, 1, 0, &fd);
                if (n == -EIO)
                        break;
                if (n < 0)
                        return log_debug_errno(n, "Failed to receive item: %m");
                iov_buffer[n] = 0;
 
                /* We can't really distinguish a zero-length datagram without any fds from EOF (both are
                 * signalled the same way by recvmsg()). Hence, accept either as end notification. */
                if (isempty(iov_buffer) && fd < 0)
                        break;
 
                if (isempty(iov_buffer) || fd < 0)
                        return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                                "Invalid item sent from child.");
 
                /* Given recvmsg cannot be used with multiple io vectors if you don't know the size in
                 * advance, use a marker to separate the name and the optional SELinux context. */
                char *selinux_label = memchr(iov_buffer, 0, n);
                assert(selinux_label);
                selinux_label++;
 
                add = portable_metadata_new(iov_buffer, path, selinux_label, fd);
                if (!add)
                        return -ENOMEM;
                fd = -EBADF;
 
                /* Note that we do not initialize 'add->source' here, as the source path is not usable here
                 * as it refers to a path only valid in the short-living namespaced child process we forked
                 * here. */
 
                if (PORTABLE_METADATA_IS_UNIT(add)) {
                        r = hashmap_put(unit_files, add->name, add);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to add item to unit file list: %m");
 
                        add = NULL;
 
                } else if (PORTABLE_METADATA_IS_OS_RELEASE(add) || PORTABLE_METADATA_IS_EXTENSION_RELEASE(add)) {
 
                        assert(!os_release);
                        os_release = TAKE_PTR(add);
                } else
                        assert_not_reached();
        }
 
        *ret_os_release = TAKE_PTR(os_release);
        *ret_unit_files = TAKE_PTR(unit_files);
        return 0;
}
 
static int extract_now(
                RuntimeScope scope,
                int rfd,
                const char *image_path,
                char **matches,
                const char *image_name,
                bool path_is_extension,
                bool relax_extension_release_check,
                int socket_fd,
                PortableMetadata **ret_os_release,
                Hashmap **ret_unit_files) {
 
        _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
        _cleanup_(portable_metadata_unrefp) PortableMetadata *os_release = NULL;
        _cleanup_(lookup_paths_done) LookupPaths paths = {};
        _cleanup_close_ int os_release_fd = -EBADF;
        _cleanup_free_ char *os_release_path = NULL;
        const char *os_release_id;
        int r;
 
        /* Extracts the metadata from a directory tree 'dir_fd'. Extracts two kinds of information: the /etc/os-release
         * data, and all unit files matching the specified expression. Note that this function is called in two very
         * different but also similar contexts. When the tool gets invoked on a directory tree, we'll process it
         * directly, and in-process, and thus can return the requested data directly, via 'ret_os_release' and
         * 'ret_unit_files'. However, if the tool is invoked on a raw disk image — which needs to be mounted first — we
         * are invoked in a child process with private mounts and then need to send the collected data to our
         * parent. To handle both cases in one call this function also gets a 'socket_fd' parameter, which when >= 0 is
         * used to send the data to the parent. */
 
        assert(scope < _RUNTIME_SCOPE_MAX);
        assert(rfd >= 0);
 
        /* First, find os-release/extension-release and send it upstream (or just save it). */
        if (path_is_extension) {
                ImageClass class = IMAGE_SYSEXT;
 
                r = open_extension_release_at(rfd, IMAGE_SYSEXT, image_name, relax_extension_release_check, &os_release_path, &os_release_fd);
                if (r == -ENOENT) {
                        r = open_extension_release_at(rfd, IMAGE_CONFEXT, image_name, relax_extension_release_check, &os_release_path, &os_release_fd);
                        if (r >= 0)
                                class = IMAGE_CONFEXT;
                }
                if (r < 0)
                        return log_error_errno(r, "Failed to open extension release from '%s': %m", image_name);
 
                os_release_id = strjoina((class == IMAGE_SYSEXT) ? "/usr/lib" : "/etc", "/extension-release.d/extension-release.", image_name);
        } else {
                os_release_id = "/etc/os-release";
                r = open_os_release_at(rfd, &os_release_path, &os_release_fd);
        }
        if (r < 0)
                log_debug_errno(r,
                                "Couldn't acquire %s file, ignoring: %m",
                                path_is_extension ? "extension-release " : "os-release");
        else {
                if (socket_fd >= 0) {
                        struct iovec iov[] = {
                                IOVEC_MAKE_STRING(os_release_id),
                                IOVEC_MAKE((char *)"\0", sizeof(char)),
                        };
 
                        r = send_one_fd_iov_with_data_fd(socket_fd, iov, ELEMENTSOF(iov), os_release_fd);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to send os-release file: %m");
                }
 
                if (ret_os_release) {
                        os_release = portable_metadata_new(os_release_id, NULL, NULL, os_release_fd);
                        if (!os_release)
                                return -ENOMEM;
 
                        os_release_fd = -EBADF;
                        os_release->source = TAKE_PTR(os_release_path);
                }
        }
 
        /* Then, send unit file data to the parent (or/and add it to the hashmap). For that we use our usual
         * unit discovery logic. If we're running in a user session, we look for units in
         * /usr/lib/systemd/user/ and corresponding directories. */
        r = lookup_paths_init(
                        &paths,
                        scope == RUNTIME_SCOPE_USER ? RUNTIME_SCOPE_GLOBAL : RUNTIME_SCOPE_SYSTEM,
                        LOOKUP_PATHS_SPLIT_USR,
                        /* root_dir= */ NULL);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire lookup paths: %m");
 
        unit_files = hashmap_new(&portable_metadata_hash_ops);
        if (!unit_files)
                return -ENOMEM;
 
        STRV_FOREACH(i, paths.search_path) {
                _cleanup_free_ char *relative = NULL, *resolved = NULL;
                _cleanup_closedir_ DIR *d = NULL;
 
                r = chase_and_opendirat(rfd, rfd, *i, /* chase_flags= */ 0, &relative, &d);
                if (r < 0) {
                        log_debug_errno(r, "Failed to open unit path '%s', ignoring: %m", *i);
                        continue;
                }
 
                r = chaseat_prefix_root(relative, image_path, &resolved);
                if (r < 0)
                        return r;
 
                FOREACH_DIRENT(de, d, return log_debug_errno(errno, "Failed to read directory: %m")) {
                        _cleanup_(portable_metadata_unrefp) PortableMetadata *m = NULL;
                        _cleanup_freecon_ char *con = NULL;
                        _cleanup_close_ int fd = -EBADF;
                        struct stat st;
 
                        if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
                                continue;
 
                        if (!unit_match(de->d_name, matches))
                                continue;
 
                        /* Filter out duplicates */
                        if (hashmap_contains(unit_files, de->d_name))
                                continue;
 
                        if (!IN_SET(de->d_type, DT_LNK, DT_REG))
                                continue;
 
                        fd = chase_and_openat(
                                        rfd,
                                        dirfd(d),
                                        de->d_name,
                                        CHASE_MUST_BE_REGULAR,
                                        O_RDONLY|O_CLOEXEC,
                                        /* ret_path= */ NULL);
                        if (fd < 0) {
                                log_debug_errno(fd, "Failed to open unit file '%s', ignoring: %m", de->d_name);
                                continue;
                        }
 
                        /* Reject empty files, just in case */
                        if (fstat(fd, &st) < 0) {
                                log_debug_errno(errno, "Failed to stat unit file '%s', ignoring: %m", de->d_name);
                                continue;
                        }
 
                        if (st.st_size <= 0) {
                                log_debug("Unit file '%s' is empty, ignoring.", de->d_name);
                                continue;
                        }
 
#if HAVE_SELINUX
                        /* The units will be copied on the host's filesystem, so if they had a SELinux label
                         * we have to preserve it. Copy it out so that it can be applied later. */
                        if (mac_selinux_use()) {
                                r = sym_fgetfilecon_raw(fd, &con);
                                if (r < 0 && !ERRNO_IS_XATTR_ABSENT(errno))
                                        log_debug_errno(errno, "Failed to get SELinux file context from '%s', ignoring: %m", de->d_name);
                        }
#endif
 
                        if (socket_fd >= 0) {
                                struct iovec iov[] = {
                                        IOVEC_MAKE_STRING(de->d_name),
                                        IOVEC_MAKE((char *)"\0", sizeof(char)),
                                        IOVEC_MAKE_STRING(strempty(con)),
                                };
 
                                r = send_one_fd_iov_with_data_fd(socket_fd, iov, ELEMENTSOF(iov), fd);
                                if (r < 0)
                                        return log_debug_errno(r, "Failed to send unit metadata to parent: %m");
                        }
 
                        m = portable_metadata_new(de->d_name, image_path, con, fd);
                        if (!m)
                                return -ENOMEM;
                        fd = -EBADF;
 
                        m->source = path_join(resolved, de->d_name);
                        if (!m->source)
                                return -ENOMEM;
 
                        r = hashmap_put(unit_files, m->name, m);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to add unit to hashmap: %m");
                        m = NULL;
                }
        }
 
        if (ret_os_release)
                *ret_os_release = TAKE_PTR(os_release);
        if (ret_unit_files)
                *ret_unit_files = TAKE_PTR(unit_files);
 
        return 0;
}
 
static int portable_extract_by_path(
                RuntimeScope scope,
                const char *path,
                bool path_is_extension,
                bool relax_extension_release_check,
                char **matches,
                const ImagePolicy *image_policy,
                PortableMetadata **ret_os_release,
                Hashmap **ret_unit_files,
                ImagePolicy **ret_pinned_image_policy,
                sd_bus_error *error) {
 
        _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
        _cleanup_(portable_metadata_unrefp) PortableMetadata* os_release = NULL;
        _cleanup_(image_policy_freep) ImagePolicy *pinned_image_policy = NULL;
        int r;
 
        assert(path);
 
        _cleanup_close_ int rfd = open(path, O_PATH|O_CLOEXEC);
        if (rfd < 0)
                return log_debug_errno(errno, "Failed to open '%s': %m", path);
 
        struct stat st;
        if (fstat(rfd, &st) < 0)
                return log_debug_errno(errno, "Failed to stat '%s': %m", path);
 
        if (S_ISDIR(st.st_mode)) {
                _cleanup_free_ char *image_name = NULL;
                r = path_extract_filename(path, &image_name);
                if (r < 0)
                        return log_debug_errno(r, "Failed to extract image name from path '%s': %m", path);
 
                if (scope == RUNTIME_SCOPE_USER && uid_is_foreign(st.st_uid)) {
                        _cleanup_close_ int userns_fd = nsresource_allocate_userns(
                                        /* vl= */ NULL,
                                        /* name= */ NULL,
                                        NSRESOURCE_UIDS_64K);
                        if (userns_fd < 0)
                                return log_debug_errno(userns_fd, "Failed to allocate user namespace: %m");
 
                        _cleanup_close_ int mfd = -EBADF;
                        r = mountfsd_mount_directory_fd(
                                        /* vl= */ NULL,
                                        rfd,
                                        userns_fd,
                                        DISSECT_IMAGE_FOREIGN_UID,
                                        &mfd);
                        if (r < 0)
                                return r;
 
                        _cleanup_close_pair_ int seq[2] = EBADF_PAIR;
                        if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, seq) < 0)
                                return log_debug_errno(errno, "Failed to allocated SOCK_SEQPACKET socket: %m");
 
                        _cleanup_close_pair_ int errno_pipe_fd[2] = EBADF_PAIR;
                        if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
                                return log_debug_errno(errno, "Failed to create pipe: %m");
 
                        _cleanup_(pidref_done_sigkill_wait) PidRef child = PIDREF_NULL;
                        r = pidref_safe_fork("(sd-extract)",
                                             FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGKILL|FORK_REOPEN_LOG,
                                             &child);
                        if (r < 0)
                                return r;
                        if (r == 0) {
                                seq[0] = safe_close(seq[0]);
                                errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
 
                                if (setns(userns_fd, CLONE_NEWUSER) < 0) {
                                        r = log_debug_errno(errno, "Failed to join userns: %m");
                                        report_errno_and_exit(errno_pipe_fd[1], r);
                                }
 
                                r = extract_now(scope,
                                                mfd,
                                                path,
                                                matches,
                                                image_name,
                                                path_is_extension,
                                                relax_extension_release_check,
                                                seq[1],
                                                /* ret_os_release= */ NULL,
                                                /* ret_unit_files= */ NULL);
                                report_errno_and_exit(errno_pipe_fd[1], r);
                        }
 
                        seq[1] = safe_close(seq[1]);
                        errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
 
                        r = receive_portable_metadata(seq[0], path, &os_release, &unit_files);
                        if (r < 0)
                                return r;
 
                        r = pidref_wait_for_terminate_and_check("(sd-extract)", &child, 0);
                        if (r < 0)
                                return r;
                        if (r != EXIT_SUCCESS) {
                                if (read(errno_pipe_fd[0], &r, sizeof(r)) == sizeof(r))
                                        return log_debug_errno(r, "Failed to extract portable metadata from '%s': %m", path);
 
                                return log_debug_errno(SYNTHETIC_ERRNO(EPROTO), "Child failed.");
                        }
                } else {
                        r = extract_now(scope,
                                        rfd,
                                        path,
                                        matches,
                                        image_name,
                                        path_is_extension,
                                        relax_extension_release_check,
                                        /* socket_fd= */ -EBADF,
                                        &os_release,
                                        &unit_files);
                        if (r < 0)
                                return r;
                }
        } else {
                _cleanup_(dissected_image_unrefp) DissectedImage *m = NULL;
                _cleanup_(rmdir_and_freep) char *tmpdir = NULL;
                _cleanup_close_pair_ int seq[2] = EBADF_PAIR, errno_pipe_fd[2] = EBADF_PAIR;
                _cleanup_(pidref_done_sigkill_wait) PidRef child = PIDREF_NULL;
                _cleanup_close_ int userns_fd = -EBADF;
                DissectImageFlags flags =
                        DISSECT_IMAGE_READ_ONLY |
                        DISSECT_IMAGE_GENERIC_ROOT |
                        DISSECT_IMAGE_REQUIRE_ROOT |
                        DISSECT_IMAGE_DISCARD_ON_LOOP |
                        DISSECT_IMAGE_RELAX_VAR_CHECK |
                        DISSECT_IMAGE_USR_NO_ROOT |
                        DISSECT_IMAGE_ADD_PARTITION_DEVICES |
                        DISSECT_IMAGE_PIN_PARTITION_DEVICES |
                        DISSECT_IMAGE_VERITY_SHARE |
                        DISSECT_IMAGE_ALLOW_USERSPACE_VERITY;
 
                if (path_is_extension)
                        flags |= DISSECT_IMAGE_VALIDATE_OS_EXT | (relax_extension_release_check ? DISSECT_IMAGE_RELAX_EXTENSION_CHECK : 0);
                else
                        flags |= DISSECT_IMAGE_VALIDATE_OS;
 
                _cleanup_(verity_settings_done) VeritySettings verity = VERITY_SETTINGS_DEFAULT;
                r = verity_settings_load(
                                &verity,
                                path,
                                /* root_hash_path= */ NULL,
                                /* root_hash_sig_path= */ NULL);
                if (r < 0)
                        return log_debug_errno(r, "Failed to read verity artifacts for %s: %m", path);
 
                if (verity.data_path)
                        flags |= DISSECT_IMAGE_NO_PARTITION_TABLE;
 
                /* We now have a loopback block device, let's fork off a child in its own mount namespace, mount it
                 * there, and extract the metadata we need. The metadata is sent from the child back to us. */
 
                /* Load some libraries before we fork workers off that want to use them */
                (void) dlopen_cryptsetup(LOG_DEBUG);
                (void) dlopen_libmount(LOG_DEBUG);
 
                r = mkdtemp_malloc("/tmp/inspect-XXXXXX", &tmpdir);
                if (r < 0)
                        return log_debug_errno(r, "Failed to create temporary directory: %m");
 
                if (scope == RUNTIME_SCOPE_USER) {
                        userns_fd = nsresource_allocate_userns(
                                        /* vl= */ NULL,
                                        /* name= */ NULL,
                                        NSRESOURCE_UIDS_64K);
                        if (userns_fd < 0)
                                return log_debug_errno(userns_fd, "Failed to allocate user namespace: %m");
 
                        r = mountfsd_mount_image_fd(
                                        /* vl= */ NULL,
                                        rfd,
                                        userns_fd,
                                        /* options= */ NULL,
                                        image_policy,
                                        &verity,
                                        flags,
                                        &m);
                        if (r < 0)
                                return r;
                } else {
                        _cleanup_(loop_device_unrefp) LoopDevice *d = NULL;
 
                        r = loop_device_make_by_path_at(
                                        rfd,
                                        /* path= */ NULL,
                                        O_RDONLY,
                                        /* sector_size= */ UINT32_MAX,
                                        LO_FLAGS_PARTSCAN,
                                        LOCK_SH,
                                        &d);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to set up loopback device for %s: %m", path);
 
                        r = dissect_loop_device(
                                        d,
                                        &verity,
                                        /* mount_options= */ NULL,
                                        image_policy,
                                        /* image_filter= */ NULL,
                                        flags,
                                        &m);
                        if (r == -ENOPKG)
                                sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Couldn't identify a suitable partition table or file system in '%s'.", path);
                        else if (r == -EADDRNOTAVAIL)
                                sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No root partition for specified root hash found in '%s'.", path);
                        else if (r == -ENOTUNIQ)
                                sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Multiple suitable root partitions found in image '%s'.", path);
                        else if (r == -ENXIO)
                                sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No suitable root partition found in image '%s'.", path);
                        else if (r == -EPROTONOSUPPORT)
                                sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Device '%s' is loopback block device with partition scanning turned off, please turn it on.", path);
                        if (r < 0)
                                return r;
 
                        r = dissected_image_load_verity_sig_partition(m, d->fd, &verity);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to load verity sig partition for '%s': %m", path);
 
                        r = dissected_image_guess_verity_roothash(m, &verity);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to guess verity roothash for '%s': %m", path);
                }
 
                if (!m->image_name) {
                        r = dissected_image_name_from_path(path, &m->image_name);
                        if (r < 0)
                                return r;
                }
 
                if (ret_pinned_image_policy) {
                        pinned_image_policy = image_policy_new_from_dissected(m, &verity);
                        if (!pinned_image_policy)
                                return -ENOMEM;
                }
 
                if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, seq) < 0)
                        return log_debug_errno(errno, "Failed to allocated SOCK_SEQPACKET socket: %m");
 
                if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
                        return log_debug_errno(errno, "Failed to create pipe: %m");
 
                r = pidref_safe_fork(
                                "(sd-dissect)",
                                FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGKILL|(scope == RUNTIME_SCOPE_SYSTEM ? FORK_NEW_MOUNTNS|FORK_MOUNTNS_SLAVE : 0),
                                &child);
                if (r < 0)
                        return r;
                if (r == 0) {
                        seq[0] = safe_close(seq[0]);
                        errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
 
                        if (scope == RUNTIME_SCOPE_USER) {
                                r = detach_mount_namespace_userns(userns_fd);
                                if (r < 0) {
                                        log_debug_errno(r, "Failed to detach mount namespace: %m");
                                        report_errno_and_exit(errno_pipe_fd[1], r);
                                }
                        }
 
                        r = dissected_image_mount(
                                        m,
                                        tmpdir,
                                        /* uid_shift= */ UID_INVALID,
                                        /* uid_range= */ UID_INVALID,
                                        userns_fd,
                                        flags);
                        if (r < 0) {
                                log_debug_errno(r, "Failed to mount dissected image '%s': %m", path);
                                report_errno_and_exit(errno_pipe_fd[1], r);
                        }
 
                        _cleanup_close_ int mfd = open(tmpdir, O_DIRECTORY|O_CLOEXEC);
                        if (mfd < 0) {
                                r = log_debug_errno(errno, "Failed to open '%s': %m", tmpdir);
                                report_errno_and_exit(errno_pipe_fd[1], r);
                        }
 
                        r = extract_now(scope,
                                        mfd,
                                        path,
                                        matches,
                                        m->image_name,
                                        path_is_extension,
                                        relax_extension_release_check,
                                        seq[1],
                                        /* ret_os_release= */ NULL,
                                        /* ret_unit_files= */ NULL);
                        report_errno_and_exit(errno_pipe_fd[1], r);
                }
 
                seq[1] = safe_close(seq[1]);
                errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
 
                r = receive_portable_metadata(seq[0], path, &os_release, &unit_files);
                if (r < 0)
                        return r;
 
                r = pidref_wait_for_terminate_and_check("(sd-dissect)", &child, 0);
                if (r < 0)
                        return r;
 
                pidref_done(&child);
 
                if (r != EXIT_SUCCESS) {
                        if (read(errno_pipe_fd[0], &r, sizeof(r)) == sizeof(r))
                                return log_debug_errno(r, "Failed to extract portable metadata from '%s': %m", path);
 
                        return log_debug_errno(SYNTHETIC_ERRNO(EPROTO), "Child failed.");
                }
        }
 
        if (!os_release)
                return sd_bus_error_setf(error,
                                         SD_BUS_ERROR_INVALID_ARGS,
                                         "Image '%s' lacks %s data, refusing.",
                                         path,
                                         path_is_extension ? "extension-release" : "os-release");
 
        if (ret_unit_files)
                *ret_unit_files = TAKE_PTR(unit_files);
 
        if (ret_os_release)
                *ret_os_release = TAKE_PTR(os_release);
 
        if (ret_pinned_image_policy)
                *ret_pinned_image_policy = TAKE_PTR(pinned_image_policy);
 
        return 0;
}
 
static int extract_image_and_extensions(
                RuntimeScope scope,
                const char *name_or_path,
                char **matches,
                char **extension_image_paths,
                bool validate_extension,
                bool relax_extension_release_check,
                const ImagePolicy *image_policy,
                Image **ret_image,
                OrderedHashmap **ret_extension_images,
                OrderedHashmap **ret_extension_releases,
                PortableMetadata **ret_os_release,
                Hashmap **ret_unit_files,
                char ***ret_valid_prefixes,
                ImagePolicy **ret_pinned_root_image_policy,
                ImagePolicy **ret_pinned_ext_image_policy,
                sd_bus_error *error) {
 
        _cleanup_free_ char *id = NULL, *id_like = NULL, *version_id = NULL, *sysext_level = NULL, *confext_level = NULL;
        _cleanup_(image_policy_freep) ImagePolicy *pinned_root_image_policy = NULL, *pinned_ext_image_policy = NULL;
        _cleanup_(portable_metadata_unrefp) PortableMetadata *os_release = NULL;
        _cleanup_ordered_hashmap_free_ OrderedHashmap *extension_images = NULL, *extension_releases = NULL;
        _cleanup_(pick_result_done) PickResult result = PICK_RESULT_NULL;
        _cleanup_hashmap_free_ Hashmap *unit_files = NULL;
        _cleanup_strv_free_ char **valid_prefixes = NULL;
        _cleanup_(image_unrefp) Image *image = NULL;
        Image *ext;
        int r;
 
        assert(name_or_path);
 
        /* If we get a path, then check if it can be resolved with vpick. We need this as we might just
         * get a simple image name, which would make vpick error out. */
        if (path_is_absolute(name_or_path)) {
                r = path_pick(/* root_path= */ NULL,
                              /* root_fd= */ AT_FDCWD,
                              /* dir_fd= */ AT_FDCWD,
                              name_or_path,
                              pick_filter_image_any,
                              ELEMENTSOF(pick_filter_image_any),
                              PICK_ARCHITECTURE|PICK_TRIES|PICK_RESOLVE,
                              &result);
                if (r < 0)
                        return r;
                if (!result.path)
                        return log_debug_errno(
                                        SYNTHETIC_ERRNO(ENOENT),
                                        "No matching entry in .v/ directory %s found.",
                                        name_or_path);
 
                name_or_path = result.path;
        }
 
        r = image_find_harder(scope, IMAGE_PORTABLE, name_or_path, /* root= */ NULL, &image);
        if (r < 0)
                return r;
 
        if (!strv_isempty(extension_image_paths)) {
                extension_images = ordered_hashmap_new(&image_hash_ops);
                if (!extension_images)
                        return -ENOMEM;
 
                if (ret_extension_releases) {
                        extension_releases = ordered_hashmap_new(&portable_metadata_hash_ops);
                        if (!extension_releases)
                                return -ENOMEM;
                }
 
                STRV_FOREACH(p, extension_image_paths) {
                        _cleanup_(pick_result_done) PickResult ext_result = PICK_RESULT_NULL;
                        _cleanup_(image_unrefp) Image *new = NULL;
                        const char *path = *p;
 
                        if (path_is_absolute(*p)) {
                                r = path_pick(/* root_path= */ NULL,
                                              /* root_fd= */ AT_FDCWD,
                                              /* dir_fd= */ AT_FDCWD,
                                              *p,
                                              pick_filter_image_any,
                                              ELEMENTSOF(pick_filter_image_any),
                                              PICK_ARCHITECTURE|PICK_TRIES|PICK_RESOLVE,
                                              &ext_result);
                                if (r < 0)
                                        return r;
                                if (!ext_result.path)
                                        return log_debug_errno(
                                                        SYNTHETIC_ERRNO(ENOENT),
                                                        "No matching entry in .v/ directory %s found.",
                                                        *p);
 
                                path = ext_result.path;
                        }
 
                        r = image_find_harder(scope, IMAGE_PORTABLE, path, NULL, &new);
                        if (r < 0)
                                return r;
 
                        r = ordered_hashmap_put(extension_images, new->name, new);
                        if (r < 0)
                                return r;
                        TAKE_PTR(new);
                }
        }
 
        r = portable_extract_by_path(
                        scope,
                        image->path,
                        /* path_is_extension= */ false,
                        /* relax_extension_release_check= */ false,
                        matches,
                        image_policy,
                        &os_release,
                        &unit_files,
                        &pinned_root_image_policy,
                        error);
        if (r < 0)
                return r;
 
        /* If we are layering extension images on top of a runtime image, check that the os-release and
         * extension-release metadata match, otherwise reject it immediately as invalid, or it will fail when
         * the units are started. Also, collect valid portable prefixes if caller requested that. */
        if (validate_extension || ret_valid_prefixes) {
                _cleanup_free_ char *prefixes = NULL, *portable_scope_str = NULL;
 
                r = parse_env_file_fd(
                                os_release->fd, os_release->name,
                                "ID", &id,
                                "ID_LIKE", &id_like,
                                "VERSION_ID", &version_id,
                                "SYSEXT_LEVEL", &sysext_level,
                                "CONFEXT_LEVEL", &confext_level,
                                "PORTABLE_PREFIXES", &prefixes,
                                "PORTABLE_SCOPE", &portable_scope_str);
                if (r < 0)
                        return r;
                if (isempty(id))
                        return sd_bus_error_set_errnof(error, ESTALE, "Image %s os-release metadata lacks the ID field", name_or_path);
 
                if (prefixes) {
                        valid_prefixes = strv_split(prefixes, WHITESPACE);
                        if (!valid_prefixes)
                                return -ENOMEM;
                }
 
                RuntimeScope portable_scope = RUNTIME_SCOPE_SYSTEM;
                if (portable_scope_str) {
                        if (streq(portable_scope_str, "any"))
                                portable_scope = _RUNTIME_SCOPE_INVALID;
                        else {
                                portable_scope = runtime_scope_from_string(portable_scope_str);
                                if (portable_scope < 0)
                                        return sd_bus_error_setf(
                                                        error,
                                                        SD_BUS_ERROR_INVALID_ARGS,
                                                        "Invalid PORTABLE_SCOPE value '%s' in image %s.",
                                                        portable_scope_str,
                                                        name_or_path);
                        }
                }
 
                if (portable_scope != _RUNTIME_SCOPE_INVALID && portable_scope != scope)
                        return sd_bus_error_setf(
                                        error,
                                        SD_BUS_ERROR_INVALID_ARGS,
                                        "Image %s portable scope '%s' incompatible with portabled runtime scope '%s'.",
                                        name_or_path,
                                        runtime_scope_to_string(portable_scope),
                                        runtime_scope_to_string(scope));
        }
 
        ORDERED_HASHMAP_FOREACH(ext, extension_images) {
                _cleanup_(portable_metadata_unrefp) PortableMetadata *extension_release_meta = NULL;
                _cleanup_(image_policy_freep) ImagePolicy *policy = NULL;
                _cleanup_hashmap_free_ Hashmap *extra_unit_files = NULL;
                _cleanup_strv_free_ char **extension_release = NULL;
                const char *e;
 
                r = portable_extract_by_path(
                                scope,
                                ext->path,
                                /* path_is_extension= */ true,
                                relax_extension_release_check,
                                matches,
                                image_policy,
                                &extension_release_meta,
                                &extra_unit_files,
                                &policy,
                                error);
                if (r < 0)
                        return r;
 
                r = hashmap_move(unit_files, extra_unit_files);
                if (r < 0)
                        return r;
 
                if (!pinned_ext_image_policy && policy)
                        pinned_ext_image_policy = TAKE_PTR(policy);
                else if (policy) {
                        _cleanup_(image_policy_freep) ImagePolicy *intersected_policy = NULL;
 
                        /* There is a single policy for all extension images, so we need a union */
                        r = image_policy_union(pinned_ext_image_policy, policy, &intersected_policy);
                        if (r < 0)