#include <ctype.h>

#include <errno.h>

#include <getopt.h>

#include <limits.h>

#include <linux/magic.h>

#include <stdbool.h>

#include <stdlib.h>

#include <sys/mman.h>

#include <unistd.h>

#include "sd-id128.h"

#include "alloc-util.h"

#include "blkid-util.h"

#include "bootspec.h"

#include "copy.h"

#include "dirent-util.h"

#include "efi-api.h"

#include "efi-loader.h"

#include "efivars.h"

#include "env-file.h"

#include "env-util.h"

#include "escape.h"

#include "fd-util.h"

#include "fileio.h"

#include "find-esp.h"

#include "fs-util.h"

#include "glyph-util.h"

#include "main-func.h"

#include "mkdir.h"

#include "os-util.h"

#include "pager.h"

#include "parse-argument.h"

#include "parse-util.h"

#include "pretty-print.h"

#include "random-util.h"

#include "rm-rf.h"

#include "stat-util.h"

#include "stdio-util.h"

#include "string-table.h"

#include "string-util.h"

#include "strv.h"

#include "sync-util.h"

#include "terminal-util.h"

#include "tmpfile-util.h"

#include "tmpfile-util-label.h"

#include "umask-util.h"

#include "utf8.h"

#include "util.h"

#include "verbs.h"

#include "virt.h"

static char *arg_esp_path = NULL;

static char *arg_xbootldr_path = NULL;

static bool arg_print_esp_path = false;

static bool arg_print_dollar_boot_path = false;

static bool arg_touch_variables = true;

static PagerFlags arg_pager_flags = 0;

static bool arg_graceful = false;

static int arg_make_entry_directory = false; /* tri-state: < 0 for automatic logic */

static sd_id128_t arg_machine_id = SD_ID128_NULL;

static char *arg_install_layout = NULL;

static enum {

ARG_ENTRY_TOKEN_MACHINE_ID,

ARG_ENTRY_TOKEN_OS_IMAGE_ID,

ARG_ENTRY_TOKEN_OS_ID,

ARG_ENTRY_TOKEN_LITERAL,

ARG_ENTRY_TOKEN_AUTO,

} arg_entry_token_type = ARG_ENTRY_TOKEN_AUTO;

static char *arg_entry_token = NULL;

static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;

STATIC_DESTRUCTOR_REGISTER(arg_esp_path, freep);

STATIC_DESTRUCTOR_REGISTER(arg_xbootldr_path, freep);

STATIC_DESTRUCTOR_REGISTER(arg_install_layout, freep);

STATIC_DESTRUCTOR_REGISTER(arg_entry_token, freep);

static const char *arg_dollar_boot_path(void) {

/* $BOOT shall be the XBOOTLDR partition if it exists, and otherwise the ESP */

return arg_xbootldr_path ?: arg_esp_path;

}

static int acquire_esp(

dev_t *ret_devid) {

char *np;

int r;

/* Find the ESP, and log about errors. Note that find_esp_and_warn() will log in all error cases on

r = find_esp_and_warn(arg_esp_path, unprivileged_mode, &np, ret_part, ret_pstart, ret_psize, ret_uuid, ret_devid);

if (r == -ENOKEY) {

if (graceful)

return log_info_errno(r, "Couldn't find EFI system partition, skipping.");

return log_error_errno(r,

"Couldn't find EFI system partition. It is recommended to mount it to /boot or /efi.\n"

"Alternatively, use --esp-path= to specify path to mount point.");

}

if (r < 0)

return r;

free_and_replace(arg_esp_path, np);

log_debug("Using EFI System Partition at %s.", arg_esp_path);

return 1;

}

static int acquire_xbootldr(

bool unprivileged_mode,

sd_id128_t *ret_uuid,

dev_t *ret_devid) {

char *np;

int r;

r = find_xbootldr_and_warn(arg_xbootldr_path, unprivileged_mode, &np, ret_uuid, ret_devid);

if (r == -ENOKEY) {

log_debug_errno(r, "Didn't find an XBOOTLDR partition, using the ESP as $BOOT.");

arg_xbootldr_path = mfree(arg_xbootldr_path);

if (ret_uuid)

*ret_uuid = SD_ID128_NULL;

if (ret_devid)

*ret_devid = 0;

return 0;

}

if (r < 0)

return r;

free_and_replace(arg_xbootldr_path, np);

log_debug("Using XBOOTLDR partition at %s as $BOOT.", arg_xbootldr_path);

return 1;

}

static int load_etc_machine_id(void) {

int r;

r = sd_id128_get_machine(&arg_machine_id);

if (IN_SET(r, -ENOENT, -ENOMEDIUM)) /* Not set or empty */

return 0;

if (r < 0)

return log_error_errno(r, "Failed to get machine-id: %m");

log_debug("Loaded machine ID %s from /etc/machine-id.", SD_ID128_TO_STRING(arg_machine_id));

return 0;

}

