HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/kernel-install/kernel-install.c

61,472 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 0fb3a4034e01998c22563f23f39938fe95975c25

Lines 1–1000 of 1,782

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <stdlib.h>
#include <sys/utsname.h>
#include <unistd.h>
 
#include "sd-json.h"
 
#include "ansi-color.h"
#include "argv-util.h"
#include "boot-entry.h"
#include "bootspec.h"
#include "build.h"
#include "chase.h"
#include "conf-files.h"
#include "dissect-image.h"
#include "dlopen-note.h"
#include "env-file.h"
#include "env-util.h"
#include "exec-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "find-esp.h"
#include "format-table.h"
#include "fs-util.h"
#include "id128-util.h"
#include "image-policy.h"
#include "kernel-config.h"
#include "kernel-image.h"
#include "loop-util.h"
#include "main-func.h"
#include "mount-util.h"
#include "parse-argument.h"
#include "path-util.h"
#include "recurse-dir.h"
#include "rm-rf.h"
#include "specifier.h"
#include "stat-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "tmpfile-util.h"
#include "verbs.h"
 
static bool arg_verbose = false;
static char *arg_esp_path = NULL;
static char *arg_xbootldr_path = NULL;
static int arg_make_entry_directory = -1; /* tristate */
static PagerFlags arg_pager_flags = 0;
static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static char *arg_root = NULL;
static char *arg_image = NULL;
static ImagePolicy *arg_image_policy = NULL;
static bool arg_legend = true;
static BootEntryTokenType arg_entry_token_type = BOOT_ENTRY_TOKEN_AUTO;
static char *arg_entry_token = NULL;
static BootEntryType arg_boot_entry_type = _BOOT_ENTRY_TYPE_INVALID;
 
STATIC_DESTRUCTOR_REGISTER(arg_esp_path, freep);
STATIC_DESTRUCTOR_REGISTER(arg_xbootldr_path, freep);
STATIC_DESTRUCTOR_REGISTER(arg_root, freep);
STATIC_DESTRUCTOR_REGISTER(arg_image, freep);
STATIC_DESTRUCTOR_REGISTER(arg_image_policy, image_policy_freep);
STATIC_DESTRUCTOR_REGISTER(arg_entry_token, freep);
 
COMMAND(
        "kernel-install\0",
        "Add and remove kernel and initrd images to and from the boot partition.",
        .footer = "This program may also be invoked as 'installkernel':\n"
                  "  installkernel [OPTION…] VERSION VMLINUZ [MAP] [INSTALLATION-DIR]\n"
                  "(The optional arguments are passed by kernel build system, but ignored.)",
        .man_pages = "kernel-install(8)\0",
        .pager_flags = &arg_pager_flags,
        .flags = COMMAND_HELP_SEPARATE,  /* the verb table is very wide */
);
 
typedef enum Action {
        ACTION_ADD,
        ACTION_REMOVE,
        ACTION_INSPECT,
        _ACTION_MAX,
        _ACTION_INVALID = -EINVAL,
} Action;
 
typedef enum Layout {
        LAYOUT_AUTO,
        LAYOUT_UKI,
        LAYOUT_BLS,
        LAYOUT_OTHER,
        _LAYOUT_MAX,
        _LAYOUT_INVALID = -EINVAL,
} Layout;
 
