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


b74129a5f0d43f64a2d0af8da78bbacb8e475ee1
[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 "fd-util.h"
29 #include "fileio.h"
30 #include "fs-util.h"
31 #include "locale-util.h"
32 #include "parse-util.h"
33 #include "rm-rf.h"
34 #include "stat-util.h"
35 #include "string-util.h"
36 #include "strv.h"
37 #include "terminal-util.h"
38 #include "umask-util.h"
39 #include "util.h"
40 #include "verbs.h"
41 #include "virt.h"
42
43 static char *arg_path = NULL;
44 static bool arg_print_path = false;
45 static bool arg_touch_variables = true;
46
47 static int acquire_esp(
48 bool unprivileged_mode,
49 uint32_t *ret_part,
50 uint64_t *ret_pstart,
51 uint64_t *ret_psize,
52 sd_id128_t *ret_uuid) {
53
54 char *np;
55 int r;
56
57 /* Find the ESP, and log about errors. Note that find_esp_and_warn() will log in all error cases on its own,
58 * except for ENOKEY (which is good, we want to show our own message in that case, suggesting use of --path=)
59 * and EACCESS (only when we request unprivileged mode; in this case we simply eat up the error here, so that
60 * --list and --status work too, without noise about this). */
61
62 r = find_esp_and_warn(arg_path, unprivileged_mode, &np, ret_part, ret_pstart, ret_psize, ret_uuid);
63 if (r == -ENOKEY)
64 return log_error_errno(r,
65 "Couldn't find EFI system partition. It is recommended to mount it to /boot or /efi.\n"
66 "Alternatively, use --path= to specify path to mount point.");
67 if (r < 0)
68 return r;
69
70 free_and_replace(arg_path, np);
71
72 log_debug("Using EFI System Partition at %s.", arg_path);
73
74 return 0;
75 }
76
77 /* search for "#### LoaderInfo: systemd-boot 218 ####" string inside the binary */
78 static int get_file_version(int fd, char **v) {
79 struct stat st;
80 char *buf;
81 const char *s, *e;
82 char *x = NULL;
83 int r = 0;
84
85 assert(fd >= 0);
86 assert(v);
87
88 if (fstat(fd, &st) < 0)
89 return log_error_errno(errno, "Failed to stat EFI binary: %m");
90
91 if (st.st_size < 27) {
92 *v = NULL;
93 return 0;
94 }
95
96 buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
97 if (buf == MAP_FAILED)
98 return log_error_errno(errno, "Failed to memory map EFI binary: %m");
99
100 s = memmem(buf, st.st_size - 8, "#### LoaderInfo: ", 17);
101 if (!s)
102 goto finish;
103 s += 17;
104
105 e = memmem(s, st.st_size - (s - buf), " ####", 5);
106 if (!e || e - s < 3) {
107 log_error("Malformed version string.");
108 r = -EINVAL;
109 goto finish;
110 }
111
112 x = strndup(s, e - s);
113 if (!x) {
114 r = log_oom();
115 goto finish;
116 }
117 r = 1;
118
119 finish:
120 (void) munmap(buf, st.st_size);
121 *v = x;
122 return r;
123 }
124
125 static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) {
126 char *p;
127 _cleanup_closedir_ DIR *d = NULL;
128 struct dirent *de;
129 int r = 0, c = 0;
130
131 p = strjoina(esp_path, "/", path);
132 d = opendir(p);
133 if (!d) {
134 if (errno == ENOENT)
135 return 0;
136
137 return log_error_errno(errno, "Failed to read \"%s\": %m", p);
138 }
139
140 FOREACH_DIRENT(de, d, break) {
141 _cleanup_close_ int fd = -1;
142 _cleanup_free_ char *v = NULL;
143
144 if (!endswith_no_case(de->d_name, ".efi"))
145 continue;
146
147 if (prefix && !startswith_no_case(de->d_name, prefix))
148 continue;
149
150 fd = openat(dirfd(d), de->d_name, O_RDONLY|O_CLOEXEC);
151 if (fd < 0)
152 return log_error_errno(errno, "Failed to open \"%s/%s\" for reading: %m", p, de->d_name);
153
154 r = get_file_version(fd, &v);
155 if (r < 0)
156 return r;
157 if (r > 0)
158 printf(" File: %s/%s/%s (%s)\n", special_glyph(TREE_RIGHT), path, de->d_name, v);
159 else
160 printf(" File: %s/%s/%s\n", special_glyph(TREE_RIGHT), path, de->d_name);
161 c++;
162 }
163
164 return c;
165 }
166
167 static int status_binaries(const char *esp_path, sd_id128_t partition) {
168 int r;
169
170 printf("Boot Loader Binaries:\n");
171
172 if (!esp_path) {
173 printf(" ESP: Cannot find or access mount point of ESP.\n\n");
174 return -ENOENT;
175 }
176
177 printf(" ESP: %s", esp_path);
178 if (!sd_id128_is_null(partition))
179 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(partition));
180 printf("\n");
181
182 r = enumerate_binaries(esp_path, "EFI/systemd", NULL);
183 if (r == 0)
184 log_error("systemd-boot not installed in ESP.");
185 else if (r < 0)
186 return r;
187
188 r = enumerate_binaries(esp_path, "EFI/BOOT", "boot");
189 if (r == 0)
190 log_error("No default/fallback boot loader installed in ESP.");
191 else if (r < 0)
192 return r;
193
194 printf("\n");
195
196 return 0;
197 }
198
199 static int print_efi_option(uint16_t id, bool in_order) {
200 _cleanup_free_ char *title = NULL;
201 _cleanup_free_ char *path = NULL;
202 sd_id128_t partition;
203 bool active;
204 int r = 0;
205
206 r = efi_get_boot_option(id, &title, &partition, &path, &active);
207 if (r < 0)
208 return r;
209
210 /* print only configured entries with partition information */
211 if (!path || sd_id128_is_null(partition))
212 return 0;
213
214 efi_tilt_backslashes(path);
215
216 printf(" Title: %s\n", strna(title));
217 printf(" ID: 0x%04X\n", id);
218 printf(" Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : "");
219 printf(" Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", SD_ID128_FORMAT_VAL(partition));
220 printf(" File: %s%s\n", special_glyph(TREE_RIGHT), path);
221 printf("\n");
222
223 return 0;
224 }
225
226 static int status_variables(void) {
227 int n_options, n_order;
228 _cleanup_free_ uint16_t *options = NULL, *order = NULL;
229 int i;
230
231 n_options = efi_get_boot_options(&options);
232 if (n_options == -ENOENT)
233 return log_error_errno(n_options,
234 "Failed to access EFI variables, efivarfs"
235 " needs to be available at /sys/firmware/efi/efivars/.");
236 if (n_options < 0)
237 return log_error_errno(n_options, "Failed to read EFI boot entries: %m");
238
239 n_order = efi_get_boot_order(&order);
240 if (n_order == -ENOENT)
241 n_order = 0;
242 else if (n_order < 0)
243 return log_error_errno(n_order, "Failed to read EFI boot order.");
244
245 /* print entries in BootOrder first */
246 printf("Boot Loader Entries in EFI Variables:\n");
247 for (i = 0; i < n_order; i++)
248 print_efi_option(order[i], true);
249
250 /* print remaining entries */
251 for (i = 0; i < n_options; i++) {
252 int j;
253
254 for (j = 0; j < n_order; j++)
255 if (options[i] == order[j])
256 goto next_option;
257
258 print_efi_option(options[i], false);
259
260 next_option:
261 continue;
262 }
263
264 return 0;
265 }
266
267 static int status_entries(const char *esp_path, sd_id128_t partition) {
268 int r;
269
270 _cleanup_(boot_config_free) BootConfig config = {};
271
272 printf("Default Boot Entry:\n");
273
274 r = boot_entries_load_config(esp_path, &config);
275 if (r < 0)
276 return log_error_errno(r, "Failed to load bootspec config from \"%s/loader\": %m",
277 esp_path);
278
279 if (config.default_entry < 0)
280 printf("%zu entries, no entry suitable as default\n", config.n_entries);
281 else {
282 const BootEntry *e = &config.entries[config.default_entry];
283
284 printf(" title: %s\n", boot_entry_title(e));
285 if (e->version)
286 printf(" version: %s\n", e->version);
287 if (e->kernel)
288 printf(" linux: %s\n", e->kernel);
289 if (!strv_isempty(e->initrd)) {
290 _cleanup_free_ char *t;
291
292 t = strv_join(e->initrd, " ");
293 if (!t)
294 return log_oom();
295
296 printf(" initrd: %s\n", t);
297 }
298 if (!strv_isempty(e->options)) {
299 _cleanup_free_ char *t;
300
301 t = strv_join(e->options, " ");
302 if (!t)
303 return log_oom();
304
305 printf(" options: %s\n", t);
306 }
307 if (e->device_tree)
308 printf(" devicetree: %s\n", e->device_tree);
309 puts("");
310 }
311
312 return 0;
313 }
314
315 static int compare_product(const char *a, const char *b) {
316 size_t x, y;
317
318 assert(a);
319 assert(b);
320
321 x = strcspn(a, " ");
322 y = strcspn(b, " ");
323 if (x != y)
324 return x < y ? -1 : x > y ? 1 : 0;
325
326 return strncmp(a, b, x);
327 }
328
329 static int compare_version(const char *a, const char *b) {
330 assert(a);
331 assert(b);
332
333 a += strcspn(a, " ");
334 a += strspn(a, " ");
335 b += strcspn(b, " ");
336 b += strspn(b, " ");
337
338 return strverscmp(a, b);
339 }
340
341 static int version_check(int fd_from, const char *from, int fd_to, const char *to) {
342 _cleanup_free_ char *a = NULL, *b = NULL;
343 int r;
344
345 assert(fd_from >= 0);
346 assert(from);
347 assert(fd_to >= 0);
348 assert(to);
349
350 r = get_file_version(fd_from, &a);
351 if (r < 0)
352 return r;
353 if (r == 0) {
354 log_error("Source file \"%s\" does not carry version information!", from);
355 return -EINVAL;
356 }
357
358 r = get_file_version(fd_to, &b);
359 if (r < 0)
360 return r;
361 if (r == 0 || compare_product(a, b) != 0) {
362 log_notice("Skipping \"%s\", since it's owned by another boot loader.", to);
363 return -EEXIST;
364 }
365
366 if (compare_version(a, b) < 0) {
367 log_warning("Skipping \"%s\", since a newer boot loader version exists already.", to);
368 return -ESTALE;
369 }
370
371 return 0;
372 }
373
374 static int copy_file_with_version_check(const char *from, const char *to, bool force) {
375 _cleanup_close_ int fd_from = -1, fd_to = -1;
376 _cleanup_free_ char *t = NULL;
377 int r;
378
379 fd_from = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
380 if (fd_from < 0)
381 return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", from);
382
383 if (!force) {
384 fd_to = open(to, O_RDONLY|O_CLOEXEC|O_NOCTTY);
385 if (fd_to < 0) {
386 if (errno != -ENOENT)
387 return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", to);
388 } else {
389 r = version_check(fd_from, from, fd_to, to);
390 if (r < 0)
391 return r;
392
393 if (lseek(fd_from, 0, SEEK_SET) == (off_t) -1)
394 return log_error_errno(errno, "Failed to seek in \"%s\": %m", from);
395
396 fd_to = safe_close(fd_to);
397 }
398 }
399
400 r = tempfn_random(to, NULL, &t);
401 if (r < 0)
402 return log_oom();
403
404 RUN_WITH_UMASK(0000) {
405 fd_to = open(t, O_WRONLY|O_CREAT|O_CLOEXEC|O_EXCL|O_NOFOLLOW, 0644);
406 if (fd_to < 0)
407 return log_error_errno(errno, "Failed to open \"%s\" for writing: %m", t);
408 }
409
410 r = copy_bytes(fd_from, fd_to, (uint64_t) -1, COPY_REFLINK);
411 if (r < 0) {
412 (void) unlink(t);
413 return log_error_errno(r, "Failed to copy data from \"%s\" to \"%s\": %m", from, t);
414 }
415
416 (void) copy_times(fd_from, fd_to);
417
418 if (fsync(fd_to) < 0) {
419 (void) unlink_noerrno(t);
420 return log_error_errno(errno, "Failed to copy data from \"%s\" to \"%s\": %m", from, t);
421 }
422
423 (void) fsync_directory_of_file(fd_to);
424
425 if (renameat(AT_FDCWD, t, AT_FDCWD, to) < 0) {
426 (void) unlink_noerrno(t);
427 return log_error_errno(errno, "Failed to rename \"%s\" to \"%s\": %m", t, to);
428 }
429
430 log_info("Copied \"%s\" to \"%s\".", from, to);
431
432 return 0;
433 }
434
435 static int mkdir_one(const char *prefix, const char *suffix) {
436 char *p;
437
438 p = strjoina(prefix, "/", suffix);
439 if (mkdir(p, 0700) < 0) {
440 if (errno != EEXIST)
441 return log_error_errno(errno, "Failed to create \"%s\": %m", p);
442 } else
443 log_info("Created \"%s\".", p);
444
445 return 0;
446 }
447
448 static const char *efi_subdirs[] = {
449 "EFI",
450 "EFI/systemd",
451 "EFI/BOOT",
452 "loader",
453 "loader/entries",
454 NULL
455 };
456
457 static int create_dirs(const char *esp_path) {
458 const char **i;
459 int r;
460
461 STRV_FOREACH(i, efi_subdirs) {
462 r = mkdir_one(esp_path, *i);
463 if (r < 0)
464 return r;
465 }
466
467 return 0;
468 }
469
470 static int copy_one_file(const char *esp_path, const char *name, bool force) {
471 char *p, *q;
472 int r;
473
474 p = strjoina(BOOTLIBDIR "/", name);
475 q = strjoina(esp_path, "/EFI/systemd/", name);
476 r = copy_file_with_version_check(p, q, force);
477
478 if (startswith(name, "systemd-boot")) {
479 int k;
480 char *v;
481
482 /* Create the EFI default boot loader name (specified for removable devices) */
483 v = strjoina(esp_path, "/EFI/BOOT/BOOT",
484 name + STRLEN("systemd-boot"));
485 ascii_strupper(strrchr(v, '/') + 1);
486
487 k = copy_file_with_version_check(p, v, force);
488 if (k < 0 && r == 0)
489 r = k;
490 }
491
492 return r;
493 }
494
495 static int install_binaries(const char *esp_path, bool force) {
496 struct dirent *de;
497 _cleanup_closedir_ DIR *d = NULL;
498 int r = 0;
499
500 if (force) {
501 /* Don't create any of these directories when we are
502 * just updating. When we update we'll drop-in our
503 * files (unless there are newer ones already), but we
504 * won't create the directories for them in the first
505 * place. */
506 r = create_dirs(esp_path);
507 if (r < 0)
508 return r;
509 }
510
511 d = opendir(BOOTLIBDIR);
512 if (!d)
513 return log_error_errno(errno, "Failed to open \""BOOTLIBDIR"\": %m");
514
515 FOREACH_DIRENT(de, d, break) {
516 int k;
517
518 if (!endswith_no_case(de->d_name, ".efi"))
519 continue;
520
521 k = copy_one_file(esp_path, de->d_name, force);
522 if (k < 0 && r == 0)
523 r = k;
524 }
525
526 return r;
527 }
528
529 static bool same_entry(uint16_t id, const sd_id128_t uuid, const char *path) {
530 _cleanup_free_ char *opath = NULL;
531 sd_id128_t ouuid;
532 int r;
533
534 r = efi_get_boot_option(id, NULL, &ouuid, &opath, NULL);
535 if (r < 0)
536 return false;
537 if (!sd_id128_equal(uuid, ouuid))
538 return false;
539 if (!streq_ptr(path, opath))
540 return false;
541
542 return true;
543 }
544
545 static int find_slot(sd_id128_t uuid, const char *path, uint16_t *id) {
546 _cleanup_free_ uint16_t *options = NULL;
547 int n, i;
548
549 n = efi_get_boot_options(&options);
550 if (n < 0)
551 return n;
552
553 /* find already existing systemd-boot entry */
554 for (i = 0; i < n; i++)
555 if (same_entry(options[i], uuid, path)) {
556 *id = options[i];
557 return 1;
558 }
559
560 /* find free slot in the sorted BootXXXX variable list */
561 for (i = 0; i < n; i++)
562 if (i != options[i]) {
563 *id = i;
564 return 1;
565 }
566
567 /* use the next one */
568 if (i == 0xffff)
569 return -ENOSPC;
570 *id = i;
571 return 0;
572 }
573
574 static int insert_into_order(uint16_t slot, bool first) {
575 _cleanup_free_ uint16_t *order = NULL;
576 uint16_t *t;
577 int n, i;
578
579 n = efi_get_boot_order(&order);
580 if (n <= 0)
581 /* no entry, add us */
582 return efi_set_boot_order(&slot, 1);
583
584 /* are we the first and only one? */
585 if (n == 1 && order[0] == slot)
586 return 0;
587
588 /* are we already in the boot order? */
589 for (i = 0; i < n; i++) {
590 if (order[i] != slot)
591 continue;
592
593 /* we do not require to be the first one, all is fine */
594 if (!first)
595 return 0;
596
597 /* move us to the first slot */
598 memmove(order + 1, order, i * sizeof(uint16_t));
599 order[0] = slot;
600 return efi_set_boot_order(order, n);
601 }
602
603 /* extend array */
604 t = realloc(order, (n + 1) * sizeof(uint16_t));
605 if (!t)
606 return -ENOMEM;
607 order = t;
608
609 /* add us to the top or end of the list */
610 if (first) {
611 memmove(order + 1, order, n * sizeof(uint16_t));
612 order[0] = slot;
613 } else
614 order[n] = slot;
615
616 return efi_set_boot_order(order, n + 1);
617 }
618
619 static int remove_from_order(uint16_t slot) {
620 _cleanup_free_ uint16_t *order = NULL;
621 int n, i;
622
623 n = efi_get_boot_order(&order);
624 if (n <= 0)
625 return n;
626
627 for (i = 0; i < n; i++) {
628 if (order[i] != slot)
629 continue;
630
631 if (i + 1 < n)
632 memmove(order + i, order + i+1, (n - i) * sizeof(uint16_t));
633 return efi_set_boot_order(order, n - 1);
634 }
635
636 return 0;
637 }
638
639 static int install_variables(const char *esp_path,
640 uint32_t part, uint64_t pstart, uint64_t psize,
641 sd_id128_t uuid, const char *path,
642 bool first) {
643 char *p;
644 uint16_t slot;
645 int r;
646
647 if (!is_efi_boot()) {
648 log_warning("Not booted with EFI, skipping EFI variable setup.");
649 return 0;
650 }
651
652 p = strjoina(esp_path, path);
653 if (access(p, F_OK) < 0) {
654 if (errno == ENOENT)
655 return 0;
656
657 return log_error_errno(errno, "Cannot access \"%s\": %m", p);
658 }
659
660 r = find_slot(uuid, path, &slot);
661 if (r < 0)
662 return log_error_errno(r,
663 r == -ENOENT ?
664 "Failed to access EFI variables. Is the \"efivarfs\" filesystem mounted?" :
665 "Failed to determine current boot order: %m");
666
667 if (first || r == 0) {
668 r = efi_add_boot_option(slot, "Linux Boot Manager",
669 part, pstart, psize,
670 uuid, path);
671 if (r < 0)
672 return log_error_errno(r, "Failed to create EFI Boot variable entry: %m");
673
674 log_info("Created EFI boot entry \"Linux Boot Manager\".");
675 }
676
677 return insert_into_order(slot, first);
678 }
679
680 static int remove_boot_efi(const char *esp_path) {
681 char *p;
682 _cleanup_closedir_ DIR *d = NULL;
683 struct dirent *de;
684 int r, c = 0;
685
686 p = strjoina(esp_path, "/EFI/BOOT");
687 d = opendir(p);
688 if (!d) {
689 if (errno == ENOENT)
690 return 0;
691
692 return log_error_errno(errno, "Failed to open directory \"%s\": %m", p);
693 }
694
695 FOREACH_DIRENT(de, d, break) {
696 _cleanup_close_ int fd = -1;
697 _cleanup_free_ char *v = NULL;
698
699 if (!endswith_no_case(de->d_name, ".efi"))
700 continue;
701
702 if (!startswith_no_case(de->d_name, "boot"))
703 continue;
704
705 fd = openat(dirfd(d), de->d_name, O_RDONLY|O_CLOEXEC);
706 if (fd < 0)
707 return log_error_errno(errno, "Failed to open \"%s/%s\" for reading: %m", p, de->d_name);
708
709 r = get_file_version(fd, &v);
710 if (r < 0)
711 return r;
712 if (r > 0 && startswith(v, "systemd-boot ")) {
713 r = unlinkat(dirfd(d), de->d_name, 0);
714 if (r < 0)
715 return log_error_errno(errno, "Failed to remove \"%s/%s\": %m", p, de->d_name);
716
717 log_info("Removed \"%s/%s\".", p, de->d_name);
718 }
719
720 c++;
721 }
722
723 return c;
724 }
725
726 static int rmdir_one(const char *prefix, const char *suffix) {
727 char *p;
728
729 p = strjoina(prefix, "/", suffix);
730 if (rmdir(p) < 0) {
731 if (!IN_SET(errno, ENOENT, ENOTEMPTY))
732 return log_error_errno(errno, "Failed to remove \"%s\": %m", p);
733 } else
734 log_info("Removed \"%s\".", p);
735
736 return 0;
737 }
738
739 static int remove_binaries(const char *esp_path) {
740 char *p;
741 int r, q;
742 unsigned i;
743
744 p = strjoina(esp_path, "/EFI/systemd");
745 r = rm_rf(p, REMOVE_ROOT|REMOVE_PHYSICAL);
746
747 q = remove_boot_efi(esp_path);
748 if (q < 0 && r == 0)
749 r = q;
750
751 for (i = ELEMENTSOF(efi_subdirs)-1; i > 0; i--) {
752 q = rmdir_one(esp_path, efi_subdirs[i-1]);
753 if (q < 0 && r == 0)
754 r = q;
755 }
756
757 return r;
758 }
759
760 static int remove_variables(sd_id128_t uuid, const char *path, bool in_order) {
761 uint16_t slot;
762 int r;
763
764 if (!is_efi_boot())
765 return 0;
766
767 r = find_slot(uuid, path, &slot);
768 if (r != 1)
769 return 0;
770
771 r = efi_remove_boot_option(slot);
772 if (r < 0)
773 return r;
774
775 if (in_order)
776 return remove_from_order(slot);
777
778 return 0;
779 }
780
781 static int install_loader_config(const char *esp_path) {
782
783 char machine_string[SD_ID128_STRING_MAX];
784 _cleanup_(unlink_and_freep) char *t = NULL;
785 _cleanup_fclose_ FILE *f = NULL;
786 sd_id128_t machine_id;
787 const char *p;
788 int r, fd;
789
790 r = sd_id128_get_machine(&machine_id);
791 if (r < 0)
792 return log_error_errno(r, "Failed to get machine id: %m");
793
794 p = strjoina(esp_path, "/loader/loader.conf");
795
796 if (access(p, F_OK) >= 0) /* Silently skip creation if the file already exists (early check) */
797 return 0;
798
799 fd = open_tmpfile_linkable(p, O_WRONLY|O_CLOEXEC, &t);
800 if (fd < 0)
801 return log_error_errno(fd, "Failed to open \"%s\" for writing: %m", p);
802
803 f = fdopen(fd, "we");
804 if (!f) {
805 safe_close(fd);
806 return log_oom();
807 }
808
809 fprintf(f, "#timeout 3\n");
810 fprintf(f, "#console-mode keep\n");
811 fprintf(f, "default %s-*\n", sd_id128_to_string(machine_id, machine_string));
812
813 r = fflush_sync_and_check(f);
814 if (r < 0)
815 return log_error_errno(r, "Failed to write \"%s\": %m", p);
816
817 r = link_tmpfile(fd, t, p);
818 if (r == -EEXIST)
819 return 0; /* Silently skip creation if the file exists now (recheck) */
820 if (r < 0)
821 return log_error_errno(r, "Failed to move \"%s\" into place: %m", p);
822
823 t = mfree(t);
824
825 return 1;
826 }
827
828 static int help(int argc, char *argv[], void *userdata) {
829
830 printf("%s [COMMAND] [OPTIONS...]\n"
831 "\n"
832 "Install, update or remove the systemd-boot EFI boot manager.\n\n"
833 " -h --help Show this help\n"
834 " --version Print version\n"
835 " --path=PATH Path to the EFI System Partition (ESP)\n"
836 " -p --print-path Print path to the EFI partition\n"
837 " --no-variables Don't touch EFI variables\n"
838 "\n"
839 "Commands:\n"
840 " status Show status of installed systemd-boot and EFI variables\n"
841 " list List boot entries\n"
842 " install Install systemd-boot to the ESP and EFI variables\n"
843 " update Update systemd-boot in the ESP and EFI variables\n"
844 " remove Remove systemd-boot from the ESP and EFI variables\n",
845 program_invocation_short_name);
846
847 return 0;
848 }
849
850 static int parse_argv(int argc, char *argv[]) {
851 enum {
852 ARG_PATH = 0x100,
853 ARG_VERSION,
854 ARG_NO_VARIABLES,
855 };
856
857 static const struct option options[] = {
858 { "help", no_argument, NULL, 'h' },
859 { "version", no_argument, NULL, ARG_VERSION },
860 { "path", required_argument, NULL, ARG_PATH },
861 { "print-path", no_argument, NULL, 'p' },
862 { "no-variables", no_argument, NULL, ARG_NO_VARIABLES },
863 { NULL, 0, NULL, 0 }
864 };
865
866 int c, r;
867
868 assert(argc >= 0);
869 assert(argv);
870
871 while ((c = getopt_long(argc, argv, "hp", options, NULL)) >= 0)
872 switch (c) {
873
874 case 'h':
875 help(0, NULL, NULL);
876 return 0;
877
878 case ARG_VERSION:
879 return version();
880
881 case ARG_PATH:
882 r = free_and_strdup(&arg_path, optarg);
883 if (r < 0)
884 return log_oom();
885 break;
886
887 case 'p':
888 arg_print_path = true;
889 break;
890
891 case ARG_NO_VARIABLES:
892 arg_touch_variables = false;
893 break;
894
895 case '?':
896 return -EINVAL;
897
898 default:
899 assert_not_reached("Unknown option");
900 }
901
902 return 1;
903 }
904
905 static void read_loader_efi_var(const char *name, char **var) {
906 int r;
907
908 r = efi_get_variable_string(EFI_VENDOR_LOADER, name, var);
909 if (r < 0 && r != -ENOENT)
910 log_warning_errno(r, "Failed to read EFI variable %s: %m", name);
911 }
912
913 static int verb_status(int argc, char *argv[], void *userdata) {
914
915 sd_id128_t uuid = SD_ID128_NULL;
916 int r, k;
917
918 r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, &uuid);
919
920 if (arg_print_path) {
921 if (r == -EACCES) /* If we couldn't acquire the ESP path, log about access errors (which is the only
922 * error the find_esp_and_warn() won't log on its own) */
923 return log_error_errno(r, "Failed to determine ESP: %m");
924 if (r < 0)
925 return r;
926
927 puts(arg_path);
928 return 0;
929 }
930
931 r = 0; /* If we couldn't determine the path, then don't consider that a problem from here on, just show what we
932 * can show */
933
934 if (is_efi_boot()) {
935 _cleanup_free_ char *fw_type = NULL, *fw_info = NULL, *loader = NULL, *loader_path = NULL, *stub = NULL;
936 sd_id128_t loader_part_uuid = SD_ID128_NULL;
937
938 read_loader_efi_var("LoaderFirmwareType", &fw_type);
939 read_loader_efi_var("LoaderFirmwareInfo", &fw_info);
940 read_loader_efi_var("LoaderInfo", &loader);
941 read_loader_efi_var("StubInfo", &stub);
942 read_loader_efi_var("LoaderImageIdentifier", &loader_path);
943
944 if (loader_path)
945 efi_tilt_backslashes(loader_path);
946
947 k = efi_loader_get_device_part_uuid(&loader_part_uuid);
948 if (k < 0 && k != -ENOENT)
949 r = log_warning_errno(k, "Failed to read EFI variable LoaderDevicePartUUID: %m");
950
951 printf("System:\n");
952 printf(" Firmware: %s (%s)\n", strna(fw_type), strna(fw_info));
953 printf(" Secure Boot: %sd\n", enable_disable(is_efi_secure_boot()));
954 printf(" Setup Mode: %s\n", is_efi_secure_boot_setup_mode() ? "setup" : "user");
955 printf("\n");
956
957 printf("Current Loader:\n");
958 printf(" Product: %s\n", strna(loader));
959 if (stub)
960 printf(" Stub: %s\n", stub);
961 if (!sd_id128_is_null(loader_part_uuid))
962 printf(" ESP: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
963 SD_ID128_FORMAT_VAL(loader_part_uuid));
964 else
965 printf(" ESP: n/a\n");
966 printf(" File: %s%s\n", special_glyph(TREE_RIGHT), strna(loader_path));
967 printf("\n");
968 } else
969 printf("System:\n Not booted with EFI\n\n");
970
971 if (arg_path) {
972 k = status_binaries(arg_path, uuid);
973 if (k < 0)
974 r = k;
975 }
976
977 if (is_efi_boot()) {
978 k = status_variables();
979 if (k < 0)
980 r = k;
981 }
982
983 if (arg_path) {
984 k = status_entries(arg_path, uuid);
985 if (k < 0)
986 r = k;
987 }
988
989 return r;
990 }
991
992 static int verb_list(int argc, char *argv[], void *userdata) {
993 _cleanup_(boot_config_free) BootConfig config = {};
994 sd_id128_t uuid = SD_ID128_NULL;
995 unsigned n;
996 int r;
997
998 /* If we lack privileges we invoke find_esp_and_warn() in "unprivileged mode" here, which does two things: turn
999 * off logging about access errors and turn off potentially privileged device probing. Here we're interested in
1000 * the latter but not the former, hence request the mode, and log about EACCES. */
1001
1002 r = acquire_esp(geteuid() != 0, NULL, NULL, NULL, &uuid);
1003 if (r == -EACCES) /* We really need the ESP path for this call, hence also log about access errors */
1004 return log_error_errno(r, "Failed to determine ESP: %m");
1005 if (r < 0)
1006 return r;
1007
1008 r = boot_entries_load_config(arg_path, &config);
1009 if (r < 0)
1010 return log_error_errno(r, "Failed to load bootspec config from \"%s/loader\": %m",
1011 arg_path);
1012
1013 printf("Available boot entries:\n");
1014
1015 for (n = 0; n < config.n_entries; n++) {
1016 const BootEntry *e = &config.entries[n];
1017
1018 printf(" title: %s%s%s%s%s%s\n",
1019 ansi_highlight(),
1020 boot_entry_title(e),
1021 ansi_normal(),
1022 ansi_highlight_green(),
1023 n == (unsigned) config.default_entry ? " (default)" : "",
1024 ansi_normal());
1025 if (e->version)
1026 printf(" version: %s\n", e->version);
1027 if (e->machine_id)
1028 printf(" machine-id: %s\n", e->machine_id);
1029 if (e->architecture)
1030 printf(" architecture: %s\n", e->architecture);
1031 if (e->kernel)
1032 printf(" linux: %s\n", e->kernel);
1033 if (!strv_isempty(e->initrd)) {
1034 _cleanup_free_ char *t;
1035
1036 t = strv_join(e->initrd, " ");
1037 if (!t)
1038 return log_oom();
1039
1040 printf(" initrd: %s\n", t);
1041 }
1042 if (!strv_isempty(e->options)) {
1043 _cleanup_free_ char *t;
1044
1045 t = strv_join(e->options, " ");
1046 if (!t)
1047 return log_oom();
1048
1049 printf(" options: %s\n", t);
1050 }
1051 if (e->device_tree)
1052 printf(" devicetree: %s\n", e->device_tree);
1053
1054 puts("");
1055 }
1056
1057 return 0;
1058 }
1059
1060 static int verb_install(int argc, char *argv[], void *userdata) {
1061
1062 sd_id128_t uuid = SD_ID128_NULL;
1063 uint64_t pstart = 0, psize = 0;
1064 uint32_t part = 0;
1065 bool install;
1066 int r;
1067
1068 r = acquire_esp(false, &part, &pstart, &psize, &uuid);
1069 if (r < 0)
1070 return r;
1071
1072 install = streq(argv[0], "install");
1073
1074 RUN_WITH_UMASK(0002) {
1075 r = install_binaries(arg_path, install);
1076 if (r < 0)
1077 return r;
1078
1079 if (install) {
1080 r = install_loader_config(arg_path);
1081 if (r < 0)
1082 return r;
1083 }
1084 }
1085
1086 if (arg_touch_variables)
1087 r = install_variables(arg_path,
1088 part, pstart, psize, uuid,
1089 "/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi",
1090 install);
1091
1092 return r;
1093 }
1094
1095 static int verb_remove(int argc, char *argv[], void *userdata) {
1096 sd_id128_t uuid = SD_ID128_NULL;
1097 int r;
1098
1099 r = acquire_esp(false, NULL, NULL, NULL, &uuid);
1100 if (r < 0)
1101 return r;
1102
1103 r = remove_binaries(arg_path);
1104
1105 if (arg_touch_variables) {
1106 int q;
1107
1108 q = remove_variables(uuid, "/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi", true);
1109 if (q < 0 && r == 0)
1110 r = q;
1111 }
1112
1113 return r;
1114 }
1115
1116 static int bootctl_main(int argc, char *argv[]) {
1117
1118 static const Verb verbs[] = {
1119 { "help", VERB_ANY, VERB_ANY, 0, help },
1120 { "status", VERB_ANY, 1, VERB_DEFAULT, verb_status },
1121 { "list", VERB_ANY, 1, 0, verb_list },
1122 { "install", VERB_ANY, 1, VERB_MUST_BE_ROOT, verb_install },
1123 { "update", VERB_ANY, 1, VERB_MUST_BE_ROOT, verb_install },
1124 { "remove", VERB_ANY, 1, VERB_MUST_BE_ROOT, verb_remove },
1125 {}
1126 };
1127
1128 return dispatch_verb(argc, argv, verbs, NULL);
1129 }
1130
1131 int main(int argc, char *argv[]) {
1132 int r;
1133
1134 log_parse_environment();
1135 log_open();
1136
1137 /* If we run in a container, automatically turn of EFI file system access */
1138 if (detect_container() > 0)
1139 arg_touch_variables = false;
1140
1141 r = parse_argv(argc, argv);
1142 if (r <= 0)
1143 goto finish;
1144
1145 r = bootctl_main(argc, argv);
1146
1147 finish:
1148 free(arg_path);
1149 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1150 }
Unnamed repository; edit this file 'description' to name the repository.