static int load_etc_machine_info(void) {

/* systemd v250 added support to store the kernel-install layout setting and the machine ID to use

_cleanup_free_ char *s = NULL, *layout = NULL;

int r;

r = parse_env_file(NULL, "/etc/machine-info",

"KERNEL_INSTALL_LAYOUT", &layout,

"KERNEL_INSTALL_MACHINE_ID", &s);

if (r == -ENOENT)

return 0;

if (r < 0)

return log_error_errno(r, "Failed to parse /etc/machine-info: %m");

if (!isempty(s)) {

log_notice("Read $KERNEL_INSTALL_MACHINE_ID from /etc/machine-info. Please move it to /etc/kernel/entry-token.");

r = sd_id128_from_string(s, &arg_machine_id);

if (r < 0)

return log_error_errno(r, "Failed to parse KERNEL_INSTALL_MACHINE_ID=%s in /etc/machine-info: %m", s);

log_debug("Loaded KERNEL_INSTALL_MACHINE_ID=%s from KERNEL_INSTALL_MACHINE_ID in /etc/machine-info.",

SD_ID128_TO_STRING(arg_machine_id));

}

if (!isempty(layout)) {

log_notice("Read $KERNEL_INSTALL_LAYOUT from /etc/machine-info. Please move it to the layout= setting of /etc/kernel/install.conf.");

log_debug("KERNEL_INSTALL_LAYOUT=%s is specified in /etc/machine-info.", layout);

free_and_replace(arg_install_layout, layout);

}

return 0;

}

static int load_etc_kernel_install_conf(void) {

_cleanup_free_ char *layout = NULL;

int r;

r = parse_env_file(NULL, "/etc/kernel/install.conf",

"layout", &layout);

if (r == -ENOENT)

return 0;

if (r < 0)

return log_error_errno(r, "Failed to parse /etc/kernel/install.conf: %m");

if (!isempty(layout)) {

log_debug("layout=%s is specified in /etc/machine-info.", layout);

free_and_replace(arg_install_layout, layout);

}

return 0;

}

static int settle_entry_token(void) {

int r;

switch (arg_entry_token_type) {

case ARG_ENTRY_TOKEN_AUTO: {

_cleanup_free_ char *buf = NULL;

r = read_one_line_file("/etc/kernel/entry-token", &buf);

if (r < 0 && r != -ENOENT)

return log_error_errno(r, "Failed to read /etc/kernel/entry-token: %m");

if (!isempty(buf)) {

free_and_replace(arg_entry_token, buf);

arg_entry_token_type = ARG_ENTRY_TOKEN_LITERAL;

} else if (sd_id128_is_null(arg_machine_id)) {

_cleanup_free_ char *id = NULL, *image_id = NULL;

r = parse_os_release(NULL,

"IMAGE_ID", &image_id,

"ID", &id);

if (r < 0)

return log_error_errno(r, "Failed to load /etc/os-release: %m");

if (!isempty(image_id)) {

free_and_replace(arg_entry_token, image_id);

arg_entry_token_type = ARG_ENTRY_TOKEN_OS_IMAGE_ID;

} else if (!isempty(id)) {

free_and_replace(arg_entry_token, id);

arg_entry_token_type = ARG_ENTRY_TOKEN_OS_ID;

} else

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No machine ID set, and /etc/os-release carries no ID=/IMAGE_ID= fields.");

} else {

r = free_and_strdup_warn(&arg_entry_token, SD_ID128_TO_STRING(arg_machine_id));

if (r < 0)

return r;

arg_entry_token_type = ARG_ENTRY_TOKEN_MACHINE_ID;

}

break;

}

case ARG_ENTRY_TOKEN_MACHINE_ID:

if (sd_id128_is_null(arg_machine_id))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No machine ID set.");

r = free_and_strdup_warn(&arg_entry_token, SD_ID128_TO_STRING(arg_machine_id));

if (r < 0)

return r;

break;

case ARG_ENTRY_TOKEN_OS_IMAGE_ID: {

_cleanup_free_ char *buf = NULL;

r = parse_os_release(NULL, "IMAGE_ID", &buf);

if (r < 0)

return log_error_errno(r, "Failed to load /etc/os-release: %m");

if (isempty(buf))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "IMAGE_ID= field not set in /etc/os-release.");

free_and_replace(arg_entry_token, buf);

break;

}

case ARG_ENTRY_TOKEN_OS_ID: {

_cleanup_free_ char *buf = NULL;

r = parse_os_release(NULL, "ID", &buf);

if (r < 0)

return log_error_errno(r, "Failed to load /etc/os-release: %m");

if (isempty(buf))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "ID= field not set in /etc/os-release.");

free_and_replace(arg_entry_token, buf);

break;

}

case ARG_ENTRY_TOKEN_LITERAL:

assert(!isempty(arg_entry_token)); /* already filled in by command line parser */

break;

}