static const char * const layout_table[_LAYOUT_MAX] = {
        [LAYOUT_AUTO]  = "auto",
        [LAYOUT_UKI]   = "uki",
        [LAYOUT_BLS]   = "bls",
        [LAYOUT_OTHER] = "other",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP(layout, Layout);
 
typedef struct Context {
        int rfd;
        Action action;
        sd_id128_t machine_id;
        bool machine_id_is_random;
        BootEntryType entry_type;
        KernelImageType kernel_image_type;
        Layout layout;
        char *layout_other;
        char *conf_root;
        char *boot_root;
        BootEntryTokenType entry_token_type;
        char *entry_token;
        char *entry_dir;
        char *version;
        char *kernel;
        char **initrds;
        char *initrd_generator;
        char *uki_generator;
        char *entry_name_format;
        char *entry_name;
        char *staging_area;
        char **plugins;
        char **argv;
        char **envp;
} Context;
 
/* Longest filename suffix plugins append to the entry name (from 90-uki-copy.install) */
#define ENTRY_NAME_SUFFIX_MAX STRLEN(".efi.extra.d")
 
#define DEFAULT_ENTRY_NAME_FORMAT "%e-%v"
 
#define CONTEXT_NULL                                                    \
        (Context) {                                                     \
                .rfd = XAT_FDROOT,                                      \
                .action = _ACTION_INVALID,                              \
                .kernel_image_type = _KERNEL_IMAGE_TYPE_INVALID,        \
                .layout = _LAYOUT_INVALID,                              \
                .entry_type = _BOOT_ENTRY_TYPE_INVALID,                 \
                .entry_token_type = _BOOT_ENTRY_TOKEN_TYPE_INVALID,     \
        }
 
static void context_done(Context *c) {
        assert(c);
 
        free(c->layout_other);
        free(c->conf_root);
        free(c->boot_root);
        free(c->entry_token);
        free(c->entry_dir);
        free(c->version);
        free(c->kernel);
        strv_free(c->initrds);
        free(c->initrd_generator);
        free(c->uki_generator);
        free(c->entry_name_format);
        free(c->entry_name);
        if (c->action == ACTION_INSPECT)
                free(c->staging_area);
        else
                rm_rf_physical_and_free(c->staging_area);
        strv_free(c->plugins);
        strv_free(c->argv);
        strv_free(c->envp);
 
        safe_close(c->rfd);
}
 
static int context_copy(const Context *source, Context *ret) {
        int r;
 
        assert(source);
        assert(ret);
        assert(wildcard_fd_is_valid(source->rfd));
 
        _cleanup_(context_done) Context copy = (Context) {
                .rfd = source->rfd,
                .action = source->action,
                .machine_id = source->machine_id,
                .machine_id_is_random = source->machine_id_is_random,
                .kernel_image_type = source->kernel_image_type,
                .layout = source->layout,
                .entry_token_type = source->entry_token_type,
        };
 
        if (source->rfd >= 0) {
                copy.rfd = fd_reopen(source->rfd, O_CLOEXEC|O_DIRECTORY|O_PATH);
                if (copy.rfd < 0)
                        return copy.rfd;
        }
 
        r = strdup_to(&copy.layout_other, source->layout_other);
        if (r < 0)
                return r;
        r = strdup_to(&copy.conf_root, source->conf_root);
        if (r < 0)
                return r;
        r = strdup_to(&copy.boot_root, source->boot_root);
        if (r < 0)
                return r;
        r = strdup_to(&copy.entry_token, source->entry_token);
        if (r < 0)
                return r;
        r = strdup_to(&copy.entry_dir, source->entry_dir);
        if (r < 0)
                return r;
        r = strdup_to(&copy.version, source->version);
        if (r < 0)
                return r;
        r = strdup_to(&copy.kernel, source->kernel);
        if (r < 0)
                return r;
        r = strv_copy_unless_empty(source->initrds, &copy.initrds);
        if (r < 0)
                return r;
        r = strdup_to(&copy.initrd_generator, source->initrd_generator);
        if (r < 0)
                return r;
        r = strdup_to(&copy.uki_generator, source->uki_generator);
        if (r < 0)
                return r;
        r = strdup_to(&copy.entry_name_format, source->entry_name_format);
        if (r < 0)
                return r;
        r = strdup_to(&copy.staging_area, source->staging_area);
        if (r < 0)
                return r;
        r = strv_copy_unless_empty(source->plugins, &copy.plugins);
        if (r < 0)
                return r;
        r = strv_copy_unless_empty(source->argv, &copy.argv);
        if (r < 0)
                return r;
        r = strv_copy_unless_empty(source->envp, &copy.envp);
        if (r < 0)
                return r;
 
        *ret = copy;
        copy = CONTEXT_NULL;
 
        return 0;
}
 
static int context_open_root(Context *c) {
        int r;
 
        assert(c);
        assert(c->rfd < 0);
 
        if (isempty(arg_root))
                return 0;
 
        r = path_is_root(arg_root);
        if (r < 0)
                return log_error_errno(r, "Failed to determine if '%s' is the root directory: %m", arg_root);
        if (r > 0)
                return 0;
 
        c->rfd = open(arg_root, O_CLOEXEC | O_DIRECTORY | O_PATH);
        if (c->rfd < 0)
                return log_error_errno(errno, "Failed to open root directory '%s': %m", arg_root);
 
        return 0;
}
 
static const char* context_get_layout(const Context *c) {
        assert(c);
        assert(c->layout >= 0);
 
        return c->layout_other ?: layout_to_string(c->layout);
}
 
static int context_set_layout(Context *c, const char *s, const char *source) {
        Layout t;
 
        assert(c);
        assert(source);
 
        if (c->layout >= 0 || !s)
                return 0;
 
        assert(!c->layout_other);
 
        t = layout_from_string(s);
        if (t >= 0)
                c->layout = t;
        else if (isempty(s))
                c->layout = LAYOUT_AUTO;
        else {
                c->layout_other = strdup(s);
                if (!c->layout_other)
                        return log_oom();
 
                c->layout = LAYOUT_OTHER;
        }
 
        log_debug("layout=%s set via %s", context_get_layout(c), source);
        return 1;
}
 
static int context_set_machine_id(Context *c, const char *s, const char *source) {
        int r;
 
        assert(c);
        assert(source);
 
        if (!sd_id128_is_null(c->machine_id) || !s)
                return 0;
 
        r = sd_id128_from_string(s, &c->machine_id);
        if (r < 0)
                return log_warning_errno(r, "Failed to parse machine ID specified via %s, ignoring.", source);
 
        if (sd_id128_is_null(c->machine_id))
                return 0;
 
        log_debug("MACHINE_ID=%s set via %s.", SD_ID128_TO_STRING(c->machine_id), source);
        return 1;
}
 
static int context_set_string(const char *s, const char *source, const char *name, char **dest) {
        char *p;
 
        assert(source);
        assert(name);
        assert(dest);
 
        if (*dest || !s)
                return 0;
 
        p = strdup(s);
        if (!p)
                return log_oom();
 
        log_debug("%s (%s) set via %s.", name, p, source);
 
        *dest = p;
        return 1;
}
 
static int context_set_initrd_generator(Context *c, const char *s, const char *source) {
        assert(c);
        return context_set_string(s, source, "INITRD_GENERATOR", &c->initrd_generator);
}
 
static int context_set_uki_generator(Context *c, const char *s, const char *source) {
        assert(c);
        return context_set_string(s, source, "UKI_GENERATOR", &c->uki_generator);
}
 
static int context_set_entry_name_format(Context *c, const char *s, const char *source) {
        assert(c);
        return context_set_string(s, source, "ENTRY_NAME_FORMAT", &c->entry_name_format);
}
 
static int context_resolve_entry_name(Context *c) {
        assert(c);
 
        if (c->entry_name)
                return 0;
 
        const Specifier table[] = {
                { 'e', specifier_string,           c->entry_token },
                { 'm', specifier_id128,            &c->machine_id },
                { 'v', specifier_string,           c->version ?: "KERNEL_VERSION" },
                { 'a', specifier_architecture,     NULL },
                { 'A', specifier_os_image_version, NULL },
                { 'B', specifier_os_build_id,      NULL },
                { 'H', specifier_hostname,         NULL },
                { 'l', specifier_short_hostname,   NULL },
                { 'q', specifier_pretty_hostname,  NULL },
                { 'M', specifier_os_image_id,      NULL },
                { 'o', specifier_os_id,            NULL },
                { 'w', specifier_os_version_id,    NULL },
                { 'W', specifier_os_variant_id,    NULL },
                {}
        };
 
        _cleanup_free_ char *resolved = NULL;
        int r;
 
        r = specifier_printf(
                        c->entry_name_format ?: DEFAULT_ENTRY_NAME_FORMAT,
                        NAME_MAX - ENTRY_NAME_SUFFIX_MAX,
                        table,
                        arg_root,
                        /* userdata= */ c,
                        &resolved);
        if (r < 0)
                return log_error_errno(r, "Failed to expand entry name format '%s': %m",
                                       c->entry_name_format ?: DEFAULT_ENTRY_NAME_FORMAT);
 
        if (isempty(resolved))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Entry name format '%s' resolved to empty string.",
                                       c->entry_name_format ?: DEFAULT_ENTRY_NAME_FORMAT);
 
        if (!filename_is_valid(resolved))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Entry name format '%s' resolved to invalid filename: %s",
                                       c->entry_name_format ?: DEFAULT_ENTRY_NAME_FORMAT, resolved);
 
        c->entry_name = TAKE_PTR(resolved);
        log_debug("Using entry name: %s", c->entry_name);
        return 0;
}
 
