]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/boot/bootctl.c
projects / thirdparty / systemd.git / blob
? search:


66bc3dc342bc983770df955b6d30372ff20cfaea
[thirdparty/systemd.git] / src / boot / bootctl.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <blkid.h>
4 #include <ctype.h>
5 #include <dirent.h>
6 #include <errno.h>
7 #include <ftw.h>
8 #include <getopt.h>
9 #include <limits.h>
10 #include <linux/magic.h>
11 #include <stdbool.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <sys/mman.h>
16 #include <sys/stat.h>
17 #include <sys/statfs.h>
18 #include <unistd.h>
19
20 #include "sd-id128.h"
21
22 #include "alloc-util.h"
23 #include "blkid-util.h"
24 #include "bootspec.h"
25 #include "copy.h"
26 #include "dirent-util.h"
27 #include "efivars.h"
28 #include "escape.h"
29 #include "fd-util.h"
30 #include "fileio.h"
31 #include "fs-util.h"
32 #include "locale-util.h"
33 #include "main-func.h"
34 #include "pager.h"
35 #include "parse-util.h"
36 #include "pretty-print.h"
37 #include "rm-rf.h"
38 #include "stat-util.h"
39 #include "stdio-util.h"
40 #include "string-util.h"
41 #include "strv.h"
42 #include "terminal-util.h"
43 #include "tmpfile-util.h"
44 #include "umask-util.h"
45 #include "utf8.h"
46 #include "util.h"
47 #include "verbs.h"
48 #include "virt.h"
49
50 static char *arg_esp_path = NULL;
51 static char *arg_xbootldr_path = NULL;
52 static bool arg_print_esp_path = false;
53 static bool arg_print_dollar_boot_path = false;
54 static bool arg_touch_variables = true;
55 static PagerFlags arg_pager_flags = 0;
56
57 STATIC_DESTRUCTOR_REGISTER(arg_esp_path, freep);
58 STATIC_DESTRUCTOR_REGISTER(arg_xbootldr_path, freep);
59
60 static const char *arg_dollar_boot_path(void) {
61 /* $BOOT shall be the XBOOTLDR partition if it exists, and otherwise the ESP */
62 return arg_xbootldr_path ?: arg_esp_path;
63 }
64
65 static int acquire_esp(
66 bool unprivileged_mode,
67 uint32_t *ret_part,
68 uint64_t *ret_pstart,
69 uint64_t *ret_psize,
70 sd_id128_t *ret_uuid) {
71
72 char *np;
73 int r;
74
75 /* Find the ESP, and log about errors. Note that find_esp_and_warn() will log in all error cases on
76 * its own, except for ENOKEY (which is good, we want to show our own message in that case,
77 * suggesting use of --esp-path=) and EACCESS (only when we request unprivileged mode; in this case
78 * we simply eat up the error here, so that --list and --status work too, without noise about
79 * this). */
80
81 r = find_esp_and_warn(arg_esp_path, unprivileged_mode, &np, ret_part, ret_pstart, ret_psize, ret_uuid);
82 if (r == -ENOKEY)
83 return log_error_errno(r,
84 "Couldn't find EFI system partition. It is recommended to mount it to /boot or /efi.\n"
85 "Alternatively, use --esp-path= to specify path to mount point.");
86 if (r < 0)
87 return r;
88
89 free_and_replace(arg_esp_path, np);
90 log_debug("Using EFI System Partition at %s.", arg_esp_path);
91
92 return 1;
93 }
94
95 static int acquire_xbootldr(bool unprivileged_mode, sd_id128_t *ret_uuid) {
96 char *np;
97 int r;
98
99 r = find_xbootldr_and_warn(arg_xbootldr_path, unprivileged_mode, &np, ret_uuid);
100 if (r == -ENOKEY) {
101 log_debug_errno(r, "Didn't find an XBOOTLDR partition, using the ESP as $BOOT.");
102 if (ret_uuid)
103 *ret_uuid = SD_ID128_NULL;
104 return 0;
105 }
106 if (r < 0)
107 return r;
108
109 free_and_replace(arg_xbootldr_path, np);
110 log_debug("Using XBOOTLDR partition at %s as $BOOT.", arg_xbootldr_path);
111
112 return 1;
113 }
114
115 /* search for "#### LoaderInfo: systemd-boot 218 ####" string inside the binary */
116 static int get_file_version(int fd, char **v) {
117 struct stat st;
118 char *buf;
119 const char *s, *e;
120 char *x = NULL;
121 int r = 0;
122
123 assert(fd >= 0);
124 assert(v);
125
126 if (fstat(fd, &st) < 0)
127 return log_error_errno(errno, "Failed to stat EFI binary: %m");
128
129 r = stat_verify_regular(&st);
130 if (r < 0)
131 return log_error_errno(r, "EFI binary is not a regular file: %m");
132
133 if (st.st_size < 27) {
134 *v = NULL;
135 return 0;
136 }
137
138 buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
139 if (buf == MAP_FAILED)
140 return log_error_errno(errno, "Failed to memory map EFI binary: %m");
141
142 s = memmem(buf, st.st_size - 8, "#### LoaderInfo: ", 17);
143 if (!s)
144 goto finish;
145 s += 17;
146
147 e = memmem(s, st.st_size - (s - buf), " ####", 5);
148 if (!e || e - s < 3) {
149 r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Malformed version string.");
150 goto finish;
151 }
152
153 x = strndup(s, e - s);
154 if (!x) {
155 r = log_oom();
156 goto finish;
157 }
158 r = 1;
159
160 finish:
161 (void) munmap(buf, st.st_size);
162 *v = x;
163 return r;
164 }
165
166 static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) {
167 _cleanup_closedir_ DIR *d = NULL;
168 struct dirent *de;
169 const char *p;
170 int c = 0, r;
171
172 assert(esp_path);
173 assert(path);
174
175 p = prefix_roota(esp_path, path);
176 d = opendir(p);
177 if (!d) {
178 if (errno == ENOENT)
179 return 0;
180
181 return log_error_errno(errno, "Failed to read \"%s\": %m", p);
182 }
183
184 FOREACH_DIRENT(de, d, break) {
185 _cleanup_free_ char *v = NULL;
186 _cleanup_close_ int fd = -1;
187
188 if (!endswith_no_case(de->d_name, ".efi"))
189 continue;
190
191 if (prefix && !startswith_no_case(de->d_name, prefix))
192 continue;
193
194 fd = openat(dirfd(d), de->d_name, O_RDONLY|O_CLOEXEC);
195 if (fd < 0)
196 return log_error_errno(errno, "Failed to open \"%s/%s\" for reading: %m", p, de->d_name);
197
198 r = get_file_version(fd, &v);
199 if (r < 0)
200 return r;
201 if (r > 0)
202 printf(" File: %s/%s/%s (%s%s%s)\n", special_glyph(SPECIAL_GLYPH_TREE_RIGHT), path, de->d_name, ansi_highlight(), v, ansi_normal());
203 else
204 printf(" File: %s/%s/%s\n", special_glyph(SPECIAL_GLYPH_TREE_RIGHT), path, de->d_name);
205
206 c++;
207 }
208
209 return c;
210 }
211
212 static int status_binaries(const char *esp_path, sd_id128_t partition) {
213 int r;
214
215 printf("Available Boot Loaders on ESP:\n");
216
217 if (!esp_path) {
218 printf(" ESP: Cannot find or access mount point of ESP.\n\n");
219 return -ENOENT;
220 }
221
222 printf(" ESP: %s", esp_path);
223 if (!sd_id128_is_null(partition))
224 printf(" (/dev/disk/by-partuuid/" SD_ID128_UUID_FORMAT_STR ")", SD_ID128_FORMAT_VAL(partition));
225 printf("\n");
226
227 r = enumerate_binaries(esp_path, "EFI/systemd", NULL);
228 if (r < 0)
229 goto finish;
230 if (r == 0)
231 log_info("systemd-boot not installed in ESP.");
232
233 r = enumerate_binaries(esp_path, "EFI/BOOT", "boot");
234 if (r < 0)
235 goto finish;
236 if (r == 0)
237 log_info("No default/fallback boot loader installed in ESP.");
238
239 r = 0;
240
241 finish:
242 printf("\n");
243 return r;
244 }
245
246 static int print_efi_option(uint16_t id, bool in_order) {
247 _cleanup_free_ char *title = NULL;
248 _cleanup_free_ char *path = NULL;
249 sd_id128_t partition;
250 bool active;
251 int r = 0;
252
253 r = efi_get_boot_option(id, &title, &partition, &path, &active);
254 if (r < 0)
255 return r;
256
257 /* print only configured entries with partition information */
258 if (!path || sd_id128_is_null(partition))
259 return 0;
260
261 efi_tilt_backslashes(path);
262
263 printf(" Title: %s%s%s\n", ansi_highlight(), strna(title), ansi_normal());
264 printf(" ID: 0x%04X\n", id);
265 printf(" Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : "");
266 printf(" Partition: /dev/disk/by-partuuid/" SD_ID128_UUID_FORMAT_STR "\n",
267 SD_ID128_FORMAT_VAL(partition));
268 printf(" File: %s%s\n", special_glyph(SPECIAL_GLYPH_TREE_RIGHT), path);
269 printf("\n");
270
271 return 0;
272 }
273
274 static int status_variables(void) {
275 _cleanup_free_ uint16_t *options = NULL, *order = NULL;
276 int n_options, n_order, i;
277
278 n_options = efi_get_boot_options(&options);
279 if (n_options == -ENOENT)
280 return log_error_errno(n_options,
281 "Failed to access EFI variables, efivarfs"
282 " needs to be available at /sys/firmware/efi/efivars/.");
283 if (n_options < 0)
284 return log_error_errno(n_options, "Failed to read EFI boot entries: %m");
285
286 n_order = efi_get_boot_order(&order);
287 if (n_order == -ENOENT)
288 n_order = 0;
289 else if (n_order < 0)
290 return log_error_errno(n_order, "Failed to read EFI boot order: %m");
291
292 /* print entries in BootOrder first */
293 printf("Boot Loaders Listed in EFI Variables:\n");
294 for (i = 0; i < n_order; i++)
295 print_efi_option(order[i], true);
296
297 /* print remaining entries */
298 for (i = 0; i < n_options; i++) {
299 int j;
300
301 for (j = 0; j < n_order; j++)
302 if (options[i] == order[j])
303 goto next_option;
304
305 print_efi_option(options[i], false);
306
307 next_option:
308 continue;
309 }
310
311 return 0;
312 }
313
314 static int boot_entry_file_check(const char *root, const char *p) {
315 _cleanup_free_ char *path;
316
317 path = path_join(root, p);
318 if (!path)
319 return log_oom();
320
321 if (access(path, F_OK) < 0)
322 return -errno;
323
324 return 0;
325 }
326
327 static void boot_entry_file_list(const char *field, const char *root, const char *p, int *ret_status) {
328 int status = boot_entry_file_check(root, p);
329
330 printf("%13s%s ", strempty(field), field ? ":" : " ");
331 if (status < 0) {
332 errno = -status;
333 printf("%s%s%s (%m)\n", ansi_highlight_red(), p, ansi_normal());
334 } else
335 printf("%s\n", p);
336
337 if (*ret_status == 0 && status < 0)
338 *ret_status = status;
339 }
340
341 static int boot_entry_show(const BootEntry *e, bool show_as_default) {
342 int status = 0;
343
344 /* Returns 0 on success, negative on processing error, and positive if something is wrong with the
345 boot entry itself. */
346
347 assert(e);
348
349 printf(" title: %s%s%s" "%s%s%s\n",
350 ansi_highlight(), boot_entry_title(e), ansi_normal(),
351 ansi_highlight_green(), show_as_default ? " (default)" : "", ansi_normal());
352
353 if (e->id)
354 printf(" id: %s\n", e->id);
355 if (e->path) {
356 _cleanup_free_ char *link = NULL;
357
358 /* Let's urlify the link to make it easy to view in an editor, but only if it is a text
359 * file. Unified images are binary ELFs, and EFI variables are not pure text either. */
360 if (e->type == BOOT_ENTRY_CONF)
361 (void) terminal_urlify_path(e->path, NULL, &link);
362
363 printf(" source: %s\n", link ?: e->path);
364 }
365 if (e->version)
366 printf(" version: %s\n", e->version);
367 if (e->machine_id)
368 printf(" machine-id: %s\n", e->machine_id);
369 if (e->architecture)
370 printf(" architecture: %s\n", e->architecture);
371 if (e->kernel)
372 boot_entry_file_list("linux", e->root, e->kernel, &status);
373
374 char **s;
375 STRV_FOREACH(s, e->initrd)
376 boot_entry_file_list(s == e->initrd ? "initrd" : NULL,
377 e->root,
378 *s,
379 &status);
380 if (!strv_isempty(e->options)) {
381 _cleanup_free_ char *t = NULL, *t2 = NULL;
382 _cleanup_strv_free_ char **ts = NULL;
383
384 t = strv_join(e->options, " ");
385 if (!t)
386 return log_oom();
387
388 ts = strv_split_newlines(t);
389 if (!ts)
390 return log_oom();
391
392 t2 = strv_join(ts, "\n ");
393 if (!t2)
394 return log_oom();
395
396 printf(" options: %s\n", t2);
397 }
398 if (e->device_tree)
399 boot_entry_file_list("devicetree", e->root, e->device_tree, &status);
400
401 return -status;
402 }
403
404 static int status_entries(
405 const char *esp_path,
406 sd_id128_t esp_partition_uuid,
407 const char *xbootldr_path,
408 sd_id128_t xbootldr_partition_uuid) {
409
410 _cleanup_(boot_config_free) BootConfig config = {};
411 sd_id128_t dollar_boot_partition_uuid;
412 const char *dollar_boot_path;
413 int r;
414
415 assert(esp_path || xbootldr_path);
416
417 if (xbootldr_path) {
418 dollar_boot_path = xbootldr_path;
419 dollar_boot_partition_uuid = xbootldr_partition_uuid;
420 } else {
421 dollar_boot_path = esp_path;
422 dollar_boot_partition_uuid = esp_partition_uuid;
423 }
424
425 printf("Boot Loader Entries:\n"
426 " $BOOT: %s", dollar_boot_path);
427 if (!sd_id128_is_null(dollar_boot_partition_uuid))
428 printf(" (/dev/disk/by-partuuid/" SD_ID128_UUID_FORMAT_STR ")",
429 SD_ID128_FORMAT_VAL(dollar_boot_partition_uuid));
430 printf("\n\n");
431
432 r = boot_entries_load_config(esp_path, xbootldr_path, &config);
433 if (r < 0)
434 return r;
435
436 if (config.default_entry < 0)
437 printf("%zu entries, no entry could be determined as default.\n", config.n_entries);
438 else {
439 printf("Default Boot Loader Entry:\n");
440
441 r = boot_entry_show(config.entries + config.default_entry, false);
442 if (r > 0)
443 /* < 0 is already logged by the function itself, let's just emit an extra warning if
444 the default entry is broken */
445 printf("\nWARNING: default boot entry is broken\n");
446 }
447
448 return 0;
449 }
450
451 static int compare_product(const char *a, const char *b) {
452 size_t x, y;
453
454 assert(a);
455 assert(b);
456
457 x = strcspn(a, " ");
458 y = strcspn(b, " ");
459 if (x != y)
460 return x < y ? -1 : x > y ? 1 : 0;
461
462 return strncmp(a, b, x);
463 }
464
465 static int compare_version(const char *a, const char *b) {
466 assert(a);
467 assert(b);
468
469 a += strcspn(a, " ");
470 a += strspn(a, " ");
471 b += strcspn(b, " ");
472 b += strspn(b, " ");
473
474 return strverscmp(a, b);
475 }
476
477 static int version_check(int fd_from, const char *from, int fd_to, const char *to) {
478 _cleanup_free_ char *a = NULL, *b = NULL;
479 int r;
480
481 assert(fd_from >= 0);
482 assert(from);
483 assert(fd_to >= 0);
484 assert(to);
485
486 r = get_file_version(fd_from, &a);
487 if (r < 0)
488 return r;
489 if (r == 0)
490 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
491 "Source file \"%s\" does not carry version information!",
492 from);
493
494 r = get_file_version(fd_to, &b);
495 if (r < 0)
496 return r;
497 if (r == 0 || compare_product(a, b) != 0)
498 return log_notice_errno(SYNTHETIC_ERRNO(EEXIST),
499 "Skipping \"%s\", since it's owned by another boot loader.",
500 to);
501
502 if (compare_version(a, b) < 0)
503 return log_warning_errno(SYNTHETIC_ERRNO(ESTALE), "Skipping \"%s\", since a newer boot loader version exists already.", to);
504
505 return 0;
506 }
507
508 static int copy_file_with_version_check(const char *from, const char *to, bool force) {
509 _cleanup_close_ int fd_from = -1, fd_to = -1;
510 _cleanup_free_ char *t = NULL;
511 int r;
512
513 fd_from = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
514 if (fd_from < 0)
515 return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", from);
516
517 if (!force) {
518 fd_to = open(to, O_RDONLY|O_CLOEXEC|O_NOCTTY);
519 if (fd_to < 0) {
520 if (errno != -ENOENT)
521 return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", to);
522 } else {
523 r = version_check(fd_from, from, fd_to, to);
524 if (r < 0)
525 return r;
526
527 if (lseek(fd_from, 0, SEEK_SET) == (off_t) -1)
528 return log_error_errno(errno, "Failed to seek in \"%s\": %m", from);
529
530 fd_to = safe_close(fd_to);
531 }
532 }
533
534 r = tempfn_random(to, NULL, &t);
535 if (r < 0)
536 return log_oom();
537
538 RUN_WITH_UMASK(0000) {
539 fd_to = open(t, O_WRONLY|O_CREAT|O_CLOEXEC|O_EXCL|O_NOFOLLOW, 0644);
540 if (fd_to < 0)
541 return log_error_errno(errno, "Failed to open \"%s\" for writing: %m", t);
542 }
543
544 r = copy_bytes(fd_from, fd_to, (uint64_t) -1, COPY_REFLINK);
545 if (r < 0) {
546 (void) unlink(t);
547 return log_error_errno(r, "Failed to copy data from \"%s\" to \"%s\": %m", from, t);
548 }
549
550 (void) copy_times(fd_from, fd_to, 0);
551
552 if (fsync(fd_to) < 0) {
553 (void) unlink_noerrno(t);
554 return log_error_errno(errno, "Failed to copy data from \"%s\" to \"%s\": %m", from, t);
555 }
556
557 (void) fsync_directory_of_file(fd_to);
558
559 if (renameat(AT_FDCWD, t, AT_FDCWD, to) < 0) {
560 (void) unlink_noerrno(t);
561 return log_error_errno(errno, "Failed to rename \"%s\" to \"%s\": %m", t, to);
562 }
563
564 log_info("Copied \"%s\" to \"%s\".", from, to);
565
566 return 0;
567 }
568
569 static int mkdir_one(const char *prefix, const char *suffix) {
570 _cleanup_free_ char *p = NULL;
571
572 p = path_join(prefix, suffix);
573 if (mkdir(p, 0700) < 0) {
574 if (errno != EEXIST)
575 return log_error_errno(errno, "Failed to create \"%s\": %m", p);
576 } else
577 log_info("Created \"%s\".", p);
578
579 return 0;
580 }
581
582 static const char *const esp_subdirs[] = {
583 "EFI",
584 "EFI/systemd",
585 "EFI/BOOT",
586 "loader",
587 /* Note that "/loader/entries" is not listed here, since it should be placed in $BOOT, which might
588 * not necessarily be the ESP */
589 NULL
590 };
591
592 static int create_esp_subdirs(const char *esp_path) {
593 const char *const *i;
594 int r;
595
596 STRV_FOREACH(i, esp_subdirs) {
597 r = mkdir_one(esp_path, *i);
598 if (r < 0)
599 return r;
600 }
601
602 return 0;
603 }
604
605 static int copy_one_file(const char *esp_path, const char *name, bool force) {
606 const char *e;
607 char *p, *q;
608 int r;
609
610 p = strjoina(BOOTLIBDIR "/", name);
611 q = strjoina(esp_path, "/EFI/systemd/", name);
612 r = copy_file_with_version_check(p, q, force);
613
614 e = startswith(name, "systemd-boot");
615 if (e) {
616 int k;
617 char *v;
618
619 /* Create the EFI default boot loader name (specified for removable devices) */
620 v = strjoina(esp_path, "/EFI/BOOT/BOOT", e);
621 ascii_strupper(strrchr(v, '/') + 1);
622
623 k = copy_file_with_version_check(p, v, force);
624 if (k < 0 && r == 0)
625 r = k;
626 }
627
628 return r;
629 }
630
631 static int install_binaries(const char *esp_path, bool force) {
632 struct dirent *de;
633 _cleanup_closedir_ DIR *d = NULL;
634 int r = 0;
635
636 d = opendir(BOOTLIBDIR);
637 if (!d)
638 return log_error_errno(errno, "Failed to open \""BOOTLIBDIR"\": %m");
639
640 FOREACH_DIRENT(de, d, return log_error_errno(errno, "Failed to read \""BOOTLIBDIR"\": %m")) {
641 int k;
642
643 if (!endswith_no_case(de->d_name, ".efi"))
644 continue;
645
646 k = copy_one_file(esp_path, de->d_name, force);
647 if (k < 0 && r == 0)
648 r = k;
649 }
650
651 return r;
652 }
653
654 static bool same_entry(uint16_t id, sd_id128_t uuid, const char *path) {
655 _cleanup_free_ char *opath = NULL;
656 sd_id128_t ouuid;
657 int r;
658
659 r = efi_get_boot_option(id, NULL, &ouuid, &opath, NULL);
660 if (r < 0)
661 return false;
662 if (!sd_id128_equal(uuid, ouuid))
663 return false;
664 if (!streq_ptr(path, opath))
665 return false;
666
667 return true;
668 }
669
670 static int find_slot(sd_id128_t uuid, const char *path, uint16_t *id) {
671 _cleanup_free_ uint16_t *options = NULL;
672 int n, i;
673
674 n = efi_get_boot_options(&options);
675 if (n < 0)
676 return n;
677
678 /* find already existing systemd-boot entry */
679 for (i = 0; i < n; i++)
680 if (same_entry(options[i], uuid, path)) {
681 *id = options[i];
682 return 1;
683 }
684
685 /* find free slot in the sorted BootXXXX variable list */
686 for (i = 0; i < n; i++)
687 if (i != options[i]) {
688 *id = i;
689 return 1;
690 }
691
692 /* use the next one */
693 if (i == 0xffff)
694 return -ENOSPC;
695 *id = i;
696 return 0;
697 }
698
699 static int insert_into_order(uint16_t slot, bool first) {
700 _cleanup_free_ uint16_t *order = NULL;
701 uint16_t *t;
702 int n, i;
703
704 n = efi_get_boot_order(&order);
705 if (n <= 0)
706 /* no entry, add us */
707 return efi_set_boot_order(&slot, 1);
708
709 /* are we the first and only one? */
710 if (n == 1 && order[0] == slot)
711 return 0;
712
713 /* are we already in the boot order? */
714 for (i = 0; i < n; i++) {
715 if (order[i] != slot)
716 continue;
717
718 /* we do not require to be the first one, all is fine */
719 if (!first)
720 return 0;
721
722 /* move us to the first slot */
723 memmove(order + 1, order, i * sizeof(uint16_t));
724 order[0] = slot;
725 return efi_set_boot_order(order, n);
726 }
727
728 /* extend array */
729 t = reallocarray(order, n + 1, sizeof(uint16_t));
730 if (!t)
731 return -ENOMEM;
732 order = t;
733
734 /* add us to the top or end of the list */
735 if (first) {
736 memmove(order + 1, order, n * sizeof(uint16_t));
737 order[0] = slot;
738 } else
739 order[n] = slot;
740
741 return efi_set_boot_order(order, n + 1);
742 }
743
744 static int remove_from_order(uint16_t slot) {
745 _cleanup_free_ uint16_t *order = NULL;
746 int n, i;
747
748 n = efi_get_boot_order(&order);
749 if (n <= 0)
750 return n;
751
752 for (i = 0; i < n; i++) {
753 if (order[i] != slot)
754 continue;
755
756 if (i + 1 < n)
757 memmove(order + i, order + i+1, (n - i) * sizeof(uint16_t));
758 return efi_set_boot_order(order, n - 1);
759 }
760
761 return 0;
762 }
763
764 static int install_variables(const char *esp_path,
765 uint32_t part, uint64_t pstart, uint64_t psize,
766 sd_id128_t uuid, const char *path,
767 bool first) {
768 const char *p;
769 uint16_t slot;
770 int r;
771
772 if (!is_efi_boot()) {
773 log_warning("Not booted with EFI, skipping EFI variable setup.");
774 return 0;
775 }
776
777 p = prefix_roota(esp_path, path);
778 if (access(p, F_OK) < 0) {
779 if (errno == ENOENT)
780 return 0;
781
782 return log_error_errno(errno, "Cannot access \"%s\": %m", p);
783 }
784
785 r = find_slot(uuid, path, &slot);
786 if (r < 0)
787 return log_error_errno(r,
788 r == -ENOENT ?
789 "Failed to access EFI variables. Is the \"efivarfs\" filesystem mounted?" :
790 "Failed to determine current boot order: %m");
791
792 if (first || r == 0) {
793 r = efi_add_boot_option(slot, "Linux Boot Manager",
794 part, pstart, psize,
795 uuid, path);
796 if (r < 0)
797 return log_error_errno(r, "Failed to create EFI Boot variable entry: %m");
798
799 log_info("Created EFI boot entry \"Linux Boot Manager\".");
800 }
801
802 return insert_into_order(slot, first);
803 }
804
805 static int remove_boot_efi(const char *esp_path) {
806 _cleanup_closedir_ DIR *d = NULL;
807 struct dirent *de;
808 const char *p;
809 int r, c = 0;
810
811 p = prefix_roota(esp_path, "/EFI/BOOT");
812 d = opendir(p);
813 if (!d) {
814 if (errno == ENOENT)
815 return 0;
816
817 return log_error_errno(errno, "Failed to open directory \"%s\": %m", p);
818 }
819
820 FOREACH_DIRENT(de, d, break) {
821 _cleanup_close_ int fd = -1;
822 _cleanup_free_ char *v = NULL;
823
824 if (!endswith_no_case(de->d_name, ".efi"))
825 continue;
826
827 if (!startswith_no_case(de->d_name, "boot"))
828 continue;
829
830 fd = openat(dirfd(d), de->d_name, O_RDONLY|O_CLOEXEC);
831 if (fd < 0)
832 return log_error_errno(errno, "Failed to open \"%s/%s\" for reading: %m", p, de->d_name);
833
834 r = get_file_version(fd, &v);
835 if (r < 0)
836 return r;
837 if (r > 0 && startswith(v, "systemd-boot ")) {
838 r = unlinkat(dirfd(d), de->d_name, 0);
839 if (r < 0)
840 return log_error_errno(errno, "Failed to remove \"%s/%s\": %m", p, de->d_name);
841
842 log_info("Removed \"%s/%s\".", p, de->d_name);
843 }
844
845 c++;
846 }
847
848 return c;
849 }
850
851 static int rmdir_one(const char *prefix, const char *suffix) {
852 const char *p;
853
854 p = prefix_roota(prefix, suffix);
855 if (rmdir(p) < 0) {
856 bool ignore = IN_SET(errno, ENOENT, ENOTEMPTY);
857
858 log_full_errno(ignore ? LOG_DEBUG : LOG_ERR, errno,
859 "Failed to remove directory \"%s\": %m", p);
860 if (!ignore)
861 return -errno;
862 } else
863 log_info("Removed \"%s\".", p);
864
865 return 0;
866 }
867
868 static int remove_esp_subdirs(const char *esp_path) {
869 size_t i;
870 int r = 0;
871
872 for (i = ELEMENTSOF(esp_subdirs)-1; i > 0; i--) {
873 int q;
874
875 q = rmdir_one(esp_path, esp_subdirs[i-1]);
876 if (q < 0 && r >= 0)
877 r = q;
878 }
879
880 return r;
881 }
882
883 static int remove_binaries(const char *esp_path) {
884 const char *p;
885 int r, q;
886
887 p = prefix_roota(esp_path, "/EFI/systemd");
888 r = rm_rf(p, REMOVE_ROOT|REMOVE_PHYSICAL);
889
890 q = remove_boot_efi(esp_path);
891 if (q < 0 && r == 0)
892 r = q;
893
894 return r;
895 }
896
897 static int remove_loader_config(const char *esp_path) {
898 const char *p;
899
900 assert(esp_path);
901
902 p = prefix_roota(esp_path, "/loader/loader.conf");
903 if (unlink(p) < 0) {
904 log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_ERR, errno, "Failed to unlink file \"%s\": %m", p);
905 if (errno != ENOENT)
906 return -errno;
907 } else
908 log_info("Removed \"%s\".", p);
909
910 return 0;
911 }
912
913 static int remove_entries_directory(const char *dollar_boot_path) {
914 assert(dollar_boot_path);
915
916 return rmdir_one(dollar_boot_path, "/loader/entries");
917 }
918
919 static int remove_variables(sd_id128_t uuid, const char *path, bool in_order) {
920 uint16_t slot;
921 int r;
922
923 if (!is_efi_boot())
924 return 0;
925
926 r = find_slot(uuid, path, &slot);
927 if (r != 1)
928 return 0;
929
930 r = efi_remove_boot_option(slot);
931 if (r < 0)
932 return r;
933
934 if (in_order)
935 return remove_from_order(slot);
936
937 return 0;
938 }
939
940 static int install_loader_config(const char *esp_path, sd_id128_t machine_id) {
941 char machine_string[SD_ID128_STRING_MAX];
942 _cleanup_(unlink_and_freep) char *t = NULL;
943 _cleanup_fclose_ FILE *f = NULL;
944 const char *p;
945 int r, fd;
946
947 p = prefix_roota(esp_path, "/loader/loader.conf");
948 if (access(p, F_OK) >= 0) /* Silently skip creation if the file already exists (early check) */
949 return 0;
950
951 fd = open_tmpfile_linkable(p, O_WRONLY|O_CLOEXEC, &t);
952 if (fd < 0)
953 return log_error_errno(fd, "Failed to open \"%s\" for writing: %m", p);
954
955 f = fdopen(fd, "w");
956 if (!f) {
957 safe_close(fd);
958 return log_oom();
959 }
960
961 fprintf(f, "#timeout 3\n"
962 "#console-mode keep\n"
963 "default %s-*\n", sd_id128_to_string(machine_id, machine_string));
964
965 r = fflush_sync_and_check(f);
966 if (r < 0)
967 return log_error_errno(r, "Failed to write \"%s\": %m", p);
968
969 r = link_tmpfile(fd, t, p);
970 if (r == -EEXIST)
971 return 0; /* Silently skip creation if the file exists now (recheck) */
972 if (r < 0)
973 return log_error_errno(r, "Failed to move \"%s\" into place: %m", p);
974
975 t = mfree(t);
976 return 1;
977 }
978
979 static int install_entries_directories(const char *dollar_boot_path, sd_id128_t machine_id) {
980 int r;
981 char buf[SD_ID128_STRING_MAX];
982
983 assert(dollar_boot_path);
984
985 /* Both /loader/entries and the entry directories themselves should be located on the same
986 * partition. Also create the parent directory for entry directories, so that kernel-install
987 * knows where to put them. */
988
989 r = mkdir_one(dollar_boot_path, "loader/entries");
990 if (r < 0)
991 return r;
992
993 return mkdir_one(dollar_boot_path, sd_id128_to_string(machine_id, buf));
994 }
995
996 static int help(int argc, char *argv[], void *userdata) {
997 _cleanup_free_ char *link = NULL;
998 int r;
999
1000 r = terminal_urlify_man("bootctl", "1", &link);
1001 if (r < 0)
1002 return log_oom();
1003
1004 printf("%s [COMMAND] [OPTIONS...]\n\n"
1005 "Install, update or remove the systemd-boot EFI boot manager.\n\n"
1006 " -h --help Show this help\n"
1007 " --version Print version\n"
1008 " --esp-path=PATH Path to the EFI System Partition (ESP)\n"
1009 " --boot-path=PATH Path to the $BOOT partition\n"
1010 " -p --print-esp-path Print path to the EFI System Partition\n"
1011 " -x --print-boot-path Print path to the $BOOT partition\n"
1012 " --no-variables Don't touch EFI variables\n"
1013 " --no-pager Do not pipe output into a pager\n"
1014 "\nBoot Loader Commands:\n"
1015 " status Show status of installed systemd-boot and EFI variables\n"
1016 " install Install systemd-boot to the ESP and EFI variables\n"
1017 " update Update systemd-boot in the ESP and EFI variables\n"
1018 " remove Remove systemd-boot from the ESP and EFI variables\n"
1019 "\nBoot Loader Entries Commands:\n"
1020 " list List boot loader entries\n"
1021 " set-default ID Set default boot loader entry\n"
1022 " set-oneshot ID Set default boot loader entry, for next boot only\n"
1023 "\nSee the %s for details.\n"
1024 , program_invocation_short_name
1025 , link);
1026
1027 return 0;
1028 }
1029
1030 static int parse_argv(int argc, char *argv[]) {
1031 enum {
1032 ARG_ESP_PATH = 0x100,
1033 ARG_BOOT_PATH,
1034 ARG_VERSION,
1035 ARG_NO_VARIABLES,
1036 ARG_NO_PAGER,
1037 };
1038
1039 static const struct option options[] = {
1040 { "help", no_argument, NULL, 'h' },
1041 { "version", no_argument, NULL, ARG_VERSION },
1042 { "esp-path", required_argument, NULL, ARG_ESP_PATH },
1043 { "path", required_argument, NULL, ARG_ESP_PATH }, /* Compatibility alias */
1044 { "boot-path", required_argument, NULL, ARG_BOOT_PATH },
1045 { "print-esp-path", no_argument, NULL, 'p' },
1046 { "print-path", no_argument, NULL, 'p' }, /* Compatibility alias */
1047 { "print-boot-path", no_argument, NULL, 'x' },
1048 { "no-variables", no_argument, NULL, ARG_NO_VARIABLES },
1049 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
1050 {}
1051 };
1052
1053 int c, r;
1054
1055 assert(argc >= 0);
1056 assert(argv);
1057
1058 while ((c = getopt_long(argc, argv, "hpx", options, NULL)) >= 0)
1059 switch (c) {
1060
1061 case 'h':
1062 help(0, NULL, NULL);
1063 return 0;
1064
1065 case ARG_VERSION:
1066 return version();
1067
1068 case ARG_ESP_PATH:
1069 r = free_and_strdup(&arg_esp_path, optarg);
1070 if (r < 0)
1071 return log_oom();
1072 break;
1073
1074 case ARG_BOOT_PATH:
1075 r = free_and_strdup(&arg_xbootldr_path, optarg);
1076 if (r < 0)
1077 return log_oom();
1078 break;
1079
1080 case 'p':
1081 if (arg_print_dollar_boot_path)
1082 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1083 "--print-boot-path/-x cannot be combined with --print-esp-path/-p");
1084 arg_print_esp_path = true;
1085 break;
1086
1087 case 'x':
1088 if (arg_print_esp_path)
1089 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1090 "--print-boot-path/-x cannot be combined with --print-esp-path/-p");
1091 arg_print_dollar_boot_path = true;
1092 break;
1093
1094 case ARG_NO_VARIABLES:
1095 arg_touch_variables = false;
1096 break;
1097
1098 case ARG_NO_PAGER:
1099 arg_pager_flags |= PAGER_DISABLE;
1100 break;
1101
1102 case '?':
1103 return -EINVAL;
1104
1105 default:
1106 assert_not_reached("Unknown option");
1107 }
1108
1109 return 1;
1110 }
1111
1112 static void read_loader_efi_var(const char *name, char **var) {
1113 int r;
1114
1115 r = efi_get_variable_string(EFI_VENDOR_LOADER, name, var);
1116 if (r < 0 && r != -ENOENT)
1117 log_warning_errno(r, "Failed to read EFI variable %s: %m", name);
1118 }
1119
1120 static int verb_status(int argc, char *argv[], void *userdata) {
1121 sd_id128_t esp_uuid = SD_ID128_NULL, xbootldr_uuid = SD_ID128_NULL;
1122 int r, k;
1123
1124 r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, &esp_uuid);
1125 if (arg_print_esp_path) {
1126 if (r == -EACCES) /* If we couldn't acquire the ESP path, log about access errors (which is the only
1127 * error the find_esp_and_warn() won't log on its own) */
1128 return log_error_errno(r, "Failed to determine ESP location: %m");
1129 if (r < 0)
1130 return r;
1131
1132 puts(arg_esp_path);
1133 }
1134
1135 r = acquire_xbootldr(geteuid() != 0, &xbootldr_uuid);
1136 if (arg_print_dollar_boot_path) {
1137 if (r == -EACCES)
1138 return log_error_errno(r, "Failed to determine XBOOTLDR location: %m");
1139 if (r < 0)
1140 return r;
1141
1142 puts(arg_dollar_boot_path());
1143 }
1144
1145 if (arg_print_esp_path || arg_print_dollar_boot_path)
1146 return 0;
1147
1148 r = 0; /* If we couldn't determine the path, then don't consider that a problem from here on, just show what we
1149 * can show */
1150
1151 (void) pager_open(arg_pager_flags);
1152
1153 if (is_efi_boot()) {
1154 static const struct {
1155 uint64_t flag;
1156 const char *name;
1157 } flags[] = {
1158 { EFI_LOADER_FEATURE_BOOT_COUNTING, "Boot counting" },
1159 { EFI_LOADER_FEATURE_CONFIG_TIMEOUT, "Menu timeout control" },
1160 { EFI_LOADER_FEATURE_CONFIG_TIMEOUT_ONE_SHOT, "One-shot menu timeout control" },
1161 { EFI_LOADER_FEATURE_ENTRY_DEFAULT, "Default entry control" },
1162 { EFI_LOADER_FEATURE_ENTRY_ONESHOT, "One-shot entry control" },
1163 { EFI_LOADER_FEATURE_XBOOTLDR, "Support for XBOOTLDR partition" },
1164 };
1165
1166 _cleanup_free_ char *fw_type = NULL, *fw_info = NULL, *loader = NULL, *loader_path = NULL, *stub = NULL;
1167 sd_id128_t loader_part_uuid = SD_ID128_NULL;
1168 uint64_t loader_features = 0;
1169 size_t i;
1170
1171 read_loader_efi_var("LoaderFirmwareType", &fw_type);
1172 read_loader_efi_var("LoaderFirmwareInfo", &fw_info);
1173 read_loader_efi_var("LoaderInfo", &loader);
1174 read_loader_efi_var("StubInfo", &stub);
1175 read_loader_efi_var("LoaderImageIdentifier", &loader_path);
1176 (void) efi_loader_get_features(&loader_features);
1177
1178 if (loader_path)
1179 efi_tilt_backslashes(loader_path);
1180
1181 k = efi_loader_get_device_part_uuid(&loader_part_uuid);
1182 if (k < 0 && k != -ENOENT)
1183 r = log_warning_errno(k, "Failed to read EFI variable LoaderDevicePartUUID: %m");
1184
1185 printf("System:\n");
1186 printf(" Firmware: %s%s (%s)%s\n", ansi_highlight(), strna(fw_type), strna(fw_info), ansi_normal());
1187 printf(" Secure Boot: %sd\n", enable_disable(is_efi_secure_boot()));
1188 printf(" Setup Mode: %s\n", is_efi_secure_boot_setup_mode() ? "setup" : "user");
1189 printf("\n");
1190
1191 printf("Current Boot Loader:\n");
1192 printf(" Product: %s%s%s\n", ansi_highlight(), strna(loader), ansi_normal());
1193
1194 for (i = 0; i < ELEMENTSOF(flags); i++) {
1195
1196 if (i == 0)
1197 printf(" Features: ");
1198 else
1199 printf(" ");
1200
1201 if (FLAGS_SET(loader_features, flags[i].flag))
1202 printf("%s%s%s %s\n", ansi_highlight_green(), special_glyph(SPECIAL_GLYPH_CHECK_MARK), ansi_normal(), flags[i].name);
1203 else
1204 printf("%s%s%s %s\n", ansi_highlight_red(), special_glyph(SPECIAL_GLYPH_CROSS_MARK), ansi_normal(), flags[i].name);
1205 }
1206
1207 if (stub)
1208 printf(" Stub: %s\n", stub);
1209 if (!sd_id128_is_null(loader_part_uuid))
1210 printf(" ESP: /dev/disk/by-partuuid/" SD_ID128_UUID_FORMAT_STR "\n",
1211 SD_ID128_FORMAT_VAL(loader_part_uuid));
1212 else
1213 printf(" ESP: n/a\n");
1214 printf(" File: %s%s\n", special_glyph(SPECIAL_GLYPH_TREE_RIGHT), strna(loader_path));
1215 printf("\n");
1216 } else
1217 printf("System:\n Not booted with EFI\n\n");
1218
1219 if (arg_esp_path) {
1220 k = status_binaries(arg_esp_path, esp_uuid);
1221 if (k < 0)
1222 r = k;
1223 }
1224
1225 if (is_efi_boot()) {
1226 k = status_variables();
1227 if (k < 0)
1228 r = k;
1229 }
1230
1231 if (arg_esp_path || arg_xbootldr_path) {
1232 k = status_entries(arg_esp_path, esp_uuid, arg_xbootldr_path, xbootldr_uuid);
1233 if (k < 0)
1234 r = k;
1235 }
1236
1237 return r;
1238 }
1239
1240 static int verb_list(int argc, char *argv[], void *userdata) {
1241 _cleanup_(boot_config_free) BootConfig config = {};
1242 int r;
1243
1244 /* If we lack privileges we invoke find_esp_and_warn() in "unprivileged mode" here, which does two things: turn
1245 * off logging about access errors and turn off potentially privileged device probing. Here we're interested in
1246 * the latter but not the former, hence request the mode, and log about EACCES. */
1247
1248 r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, NULL);
1249 if (r == -EACCES) /* We really need the ESP path for this call, hence also log about access errors */
1250 return log_error_errno(r, "Failed to determine ESP: %m");
1251 if (r < 0)
1252 return r;
1253
1254 r = acquire_xbootldr(geteuid() != 0, NULL);
1255 if (r == -EACCES)
1256 return log_error_errno(r, "Failed to determine XBOOTLDR partition: %m");
1257 if (r < 0)
1258 return r;
1259
1260 r = boot_entries_load_config(arg_esp_path, arg_xbootldr_path, &config);
1261 if (r < 0)
1262 return r;
1263
1264 (void) boot_entries_augment_from_loader(&config, false);
1265
1266 if (config.n_entries == 0)
1267 log_info("No boot loader entries found.");
1268 else {
1269 size_t n;
1270
1271 (void) pager_open(arg_pager_flags);
1272
1273 printf("Boot Loader Entries:\n");
1274
1275 for (n = 0; n < config.n_entries; n++) {
1276 r = boot_entry_show(config.entries + n, n == (size_t) config.default_entry);
1277 if (r < 0)
1278 return r;
1279
1280 if (n+1 < config.n_entries)
1281 putchar('\n');
1282 }
1283 }
1284
1285 return 0;
1286 }
1287
1288 static int sync_everything(void) {
1289 int ret = 0, k;
1290
1291 if (arg_esp_path) {
1292 k = syncfs_path(AT_FDCWD, arg_esp_path);
1293 if (k < 0)
1294 ret = log_error_errno(k, "Failed to synchronize the ESP '%s': %m", arg_esp_path);
1295 }
1296
1297 if (arg_xbootldr_path) {
1298 k = syncfs_path(AT_FDCWD, arg_xbootldr_path);
1299 if (k < 0)
1300 ret = log_error_errno(k, "Failed to synchronize $BOOT '%s': %m", arg_xbootldr_path);
1301 }
1302
1303 return ret;
1304 }
1305
1306 static int verb_install(int argc, char *argv[], void *userdata) {
1307 sd_id128_t uuid = SD_ID128_NULL;
1308 uint64_t pstart = 0, psize = 0;
1309 uint32_t part = 0;
1310 sd_id128_t machine_id;
1311 bool install;
1312 int r;
1313
1314 r = acquire_esp(false, &part, &pstart, &psize, &uuid);
1315 if (r < 0)
1316 return r;
1317
1318 r = acquire_xbootldr(false, NULL);
1319 if (r < 0)
1320 return r;
1321
1322 r = sd_id128_get_machine(&machine_id);
1323 if (r < 0)
1324 return log_error_errno(r, "Failed to get machine id: %m");
1325
1326 install = streq(argv[0], "install");
1327
1328 RUN_WITH_UMASK(0002) {
1329 if (install) {
1330 /* Don't create any of these directories when we are just updating. When we update
1331 * we'll drop-in our files (unless there are newer ones already), but we won't create
1332 * the directories for them in the first place. */
1333 r = create_esp_subdirs(arg_esp_path);
1334 if (r < 0)
1335 return r;
1336 }
1337
1338 r = install_binaries(arg_esp_path, install);
1339 if (r < 0)
1340 return r;
1341
1342 if (install) {
1343 r = install_loader_config(arg_esp_path, machine_id);
1344 if (r < 0)
1345 return r;
1346
1347 r = install_entries_directories(arg_dollar_boot_path(), machine_id);
1348 if (r < 0)
1349 return r;
1350 }
1351 }
1352
1353 (void) sync_everything();
1354
1355 if (arg_touch_variables)
1356 r = install_variables(arg_esp_path,
1357 part, pstart, psize, uuid,
1358 "/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi",
1359 install);
1360
1361 return r;
1362 }
1363
1364 static int verb_remove(int argc, char *argv[], void *userdata) {
1365 sd_id128_t uuid = SD_ID128_NULL;
1366 int r, q;
1367
1368 r = acquire_esp(false, NULL, NULL, NULL, &uuid);
1369 if (r < 0)
1370 return r;
1371
1372 r = acquire_xbootldr(false, NULL);
1373 if (r < 0)
1374 return r;
1375
1376 r = remove_binaries(arg_esp_path);
1377
1378 q = remove_loader_config(arg_esp_path);
1379 if (q < 0 && r >= 0)
1380 r = q;
1381
1382 q = remove_entries_directory(arg_dollar_boot_path());
1383 if (q < 0 && r >= 0)
1384 r = q;
1385
1386 q = remove_esp_subdirs(arg_esp_path);
1387 if (q < 0 && r >= 0)
1388 r = q;
1389
1390 (void) sync_everything();
1391
1392 if (arg_touch_variables) {
1393 q = remove_variables(uuid, "/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi", true);
1394 if (q < 0 && r >= 0)
1395 r = q;
1396 }
1397
1398 return r;
1399 }
1400
1401 static int verb_set_default(int argc, char *argv[], void *userdata) {
1402 const char *name;
1403 int r;
1404
1405 if (!is_efi_boot())
1406 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
1407 "Not booted with UEFI.");
1408
1409 if (access("/sys/firmware/efi/efivars/LoaderInfo-4a67b082-0a4c-41cf-b6c7-440b29bb8c4f", F_OK) < 0) {
1410 if (errno == ENOENT) {
1411 log_error_errno(errno, "Not booted with a supported boot loader.");
1412 return -EOPNOTSUPP;
1413 }
1414
1415 return log_error_errno(errno, "Failed to detect whether boot loader supports '%s' operation: %m", argv[0]);
1416 }
1417
1418 if (detect_container() > 0)
1419 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
1420 "'%s' operation not supported in a container.",
1421 argv[0]);
1422
1423 if (!arg_touch_variables)
1424 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1425 "'%s' operation cannot be combined with --touch-variables=no.",
1426 argv[0]);
1427
1428 name = streq(argv[0], "set-default") ? "LoaderEntryDefault" : "LoaderEntryOneShot";
1429
1430 if (isempty(argv[1])) {
1431 r = efi_set_variable(EFI_VENDOR_LOADER, name, NULL, 0);
1432 if (r < 0 && r != -ENOENT)
1433 return log_error_errno(r, "Failed to remove EFI variale: %m");
1434 } else {
1435 _cleanup_free_ char16_t *encoded = NULL;
1436
1437 encoded = utf8_to_utf16(argv[1], strlen(argv[1]));
1438 if (!encoded)
1439 return log_oom();
1440
1441 r = efi_set_variable(EFI_VENDOR_LOADER, name, encoded, char16_strlen(encoded) * 2 + 2);
1442 if (r < 0)
1443 return log_error_errno(r, "Failed to update EFI variable: %m");
1444 }
1445
1446 return 0;
1447 }
1448
1449 static int bootctl_main(int argc, char *argv[]) {
1450 static const Verb verbs[] = {
1451 { "help", VERB_ANY, VERB_ANY, 0, help },
1452 { "status", VERB_ANY, 1, VERB_DEFAULT, verb_status },
1453 { "install", VERB_ANY, 1, 0, verb_install },
1454 { "update", VERB_ANY, 1, 0, verb_install },
1455 { "remove", VERB_ANY, 1, 0, verb_remove },
1456 { "list", VERB_ANY, 1, 0, verb_list },
1457 { "set-default", 2, 2, 0, verb_set_default },
1458 { "set-oneshot", 2, 2, 0, verb_set_default },
1459 {}
1460 };
1461
1462 return dispatch_verb(argc, argv, verbs, NULL);
1463 }
1464
1465 static int run(int argc, char *argv[]) {
1466 int r;
1467
1468 log_parse_environment();
1469 log_open();
1470
1471 /* If we run in a container, automatically turn off EFI file system access */
1472 if (detect_container() > 0)
1473 arg_touch_variables = false;
1474
1475 r = parse_argv(argc, argv);
1476 if (r <= 0)
1477 return r;
1478
1479 return bootctl_main(argc, argv);
1480 }
1481
1482 DEFINE_MAIN_FUNCTION(run);
Unnamed repository; edit this file 'description' to name the repository.