if (isempty(arg_entry_token) || !string_is_safe(arg_entry_token))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Selected entry token not valid: %s", arg_entry_token);

log_debug("Using entry token: %s", arg_entry_token);

return 0;

}

static bool use_boot_loader_spec_type1(void) {

/* If the layout is not specified, or if it is set explicitly to "bls" we assume Boot Loader

return !arg_install_layout || streq(arg_install_layout, "bls");

}

static int settle_make_entry_directory(void) {

int r;

r = load_etc_machine_id();

if (r < 0)

return r;

r = load_etc_machine_info();

if (r < 0)

return r;

r = load_etc_kernel_install_conf();

if (r < 0)

return r;

r = settle_entry_token();

if (r < 0)

return r;

bool layout_type1 = use_boot_loader_spec_type1();

if (arg_make_entry_directory < 0) { /* Automatic mode */

if (layout_type1) {

if (arg_entry_token == ARG_ENTRY_TOKEN_MACHINE_ID) {

r = path_is_temporary_fs("/etc/machine-id");

if (r < 0)

return log_debug_errno(r, "Couldn't determine whether /etc/machine-id is on a temporary file system: %m");

arg_make_entry_directory = r == 0;

} else

arg_make_entry_directory = true;

} else

arg_make_entry_directory = false;

}

if (arg_make_entry_directory > 0 && !layout_type1)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"KERNEL_INSTALL_LAYOUT=%s is configured, but Boot Loader Specification Type #1 entry directory creation was requested.",

arg_install_layout);

return 0;

}

static int get_file_version(int fd, char **v) {

struct stat st;

char *buf;

const char *s, *e;

char *x = NULL;

int r;

assert(fd >= 0);

assert(v);

if (fstat(fd, &st) < 0)

return log_error_errno(errno, "Failed to stat EFI binary: %m");

r = stat_verify_regular(&st);

if (r < 0)

return log_error_errno(r, "EFI binary is not a regular file: %m");

if (st.st_size < 27 || file_offset_beyond_memory_size(st.st_size)) {

*v = NULL;

return 0;

}

buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

if (buf == MAP_FAILED)

return log_error_errno(errno, "Failed to memory map EFI binary: %m");

s = mempmem_safe(buf, st.st_size - 8, "#### LoaderInfo: ", 17);

if (!s)

goto finish;

e = memmem_safe(s, st.st_size - (s - buf), " ####", 5);

if (!e || e - s < 3) {

r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Malformed version string.");

goto finish;

}

x = strndup(s, e - s);

if (!x) {

r = log_oom();

goto finish;

}

r = 1;

finish:

(void) munmap(buf, st.st_size);

*v = x;

return r;

}