static int context_set_version(Context *c, const char *s) {
        assert(c);
 
        if (s && !filename_is_valid(s))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid version specified: %s", s);
 
        return context_set_string(s, "command line", "kernel version", &c->version);
}
 
static int context_set_path(Context *c, const char *s, const char *source, const char *name, char **dest) {
        char *p;
        int r;
 
        assert(c);
        assert(source);
        assert(name);
        assert(dest);
 
        if (*dest || !s)
                return 0;
 
        if (c->rfd >= 0) {
                r = chaseat(c->rfd, c->rfd, s, /* flags= */ 0, &p, /* ret_fd= */ NULL);
                if (r < 0)
                        return log_warning_errno(r, "Failed to chase path %s for %s specified via %s, ignoring: %m",
                                                 s, name, source);
        } else {
                r = path_make_absolute_cwd(s, &p);
                if (r < 0)
                        return log_warning_errno(r, "Failed to make path '%s' for %s specified via %s absolute, ignoring: %m",
                                                 s, name, source);
        }
 
        log_debug("%s (%s) set via %s.", name, p, source);
 
        *dest = p;
        return 1;
}
 
static int context_set_boot_root(Context *c, const char *s, const char *source) {
        assert(c);
        return context_set_path(c, s, source, "BOOT_ROOT", &c->boot_root);
}
 
