HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/kernel-install/kernel-install.c
Git blob: 0fb3a4034e01998c22563f23f39938fe95975c25
Lines 1001–1782 of 1,782
if (!context_should_make_entry_dir(c))
return 0;
log_debug("mkdir -p %s", c->entry_dir);
fd = chase_and_openat(c->rfd, c->rfd, c->entry_dir, CHASE_MKDIR_0755,
O_CLOEXEC | O_CREAT | O_DIRECTORY | O_PATH, NULL);
if (fd < 0)
return log_error_errno(fd, "Failed to make directory '%s': %m", c->entry_dir);
return 0;
}
static int context_remove_entry_dir(Context *c) {
_cleanup_free_ char *p = NULL;
_cleanup_close_ int fd = -EBADF;
struct stat st;
int r;
assert(c);
assert(c->entry_dir);
if (c->action != ACTION_REMOVE)
return 0;
if (!context_should_make_entry_dir(c))
return 0;
log_debug("rm -rf %s", c->entry_dir);
fd = chase_and_openat(c->rfd, c->rfd, c->entry_dir, /* chase_flags= */ 0, O_CLOEXEC | O_DIRECTORY, &p);
if (fd < 0) {
if (IN_SET(fd, -ENOTDIR, -ENOENT))
return 0;
return log_debug_errno(fd, "Failed to chase and open %s, ignoring: %m", c->entry_dir);
}
if (fstat(fd, &st) < 0)
return log_debug_errno(errno, "Failed to stat %s: %m", p);
r = rm_rf_children(TAKE_FD(fd), REMOVE_PHYSICAL|REMOVE_MISSING_OK|REMOVE_CHMOD, &st);
if (r < 0)
log_debug_errno(r, "Failed to remove children of %s, ignoring: %m", p);
if (unlinkat(c->rfd, p, AT_REMOVEDIR) < 0)
log_debug_errno(errno, "Failed to remove %s, ignoring: %m", p);
return 0;
}
static int context_build_arguments(Context *c) {
_cleanup_strv_free_ char **a = NULL;
const char *verb;
int r;
assert(c);
assert(c->entry_dir);
if (c->argv)
return 0;
switch (c->action) {
case ACTION_ADD:
assert(c->version);
assert(c->kernel);
verb = "add";
break;
case ACTION_REMOVE:
assert(c->version);
assert(!c->kernel);
assert(!c->initrds);
verb = "remove";
break;
case ACTION_INSPECT:
verb = "add|remove";
break;
default:
assert_not_reached();
}
a = strv_new("dummy-arg", /* to make strv_free() works for this variable. */
verb,
c->version ?: "KERNEL_VERSION",
c->entry_dir);
if (!a)
return log_oom();
if (c->action == ACTION_ADD) {
r = strv_extend(&a, c->kernel);
if (r < 0)
return log_oom();
r = strv_extend_strv(&a, c->initrds, /* filter_duplicates= */ false);
if (r < 0)
return log_oom();
} else if (c->action == ACTION_INSPECT) {
r = strv_extend_many(
&a,
c->kernel ?: "[KERNEL_IMAGE]",
"[INITRD...]");
if (r < 0)
return log_oom();
}
c->argv = TAKE_PTR(a);
return 0;
}
static int context_build_environment(Context *c) {
_cleanup_strv_free_ char **e = NULL;
int r;
assert(c);
if (c->envp)
return 0;
r = context_resolve_entry_name(c);
if (r < 0)
return r;
r = strv_env_assign_many(&e,
"LC_COLLATE", SYSTEMD_DEFAULT_LOCALE,
"KERNEL_INSTALL_VERBOSE", one_zero(arg_verbose),
"KERNEL_INSTALL_IMAGE_TYPE", kernel_image_type_to_string(c->kernel_image_type),
"KERNEL_INSTALL_MACHINE_ID", SD_ID128_TO_STRING(c->machine_id),
"KERNEL_INSTALL_ENTRY_TOKEN", c->entry_token,
"KERNEL_INSTALL_BOOT_ROOT", c->boot_root,
"KERNEL_INSTALL_LAYOUT", context_get_layout(c),
"KERNEL_INSTALL_INITRD_GENERATOR", strempty(c->initrd_generator),
"KERNEL_INSTALL_UKI_GENERATOR", strempty(c->uki_generator),
"KERNEL_INSTALL_BOOT_ENTRY_TYPE", boot_entry_type_to_string(c->entry_type),
"KERNEL_INSTALL_STAGING_AREA", c->staging_area,
"KERNEL_INSTALL_ENTRY_NAME", c->entry_name);
if (r < 0)
return log_error_errno(r, "Failed to build environment variables for plugins: %m");
c->envp = TAKE_PTR(e);
return 0;
}
static int context_prepare_execution(Context *c) {
int r;
assert(c);
r = context_inspect_kernel(c);
if (r < 0)
return r;
r = context_ensure_layout(c);
if (r < 0)
return r;
r = context_set_up_staging_area(c);
if (r < 0)
return r;
r = context_build_entry_dir(c);
if (r < 0)
return r;
r = context_build_arguments(c);
if (r < 0)
return r;
r = context_build_environment(c);
if (r < 0)
return r;
return 0;
}
static int context_execute(Context *c) {
int r, ret;
assert(c);
r = context_make_entry_dir(c);
if (r < 0)
return r;
if (DEBUG_LOGGING) {
_cleanup_free_ char *x = strv_join_full(c->plugins, "", "\n ");
log_debug("Using plugins: %s", strna(x));
_cleanup_free_ char *y = strv_join_full(c->envp, "", "\n ");
log_debug("Plugin environment: %s", strna(y));
_cleanup_free_ char *z = strv_join(strv_skip(c->argv, 1), " ");
log_debug("Plugin arguments: %s", strna(z));
}
ret = execute_strv(
"plugins",
c->plugins,
/* root= */ NULL,
USEC_INFINITY,
/* callbacks= */ NULL,
/* callback_args= */ NULL,
c->argv,
c->envp,
EXEC_DIR_SKIP_REMAINING);
r = context_remove_entry_dir(c);
if (r < 0)
return r;
/* This returns 0 on success, positive exit code on plugin failure, negative errno on other failures. */
return ret;
}
static bool bypass(void) {
return should_bypass("KERNEL_INSTALL");
}
static int kernel_from_version(const char *version, char **ret_kernel) {
_cleanup_free_ char *vmlinuz = NULL;
int r;
assert(version);
assert(ret_kernel);
vmlinuz = path_join("/usr/lib/modules/", version, "/vmlinuz");
if (!vmlinuz)
return log_oom();
r = access_nofollow(vmlinuz, F_OK);
if (r == -ENOENT)
return log_error_errno(r, "Kernel image not installed to '%s', specify kernel kernel image path explicitly.", vmlinuz);
if (r < 0)
return log_error_errno(r, "Failed to determine if kernel image is installed to '%s': %m", vmlinuz);
*ret_kernel = TAKE_PTR(vmlinuz);
return 0;
}
static int do_add(
Context *c,
const char *version,
const char *kernel,
char **initrds) {
int r;
assert(c);
struct utsname un;
if (!version) {
assert_se(uname(&un) >= 0);
version = un.release;
}
_cleanup_free_ char *vmlinuz = NULL;
if (!kernel) {
r = kernel_from_version(version, &vmlinuz);
if (r < 0)
return r;
kernel = vmlinuz;
}
r = context_set_version(c, version);
if (r < 0)
return r;
r = context_set_kernel(c, kernel);
if (r < 0)
return r;
r = context_set_initrds(c, initrds);
if (r < 0)
return r;
r = context_prepare_execution(c);
if (r < 0)
return r;
return context_execute(c);
}
VERB(verb_add, "add", "[[[KERNEL-VERSION] KERNEL-IMAGE] [INITRD ...]]\0", 1, VERB_ANY, 0,
"Add a kernel and initrd images to the boot partition");
static int verb_add(int argc, char *argv[], uintptr_t _data, void *userdata) {
const char *version, *kernel;
char **initrds;
int r;
assert(argv);
if (arg_root)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "'add' does not support --root= or --image=.");
if (bypass())
return 0;
_cleanup_(context_done) Context c = CONTEXT_NULL;
r = context_from_cmdline(&c, ACTION_ADD);
if (r < 0)
return r;
/* We use the same order of arguments that "inspect" introduced, i.e. if only on argument is
* specified we take it as the kernel path, not the version, i.e. it's the first argument that is
* optional, not the 2nd. */
version = argc > 2 ? empty_or_dash_to_null(argv[1]) : NULL;
kernel = argc > 2 ? empty_or_dash_to_null(argv[2]) :
(argc > 1 ? empty_or_dash_to_null(argv[1]) : NULL);
initrds = strv_skip(argv, 3);
return do_add(&c, version, kernel, initrds);
}
VERB_NOARG(verb_add_all, "add-all",
"Add all kernels found in /usr/lib/modules/");
static int verb_add_all(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_close_ int fd = -EBADF;
size_t n = 0;
int ret = 0, r;
assert(argv);
if (arg_root)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "'add-all' does not support --root= or --image=.");
if (bypass())
return 0;
_cleanup_(context_done) Context c = CONTEXT_NULL;
r = context_from_cmdline(&c, ACTION_ADD);
if (r < 0)
return r;
fd = chase_and_openat(c.rfd, c.rfd, "/usr/lib/modules", /* chase_flags= */ 0, O_DIRECTORY|O_RDONLY|O_CLOEXEC, NULL);
if (fd < 0)
return log_error_errno(fd, "Failed to open %s/usr/lib/modules/: %m", strempty(arg_root));
_cleanup_free_ DirectoryEntries *de = NULL;
r = readdir_all(fd, RECURSE_DIR_SORT|RECURSE_DIR_IGNORE_DOT|RECURSE_DIR_MUST_BE_DIRECTORY, &de);
if (r < 0)
return log_error_errno(r, "Failed to numerate /usr/lib/modules/ contents: %m");
FOREACH_ARRAY(d, de->entries, de->n_entries) {
_cleanup_free_ char *fn = path_join((*d)->d_name, "vmlinuz");
if (!fn)
return log_oom();
if (faccessat(fd, fn, F_OK, AT_SYMLINK_NOFOLLOW) < 0) {
if (errno != ENOENT)
log_debug_errno(errno, "Failed to check if '%s/usr/lib/modules/%s/vmlinuz' exists, ignoring: %m", strempty(arg_root), (*d)->d_name);
log_notice("Not adding version '%s', because kernel image not found.", (*d)->d_name);
continue;
}
_cleanup_(context_done) Context copy = CONTEXT_NULL;
r = context_copy(&c, ©);
if (r < 0)
return log_error_errno(r, "Failed to copy execution context: %m");
/* do_add() will look up the path in the correct root directory so we don't need to prefix it
* with arg_root here. */
_cleanup_free_ char *full = path_join("/usr/lib/modules/", fn);
if (!full)
return log_oom();
r = do_add(©,
/* version= */ (*d)->d_name,
/* kernel= */ full,
/* initrds= */ NULL);
if (r == 0)
n++;
else if (ret == 0)
ret = r;
}
if (n > 0)
log_debug("Installed %zu kernel(s).", n);
else if (ret == 0)
ret = log_error_errno(SYNTHETIC_ERRNO(ENOENT), "No kernels to install found.");
return ret;
}
static int run_as_installkernel(char **args) {
/* kernel's install.sh invokes us as
* /sbin/installkernel <version> <vmlinuz> <map> <installation-dir>
* We ignore the last two arguments. */
if (strv_length(args) < 2)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "'installkernel' command requires at least two arguments.");
return verb_add(3, STRV_MAKE("add", args[0], args[1]), /* data= */ 0, /* userdata= */ NULL);
}
VERB(verb_remove, "remove", "KERNEL-VERSION\0", 2, VERB_ANY, 0,
"Remove a kernel from the boot partition");
static int verb_remove(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
assert(argc >= 2);
assert(argv);
if (arg_root)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "'remove' does not support --root= or --image=.");
if (argc > 2)
log_debug("Too many arguments specified. 'kernel-install remove' takes only kernel version. "
"Ignoring residual arguments.");
if (bypass())
return 0;
_cleanup_(context_done) Context c = CONTEXT_NULL;
r = context_from_cmdline(&c, ACTION_REMOVE);
if (r < 0)
return r;
/* Note, we do not automatically derive the kernel version to remove from uname() here (unlike we do
* it for the "add" verb), since we don't want to make it too easy to uninstall your running
* kernel, as a safety precaution */
r = context_set_version(&c, argv[1]);
if (r < 0)
return r;
r = context_prepare_execution(&c);
if (r < 0)
return r;
return context_execute(&c);
}
VERB(verb_inspect, "inspect", "[[[KERNEL-VERSION] KERNEL-IMAGE] [INITRD ...]]\0", 1, VERB_ANY, VERB_DEFAULT,
"Print details about the installation");
static int verb_inspect(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(table_unrefp) Table *t = NULL;
_cleanup_free_ char *vmlinuz = NULL;
const char *version, *kernel;
char **initrds;
struct utsname un;
int r;
_cleanup_(context_done) Context c = CONTEXT_NULL;
r = context_from_cmdline(&c, ACTION_INSPECT);
if (r < 0)
return r;
/* When only a single parameter is specified 'inspect' it's the kernel image path, and not the kernel
* version. i.e. it's the first argument that is optional, not the 2nd. That's a bit unfortunate, but
* we keep the behaviour for compatibility. If users want to specify only the version (and have the
* kernel image path derived automatically), then they may specify an empty string or "dash" as
* kernel image path. */
version = argc > 2 ? empty_or_dash_to_null(argv[1]) : NULL;
kernel = argc > 2 ? empty_or_dash_to_null(argv[2]) :
(argc > 1 ? empty_or_dash_to_null(argv[1]) : NULL);
initrds = strv_skip(argv, 3);
if (!version && !arg_root) {
assert_se(uname(&un) >= 0);
version = un.release;
}
if (!kernel && version) {
r = kernel_from_version(version, &vmlinuz);
if (r < 0)
return r;
kernel = vmlinuz;
}
r = context_set_version(&c, version);
if (r < 0)
return r;
r = context_set_kernel(&c, kernel);
if (r < 0)
return r;
r = context_set_initrds(&c, initrds);
if (r < 0)
return r;
r = context_prepare_execution(&c);
if (r < 0)
return r;
t = table_new_vertical();
if (!t)
return log_oom();
r = table_add_many(t,
TABLE_FIELD, "Machine ID",
TABLE_ID128, c.machine_id,
TABLE_FIELD, "Kernel Image Type",
TABLE_STRING, kernel_image_type_to_string(c.kernel_image_type),
TABLE_FIELD, "Layout",
TABLE_STRING, context_get_layout(&c),
TABLE_FIELD, "Boot Root",
TABLE_STRING, c.boot_root,
TABLE_FIELD, "Entry Token Type",
TABLE_STRING, boot_entry_token_type_to_string(c.entry_token_type),
TABLE_FIELD, "Entry Token",
TABLE_STRING, c.entry_token,
TABLE_FIELD, "Entry Name Format",
TABLE_STRING, c.entry_name_format ?: DEFAULT_ENTRY_NAME_FORMAT,
TABLE_FIELD, "Entry Name",
TABLE_STRING, c.entry_name,
TABLE_FIELD, "Entry Directory",
TABLE_STRING, c.entry_dir,
TABLE_FIELD, "Kernel Version",
TABLE_VERSION, c.version,
TABLE_FIELD, "Kernel",
TABLE_STRING, c.kernel,
TABLE_FIELD, "Initrds",
TABLE_STRV, c.initrds,
TABLE_FIELD, "Initrd Generator",
TABLE_STRING, c.initrd_generator,
TABLE_FIELD, "UKI Generator",
TABLE_STRING, c.uki_generator,
TABLE_FIELD, "Plugins",
TABLE_STRV, c.plugins,
TABLE_FIELD, "Plugin Environment",
TABLE_STRV, c.envp);
if (r < 0)
return table_log_add_error(r);
if (!sd_json_format_enabled(arg_json_format_flags)) {
r = table_add_many(t,
TABLE_FIELD, "Plugin Arguments",
TABLE_STRV, strv_skip(c.argv, 1));
if (r < 0)
return table_log_add_error(r);
}
table_set_ersatz_string(t, TABLE_ERSATZ_UNSET);
for (size_t row = 1; row < table_get_rows(t); row++) {
_cleanup_free_ char *name = NULL;
name = strdup(table_get_at(t, row, 0));
if (!name)
return log_oom();
r = table_set_json_field_name(t, row - 1, delete_chars(name, " "));
if (r < 0)
return log_error_errno(r, "Failed to set JSON field name: %m");
}
return table_print_with_pager(t, arg_json_format_flags, arg_pager_flags, /* show_header= */ false);
}
VERB_NOARG(verb_list, "list",
"List installed kernels");
static int verb_list(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_close_ int fd = -EBADF;
int r;
_cleanup_(context_done) Context c = CONTEXT_NULL;
r = context_from_cmdline(&c, ACTION_INSPECT);
if (r < 0)
return r;
fd = chase_and_openat(c.rfd, c.rfd, "/usr/lib/modules", /* chase_flags= */ 0, O_DIRECTORY|O_RDONLY|O_CLOEXEC, NULL);
if (fd < 0)
return log_error_errno(fd, "Failed to open %s/usr/lib/modules/: %m", strempty(arg_root));
_cleanup_free_ DirectoryEntries *de = NULL;
r = readdir_all(fd, RECURSE_DIR_SORT|RECURSE_DIR_IGNORE_DOT|RECURSE_DIR_MUST_BE_DIRECTORY, &de);
if (r < 0)
return log_error_errno(r, "Failed to numerate /usr/lib/modules/ contents: %m");
_cleanup_(table_unrefp) Table *table = NULL;
table = table_new("version", "has kernel", "path");
if (!table)
return log_oom();
table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
table_set_align_percent(table, table_get_cell(table, 0, 1), 100);
(void) table_set_sort(table, (size_t) 0);
FOREACH_ARRAY(d, de->entries, de->n_entries) {
_cleanup_free_ char *j = path_join("/usr/lib/modules/", (*d)->d_name);
if (!j)
return log_oom();
_cleanup_free_ char *fn = path_join((*d)->d_name, "vmlinuz");
if (!fn)
return log_oom();
bool exists;
if (faccessat(fd, fn, F_OK, AT_SYMLINK_NOFOLLOW) < 0) {
if (errno != ENOENT)
log_debug_errno(errno, "Failed to check if '%s/usr/lib/modules/%s/vmlinuz' exists, ignoring: %m", strempty(arg_root), (*d)->d_name);
exists = false;
} else
exists = true;
r = table_add_many(table,
TABLE_VERSION, (*d)->d_name,
TABLE_BOOLEAN_CHECKMARK, exists,
TABLE_SET_COLOR, ansi_highlight_green_red(exists),
TABLE_PATH, j);
if (r < 0)
return table_log_add_error(r);
}
return table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, arg_legend);
}
VERB_COMMON_HELP_AUTO_PROGRAM("kernel-install");
static int parse_argv(int argc, char *argv[], char ***remaining_args) {
assert(argc >= 0);
assert(argv);
assert(remaining_args);
OptionParser opts = { argc, argv };
int r;
FOREACH_OPTION_OR_RETURN(c, &opts)
switch (c) {
OPTION_COMMON_HELP:
return command_print_help_name("kernel-install");
OPTION_COMMON_VERSION:
return version();
OPTION_COMMON_NO_LEGEND:
arg_legend = false;
break;
OPTION('v', "verbose", NULL, "Increase verbosity"):
log_set_max_level(LOG_DEBUG);
arg_verbose = true;
break;
OPTION_LONG("esp-path", "PATH", "Path to the EFI System Partition (ESP)"):
r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_esp_path);
if (r < 0)
return r;
break;
OPTION_LONG("boot-path", "PATH", "Path to the $BOOT partition"):
r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_xbootldr_path);
if (r < 0)
return r;
break;
OPTION_COMMON_MAKE_ENTRY_DIRECTORY:
if (streq(opts.arg, "auto"))
arg_make_entry_directory = -1;
else {
r = parse_boolean_argument("--make-entry-directory=", opts.arg, NULL);
if (r < 0)
return r;
arg_make_entry_directory = r;
}
break;
OPTION_COMMON_ENTRY_TOKEN:
r = parse_boot_entry_token_type(opts.arg, &arg_entry_token_type, &arg_entry_token);
if (r < 0)
return r;
break;
OPTION_LONG("entry-type", "TYPE",
"Operate only on the specified bootloader entry type (type1, type2, all)"): {
if (isempty(opts.arg) || streq(opts.arg, "all")) {
arg_boot_entry_type = _BOOT_ENTRY_TYPE_INVALID;
break;
}
BootEntryType e = boot_entry_type_from_string(opts.arg);
if (e < 0)
return log_error_errno(e, "Invalid entry type: %s", opts.arg);
arg_boot_entry_type = e;
break;
}
OPTION_COMMON_NO_PAGER:
arg_pager_flags |= PAGER_DISABLE;
break;
OPTION_COMMON_JSON:
r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_LONG("root", "PATH", "Operate on an alternate filesystem root"):
r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_root);
if (r < 0)
return r;
break;
OPTION_LONG("image", "PATH", "Operate on disk image as filesystem root"):
r = parse_path_argument(opts.arg, /* suppress_root= */ false, &arg_image);
if (r < 0)
return r;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
break;
OPTION_COMMON_INTROSPECT_CLI:
return introspect_cli(arg_json_format_flags);
}
if (arg_image && arg_root)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Please specify either --root= or --image=, the combination of both is not supported.");
*remaining_args = option_parser_get_args(&opts);
return 1;
}
/* Definition for the compat interface to populate introspection data.
* Keep below the VERB definitions for the main command. */
COMMAND(
"installkernel\0",
"Add and remove kernel and initrd images to and from the boot partition.",
.argspec = "VERSION VMLINUZ [MAP] [INSTALLATION-DIR]\0",
.footer = "This is a compat interface intended only to be called from kernel Makefiles.",
.man_pages = "kernel-install(8)\0",
.pager_flags = &arg_pager_flags,
);
static int run(int argc, char* argv[]) {
int r;
LIBBLKID_NOTE(recommended);
LIBCRYPTO_NOTE(suggested);
LIBCRYPTSETUP_NOTE(suggested);
LIBMOUNT_NOTE(recommended);
log_setup();
char **args = NULL;
r = parse_argv(argc, argv, &args);
if (r <= 0)
return r;
_cleanup_(loop_device_unrefp) LoopDevice *loop_device = NULL;
_cleanup_(umount_and_freep) char *mounted_dir = NULL;
if (arg_image) {
assert(!arg_root);
r = mount_image_privately_interactively(
arg_image,
arg_image_policy,
DISSECT_IMAGE_GENERIC_ROOT |
DISSECT_IMAGE_REQUIRE_ROOT |
DISSECT_IMAGE_RELAX_VAR_CHECK |
DISSECT_IMAGE_VALIDATE_OS |
DISSECT_IMAGE_ALLOW_USERSPACE_VERITY,
&mounted_dir,
/* ret_dir_fd= */ NULL,
&loop_device);
if (r < 0)
return r;
arg_root = strdup(mounted_dir);
if (!arg_root)
return log_oom();
}
if (invoked_as(argv, "installkernel"))
return run_as_installkernel(args);
return dispatch_verb(args, /* userdata= */ NULL);
}
DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);