static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) {

_cleanup_closedir_ DIR *d = NULL;

const char *p;

int c = 0, r;

assert(esp_path);

assert(path);

p = prefix_roota(esp_path, path);

d = opendir(p);

if (!d) {

if (errno == ENOENT)

return 0;

return log_error_errno(errno, "Failed to read \"%s\": %m", p);

}

FOREACH_DIRENT(de, d, break) {

_cleanup_free_ char *v = NULL;

_cleanup_close_ int fd = -1;

if (!endswith_no_case(de->d_name, ".efi"))

continue;

if (prefix && !startswith_no_case(de->d_name, prefix))

continue;

fd = openat(dirfd(d), de->d_name, O_RDONLY|O_CLOEXEC);

if (fd < 0)

return log_error_errno(errno, "Failed to open \"%s/%s\" for reading: %m", p, de->d_name);

r = get_file_version(fd, &v);

if (r < 0)

return r;

if (r > 0)

printf(" File: %s/%s/%s (%s%s%s)\n", special_glyph(SPECIAL_GLYPH_TREE_RIGHT), path, de->d_name, ansi_highlight(), v, ansi_normal());

else

printf(" File: %s/%s/%s\n", special_glyph(SPECIAL_GLYPH_TREE_RIGHT), path, de->d_name);

c++;

}

return c;

}

static int status_binaries(const char *esp_path, sd_id128_t partition) {

int r;

printf("Available Boot Loaders on ESP:\n");

if (!esp_path) {

printf(" ESP: Cannot find or access mount point of ESP.\n\n");

return -ENOENT;

}

printf(" ESP: %s", esp_path);

if (!sd_id128_is_null(partition))

printf(" (/dev/disk/by-partuuid/" SD_ID128_UUID_FORMAT_STR ")", SD_ID128_FORMAT_VAL(partition));

printf("\n");

r = enumerate_binaries(esp_path, "EFI/systemd", NULL);

if (r < 0)

goto finish;

if (r == 0)

log_info("systemd-boot not installed in ESP.");

r = enumerate_binaries(esp_path, "EFI/BOOT", "boot");

if (r < 0)

goto finish;

if (r == 0)

log_info("No default/fallback boot loader installed in ESP.");

r = 0;

finish:

printf("\n");

return r;

}