static int context_set_conf_root(Context *c, const char *s, const char *source) {
        assert(c);
        return context_set_path(c, s, source, "CONF_ROOT", &c->conf_root);
}
 
static int context_set_kernel(Context *c, const char *s) {
        assert(c);
        return context_set_path(c, s, "command line", "kernel image file", &c->kernel);
}
 
static int context_set_path_strv(Context *c, char* const* strv, const char *source, const char *name, char ***dest) {
        _cleanup_strv_free_ char **w = NULL;
        int r;
 
        assert(c);
        assert(source);
        assert(name);
        assert(dest);
 
        if (*dest)
                return 0;
 
        STRV_FOREACH(s, strv) {
                char *p;
 
                if (c->rfd >= 0) {
                        r = chaseat(c->rfd, c->rfd, *s, /* flags= */ 0, &p, /* ret_fd= */ NULL);
                        if (r < 0)
                                return log_warning_errno(r, "Failed to chase path %s for %s specified via %s: %m",
                                                         *s, name, source);
                } else {
                        r = path_make_absolute_cwd(*s, &p);
                        if (r < 0)
                                return log_warning_errno(r, "Failed to make path '%s' for %s specified via %s absolute, ignoring: %m",
                                                         *s, name, source);
                }
                r = strv_consume(&w, p);
                if (r < 0)
                        return log_oom();
        }
 
        if (strv_isempty(w))
                return 0;
 
        log_debug("%s set via %s", name, source);
 
        *dest = TAKE_PTR(w);
        return 1;
}
 
