#include "pretty-print.h"
#include "rm-rf.h"
#include "stat-util.h"
+#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
#include "verbs.h"
#include "virt.h"
-static char *arg_path = NULL;
-static bool arg_print_path = false;
+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_DESTRUCTOR_REGISTER(arg_path, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_esp_path, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_xbootldr_path, 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(
bool unprivileged_mode,
char *np;
int r;
- /* Find the ESP, and log about errors. Note that find_esp_and_warn() will log in all error cases on its own,
- * except for ENOKEY (which is good, we want to show our own message in that case, suggesting use of --path=)
- * and EACCESS (only when we request unprivileged mode; in this case we simply eat up the error here, so that
- * --list and --status work too, without noise about this). */
+ /* Find the ESP, and log about errors. Note that find_esp_and_warn() will log in all error cases on
+ * its own, except for ENOKEY (which is good, we want to show our own message in that case,
+ * suggesting use of --esp-path=) and EACCESS (only when we request unprivileged mode; in this case
+ * we simply eat up the error here, so that --list and --status work too, without noise about
+ * this). */
- r = find_esp_and_warn(arg_path, unprivileged_mode, &np, ret_part, ret_pstart, ret_psize, ret_uuid);
+ r = find_esp_and_warn(arg_esp_path, unprivileged_mode, &np, ret_part, ret_pstart, ret_psize, ret_uuid);
if (r == -ENOKEY)
return log_error_errno(r,
"Couldn't find EFI system partition. It is recommended to mount it to /boot or /efi.\n"
- "Alternatively, use --path= to specify path to mount point.");
+ "Alternatively, use --esp-path= to specify path to mount point.");
if (r < 0)
return r;
- free_and_replace(arg_path, np);
+ free_and_replace(arg_esp_path, np);
+ log_debug("Using EFI System Partition at %s.", arg_esp_path);
- log_debug("Using EFI System Partition at %s.", arg_path);
+ return 1;
+}
- return 0;
+static int acquire_xbootldr(bool unprivileged_mode, sd_id128_t *ret_uuid) {
+ char *np;
+ int r;
+
+ r = find_xbootldr_and_warn(arg_xbootldr_path, unprivileged_mode, &np, ret_uuid);
+ if (r == -ENOKEY) {
+ log_debug_errno(r, "Didn't find an XBOOTLDR partition, using the ESP as $BOOT.");
+ if (ret_uuid)
+ *ret_uuid = SD_ID128_NULL;
+ 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;
}
/* search for "#### LoaderInfo: systemd-boot 218 ####" string inside the binary */
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(errno, "EFI binary is not a regular file: %m");
+
if (st.st_size < 27) {
*v = NULL;
return 0;
e = memmem(s, st.st_size - (s - buf), " ####", 5);
if (!e || e - s < 3) {
- log_error("Malformed version string.");
- r = -EINVAL;
+ r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Malformed version string.");
goto finish;
}
}
static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) {
- char *p;
_cleanup_closedir_ DIR *d = NULL;
struct dirent *de;
- int r = 0, c = 0;
+ int c = 0, r;
+ char *p;
+
+ assert(esp_path);
+ assert(path);
p = strjoina(esp_path, "/", path);
d = opendir(p);
}
FOREACH_DIRENT(de, d, break) {
- _cleanup_close_ int fd = -1;
_cleanup_free_ char *v = NULL;
+ _cleanup_close_ int fd = -1;
if (!endswith_no_case(de->d_name, ".efi"))
continue;
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++;
}
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.");
- else if (r < 0)
- return r;
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.");
- else if (r < 0)
- return r;
- printf("\n");
+ r = 0;
- return 0;
+finish:
+ printf("\n");
+ return r;
}
static int print_efi_option(uint16_t id, bool in_order) {
static int boot_entry_show(const BootEntry *e, bool show_as_default) {
assert(e);
- printf(" title: %s%s%s%s%s%s\n",
+ printf(" title: %s%s%s%s%s%s\n"
+ " type: %s\n",
ansi_highlight(),
boot_entry_title(e),
ansi_normal(),
ansi_highlight_green(),
show_as_default ? " (default)" : "",
- ansi_normal());
+ ansi_normal(),
+ boot_entry_type_to_string(e->type));
if (e->id)
printf(" id: %s\n", e->id);
return 0;
}
-static int status_entries(const char *esp_path, sd_id128_t partition) {
+static int status_entries(
+ const char *esp_path,
+ sd_id128_t esp_partition_uuid,
+ const char *xbootldr_path,
+ sd_id128_t xbootldr_partition_uuid) {
+
_cleanup_(boot_config_free) BootConfig config = {};
+ sd_id128_t dollar_boot_partition_uuid;
+ const char *dollar_boot_path;
int r;
- r = boot_entries_load_config(esp_path, &config);
+ 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/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x)", SD_ID128_FORMAT_VAL(dollar_boot_partition_uuid));
+ printf("\n\n");
+
+ r = boot_entries_load_config(esp_path, xbootldr_path, &config);
if (r < 0)
return r;
"Skipping \"%s\", since it's owned by another boot loader.",
to);
- if (compare_version(a, b) < 0) {
- log_warning("Skipping \"%s\", since a newer boot loader version exists already.", to);
- return -ESTALE;
- }
+ if (compare_version(a, b) < 0)
+ return log_warning_errno(SYNTHETIC_ERRNO(ESTALE), "Skipping \"%s\", since a newer boot loader version exists already.", to);
return 0;
}
return log_error_errno(r, "Failed to copy data from \"%s\" to \"%s\": %m", from, t);
}
- (void) copy_times(fd_from, fd_to);
+ (void) copy_times(fd_from, fd_to, 0);
if (fsync(fd_to) < 0) {
(void) unlink_noerrno(t);
}
static int mkdir_one(const char *prefix, const char *suffix) {
- char *p;
+ _cleanup_free_ char *p = NULL;
- p = strjoina(prefix, "/", suffix);
+ p = path_join(prefix, suffix);
if (mkdir(p, 0700) < 0) {
if (errno != EEXIST)
return log_error_errno(errno, "Failed to create \"%s\": %m", p);
return 0;
}
-static const char *efi_subdirs[] = {
+static const char *const esp_subdirs[] = {
"EFI",
"EFI/systemd",
"EFI/BOOT",
"loader",
- "loader/entries",
+ /* Note that "/loader/entries" is not listed here, since it should be placed in $BOOT, which might
+ * not necessarily be the ESP */
NULL
};
-static int create_dirs(const char *esp_path) {
- const char **i;
+static int create_esp_subdirs(const char *esp_path) {
+ const char *const *i;
int r;
- STRV_FOREACH(i, efi_subdirs) {
+ STRV_FOREACH(i, esp_subdirs) {
r = mkdir_one(esp_path, *i);
if (r < 0)
return r;
_cleanup_closedir_ DIR *d = NULL;
int r = 0;
- if (force) {
- /* Don't create any of these directories when we are
- * just updating. When we update we'll drop-in our
- * files (unless there are newer ones already), but we
- * won't create the directories for them in the first
- * place. */
- r = create_dirs(esp_path);
- if (r < 0)
- return r;
- }
-
d = opendir(BOOTLIBDIR);
if (!d)
return log_error_errno(errno, "Failed to open \""BOOTLIBDIR"\": %m");
- FOREACH_DIRENT(de, d, break) {
+ FOREACH_DIRENT(de, d, return log_error_errno(errno, "Failed to read \""BOOTLIBDIR"\": %m")) {
int k;
if (!endswith_no_case(de->d_name, ".efi"))
}
/* extend array */
- t = realloc(order, (n + 1) * sizeof(uint16_t));
+ t = reallocarray(order, n + 1, sizeof(uint16_t));
if (!t)
return -ENOMEM;
order = t;
p = strjoina(prefix, "/", suffix);
if (rmdir(p) < 0) {
- if (!IN_SET(errno, ENOENT, ENOTEMPTY))
- return log_error_errno(errno, "Failed to remove \"%s\": %m", p);
+ bool ignore = IN_SET(errno, ENOENT, ENOTEMPTY);
+
+ log_full_errno(ignore ? LOG_DEBUG : LOG_ERR, errno,
+ "Failed to remove directory \"%s\": %m", p);
+ if (!ignore)
+ return -errno;
} else
log_info("Removed \"%s\".", p);
return 0;
}
+static int remove_esp_subdirs(const char *esp_path) {
+ size_t i;
+ int r = 0;
+
+ for (i = ELEMENTSOF(esp_subdirs)-1; i > 0; i--) {
+ int q;
+
+ q = rmdir_one(esp_path, esp_subdirs[i-1]);
+ if (q < 0 && r >= 0)
+ r = q;
+ }
+
+ return r;
+}
+
static int remove_binaries(const char *esp_path) {
char *p;
int r, q;
- unsigned i;
p = strjoina(esp_path, "/EFI/systemd");
r = rm_rf(p, REMOVE_ROOT|REMOVE_PHYSICAL);
if (q < 0 && r == 0)
r = q;
- for (i = ELEMENTSOF(efi_subdirs)-1; i > 0; i--) {
- q = rmdir_one(esp_path, efi_subdirs[i-1]);
- if (q < 0 && r == 0)
- r = q;
- }
-
return r;
}
+static int remove_loader_config(const char *esp_path) {
+ const char *p;
+
+ assert(esp_path);
+
+ p = strjoina(esp_path, "/loader/loader.conf");
+ if (unlink(p) < 0) {
+ log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_ERR, errno, "Failed to unlink file \"%s\": %m", p);
+ if (errno != ENOENT)
+ return -errno;
+ } else
+ log_info("Removed \"%s\".", p);
+
+ return 0;
+}
+
+static int remove_entries_directory(const char *dollar_boot_path) {
+ assert(dollar_boot_path);
+
+ return rmdir_one(dollar_boot_path, "/loader/entries");
+}
+
static int remove_variables(sd_id128_t uuid, const char *path, bool in_order) {
uint16_t slot;
int r;
return 0;
}
-static int install_loader_config(const char *esp_path) {
-
+static int install_loader_config(const char *esp_path, sd_id128_t machine_id) {
char machine_string[SD_ID128_STRING_MAX];
_cleanup_(unlink_and_freep) char *t = NULL;
_cleanup_fclose_ FILE *f = NULL;
- sd_id128_t machine_id;
const char *p;
int r, fd;
- r = sd_id128_get_machine(&machine_id);
- if (r < 0)
- return log_error_errno(r, "Failed to get machine id: %m");
-
p = strjoina(esp_path, "/loader/loader.conf");
-
if (access(p, F_OK) >= 0) /* Silently skip creation if the file already exists (early check) */
return 0;
return log_error_errno(r, "Failed to move \"%s\" into place: %m", p);
t = mfree(t);
-
return 1;
}
+static int install_entries_directories(const char *dollar_boot_path, sd_id128_t machine_id) {
+ int r;
+ char buf[SD_ID128_STRING_MAX];
+
+ assert(dollar_boot_path);
+
+ /* Both /loader/entries and the entry directories themselves should be located on the same
+ * partition. Also create the parent directory for entry directories, so that kernel-install
+ * knows where to put them. */
+
+ r = mkdir_one(dollar_boot_path, "loader/entries");
+ if (r < 0)
+ return r;
+
+ return mkdir_one(dollar_boot_path, sd_id128_to_string(machine_id, buf));
+}
+
static int help(int argc, char *argv[], void *userdata) {
_cleanup_free_ char *link = NULL;
int r;
printf("%s [COMMAND] [OPTIONS...]\n\n"
"Install, update or remove the systemd-boot EFI boot manager.\n\n"
- " -h --help Show this help\n"
- " --version Print version\n"
- " --path=PATH Path to the EFI System Partition (ESP)\n"
- " -p --print-path Print path to the EFI partition\n"
- " --no-variables Don't touch EFI variables\n"
- " --no-pager Do not pipe output into a pager\n"
+ " -h --help Show this help\n"
+ " --version Print version\n"
+ " --esp-path=PATH Path to the EFI System Partition (ESP)\n"
+ " --boot-path=PATH Path to the $BOOT partition\n"
+ " -p --print-esp-path Print path to the EFI System Partition\n"
+ " --print-boot-path Print path to the $BOOT partition\n"
+ " --no-variables Don't touch EFI variables\n"
+ " --no-pager Do not pipe output into a pager\n"
"\nBoot Loader Commands:\n"
- " status Show status of installed systemd-boot and EFI variables\n"
- " install Install systemd-boot to the ESP and EFI variables\n"
- " update Update systemd-boot in the ESP and EFI variables\n"
- " remove Remove systemd-boot from the ESP and EFI variables\n"
+ " status Show status of installed systemd-boot and EFI variables\n"
+ " install Install systemd-boot to the ESP and EFI variables\n"
+ " update Update systemd-boot in the ESP and EFI variables\n"
+ " remove Remove systemd-boot from the ESP and EFI variables\n"
"\nBoot Loader Entries Commands:\n"
- " list List boot loader entries\n"
- " set-default ID Set default boot loader entry\n"
- " set-oneshot ID Set default boot loader entry, for next boot only\n"
+ " list List boot loader entries\n"
+ " set-default ID Set default boot loader entry\n"
+ " set-oneshot ID Set default boot loader entry, for next boot only\n"
"\nSee the %s for details.\n"
, program_invocation_short_name
, link);
static int parse_argv(int argc, char *argv[]) {
enum {
- ARG_PATH = 0x100,
+ ARG_ESP_PATH = 0x100,
+ ARG_BOOT_PATH,
+ ARG_PRINT_BOOT_PATH,
ARG_VERSION,
ARG_NO_VARIABLES,
ARG_NO_PAGER,
};
static const struct option options[] = {
- { "help", no_argument, NULL, 'h' },
- { "version", no_argument, NULL, ARG_VERSION },
- { "path", required_argument, NULL, ARG_PATH },
- { "print-path", no_argument, NULL, 'p' },
- { "no-variables", no_argument, NULL, ARG_NO_VARIABLES },
- { "no-pager", no_argument, NULL, ARG_NO_PAGER },
+ { "help", no_argument, NULL, 'h' },
+ { "version", no_argument, NULL, ARG_VERSION },
+ { "esp-path", required_argument, NULL, ARG_ESP_PATH },
+ { "path", required_argument, NULL, ARG_ESP_PATH }, /* Compatibility alias */
+ { "boot-path", required_argument, NULL, ARG_BOOT_PATH },
+ { "print-esp-path", no_argument, NULL, 'p' },
+ { "print-path", no_argument, NULL, 'p' }, /* Compatibility alias */
+ { "print-boot-path", no_argument, NULL, ARG_PRINT_BOOT_PATH },
+ { "no-variables", no_argument, NULL, ARG_NO_VARIABLES },
+ { "no-pager", no_argument, NULL, ARG_NO_PAGER },
{}
};
case ARG_VERSION:
return version();
- case ARG_PATH:
- r = free_and_strdup(&arg_path, optarg);
+ case ARG_ESP_PATH:
+ r = free_and_strdup(&arg_esp_path, optarg);
+ if (r < 0)
+ return log_oom();
+ break;
+
+ case ARG_BOOT_PATH:
+ r = free_and_strdup(&arg_xbootldr_path, optarg);
if (r < 0)
return log_oom();
break;
case 'p':
- arg_print_path = true;
+ arg_print_esp_path = true;
+ break;
+
+ case ARG_PRINT_BOOT_PATH:
+ arg_print_dollar_boot_path = true;
break;
case ARG_NO_VARIABLES:
}
static int verb_status(int argc, char *argv[], void *userdata) {
-
- sd_id128_t uuid = SD_ID128_NULL;
+ sd_id128_t esp_uuid = SD_ID128_NULL, xbootldr_uuid = SD_ID128_NULL;
int r, k;
- r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, &uuid);
-
- if (arg_print_path) {
+ r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, &esp_uuid);
+ if (arg_print_esp_path) {
if (r == -EACCES) /* If we couldn't acquire the ESP path, log about access errors (which is the only
* error the find_esp_and_warn() won't log on its own) */
- return log_error_errno(r, "Failed to determine ESP: %m");
+ return log_error_errno(r, "Failed to determine ESP location: %m");
if (r < 0)
return r;
- puts(arg_path);
- return 0;
+ puts(arg_esp_path);
+ }
+
+ r = acquire_xbootldr(geteuid() != 0, &xbootldr_uuid);
+ if (arg_print_dollar_boot_path) {
+ if (r == -EACCES)
+ return log_error_errno(r, "Failed to determine XBOOTLDR location: %m");
+ if (r < 0)
+ return r;
+
+ puts(arg_dollar_boot_path());
}
+ if (arg_print_esp_path || arg_print_dollar_boot_path)
+ return 0;
+
r = 0; /* If we couldn't determine the path, then don't consider that a problem from here on, just show what we
* can show */
} else
printf("System:\n Not booted with EFI\n\n");
- if (arg_path) {
- k = status_binaries(arg_path, uuid);
+ if (arg_esp_path) {
+ k = status_binaries(arg_esp_path, esp_uuid);
if (k < 0)
r = k;
}
r = k;
}
- if (arg_path) {
- k = status_entries(arg_path, uuid);
+ if (arg_esp_path || arg_xbootldr_path) {
+ k = status_entries(arg_esp_path, esp_uuid, arg_xbootldr_path, xbootldr_uuid);
if (k < 0)
r = k;
}
static int verb_list(int argc, char *argv[], void *userdata) {
_cleanup_(boot_config_free) BootConfig config = {};
- _cleanup_free_ char **found_by_loader = NULL;
- sd_id128_t uuid = SD_ID128_NULL;
int r;
/* If we lack privileges we invoke find_esp_and_warn() in "unprivileged mode" here, which does two things: turn
* off logging about access errors and turn off potentially privileged device probing. Here we're interested in
* the latter but not the former, hence request the mode, and log about EACCES. */
- r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, &uuid);
+ r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, NULL);
if (r == -EACCES) /* We really need the ESP path for this call, hence also log about access errors */
return log_error_errno(r, "Failed to determine ESP: %m");
if (r < 0)
return r;
- r = boot_entries_load_config(arg_path, &config);
+ r = acquire_xbootldr(geteuid() != 0, NULL);
+ if (r == -EACCES)
+ return log_error_errno(r, "Failed to determine XBOOTLDR partition: %m");
+ if (r < 0)
+ return r;
+
+ r = boot_entries_load_config(arg_esp_path, arg_xbootldr_path, &config);
if (r < 0)
return r;
- r = efi_loader_get_entries(&found_by_loader);
- if (r < 0 && !IN_SET(r, -ENOENT, -EOPNOTSUPP))
- log_debug_errno(r, "Failed to acquire boot loader discovered entries: %m");
+ (void) boot_entries_augment_from_loader(&config, false);
if (config.n_entries == 0)
log_info("No boot loader entries found.");
if (r < 0)
return r;
- puts("");
-
- strv_remove(found_by_loader, config.entries[n].id);
+ if (n+1 < config.n_entries)
+ putchar('\n');
}
}
- if (!strv_isempty(found_by_loader)) {
- char **i;
-
- printf("Automatic/Other Entries Found by Boot Loader:\n\n");
-
- STRV_FOREACH(i, found_by_loader)
- puts(*i);
- }
-
return 0;
}
-static int sync_esp(void) {
- _cleanup_close_ int fd = -1;
-
- if (!arg_path)
- return 0;
+static int sync_everything(void) {
+ int ret = 0, k;
- fd = open(arg_path, O_CLOEXEC|O_DIRECTORY|O_RDONLY);
- if (fd < 0)
- return log_error_errno(errno, "Couldn't open ESP '%s' for synchronization: %m", arg_path);
+ if (arg_esp_path) {
+ k = syncfs_path(AT_FDCWD, arg_esp_path);
+ if (k < 0)
+ ret = log_error_errno(k, "Failed to synchronize the ESP '%s': %m", arg_esp_path);
+ }
- if (syncfs(fd) < 0)
- return log_error_errno(errno, "Failed to synchronize the ESP '%s': %m", arg_path);
+ if (arg_xbootldr_path) {
+ k = syncfs_path(AT_FDCWD, arg_xbootldr_path);
+ if (k < 0)
+ ret = log_error_errno(k, "Failed to synchronize $BOOT '%s': %m", arg_xbootldr_path);
+ }
- return 1;
+ return ret;
}
static int verb_install(int argc, char *argv[], void *userdata) {
-
sd_id128_t uuid = SD_ID128_NULL;
uint64_t pstart = 0, psize = 0;
uint32_t part = 0;
+ sd_id128_t machine_id;
bool install;
int r;
if (r < 0)
return r;
+ r = acquire_xbootldr(false, NULL);
+ if (r < 0)
+ return r;
+
+ r = sd_id128_get_machine(&machine_id);
+ if (r < 0)
+ return log_error_errno(r, "Failed to get machine id: %m");
+
install = streq(argv[0], "install");
RUN_WITH_UMASK(0002) {
- r = install_binaries(arg_path, install);
+ if (install) {
+ /* Don't create any of these directories when we are just updating. When we update
+ * we'll drop-in our files (unless there are newer ones already), but we won't create
+ * the directories for them in the first place. */
+ r = create_esp_subdirs(arg_esp_path);
+ if (r < 0)
+ return r;
+ }
+
+ r = install_binaries(arg_esp_path, install);
if (r < 0)
return r;
if (install) {
- r = install_loader_config(arg_path);
+ r = install_loader_config(arg_esp_path, machine_id);
+ if (r < 0)
+ return r;
+
+ r = install_entries_directories(arg_dollar_boot_path(), machine_id);
if (r < 0)
return r;
}
}
- (void) sync_esp();
+ (void) sync_everything();
if (arg_touch_variables)
- r = install_variables(arg_path,
+ r = install_variables(arg_esp_path,
part, pstart, psize, uuid,
"/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi",
install);
static int verb_remove(int argc, char *argv[], void *userdata) {
sd_id128_t uuid = SD_ID128_NULL;
- int r;
+ int r, q;
r = acquire_esp(false, NULL, NULL, NULL, &uuid);
if (r < 0)
return r;
- r = remove_binaries(arg_path);
+ r = acquire_xbootldr(false, NULL);
+ if (r < 0)
+ return r;
- (void) sync_esp();
+ r = remove_binaries(arg_esp_path);
- if (arg_touch_variables) {
- int q;
+ q = remove_loader_config(arg_esp_path);
+ if (q < 0 && r >= 0)
+ r = q;
+
+ q = remove_entries_directory(arg_dollar_boot_path());
+ if (q < 0 && r >= 0)
+ r = q;
+ q = remove_esp_subdirs(arg_esp_path);
+ if (q < 0 && r >= 0)
+ r = q;
+
+ (void) sync_everything();
+
+ if (arg_touch_variables) {
q = remove_variables(uuid, "/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi", true);
- if (q < 0 && r == 0)
+ if (q < 0 && r >= 0)
r = q;
}
log_parse_environment();
log_open();
- /* If we run in a container, automatically turn of EFI file system access */
+ /* If we run in a container, automatically turn off EFI file system access */
if (detect_container() > 0)
arg_touch_variables = false;
projects / thirdparty / systemd.git / blobdiff