static int print_efi_option(uint16_t id, bool in_order) {

_cleanup_free_ char *title = NULL;

_cleanup_free_ char *path = NULL;

sd_id128_t partition;

bool active;

int r;

r = efi_get_boot_option(id, &title, &partition, &path, &active);

if (r < 0)

return r;

/* print only configured entries with partition information */

if (!path || sd_id128_is_null(partition))

return 0;

efi_tilt_backslashes(path);

printf(" Title: %s%s%s\n", ansi_highlight(), strna(title), ansi_normal());

printf(" ID: 0x%04X\n", id);

printf(" Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : "");

printf(" Partition: /dev/disk/by-partuuid/" SD_ID128_UUID_FORMAT_STR "\n",

SD_ID128_FORMAT_VAL(partition));

printf(" File: %s%s\n", special_glyph(SPECIAL_GLYPH_TREE_RIGHT), path);

printf("\n");

return 0;

}

static int status_variables(void) {

_cleanup_free_ uint16_t *options = NULL, *order = NULL;

int n_options, n_order;

n_options = efi_get_boot_options(&options);

if (n_options == -ENOENT)

return log_error_errno(n_options,

"Failed to access EFI variables, efivarfs"

" needs to be available at /sys/firmware/efi/efivars/.");

if (n_options < 0)

return log_error_errno(n_options, "Failed to read EFI boot entries: %m");

n_order = efi_get_boot_order(&order);

if (n_order == -ENOENT)

n_order = 0;

else if (n_order < 0)

return log_error_errno(n_order, "Failed to read EFI boot order: %m");

/* print entries in BootOrder first */

printf("Boot Loaders Listed in EFI Variables:\n");

for (int i = 0; i < n_order; i++)

print_efi_option(order[i], true);

/* print remaining entries */

for (int i = 0; i < n_options; i++) {

for (int j = 0; j < n_order; j++)

if (options[i] == order[j])

goto next_option;

print_efi_option(options[i], false);

next_option:

continue;

}

return 0;

}

static int boot_entry_file_check(const char *root, const char *p) {

_cleanup_free_ char *path = NULL;

path = path_join(root, p);

if (!path)

return log_oom();

return RET_NERRNO(access(path, F_OK));

}

static void boot_entry_file_list(const char *field, const char *root, const char *p, int *ret_status) {

int status = boot_entry_file_check(root, p);

printf("%13s%s ", strempty(field), field ? ":" : " ");

if (status < 0) {

errno = -status;

printf("%s%s%s (%m)\n", ansi_highlight_red(), p, ansi_normal());

} else

printf("%s\n", p);

if (*ret_status == 0 && status < 0)

*ret_status = status;

}

static const char* const boot_entry_type_table[_BOOT_ENTRY_TYPE_MAX] = {

[BOOT_ENTRY_CONF] = "Boot Loader Specification Type #1 (.conf)",

[BOOT_ENTRY_UNIFIED] = "Boot Loader Specification Type #2 (.efi)",

[BOOT_ENTRY_LOADER] = "Reported by Boot Loader",

[BOOT_ENTRY_LOADER_AUTO] = "Automatic",

};

DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(boot_entry_type, BootEntryType);

static int boot_entry_show(

bool show_reported) {

int status = 0;

/* Returns 0 on success, negative on processing error, and positive if something is wrong with the

assert(e);

printf(" type: %s\n",

boot_entry_type_to_string(e->type));

printf(" title: %s%s%s",

ansi_highlight(), boot_entry_title(e), ansi_normal());

if (show_as_default)

printf(" %s(default)%s",

ansi_highlight_green(), ansi_normal());

if (show_as_selected)

printf(" %s(selected)%s",

ansi_highlight_magenta(), ansi_normal());

if (show_reported) {

if (e->type == BOOT_ENTRY_LOADER)

printf(" %s(reported/absent)%s",

ansi_highlight_red(), ansi_normal());

else if (!e->reported_by_loader && e->type != BOOT_ENTRY_LOADER_AUTO)

printf(" %s(not reported/new)%s",

ansi_highlight_green(), ansi_normal());

}

putchar('\n');

if (e->id)

printf(" id: %s\n", e->id);

if (e->path) {

_cleanup_free_ char *link = NULL;

/* Let's urlify the link to make it easy to view in an editor, but only if it is a text

if (e->type == BOOT_ENTRY_CONF)

(void) terminal_urlify_path(e->path, NULL, &link);

printf(" source: %s\n", link ?: e->path);

}

if (e->sort_key)

printf(" sort-key: %s\n", e->sort_key);

if (e->version)

printf(" version: %s\n", e->version);

if (e->machine_id)

printf(" machine-id: %s\n", e->machine_id);

if (e->architecture)

printf(" architecture: %s\n", e->architecture);

if (e->kernel)

boot_entry_file_list("linux", e->root, e->kernel, &status);

STRV_FOREACH(s, e->initrd)

boot_entry_file_list(s == e->initrd ? "initrd" : NULL,

e->root,

*s,

&status);

if (!strv_isempty(e->options)) {

_cleanup_free_ char *t = NULL, *t2 = NULL;

_cleanup_strv_free_ char **ts = NULL;

t = strv_join(e->options, " ");

if (!t)

return log_oom();

ts = strv_split_newlines(t);

if (!ts)

return log_oom();

t2 = strv_join(ts, "\n ");

if (!t2)

return log_oom();

printf(" options: %s\n", t2);

}

if (e->device_tree)

boot_entry_file_list("devicetree", e->root, e->device_tree, &status);

STRV_FOREACH(s, e->device_tree_overlay)

boot_entry_file_list(s == e->device_tree_overlay ? "devicetree-overlay" : NULL,

e->root,

*s,

&status);

return -status;

}

static int status_entries(

sd_id128_t xbootldr_partition_uuid) {

_cleanup_(boot_config_free) BootConfig config = BOOT_CONFIG_NULL;

sd_id128_t dollar_boot_partition_uuid;

const char *dollar_boot_path;

int r;

assert(esp_path || xbootldr_path);

if (xbootldr_path) {

dollar_boot_path = xbootldr_path;

dollar_boot_partition_uuid = xbootldr_partition_uuid;

} else {

dollar_boot_path = esp_path;

dollar_boot_partition_uuid = esp_partition_uuid;

}

printf("Boot Loader Entries:\n"

" $BOOT: %s", dollar_boot_path);

if (!sd_id128_is_null(dollar_boot_partition_uuid))

printf(" (/dev/disk/by-partuuid/" SD_ID128_UUID_FORMAT_STR ")",

SD_ID128_FORMAT_VAL(dollar_boot_partition_uuid));

printf("\n\n");

r = boot_config_load(&config, esp_path, xbootldr_path);

if (r < 0)

return r;

r = boot_config_select_special_entries(&config);

if (r < 0)

return r;

if (config.default_entry < 0)

printf("%zu entries, no entry could be determined as default.\n", config.n_entries);

else {

printf("Default Boot Loader Entry:\n");

r = boot_entry_show(

boot_config_default_entry(&config),

/* show_as_default= */ false,

/* show_as_selected= */ false,

/* show_discovered= */ false);

if (r > 0)

/* < 0 is already logged by the function itself, let's just emit an extra warning if

printf("\nWARNING: default boot entry is broken\n");

}

return 0;

}

static int compare_product(const char *a, const char *b) {

size_t x, y;

assert(a);

assert(b);

x = strcspn(a, " ");

y = strcspn(b, " ");

if (x != y)

return x < y ? -1 : x > y ? 1 : 0;

return strncmp(a, b, x);

}

static int compare_version(const char *a, const char *b) {

assert(a);

assert(b);

a += strcspn(a, " ");

a += strspn(a, " ");

b += strcspn(b, " ");

b += strspn(b, " ");

return strverscmp_improved(a, b);

}

static int version_check(int fd_from, const char *from, int fd_to, const char *to) {

_cleanup_free_ char *a = NULL, *b = NULL;

int r;

assert(fd_from >= 0);

assert(from);

assert(fd_to >= 0);

assert(to);

r = get_file_version(fd_from, &a);

if (r < 0)

return r;

if (r == 0)

return log_notice_errno(SYNTHETIC_ERRNO(EREMOTE),

"Source file \"%s\" does not carry version information!",

from);

r = get_file_version(fd_to, &b);

if (r < 0)

return r;

if (r == 0 || compare_product(a, b) != 0)

return log_notice_errno(SYNTHETIC_ERRNO(EREMOTE),

"Skipping \"%s\", since it's owned by another boot loader.",

to);

r = compare_version(a, b);

if (r < 0)

return log_warning_errno(SYNTHETIC_ERRNO(ESTALE), "Skipping \"%s\", since newer boot loader version in place already.", to);

else if (r == 0)

return log_info_errno(SYNTHETIC_ERRNO(ESTALE), "Skipping \"%s\", since same boot loader version in place already.", to);

return 0;

}

static int copy_file_with_version_check(const char *from, const char *to, bool force) {

_cleanup_close_ int fd_from = -1, fd_to = -1;

_cleanup_free_ char *t = NULL;

int r;

fd_from = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);

if (fd_from < 0)

return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", from);

if (!force) {

fd_to = open(to, O_RDONLY|O_CLOEXEC|O_NOCTTY);

if (fd_to < 0) {

if (errno != ENOENT)

return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", to);

} else {

r = version_check(fd_from, from, fd_to, to);

if (r < 0)

return r;

if (lseek(fd_from, 0, SEEK_SET) == (off_t) -1)

return log_error_errno(errno, "Failed to seek in \"%s\": %m", from);

fd_to = safe_close(fd_to);

}

}

r = tempfn_random(to, NULL, &t);

if (r < 0)

return log_oom();

RUN_WITH_UMASK(0000) {

fd_to = open(t, O_WRONLY|O_CREAT|O_CLOEXEC|O_EXCL|O_NOFOLLOW, 0644);

if (fd_to < 0)

return log_error_errno(errno, "Failed to open \"%s\" for writing: %m", t);

}

r = copy_bytes(fd_from, fd_to, UINT64_MAX, COPY_REFLINK);

if (r < 0) {

(void) unlink(t);

return log_error_errno(r, "Failed to copy data from \"%s\" to \"%s\": %m", from, t);

}

(void) copy_times(fd_from, fd_to, 0);

r = fsync_full(fd_to);

if (r < 0) {

(void) unlink_noerrno(t);

return log_error_errno(r, "Failed to copy data from \"%s\" to \"%s\": %m", from, t);

}

if (renameat(AT_FDCWD, t, AT_FDCWD, to) < 0) {

(void) unlink_noerrno(t);

return log_error_errno(errno, "Failed to rename \"%s\" to \"%s\": %m", t, to);

}

log_info("Copied \"%s\" to \"%s\".", from, to);

return 0;

}

static int mkdir_one(const char *prefix, const char *suffix) {

_cleanup_free_ char *p = NULL;

p = path_join(prefix, suffix);

if (mkdir(p, 0700) < 0) {

if (errno != EEXIST)

return log_error_errno(errno, "Failed to create \"%s\": %m", p);

} else

log_info("Created \"%s\".", p);

return 0;

}

static const char *const esp_subdirs[] = {

/* The directories to place in the ESP */

"EFI",

"EFI/systemd",

"EFI/BOOT",

"loader",

NULL

};