static int context_set_plugins(Context *c, const char *s, const char *source) {
        _cleanup_strv_free_ char **v = NULL;
        int r;
 
        assert(c);
 
        if (c->plugins || !s)
                return 0;
 
        r = strv_split_full(&v, s, NULL, EXTRACT_UNQUOTE);
        if (r < 0)
                return log_error_errno(r, "Failed to parse plugin paths from %s: %m", source);
 
        return context_set_path_strv(c, v, source, "plugins", &c->plugins);
}
 
static int context_set_initrds(Context *c, char* const* strv) {
        assert(c);
        return context_set_path_strv(c, strv, "command line", "initrds", &c->initrds);
}
 
static int context_load_environment(Context *c) {
        assert(c);
 
        (void) context_set_machine_id(c, getenv("MACHINE_ID"), "environment");
        (void) context_set_boot_root(c, getenv("BOOT_ROOT"), "environment");
        (void) context_set_conf_root(c, getenv("KERNEL_INSTALL_CONF_ROOT"), "environment");
        (void) context_set_plugins(c, getenv("KERNEL_INSTALL_PLUGINS"), "environment");
        (void) context_set_entry_name_format(c, getenv("KERNEL_INSTALL_ENTRY_NAME_FORMAT"), "environment");
        return 0;
}
 
static int context_load_install_conf(Context *c) {
        _cleanup_free_ char *machine_id = NULL, *boot_root = NULL, *layout = NULL,
                            *initrd_generator = NULL, *uki_generator = NULL,
                            *entry_name_format = NULL;
        int r;
 
        assert(c);
 
        r = load_kernel_install_conf_at(
                        c->conf_root ? NULL : arg_root,
                        c->conf_root ? XAT_FDROOT : c->rfd,
                        c->conf_root,
                        &machine_id,
                        &boot_root,
                        &layout,
                        &initrd_generator,
                        &uki_generator,
                        &entry_name_format);
        if (r <= 0)
                return r;
 
        (void) context_set_machine_id(c, machine_id, "config");
        (void) context_set_boot_root(c, boot_root, "config");
        (void) context_set_layout(c, layout, "config");
        (void) context_set_initrd_generator(c, initrd_generator, "config");
        (void) context_set_uki_generator(c, uki_generator, "config");
        (void) context_set_entry_name_format(c, entry_name_format, "config");
 
        log_debug("Loaded config.");
        return 0;
}
 
static int context_load_machine_info(Context *c) {
        _cleanup_fclose_ FILE *f = NULL;
        _cleanup_free_ char *machine_id = NULL, *layout = NULL;
        static const char *path = "/etc/machine-info";
        int r;
 
        assert(c);
 
        /* If the user configured an explicit machine ID in /etc/machine-info to use for our purpose, we'll
         * use that instead (for compatibility). */
 
        if (!sd_id128_is_null(c->machine_id) && c->layout >= 0)
                return 0;
 
        /* For testing. To make not read host's /etc/machine-info. */
        r = getenv_bool("KERNEL_INSTALL_READ_MACHINE_INFO");
        if (r < 0 && r != -ENXIO)
                log_warning_errno(r, "Failed to read $KERNEL_INSTALL_READ_MACHINE_INFO, assuming yes: %m");
        if (r == 0) {
                log_debug("Skipping reading of /etc/machine-info.");
                return 0;
        }
 
        r = chase_and_fopenat_unlocked(c->rfd, c->rfd, path, /* chase_flags= */ 0, "re", NULL, &f);
        if (r == -ENOENT)
                return 0;
        if (r < 0)
                return log_error_errno(r, "Failed to chase %s: %m", path);
 
        log_debug("Loading %s…", path);
 
        r = parse_env_file(f, path,
                           "KERNEL_INSTALL_MACHINE_ID", &machine_id,
                           "KERNEL_INSTALL_LAYOUT", &layout);
        if (r < 0)
                return log_error_errno(r, "Failed to parse '%s': %m", path);
 
        (void) context_set_machine_id(c, machine_id, path);
        (void) context_set_layout(c, layout, path);
        return 0;
}
 