static const char *const dollar_boot_subdirs[] = {

/* The directories to place in the XBOOTLDR partition or the ESP, depending what exists */

"loader",

"loader/entries", /* Type #1 entries */

"EFI",

"EFI/Linux", /* Type #2 entries */

NULL

};

static int create_subdirs(const char *root, const char * const *subdirs) {

int r;

STRV_FOREACH(i, subdirs) {

r = mkdir_one(root, *i);

if (r < 0)

return r;

}

return 0;

}

static int copy_one_file(const char *esp_path, const char *name, bool force) {

const char *e;

char *p, *q, *dest_name, *s;

int r;

dest_name = strdupa_safe(name);

s = endswith_no_case(dest_name, ".signed");

if (s)

*s = 0;

p = strjoina(BOOTLIBDIR "/", name);

q = strjoina(esp_path, "/EFI/systemd/", dest_name);

r = copy_file_with_version_check(p, q, force);

e = startswith(dest_name, "systemd-boot");

if (e) {

int k;

char *v;

/* Create the EFI default boot loader name (specified for removable devices) */

v = strjoina(esp_path, "/EFI/BOOT/BOOT", e);

ascii_strupper(strrchr(v, '/') + 1);

k = copy_file_with_version_check(p, v, force);

if (k < 0 && r == 0)

r = k;

}

return r;

}

static int install_binaries(const char *esp_path, bool force) {

_cleanup_closedir_ DIR *d = NULL;

int r = 0;

d = opendir(BOOTLIBDIR);

if (!d)

return log_error_errno(errno, "Failed to open \""BOOTLIBDIR"\": %m");

FOREACH_DIRENT(de, d, return log_error_errno(errno, "Failed to read \""BOOTLIBDIR"\": %m")) {

int k;

if (!endswith_no_case(de->d_name, ".efi") && !endswith_no_case(de->d_name, ".efi.signed"))

continue;

/* skip the .efi file, if there's a .signed version of it */

if (endswith_no_case(de->d_name, ".efi")) {

_cleanup_free_ const char *s = strjoin(de->d_name, ".signed");

if (!s)

return log_oom();

if (faccessat(dirfd(d), s, F_OK, 0) >= 0)

continue;

}

k = copy_one_file(esp_path, de->d_name, force);

/* Don't propagate an error code if no update necessary, installed version already equal or

if (arg_graceful && IN_SET(k, -ESTALE, -EREMOTE))

continue;

if (k < 0 && r == 0)

r = k;

}

return r;

}

static bool same_entry(uint16_t id, sd_id128_t uuid, const char *path) {

_cleanup_free_ char *opath = NULL;

sd_id128_t ouuid;

int r;

r = efi_get_boot_option(id, NULL, &ouuid, &opath, NULL);

if (r < 0)

return false;

if (!sd_id128_equal(uuid, ouuid))

return false;

/* Some motherboards convert the path to uppercase under certain circumstances

if (!strcaseeq_ptr(path, opath))

return false;

return true;

}

static int find_slot(sd_id128_t uuid, const char *path, uint16_t *id) {

_cleanup_free_ uint16_t *options = NULL;

int n, i;

n = efi_get_boot_options(&options);

if (n < 0)

return n;

/* find already existing systemd-boot entry */

for (i = 0; i < n; i++)

if (same_entry(options[i], uuid, path)) {

*id = options[i];

return 1;