static int context_load_machine_id(Context *c) {
        int r;
 
        assert(c);
 
        r = id128_get_machine_at(c->rfd, &c->machine_id);
        if (ERRNO_IS_NEG_MACHINE_ID_UNSET(r))
                return 0;
        if (r < 0)
                return log_error_errno(r, "Failed to load machine ID from /etc/machine-id: %m");
 
        log_debug("MACHINE_ID=%s set via /etc/machine-id.", SD_ID128_TO_STRING(c->machine_id));
        return 1; /* loaded */
}
 
static int context_ensure_machine_id(Context *c) {
        int r;
 
        assert(c);
 
        if (!sd_id128_is_null(c->machine_id))
                return 0;
 
        /* If /etc/machine-id is initialized we'll use it. */
        r = context_load_machine_id(c);
        if (r != 0)
                return r;
 
        /* Otherwise we'll use a freshly generated one. */
        r = sd_id128_randomize(&c->machine_id);
        if (r < 0)
                return log_error_errno(r, "Failed to generate random ID: %m");
 
        c->machine_id_is_random = true;
        log_debug("New machine ID '%s' generated.", SD_ID128_TO_STRING(c->machine_id));
        return 0;
}
 
static int context_acquire_xbootldr(Context *c) {
        int r;
 
        assert(c);
        assert(!c->boot_root);
 
        r = find_xbootldr_and_warn_at(
                        /* rfd= */ c->rfd,
                        /* path= */ arg_xbootldr_path,
                        /* unprivileged_mode= */ -1,
                        /* ret_path= */ &c->boot_root,
                        /* ret_fd= */ NULL);
        if (r == -ENOKEY) {
                log_debug_errno(r, "Couldn't find an XBOOTLDR partition.");
                return 0;
        }
        if (r == -EACCES && geteuid() != 0)
                return log_error_errno(r, "Failed to determine XBOOTLDR partition: %m");
        if (r < 0)
                return r;
 
        log_debug("Using XBOOTLDR partition at %s as $BOOT_ROOT.", c->boot_root);
        return 1; /* found */
}
 
static int context_acquire_esp(Context *c) {
        int r;
 
        assert(c);
        assert(!c->boot_root);
 
        r = find_esp_and_warn_at(
                        /* rfd= */ c->rfd,
                        /* path= */ arg_esp_path,
                        /* unprivileged_mode= */ -1,
                        /* ret_path= */ &c->boot_root,
                        /* ret_fd= */ NULL);
        if (r == -ENOKEY) {
                log_debug_errno(r, "Couldn't find EFI system partition, ignoring.");
                return 0;
        }
        if (r == -EACCES && geteuid() != 0)
                return log_error_errno(r, "Failed to determine EFI system partition: %m");
        if (r < 0)
                return r;
 
        log_debug("Using EFI System Partition at %s as $BOOT_ROOT.", c->boot_root);
        return 1; /* found */
}
 
static int context_ensure_boot_root(Context *c) {
        int r;
 
        assert(c);
 
        /* If BOOT_ROOT is specified via environment or install.conf, then use it. */
        if (c->boot_root)
                return 0;
 
        /* Otherwise, use XBOOTLDR partition, if mounted. */
        r = context_acquire_xbootldr(c);
        if (r != 0)
                return r;
 
        /* Otherwise, use EFI system partition, if mounted. */
        r = context_acquire_esp(c);
        if (r != 0)
                return r;
 
        /* If all else fails, use /boot. */
        if (c->rfd >= 0) {
                r = chaseat(c->rfd, c->rfd, "/boot", 0, &c->boot_root, /* ret_fd= */ NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to chase '/boot/': %m");
        } else {
                c->boot_root = strdup("/boot");
                if (!c->boot_root)
                        return log_oom();
        }
 
        log_debug("KERNEL_INSTALL_BOOT_ROOT autodetection yielded no candidates, using \"%s\".", c->boot_root);
        return 0;
}
 
static int context_ensure_entry_token(Context *c) {
        int r;
 
        assert(c);
 
        /* Now that we determined the machine ID to use, let's determine the "token" for the boot loader
         * entry to generate. We use that for naming the directory below $BOOT where we want to place the
         * kernel/initrd and related resources, as well for naming the .conf boot loader spec entry.
         * Typically this is just the machine ID, but it can be anything else, too, if we are told so. */
 
        r = boot_entry_token_ensure_at(
                        c->rfd,
                        c->conf_root,
                        c->machine_id,
                        c->machine_id_is_random,
                        &c->entry_token_type,
                        &c->entry_token);
        if (r < 0)
                return r;
 
        log_debug("Using entry token: %s", c->entry_token);
        return 0;
}
 
static int context_load_plugins(Context *c) {
        int r;
 
        assert(c);
 
        if (c->plugins)
                return 0;
 
        r = conf_files_list_strv_at(
                        &c->plugins,
                        ".install",
                        c->rfd,
                        CONF_FILES_EXECUTABLE | CONF_FILES_REGULAR | CONF_FILES_FILTER_MASKED | CONF_FILES_WARN,
                        STRV_MAKE_CONST("/etc/kernel/install.d", "/usr/lib/kernel/install.d"));
        if (r < 0)
                return log_error_errno(r, "Failed to find plugins: %m");
 
        return 0;
}
 
static int context_setup(Context *c) {
        int r;
 
        assert(c);
 
        if (c->kernel_image_type < 0)
                c->kernel_image_type = KERNEL_IMAGE_TYPE_UNKNOWN;
        if (c->entry_token_type < 0)
                c->entry_token_type = BOOT_ENTRY_TOKEN_AUTO;
 
        r = context_open_root(c);
        if (r < 0)
                return r;
 
        r = context_load_environment(c);
        if (r < 0)
                return r;
 
        r = context_load_install_conf(c);
        if (r < 0)
                return r;
 
        r = context_load_machine_info(c);
        if (r < 0)
                return r;
 
        r = context_ensure_machine_id(c);
        if (r < 0)
                return r;
 
        r = context_ensure_boot_root(c);
        if (r < 0)
                return r;
 
        r = context_ensure_entry_token(c);
        if (r < 0)
                return r;
 
        r = context_load_plugins(c);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int context_from_cmdline(Context *c, Action action) {
        int r;
 
        assert(c);
 
        c->action = action;
 
        c->entry_type = arg_boot_entry_type;
 
        r = free_and_strdup_warn(&c->entry_token, arg_entry_token);
        if (r < 0)
                return r;
 
        c->entry_token_type = arg_entry_token_type;
 
        return context_setup(c);
}
 
static int context_inspect_kernel(Context *c) {
        int r;
 
        assert(c);
 
        if (!c->kernel)
                return 0;
 
        r = inspect_kernel(
                        c->rfd,
                        c->kernel,
                        &c->kernel_image_type);
        if (r < 0)
                return log_error_errno(r, "Failed to inspect kernel image '%s': %m", c->kernel);
 
        return 0;
}
 
static int context_ensure_layout(Context *c) {
        int r;
 
        assert(c);
        assert(c->boot_root);
        assert(c->entry_token);
 
        if (c->layout >= 0 && c->layout != LAYOUT_AUTO)
                return 0;
 
        /* No layout configured by the administrator. Let's try to figure it out automatically from metadata
         * already contained in $BOOT_ROOT. */
 
        if (c->kernel_image_type == KERNEL_IMAGE_TYPE_UKI) {
                c->layout = LAYOUT_UKI;
                log_debug("Kernel image type is %s, using layout=%s.",
                          kernel_image_type_to_string(c->kernel_image_type), layout_to_string(c->layout));
                return 0;
        }
 
        _cleanup_free_ char *srel_path = path_join(c->boot_root, "loader/entries.srel");
        if (!srel_path)
                return log_oom();
 
        _cleanup_fclose_ FILE *f = NULL;
        r = chase_and_fopenat_unlocked(c->rfd, c->rfd, srel_path, CHASE_MUST_BE_REGULAR, "re", /* ret_path= */ NULL, &f);
        if (r < 0) {
                if (r != -ENOENT)
                        return log_error_errno(r, "Failed to open '%s': %m", srel_path);
        } else {
                _cleanup_free_ char *srel = NULL;
 
                r = read_line(f, LONG_LINE_MAX, &srel);
                if (r < 0)
                        return log_error_errno(r, "Failed to read %s: %m", srel_path);
 
                if (streq(srel, "type1"))
                        /* The loader/entries.srel file clearly indicates that the installed boot loader
                         * implements the proper standard upstream boot loader spec for Type #1 entries.
                         * Let's default to that, then. */
                        c->layout = LAYOUT_BLS;
                else
                        /* The loader/entries.srel file indicates some other spec is implemented and owns the
                         * /loader/entries/ directory. Since we have no idea what that means, let's stay away
                         * from it by default. */
                        c->layout = LAYOUT_OTHER;
 
                log_debug("%s with '%s' found, using layout=%s.", srel_path, srel, layout_to_string(c->layout));
                return 0;
        }
 
        _cleanup_free_ char *entry_token_path = path_join(c->boot_root, c->entry_token);
        if (!entry_token_path)
                return log_oom();
 
        r = chaseat(c->rfd, c->rfd, entry_token_path, CHASE_MUST_BE_DIRECTORY, /* ret_path= */ NULL, /* ret_fd= */ NULL);
        if (r < 0) {
                if (!IN_SET(r, -ENOENT, -ENOTDIR))
                        return log_error_errno(r, "Failed to check if '%s' exists and is a directory: %m", entry_token_path);
        } else {
                /* If the metadata in $BOOT_ROOT doesn't tell us anything, then check if the entry token
                 * directory already exists. If so, let's assume it's the standard boot loader spec, too. */
                c->layout = LAYOUT_BLS;
                log_debug("%s exists, using layout=%s.", entry_token_path, layout_to_string(c->layout));
                return 0;
        }
 
        /* There's no metadata in $BOOT_ROOT, and apparently no entry token directory installed? Then we
         * really don't know anything. */
        c->layout = LAYOUT_OTHER;
        log_debug("Entry-token directory %s not found, using layout=%s.",
                  entry_token_path,
                  layout_to_string(c->layout));
        return 0;
}
 
static int context_set_up_staging_area(Context *c) {
        int r;
 
        assert(c);
 
        if (c->staging_area)
                return 0;
 
        const char *d;
        r = var_tmp_dir(&d);
        if (r < 0)
                return log_error_errno(r, "Failed to determine temporary directory location: %m");
 
        _cleanup_free_ char *template = path_join(d, "kernel-install.staging.XXXXXX");
        if (!template)
                return log_oom();
 
        if (c->action == ACTION_INSPECT)
                /* This is only used for display. The directory will not be created. */
                c->staging_area = TAKE_PTR(template);
        else {
                r = mkdtemp_malloc(template, &c->staging_area);
                if (r < 0)
                        return log_error_errno(r, "Failed to create staging area: %m");
        }
 
        return 0;
}
 
static int context_build_entry_dir(Context *c) {
        assert(c);
        assert(c->boot_root);
        assert(c->entry_token);
        assert(c->version || c->action == ACTION_INSPECT);
 
        if (c->entry_dir)
                return 0;
 
        c->entry_dir = path_join(c->boot_root, c->entry_token, c->version ?: "KERNEL_VERSION");
        if (!c->entry_dir)
                return log_oom();
 
        log_debug("Using ENTRY_DIR=%s", c->entry_dir);
        return 0;
}
 
static bool context_should_make_entry_dir(Context *c) {
        assert(c);
 
        /* Compatibility with earlier versions that used the presence of $BOOT_ROOT/$ENTRY_TOKEN to signal to
         * 00-entry-directory to create $ENTRY_DIR to serve as the indication to use or to not use the BLS */
 
        if (arg_make_entry_directory < 0)
                return c->layout == LAYOUT_BLS;
 
        return arg_make_entry_directory;
}
 
static int context_make_entry_dir(Context *c) {
        _cleanup_close_ int fd = -EBADF;
 
        assert(c);
        assert(c->entry_dir);
 
        if (c->action != ACTION_ADD)
                return 0;