From d3515ad22e02262b2db8620adad7427cb02aae76 Mon Sep 17 00:00:00 2001 From: Riccardo Boninsegna Date: Wed, 17 Jun 2015 23:06:33 +0200 Subject: [PATCH] Stable upload --- README.md | 40 + gummiboot-nomachineid-48/.gitignore | 40 + gummiboot-nomachineid-48/.pc/.quilt_patches | 1 + gummiboot-nomachineid-48/.pc/.quilt_series | 1 + gummiboot-nomachineid-48/.pc/.version | 1 + .../src/setup/setup.c | 1425 ++++++++++++ gummiboot-nomachineid-48/.pc/applied-patches | 3 + .../.pc/disable-machine-id-logic/README | 26 + .../man/gummiboot.xml | 137 ++ .../src/efi/gummiboot.c | 2037 +++++++++++++++++ .../src/setup/setup.c | 1445 ++++++++++++ .../src/setup/setup.c | 1425 ++++++++++++ gummiboot-nomachineid-48/.vimrc | 4 + gummiboot-nomachineid-48/LICENSE | 502 ++++ gummiboot-nomachineid-48/Makefile.am | 202 ++ gummiboot-nomachineid-48/README | 26 + gummiboot-nomachineid-48/TODO | 0 gummiboot-nomachineid-48/autogen.sh | 36 + gummiboot-nomachineid-48/configure.ac | 155 ++ gummiboot-nomachineid-48/debian/changelog | 54 + gummiboot-nomachineid-48/debian/compat | 1 + gummiboot-nomachineid-48/debian/control | 35 + gummiboot-nomachineid-48/debian/copyright | 23 + gummiboot-nomachineid-48/debian/gbp.conf | 5 + gummiboot-nomachineid-48/debian/gummiboot.5 | 55 + .../debian/gummiboot.default | 11 + .../debian/gummiboot.install | 2 + .../debian/gummiboot.links | 2 + .../debian/gummiboot.manpages | 2 + .../debian/gummiboot.postinst | 18 + ...-boot-efi-as-default-ESP-mount-point.patch | 25 + .../debian/patches/disable-machine-id-logic | 175 ++ .../debian/patches/series | 3 + ...the-boot-.efi-to-the-case-used-by-th.patch | 68 + gummiboot-nomachineid-48/debian/rules | 10 + gummiboot-nomachineid-48/debian/source/format | 1 + .../debian/update-gummiboot | 87 + gummiboot-nomachineid-48/debian/watch | 2 + .../debian/zz-update-gummiboot | 10 + gummiboot-nomachineid-48/m4/arch.m4 | 13 + gummiboot-nomachineid-48/man/gummiboot.xml | 134 ++ gummiboot-nomachineid-48/src/efi/console.c | 141 ++ gummiboot-nomachineid-48/src/efi/console.h | 34 + gummiboot-nomachineid-48/src/efi/graphics.c | 389 ++++ gummiboot-nomachineid-48/src/efi/graphics.h | 26 + gummiboot-nomachineid-48/src/efi/gummiboot.c | 1982 ++++++++++++++++ gummiboot-nomachineid-48/src/efi/linux.c | 128 ++ gummiboot-nomachineid-48/src/efi/linux.h | 23 + gummiboot-nomachineid-48/src/efi/pefile.c | 172 ++ gummiboot-nomachineid-48/src/efi/pefile.h | 22 + gummiboot-nomachineid-48/src/efi/stub.c | 102 + gummiboot-nomachineid-48/src/efi/util.c | 322 +++ gummiboot-nomachineid-48/src/efi/util.h | 44 + gummiboot-nomachineid-48/src/setup/efivars.c | 647 ++++++ gummiboot-nomachineid-48/src/setup/efivars.h | 55 + gummiboot-nomachineid-48/src/setup/setup.c | 1425 ++++++++++++ gummiboot-nomachineid-48/test/gummiboot.svg | 1327 +++++++++++ gummiboot-nomachineid-48/test/splash.bmp | Bin 0 -> 289238 bytes .../test/test-create-disk.sh | 43 + gummiboot-nomachineid_48.orig.tar.gz | Bin 0 -> 122945 bytes 60 files changed, 15124 insertions(+) create mode 100644 gummiboot-nomachineid-48/.gitignore create mode 100644 gummiboot-nomachineid-48/.pc/.quilt_patches create mode 100644 gummiboot-nomachineid-48/.pc/.quilt_series create mode 100644 gummiboot-nomachineid-48/.pc/.version create mode 100644 gummiboot-nomachineid-48/.pc/Set-boot-efi-as-default-ESP-mount-point.patch/src/setup/setup.c create mode 100644 gummiboot-nomachineid-48/.pc/applied-patches create mode 100644 gummiboot-nomachineid-48/.pc/disable-machine-id-logic/README create mode 100644 gummiboot-nomachineid-48/.pc/disable-machine-id-logic/man/gummiboot.xml create mode 100644 gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/efi/gummiboot.c create mode 100644 gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/setup/setup.c create mode 100644 gummiboot-nomachineid-48/.pc/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch/src/setup/setup.c create mode 100644 gummiboot-nomachineid-48/.vimrc create mode 100644 gummiboot-nomachineid-48/LICENSE create mode 100644 gummiboot-nomachineid-48/Makefile.am create mode 100644 gummiboot-nomachineid-48/README create mode 100644 gummiboot-nomachineid-48/TODO create mode 100755 gummiboot-nomachineid-48/autogen.sh create mode 100644 gummiboot-nomachineid-48/configure.ac create mode 100644 gummiboot-nomachineid-48/debian/changelog create mode 100644 gummiboot-nomachineid-48/debian/compat create mode 100644 gummiboot-nomachineid-48/debian/control create mode 100644 gummiboot-nomachineid-48/debian/copyright create mode 100644 gummiboot-nomachineid-48/debian/gbp.conf create mode 100644 gummiboot-nomachineid-48/debian/gummiboot.5 create mode 100644 gummiboot-nomachineid-48/debian/gummiboot.default create mode 100644 gummiboot-nomachineid-48/debian/gummiboot.install create mode 100644 gummiboot-nomachineid-48/debian/gummiboot.links create mode 100644 gummiboot-nomachineid-48/debian/gummiboot.manpages create mode 100644 gummiboot-nomachineid-48/debian/gummiboot.postinst create mode 100644 gummiboot-nomachineid-48/debian/patches/Set-boot-efi-as-default-ESP-mount-point.patch create mode 100644 gummiboot-nomachineid-48/debian/patches/disable-machine-id-logic create mode 100644 gummiboot-nomachineid-48/debian/patches/series create mode 100644 gummiboot-nomachineid-48/debian/patches/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch create mode 100755 gummiboot-nomachineid-48/debian/rules create mode 100644 gummiboot-nomachineid-48/debian/source/format create mode 100755 gummiboot-nomachineid-48/debian/update-gummiboot create mode 100644 gummiboot-nomachineid-48/debian/watch create mode 100755 gummiboot-nomachineid-48/debian/zz-update-gummiboot create mode 100644 gummiboot-nomachineid-48/m4/arch.m4 create mode 100644 gummiboot-nomachineid-48/man/gummiboot.xml create mode 100644 gummiboot-nomachineid-48/src/efi/console.c create mode 100644 gummiboot-nomachineid-48/src/efi/console.h create mode 100644 gummiboot-nomachineid-48/src/efi/graphics.c create mode 100644 gummiboot-nomachineid-48/src/efi/graphics.h create mode 100644 gummiboot-nomachineid-48/src/efi/gummiboot.c create mode 100644 gummiboot-nomachineid-48/src/efi/linux.c create mode 100644 gummiboot-nomachineid-48/src/efi/linux.h create mode 100644 gummiboot-nomachineid-48/src/efi/pefile.c create mode 100644 gummiboot-nomachineid-48/src/efi/pefile.h create mode 100644 gummiboot-nomachineid-48/src/efi/stub.c create mode 100644 gummiboot-nomachineid-48/src/efi/util.c create mode 100644 gummiboot-nomachineid-48/src/efi/util.h create mode 100644 gummiboot-nomachineid-48/src/setup/efivars.c create mode 100644 gummiboot-nomachineid-48/src/setup/efivars.h create mode 100644 gummiboot-nomachineid-48/src/setup/setup.c create mode 100644 gummiboot-nomachineid-48/test/gummiboot.svg create mode 100644 gummiboot-nomachineid-48/test/splash.bmp create mode 100755 gummiboot-nomachineid-48/test/test-create-disk.sh create mode 100644 gummiboot-nomachineid_48.orig.tar.gz diff --git a/README.md b/README.md index d65b81d..9d5fcc8 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,42 @@ # gummiboot-nomachineid Gummiboot 48, without systemd + +# Instructions + +1. Download this repo with `git clone` or the compressed archives. +2. `sudo apt-get build-dep gummiboot` (should equal to: `aptitude install build-essential debhelper dh-autoreconf docbook-xsl gnu-efi libblkid-dev pkg-config xsltproc`) +3. Enter the `gummiboot-nomachineid-48` folder. +4. `dpkg-buildpackage -b -us -uc` +5. Install `gummiboot-nomachineid_48-100_amd64.deb` found in the parent folder. + +Or cheat and try skipping to step 5 by downloading that file from Github's "releases" feature... +I'm not a Github master, sorry! + +# Introduction + +*Preface, which is a part of understanding this package: in Debian-like OSes, the kernel -- installed in /boot -- must be on a partition supporting Unix-like features. So you can't mount your EFI partition directly on /boot.* + +*On the other hand, if you choose to encrypt your root partition but use GRUB2, you must split out your /boot partition anyway. On an EFI system, this means you need at least 3 partitions, one of which will be mostly empty even though it ought to be 200 MB according to EFI standards!* + +This is the source code (in dpkg-buildpackage format) for gummiboot v48 (the current version in Debian stable Jessie), with one caveat: **all *machine-id* related code is stripped out** (except where that might make older files incompatible). + +*machine-id is a 12-character hex string that for all intents and purposes is a form of UUID. Why I'm set against it will become clear later in this file.* + +This key difference obviously has advantages and disadvantages, compared to upstream gummiboot: + +* It does not act on *machine-id* rows in entry files :) -- this allegedly means you can't use it as a feature to selectively add some kernel arguments. + +... and that would be all, if not for some antifeatures in Debian's adaptation where this version is arguably better: + +* Kernels are now copied to {EFI partition}/linux-{version string}/{linux|initrd} instead of {EFI partition}/{machine-id}/{version string}/{linux|initrd}. Manual management becomes arguably easier. +* Respects the so-called "Unix philosophy" of well-focused software. +* Most notably, the adaptation has been [crippled by laziness of the Debian packagers](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=749706#15). While I wouldn't normally be pissed off by that, this resulted in an extremely strong dependency on systemd. Ironically, despite gummiboot and systemd having recently joined ways, this problem is not caused by shared code, but because systemd or dbus are the easiest way to generate a machine-id, which gummiboot requires. + +Ironically again, this is a non-issue in Arch Linux, well known for being among the most progressist distros. + +# Dedication + +This package was unofficially developed on and for the [Devuan project](http://devuan.org/). + + + diff --git a/gummiboot-nomachineid-48/.gitignore b/gummiboot-nomachineid-48/.gitignore new file mode 100644 index 0000000..d482a5d --- /dev/null +++ b/gummiboot-nomachineid-48/.gitignore @@ -0,0 +1,40 @@ +*~ +*.o +*.so +*.cache +*.log +.deps +.libs +*.8 +.dirstamp +/gummiboot +/gummiboot.so +/gummibootx64.efi +/gummibootia32.efi +/stub.so +/stubx64.efi +/stubia32.efi +/test-disk + +Makefile +aclocal.m4 +stamp-h.in +Makefile.in +configure +config.h +config.h.in +config.guess +config.status +config.sub +stamp-h +stamp-h1 +m4/*.m4 +config.rpath +mkinstalldirs +compile +depcomp +install-sh +missing + +# wanted files +!m4/arch.m4 diff --git a/gummiboot-nomachineid-48/.pc/.quilt_patches b/gummiboot-nomachineid-48/.pc/.quilt_patches new file mode 100644 index 0000000..6857a8d --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/.quilt_patches @@ -0,0 +1 @@ +debian/patches diff --git a/gummiboot-nomachineid-48/.pc/.quilt_series b/gummiboot-nomachineid-48/.pc/.quilt_series new file mode 100644 index 0000000..c206706 --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/.quilt_series @@ -0,0 +1 @@ +series diff --git a/gummiboot-nomachineid-48/.pc/.version b/gummiboot-nomachineid-48/.pc/.version new file mode 100644 index 0000000..0cfbf08 --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/.version @@ -0,0 +1 @@ +2 diff --git a/gummiboot-nomachineid-48/.pc/Set-boot-efi-as-default-ESP-mount-point.patch/src/setup/setup.c b/gummiboot-nomachineid-48/.pc/Set-boot-efi-as-default-ESP-mount-point.patch/src/setup/setup.c new file mode 100644 index 0000000..6a4275a --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/Set-boot-efi-as-default-ESP-mount-point.patch/src/setup/setup.c @@ -0,0 +1,1425 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2013 Lennart Poettering + Copyright 2013 Kay Sievers + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "efivars.h" + +#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) +#define streq(a,b) (strcmp((a),(b)) == 0) +#define UUID_EMPTY ((uint8_t[16]) {}) + +static inline bool streq_ptr(const char *a, const char *b) { + if (a && b) + return streq(a, b); + if (!a && !b) + return true; + return false; +} + +static inline bool isempty(const char *p) { + return !p || !p[0]; +} + +static inline const char *strna(const char *s) { + return isempty(s) ? "n/a" : s; +} + +static int uuid_parse(const char *s, uint8_t uuid[16]) { + int u[16]; + int i; + + if (sscanf(s, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + &u[0], &u[1], &u[2], &u[3], &u[4], &u[5], &u[6], &u[7], + &u[8], &u[9], &u[10], &u[11], &u[12], &u[13], &u[14], &u[15]) != 16) + return -EINVAL; + + for (i = 0; i < 16; i++) + uuid[i] = u[i]; + + return 0; +} + +static int verify_esp(const char *p, uint32_t *part, uint64_t *pstart, uint64_t *psize, uint8_t uuid[16]) { + struct statfs sfs; + struct stat st, st2; + char *t; + blkid_probe b = NULL; + int r; + const char *v; + + if (statfs(p, &sfs) < 0) { + fprintf(stderr, "Failed to check file system type of %s: %m\n", p); + return -errno; + } + + if (sfs.f_type != 0x4d44) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + if (stat(p, &st) < 0) { + fprintf(stderr, "Failed to determine block device node of %s: %m\n", p); + return -errno; + } + + if (major(st.st_dev) == 0) { + fprintf(stderr, "Block device node of %p is invalid.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "%s/..", p); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = stat(t, &st2); + free(t); + if (r < 0) { + fprintf(stderr, "Failed to determine block device node of parent of %s: %m\n", p); + return -errno; + } + + if (st.st_dev == st2.st_dev) { + fprintf(stderr, "Directory %s is not the root of the EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "/dev/block/%u:%u", major(st.st_dev), minor(st.st_dev)); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + errno = 0; + b = blkid_new_probe_from_filename(t); + free(t); + if (!b) { + if (errno != 0) { + fprintf(stderr, "Failed to open file system %s: %m\n", p); + return -errno; + } + + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + blkid_probe_enable_superblocks(b, 1); + blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE); + blkid_probe_enable_partitions(b, 1); + blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS); + + errno = 0; + r = blkid_do_safeprobe(b); + if (r == -2) { + fprintf(stderr, "File system %s is ambigious.\n", p); + r = -ENODEV; + goto fail; + } else if (r == 1) { + fprintf(stderr, "File system %s does not contain a label.\n", p); + r = -ENODEV; + goto fail; + } else if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system %s: %s\n", p, strerror(-r)); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system type %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "vfat") != 0) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system after all.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SCHEME", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition scheme %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "gpt") != 0) { + fprintf(stderr, "File system %s is not on a GPT partition table.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition type UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "c12a7328-f81f-11d2-ba4b-00a0c93ec93b") != 0) { + r = -ENODEV; + fprintf(stderr, "File system %s is not an EFI System Partition (ESP).\n", p); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_UUID", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition entry UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + uuid_parse(v, uuid); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_NUMBER", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition number %s: %s\n", p, strerror(-r)); + goto fail; + } + *part = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_OFFSET", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition offset %s: %s\n", p, strerror(-r)); + goto fail; + } + *pstart = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SIZE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition size %s: %s\n", p, strerror(-r)); + goto fail; + } + *psize = strtoul(v, NULL, 10); + + blkid_free_probe(b); + return 0; +fail: + if (b) + blkid_free_probe(b); + return r; +} + +/* search for "#### LoaderInfo: gummiboot 31 ####" string inside the binary */ +static int get_file_version(FILE *f, char **v) { + struct stat st; + char *buf; + const char *s, *e; + char *x = NULL; + int r = 0; + + assert(f); + assert(v); + + if (fstat(fileno(f), &st) < 0) + return -errno; + + if (st.st_size < 27) + return 0; + + buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fileno(f), 0); + if (buf == MAP_FAILED) + return -errno; + + s = memmem(buf, st.st_size - 8, "#### LoaderInfo: ", 17); + if (!s) + goto finish; + s += 17; + + e = memmem(s, st.st_size - (s - buf), " ####", 5); + if (!e || e - s < 3) { + fprintf(stderr, "Malformed version string.\n"); + r = -EINVAL; + goto finish; + } + + x = strndup(s, e - s); + if (!x) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + r = 1; + +finish: + munmap(buf, st.st_size); + *v = x; + return r; +} + +static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".efi") != 0) + continue; + + if (prefix && strncasecmp(de->d_name, prefix, strlen(prefix)) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s/%s", esp_path, path, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0) + printf(" File: └─/%s/%s (%s)\n", path, de->d_name, v); + else + printf(" File: └─/%s/%s\n", path, de->d_name); + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + + free(p); + free(q); + return r; +} + +static int status_binaries(const char *esp_path, uint8_t partition[16]) { + int r; + + printf("Boot Loader Binaries:\n"); + + printf(" ESP: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + + r = enumerate_binaries(esp_path, "EFI/gummiboot", NULL); + if (r == 0) + fprintf(stderr, "Gummiboot not installed in ESP.\n"); + else if (r < 0) + return r; + + r = enumerate_binaries(esp_path, "EFI/Boot", "boot"); + if (r == 0) + fprintf(stderr, "No default/fallback boot loader installed in ESP.\n"); + else if (r < 0) + return r; + + printf("\n"); + return 0; +} + +static int print_efi_option(uint16_t id, bool in_order) { + char *title = NULL; + char *path = NULL; + uint8_t partition[16]; + bool active; + int r = 0; + + r = efi_get_boot_option(id, &title, partition, &path, &active); + if (r < 0) + goto finish; + + /* print only configured entries with partition information */ + if (!path || memcmp(partition, UUID_EMPTY, 16) == 0) + return 0; + + printf(" Title: %s\n", strna(title)); + printf(" ID: 0x%04X\n", id); + printf(" Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : ""); + printf(" Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + printf(" File: └─%s\n", path); + printf("\n"); + +finish: + free(title); + free(path); + return r; +} + +static int status_variables(void) { + int n_options, n_order; + uint16_t *options = NULL, *order = NULL; + int r, i; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, not showing EFI variables.\n"); + return 0; + } + + n_options = efi_get_boot_options(&options); + if (n_options < 0) { + if (n_options == -ENOENT) + fprintf(stderr, "Failed to access EFI variables, " + "efivarfs needs to be available at /sys/firmware/efi/efivars/.\n"); + else + fprintf(stderr, "Failed to read EFI boot entries: %s\n", strerror(-n_options)); + r = n_options; + goto finish; + } + + printf("Boot Loader Entries in EFI Variables:\n"); + n_order = efi_get_boot_order(&order); + if (n_order == -ENOENT) { + n_order = 0; + } else if (n_order < 0) { + fprintf(stderr, "Failed to read EFI boot order.\n"); + r = n_order; + goto finish; + } + + /* print entries in BootOrder first */ + for (i = 0; i < n_order; i++) + print_efi_option(order[i], true); + + /* print remaining entries */ + for (i = 0; i < n_options; i++) { + int j; + bool found = false; + + for (j = 0; j < n_order; j++) + if (options[i] == order[j]) { + found = true; + break; + } + + if (found) + continue; + + print_efi_option(options[i], false); + } + + r = 0; +finish: + free(options); + free(order); + + return r; +} + +static int compare_product(const char *a, const char *b) { + size_t x, y; + + assert(a); + assert(b); + + x = strcspn(a, " "); + y = strcspn(b, " "); + if (x != y) + return x < y ? -1 : x > y ? 1 : 0; + + return strncmp(a, b, x); +} + +static int compare_version(const char *a, const char *b) { + assert(a); + assert(b); + + a += strcspn(a, " "); + a += strspn(a, " "); + b += strcspn(b, " "); + b += strspn(b, " "); + + return strverscmp(a, b); +} + +static int version_check(FILE *f, const char *from, const char *to) { + FILE *g = NULL; + char *a = NULL, *b = NULL; + int r; + + assert(f); + assert(from); + assert(to); + + r = get_file_version(f, &a); + if (r < 0) + goto finish; + if (r == 0) { + r = -EINVAL; + fprintf(stderr, "Source file %s does not carry version information!\n", from); + goto finish; + } + + g = fopen(to, "re"); + if (!g) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + r = -errno; + fprintf(stderr, "Failed to open %s for reading: %m\n", to); + goto finish; + } + + r = get_file_version(g, &b); + if (r < 0) + goto finish; + if (r == 0 || compare_product(a, b) != 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's owned by another boot loader.\n", to); + goto finish; + } + + if (compare_version(a, b) < 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's a newer boot loader version already.\n", to); + goto finish; + } + + r = 0; + +finish: + free(a); + free(b); + if (g) + fclose(g); + return r; +} + +static int copy_file(const char *from, const char *to, bool force) { + FILE *f = NULL, *g = NULL; + char *p = NULL; + int r; + struct timespec t[2]; + struct stat st; + + assert(from); + assert(to); + + f = fopen(from, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", from); + return -errno; + } + + if (!force) { + /* If this is an update, then let's compare versions first */ + r = version_check(f, from, to); + if (r < 0) + goto finish; + } + + if (asprintf(&p, "%s~", to) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + g = fopen(p, "wxe"); + if (!g) { + /* Directory doesn't exist yet? Then let's skip this... */ + if (!force && errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to open %s for writing: %m\n", to); + r = -errno; + goto finish; + } + + rewind(f); + do { + size_t k; + uint8_t buf[32*1024]; + + k = fread(buf, 1, sizeof(buf), f); + if (ferror(f)) { + fprintf(stderr, "Failed to read %s: %m\n", from); + r = -errno; + goto finish; + } + if (k == 0) + break; + + fwrite(buf, 1, k, g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + } while (!feof(f)); + + fflush(g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + + r = fstat(fileno(f), &st); + if (r < 0) { + fprintf(stderr, "Failed to get file timestamps of %s: %m", from); + r = -errno; + goto finish; + } + + t[0] = st.st_atim; + t[1] = st.st_mtim; + + r = futimens(fileno(g), t); + if (r < 0) { + fprintf(stderr, "Failed to change file timestamps for %s: %m", p); + r = -errno; + goto finish; + } + + if (rename(p, to) < 0) { + fprintf(stderr, "Failed to rename %s to %s: %m\n", p, to); + r = -errno; + goto finish; + } + + fprintf(stderr, "Copied %s to %s.\n", from, to); + + free(p); + p = NULL; + r = 0; + +finish: + if (f) + fclose(f); + if (g) + fclose(g); + if (p) { + unlink(p); + free(p); + } + return r; +} + +static char* strupper(char *s) { + char *p; + + for (p = s; *p; p++) + *p = toupper(*p); + + return s; +} + +static int mkdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (mkdir(p, 0700) < 0) { + if (errno != EEXIST) { + fprintf(stderr, "Failed to create %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Created %s.\n", p); + + free(p); + return 0; +} + +static int create_dirs(const char *esp_path) { + int r; + + r = mkdir_one(esp_path, "EFI"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/gummiboot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/Boot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader/entries"); + if (r < 0) + return r; + + return 0; +} + +static int copy_one_file(const char *esp_path, const char *name, bool force) { + char *p = NULL, *q = NULL, *v = NULL; + int r; + + if (asprintf(&p, GUMMIBOOTLIBDIR "/%s", name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + if (asprintf(&q, "%s/EFI/gummiboot/%s", esp_path, name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + r = copy_file(p, q, force); + + if (strncmp(name, "gummiboot", 9) == 0) { + int k; + + /* Create the EFI default boot loader name (specified for removable devices) */ + if (asprintf(&v, "%s/EFI/Boot/%s", esp_path, name + 5) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + strupper(strrchr(v, '/') + 1); + + k = copy_file(p, v, force); + if (k < 0 && r == 0) { + r = k; + goto finish; + } + } + +finish: + free(p); + free(q); + free(v); + return r; +} + +static int install_binaries(const char *esp_path, bool force) { + struct dirent *de; + DIR *d; + 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(GUMMIBOOTLIBDIR); + if (!d) { + fprintf(stderr, "Failed to open "GUMMIBOOTLIBDIR": %m\n"); + return -errno; + } + + while ((de = readdir(d))) { + size_t n; + int k; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcmp(de->d_name + n - 4, ".efi") != 0) + continue; + + k = copy_one_file(esp_path, de->d_name, force); + if (k < 0 && r == 0) + r = k; + } + + closedir(d); + return r; +} + +static bool same_entry(uint16_t id, const uint8_t uuid[16], const char *path) { + char *opath = NULL; + uint8_t ouuid[16]; + int err; + bool same = false; + + err = efi_get_boot_option(id, NULL, ouuid, &opath, NULL); + if (err < 0) + return false; + if (memcmp(uuid, ouuid, 16) != 0) + goto finish; + + if (!streq_ptr(path, opath)) + goto finish; + + same = true; + +finish: + free(opath); + return same; +} + +static int find_slot(const uint8_t uuid[16], const char *path, uint16_t *id) { + uint16_t *options = NULL; + int n_options; + int i; + uint16_t new_id = 0; + bool existing = false; + + n_options = efi_get_boot_options(&options); + if (n_options < 0) + return n_options; + + /* find already existing gummiboot entry */ + for (i = 0; i < n_options; i++) + if (same_entry(options[i], uuid, path)) { + new_id = options[i]; + existing = true; + goto finish; + } + + /* find free slot in the sorted BootXXXX variable list */ + for (i = 0; i < n_options; i++) + if (i != options[i]) { + new_id = i; + goto finish; + } + + /* use the next one */ + if (i == 0xffff) + return -ENOSPC; + new_id = i; + +finish: + *id = new_id; + free(options); + return existing; +} + +static int insert_into_order(uint16_t slot, bool first) { + uint16_t *order = NULL; + uint16_t *new_order; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order <= 0) { + /* no entry, add us */ + err = efi_set_boot_order(&slot, 1); + goto finish; + } + + /* are we the first and only one? */ + if (n_order == 1 && order[0] == slot) + goto finish; + + /* are we already in the boot order? */ + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + /* we do not require to be the first one, all is fine */ + if (!first) + goto finish; + + /* move us to the first slot */ + memmove(&order[1], order, i * sizeof(uint16_t)); + order[0] = slot; + efi_set_boot_order(order, n_order); + goto finish; + } + + /* extend array */ + new_order = realloc(order, (n_order+1) * sizeof(uint16_t)); + if (!new_order) { + err = -ENOMEM; + goto finish; + } + order = new_order; + + /* add us to the top or end of the list */ + if (first) { + memmove(&order[1], order, n_order * sizeof(uint16_t)); + order[0] = slot; + } else + order[n_order] = slot; + + efi_set_boot_order(order, n_order+1); + +finish: + free(order); + return err; +} + +static int remove_from_order(uint16_t slot) { + uint16_t *order = NULL; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order < 0) + return n_order; + if (n_order == 0) + return 0; + + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + if (i+1 < n_order) + memmove(&order[i], &order[i+1], (n_order - i) * sizeof(uint16_t)); + efi_set_boot_order(order, n_order-1); + break; + } + + free(order); + return err; +} + +static int install_variables(const char *esp_path, + uint32_t part, uint64_t pstart, uint64_t psize, + const uint8_t uuid[16], const char *path, + bool first) { + char *p = NULL; + uint16_t *options = NULL; + uint16_t slot; + int r; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, skipping EFI variable setup.\n"); + return 0; + } + + if (asprintf(&p, "%s%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (access(p, F_OK) < 0) { + if (errno == ENOENT) + r = 0; + else + r = -errno; + goto finish; + } + + r = find_slot(uuid, path, &slot); + if (r < 0) { + if (r == -ENOENT) + fprintf(stderr, "Failed to access EFI variables. Is the \"efivarfs\" filesystem mounted?\n"); + else + fprintf(stderr, "Failed to determine current boot order: %s\n", strerror(-r)); + goto finish; + } + + if (first || r == false) { + r = efi_add_boot_option(slot, "Linux Boot Manager", + part, pstart, psize, + uuid, path); + if (r < 0) { + fprintf(stderr, "Failed to create EFI Boot variable entry: %s\n", strerror(-r)); + goto finish; + } + fprintf(stderr, "Created EFI boot entry \"Linux Boot Manager\".\n"); + } + + insert_into_order(slot, first); + +finish: + free(p); + free(options); + return r; +} + +static int delete_nftw(const char *path, const struct stat *sb, int typeflag, struct FTW *ftw) { + int r; + + if (typeflag == FTW_D || typeflag == FTW_DNR || typeflag == FTW_DP) + r = rmdir(path); + else + r = unlink(path); + + if (r < 0) + fprintf(stderr, "Failed to remove %s: %m\n", path); + else + fprintf(stderr, "Removed %s.\n", path); + + return 0; +} + +static int rm_rf(const char *p) { + nftw(p, delete_nftw, 20, FTW_DEPTH|FTW_MOUNT|FTW_PHYS); + return 0; +} + +static int remove_boot_efi(const char *esp_path) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/EFI/Boot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".EFI") != 0) + continue; + + if (strncasecmp(de->d_name, "Boot", 4) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s", p, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0 && strncmp(v, "gummiboot ", 10) == 0) { + + r = unlink(q); + if (r < 0) { + fprintf(stderr, "Failed to remove %s: %m\n", q); + r = -errno; + free(v); + goto finish; + } else + fprintf(stderr, "Removed %s.\n", q); + } + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + free(p); + free(q); + + return r; +} + +static int rmdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (rmdir(p) < 0) { + if (errno != ENOENT && errno != ENOTEMPTY) { + fprintf(stderr, "Failed to remove %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Removed %s.\n", p); + + free(p); + return 0; +} + + +static int remove_binaries(const char *esp_path) { + char *p; + int r, q; + + if (asprintf(&p, "%s/EFI/gummiboot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = rm_rf(p); + free(p); + + q = remove_boot_efi(esp_path); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader/entries"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/Boot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/gummiboot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI"); + if (q < 0 && r == 0) + r = q; + + return r; +} + +static int remove_variables(const uint8_t uuid[16], const char *path, bool in_order) { + uint16_t slot; + int r; + + if (!is_efi_boot()) + return 0; + + r = find_slot(uuid, path, &slot); + if (r != 1) + return 0; + + r = efi_remove_boot_option(slot); + if (r < 0) + return r; + + if (in_order) + remove_from_order(slot); + + return 0; +} + +static int install_loader_config(const char *esp_path) { + char *p = NULL; + char line[64]; + char *machine = NULL; + FILE *f; + + f = fopen("/etc/machine-id", "re"); + if (!f) + return -errno; + + if (fgets(line, sizeof(line), f) != NULL) { + char *s; + + s = strchr(line, '\n'); + if (s) + s[0] = '\0'; + if (strlen(line) == 32) + machine = line; + } + + fclose(f); + + if (!machine) + return -ESRCH; + + if (asprintf(&p, "%s/%s", esp_path, "loader/loader.conf") < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + f = fopen(p, "wxe"); + if (f) { + fprintf(f, "#timeout 3\n"); + fprintf(f, "default %s-*\n", machine); + fclose(f); + } + + free(p); + return 0; +} + +static int help(void) { + printf("%s [COMMAND] [OPTIONS...]\n" + "\n" + "Install, update or remove the Gummiboot EFI boot loader.\n\n" + " -h --help Show this help\n" + " --version Print version\n" + " --path=PATH Path to the EFI System Partition (ESP)\n" + " --no-variables Don't touch EFI variables\n" + "\n" + "Comands:\n" + " status Show status of installed Gummiboot and EFI variables\n" + " install Install Gummiboot to the ESP and EFI variables\n" + " update Update Gummiboot in the ESP and EFI variables\n" + " remove Remove Gummiboot from the ESP and EFI variables\n", + program_invocation_short_name); + + return 0; +} + +static const char *arg_path = NULL; +static bool arg_touch_variables = true; + +static int parse_argv(int argc, char *argv[]) { + enum { + ARG_PATH = 0x100, + ARG_VERSION, + ARG_NO_VARIABLES, + }; + + static const struct option options[] = { + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, ARG_VERSION }, + { "path", required_argument, NULL, ARG_PATH }, + { "no-variables", no_argument, NULL, ARG_NO_VARIABLES }, + { NULL, 0, NULL, 0 } + }; + + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) { + switch (c) { + + case 'h': + help(); + return 0; + + case ARG_VERSION: + printf(VERSION "\n"); + return 0; + + case ARG_PATH: + arg_path = optarg; + break; + + case ARG_NO_VARIABLES: + arg_touch_variables = false; + break; + + case '?': + return -EINVAL; + + default: + fprintf(stderr, "Unknown option code '%c'.\n", c); + return -EINVAL; + } + } + + return 1; +} + +int main(int argc, char*argv[]) { + enum action { + ACTION_STATUS, + ACTION_INSTALL, + ACTION_UPDATE, + ACTION_REMOVE + } arg_action = ACTION_STATUS; + + static const struct { + const char* verb; + enum action action; + } verbs[] = { + { "status", ACTION_STATUS }, + { "install", ACTION_INSTALL }, + { "update", ACTION_UPDATE }, + { "remove", ACTION_REMOVE }, + }; + + uint8_t uuid[16] = ""; + uint32_t part = 0; + uint64_t pstart = 0; + uint64_t psize = 0; + unsigned int i; + int q; + int r; + + r = parse_argv(argc, argv); + if (r <= 0) + goto finish; + + if (argv[optind]) { + for (i = 0; i < ELEMENTSOF(verbs); i++) { + if (!streq(argv[optind], verbs[i].verb)) + continue; + arg_action = verbs[i].action; + break; + } + if (i >= ELEMENTSOF(verbs)) { + fprintf(stderr, "Unknown operation %s\n", argv[optind]); + r = -EINVAL; + goto finish; + } + } + + if (!arg_path) + arg_path = "/boot"; + + if (geteuid() != 0) { + fprintf(stderr, "Need to be root.\n"); + r = -EPERM; + goto finish; + } + + r = verify_esp(arg_path, &part, &pstart, &psize, uuid); + if (r == -ENODEV && !arg_path) + fprintf(stderr, "You might want to use --path= to indicate the path to your ESP, in case it is not mounted to /boot.\n"); + if (r < 0) + goto finish; + + switch (arg_action) { + case ACTION_STATUS: + r = status_binaries(arg_path, uuid); + if (r < 0) + goto finish; + + if (arg_touch_variables) + r = status_variables(); + break; + + case ACTION_INSTALL: + case ACTION_UPDATE: + umask(0002); + + r = install_binaries(arg_path, arg_action == ACTION_INSTALL); + if (r < 0) + goto finish; + + if (arg_action == ACTION_INSTALL) + install_loader_config(arg_path); + + if (arg_touch_variables) + r = install_variables(arg_path, + part, pstart, psize, uuid, + "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", + arg_action == ACTION_INSTALL); + break; + + case ACTION_REMOVE: + r = remove_binaries(arg_path); + + if (arg_touch_variables) { + q = remove_variables(uuid, "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", true); + if (q < 0 && r == 0) + r = q; + } + break; + } + +finish: + return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS; +} diff --git a/gummiboot-nomachineid-48/.pc/applied-patches b/gummiboot-nomachineid-48/.pc/applied-patches new file mode 100644 index 0000000..a7da49b --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/applied-patches @@ -0,0 +1,3 @@ +Set-boot-efi-as-default-ESP-mount-point.patch +setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch +disable-machine-id-logic diff --git a/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/README b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/README new file mode 100644 index 0000000..09f835f --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/README @@ -0,0 +1,26 @@ +gummiboot Simple UEFI boot manager + +gummiboot executes EFI images. The default entry is selected by a configured +pattern (glob) or an on-screen menu. + +gummiboot operates on the EFI System Partition (ESP) only. Configuration +file fragments, kernels, initrds, other EFI images need to reside on the +ESP. Linux kernels must be built with CONFIG_EFI_STUB to be able to be +directly executed as an EFI image. + +gummiboot reads simple and entirely generic configurion files; one file +per boot entry to select from. + +Pressing Space (or most other) keys during bootup will show an on-screen +menu with all configured entries to select from. Pressing enter on the +selected entry loads and starts the EFI image. + +If no timeout is configured and no key pressed during bootup, the default +entry is booted right away. + +Further documentation is available in the gummiboot wiki at: + http://freedesktop.org/wiki/Software/gummiboot + +Links: + http://www.freedesktop.org/wiki/Specifications/BootLoaderSpec + http://www.freedesktop.org/software/systemd/man/kernel-install.html diff --git a/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/man/gummiboot.xml b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/man/gummiboot.xml new file mode 100644 index 0000000..36552f8 --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/man/gummiboot.xml @@ -0,0 +1,137 @@ + + + + + + + + gummiboot + gummiboot + + + + Developer + Kay + Sievers + kay@vrfy.org + + + + + + gummiboot + 8 + + + + gummiboot + Setup and manage Gummiboot Boot Manager + + + + + gummiboot OPTIONSstatus + + + gummiboot OPTIONSupdate + + + gummiboot OPTIONSinstall + + + gummiboot OPTIONSremove + + + + + Description + + gummiboot checks, updates, + installs or removes the boot loader from the current + system. + + gummiboot status checks and prints the + currently installed versions of the boot loader binaries and the + all current EFI boot variables. + + gummiboot update updates all installed + versions of gummiboot, if the current version is newer than the + version installed in the EFI system partition. This also includes + the EFI default/fallback loader at /EFI/Boot/boot*.efi. An + gummiboot entry in the EFI boot variables is created, if there + is no current entry. A created entry will be added to the end of + the boot order list. + + gummiboot install installs gummiboot into + the EFI system partition. A copy of gummiboot will be stored as + the EFI default/fallback loader at /EFI/Boot/boot*.efi. An gummiboot + entry in the EFI boot variables is created and added to the top + of the boot order list. + + gummiboot remove removes all installed + versions of gummiboot from the EFI system partition, and removes + gummiboot from the EFI boot variables. + + If no command is passed status is + implied. + + + + Options + The following options are understood: + + + + + + + Prints a short help + text and exits. + + + + + Path to the EFI system + partition. The default is /boot. + + + + + Do not touch the EFI boot + variables. + + + + + + Exit status + On success 0 is returned, a non-zero failure + code otherwise. + + + + See Also + + Gummiboot wiki + Boot loader specification + Systemd boot loader interface + bootctl1 + + + diff --git a/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/efi/gummiboot.c b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/efi/gummiboot.c new file mode 100644 index 0000000..4e71ca6 --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/efi/gummiboot.c @@ -0,0 +1,2037 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * Simple UEFI boot loader which executes configured EFI images, where the + * default entry is selected by a configured pattern (glob) or an on-screen + * menu. + * + * All gummiboot code is LGPL not GPL, to stay out of politics and to give + * the freedom of copying code from programs to possible future libraries. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + * + * "Any intelligent fool can make things bigger, more complex, and more violent." + * -- Albert Einstein + */ + +#include +#include + +#include "util.h" +#include "console.h" +#include "graphics.h" +#include "pefile.h" +#include "linux.h" + +#ifndef EFI_OS_INDICATIONS_BOOT_TO_FW_UI +#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI 0x0000000000000001ULL +#endif + +#ifndef EFI_SECURITY_VIOLATION +#define EFI_SECURITY_VIOLATION EFIERR(26) +#endif + +/* magic string to find in the binary image */ +static const char __attribute__((used)) magic[] = "#### LoaderInfo: gummiboot " VERSION " ####"; + +static const EFI_GUID global_guid = EFI_GLOBAL_VARIABLE; + +enum loader_type { + LOADER_UNDEFINED, + LOADER_EFI, + LOADER_LINUX +}; + +typedef struct { + CHAR16 *file; + CHAR16 *title_show; + CHAR16 *title; + CHAR16 *version; + CHAR16 *machine_id; + EFI_HANDLE *device; + enum loader_type type; + CHAR16 *loader; + CHAR16 *options; + CHAR16 *splash; + CHAR16 key; + EFI_STATUS (*call)(VOID); + BOOLEAN no_autoselect; + BOOLEAN non_unique; +} ConfigEntry; + +typedef struct { + ConfigEntry **entries; + UINTN entry_count; + INTN idx_default; + INTN idx_default_efivar; + UINTN timeout_sec; + UINTN timeout_sec_config; + INTN timeout_sec_efivar; + CHAR16 *entry_default_pattern; + CHAR16 *splash; + EFI_GRAPHICS_OUTPUT_BLT_PIXEL *background; + CHAR16 *entry_oneshot; + CHAR16 *options_edit; + CHAR16 *entries_auto; +} Config; + +static VOID cursor_left(UINTN *cursor, UINTN *first) +{ + if ((*cursor) > 0) + (*cursor)--; + else if ((*first) > 0) + (*first)--; +} + +static VOID cursor_right(UINTN *cursor, UINTN *first, UINTN x_max, UINTN len) +{ + if ((*cursor)+1 < x_max) + (*cursor)++; + else if ((*first) + (*cursor) < len) + (*first)++; +} + +static BOOLEAN line_edit(CHAR16 *line_in, CHAR16 **line_out, UINTN x_max, UINTN y_pos) { + CHAR16 *line; + UINTN size; + UINTN len; + UINTN first; + CHAR16 *print; + UINTN cursor; + UINTN clear; + BOOLEAN exit; + BOOLEAN enter; + + if (!line_in) + line_in = L""; + size = StrLen(line_in) + 1024; + line = AllocatePool(size * sizeof(CHAR16)); + StrCpy(line, line_in); + len = StrLen(line); + print = AllocatePool((x_max+1) * sizeof(CHAR16)); + + uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, TRUE); + + first = 0; + cursor = 0; + clear = 0; + enter = FALSE; + exit = FALSE; + while (!exit) { + EFI_STATUS err; + UINT64 key; + UINTN i; + + i = len - first; + if (i >= x_max-1) + i = x_max-1; + CopyMem(print, line + first, i * sizeof(CHAR16)); + while (clear > 0 && i < x_max-1) { + clear--; + print[i++] = ' '; + } + print[i] = '\0'; + + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_pos); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, print); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + + err = console_key_read(&key, TRUE); + if (EFI_ERROR(err)) + continue; + + switch (key) { + case KEYPRESS(0, SCAN_ESC, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'c'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'g'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('c')): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('g')): + exit = TRUE; + break; + + case KEYPRESS(0, SCAN_HOME, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'a'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('a')): + /* beginning-of-line */ + cursor = 0; + first = 0; + continue; + + case KEYPRESS(0, SCAN_END, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'e'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('e')): + /* end-of-line */ + cursor = len - first; + if (cursor+1 >= x_max) { + cursor = x_max-1; + first = len - (x_max-1); + } + continue; + + case KEYPRESS(0, SCAN_DOWN, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, 'f'): + case KEYPRESS(EFI_CONTROL_PRESSED, SCAN_RIGHT, 0): + /* forward-word */ + while (line[first + cursor] && line[first + cursor] == ' ') + cursor_right(&cursor, &first, x_max, len); + while (line[first + cursor] && line[first + cursor] != ' ') + cursor_right(&cursor, &first, x_max, len); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(0, SCAN_UP, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, 'b'): + case KEYPRESS(EFI_CONTROL_PRESSED, SCAN_LEFT, 0): + /* backward-word */ + if ((first + cursor) > 0 && line[first + cursor-1] == ' ') { + cursor_left(&cursor, &first); + while ((first + cursor) > 0 && line[first + cursor] == ' ') + cursor_left(&cursor, &first); + } + while ((first + cursor) > 0 && line[first + cursor-1] != ' ') + cursor_left(&cursor, &first); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(0, SCAN_RIGHT, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'f'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('f')): + /* forward-char */ + if (first + cursor == len) + continue; + cursor_right(&cursor, &first, x_max, len); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(0, SCAN_LEFT, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'b'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('b')): + /* backward-char */ + cursor_left(&cursor, &first); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(EFI_ALT_PRESSED, 0, 'd'): + /* kill-word */ + clear = 0; + for (i = first + cursor; i < len && line[i] == ' '; i++) + clear++; + for (; i < len && line[i] != ' '; i++) + clear++; + + for (i = first + cursor; i + clear < len; i++) + line[i] = line[i + clear]; + len -= clear; + line[len] = '\0'; + continue; + + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'w'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('w')): + case KEYPRESS(EFI_ALT_PRESSED, 0, CHAR_BACKSPACE): + /* backward-kill-word */ + clear = 0; + if ((first + cursor) > 0 && line[first + cursor-1] == ' ') { + cursor_left(&cursor, &first); + clear++; + while ((first + cursor) > 0 && line[first + cursor] == ' ') { + cursor_left(&cursor, &first); + clear++; + } + } + while ((first + cursor) > 0 && line[first + cursor-1] != ' ') { + cursor_left(&cursor, &first); + clear++; + } + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + + for (i = first + cursor; i + clear < len; i++) + line[i] = line[i + clear]; + len -= clear; + line[len] = '\0'; + continue; + + case KEYPRESS(0, SCAN_DELETE, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'd'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('d')): + if (len == 0) + continue; + if (first + cursor == len) + continue; + for (i = first + cursor; i < len; i++) + line[i] = line[i+1]; + clear = 1; + len--; + continue; + + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'k'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('k')): + /* kill-line */ + line[first + cursor] = '\0'; + clear = len - (first + cursor); + len = first + cursor; + continue; + + case KEYPRESS(0, 0, CHAR_LINEFEED): + case KEYPRESS(0, 0, CHAR_CARRIAGE_RETURN): + if (StrCmp(line, line_in) != 0) { + *line_out = line; + line = NULL; + } + enter = TRUE; + exit = TRUE; + break; + + case KEYPRESS(0, 0, CHAR_BACKSPACE): + if (len == 0) + continue; + if (first == 0 && cursor == 0) + continue; + for (i = first + cursor-1; i < len; i++) + line[i] = line[i+1]; + clear = 1; + len--; + if (cursor > 0) + cursor--; + if (cursor > 0 || first == 0) + continue; + /* show full line if it fits */ + if (len < x_max) { + cursor = first; + first = 0; + continue; + } + /* jump left to see what we delete */ + if (first > 10) { + first -= 10; + cursor = 10; + } else { + cursor = first; + first = 0; + } + continue; + + case KEYPRESS(0, 0, ' ') ... KEYPRESS(0, 0, '~'): + case KEYPRESS(0, 0, 0x80) ... KEYPRESS(0, 0, 0xffff): + if (len+1 == size) + continue; + for (i = len; i > first + cursor; i--) + line[i] = line[i-1]; + line[first + cursor] = KEYCHAR(key); + len++; + line[len] = '\0'; + if (cursor+1 < x_max) + cursor++; + else if (first + cursor < len) + first++; + continue; + } + } + + uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, FALSE); + FreePool(print); + FreePool(line); + return enter; +} + +static UINTN entry_lookup_key(Config *config, UINTN start, CHAR16 key) { + UINTN i; + + if (key == 0) + return -1; + + /* select entry by number key */ + if (key >= '1' && key <= '9') { + i = key - '0'; + if (i > config->entry_count) + i = config->entry_count; + return i-1; + } + + /* find matching key in config entries */ + for (i = start; i < config->entry_count; i++) + if (config->entries[i]->key == key) + return i; + + for (i = 0; i < start; i++) + if (config->entries[i]->key == key) + return i; + + return -1; +} + +static VOID print_status(Config *config, EFI_FILE *root_dir, CHAR16 *loaded_image_path) { + UINT64 key; + UINTN i; + CHAR16 *s; + CHAR8 *b; + UINTN x; + UINTN y; + UINTN size; + EFI_STATUS err; + UINTN color = 0; + const EFI_GRAPHICS_OUTPUT_BLT_PIXEL *pixel = config->background; + + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + + /* show splash and wait for key */ + for (;;) { + static const EFI_GRAPHICS_OUTPUT_BLT_PIXEL colors[] = { + { .Red = 0xff, .Green = 0xff, .Blue = 0xff }, + { .Red = 0xc0, .Green = 0xc0, .Blue = 0xc0 }, + { .Red = 0xff, .Green = 0, .Blue = 0 }, + { .Red = 0, .Green = 0xff, .Blue = 0 }, + { .Red = 0, .Green = 0, .Blue = 0xff }, + { .Red = 0, .Green = 0, .Blue = 0 }, + }; + + err = EFI_NOT_FOUND; + if (config->splash) + err = graphics_splash(root_dir, config->splash, pixel); + if (EFI_ERROR(err)) + err = graphics_splash(root_dir, L"\\EFI\\gummiboot\\splash.bmp", pixel); + if (EFI_ERROR(err)) + break; + + /* 'b' rotates through background colors */ + console_key_read(&key, TRUE); + if (key == KEYPRESS(0, 0, 'b')) { + pixel = &colors[color++]; + if (color == ELEMENTSOF(colors)) + color = 0; + + continue; + } + + graphics_mode(FALSE); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + break; + } + + Print(L"gummiboot version: " VERSION "\n"); + Print(L"gummiboot architecture: " MACHINE_TYPE_NAME "\n"); + Print(L"loaded image: %s\n", loaded_image_path); + Print(L"UEFI specification: %d.%02d\n", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff); + Print(L"firmware vendor: %s\n", ST->FirmwareVendor); + Print(L"firmware version: %d.%02d\n", ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); + + if (uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut, ST->ConOut->Mode->Mode, &x, &y) == EFI_SUCCESS) + Print(L"console size: %d x %d\n", x, y); + + if (efivar_get_raw(&global_guid, L"SecureBoot", &b, &size) == EFI_SUCCESS) { + Print(L"SecureBoot: %s\n", *b > 0 ? L"enabled" : L"disabled"); + FreePool(b); + } + + if (efivar_get_raw(&global_guid, L"SetupMode", &b, &size) == EFI_SUCCESS) { + Print(L"SetupMode: %s\n", *b > 0 ? L"setup" : L"user"); + FreePool(b); + } + + if (efivar_get_raw(&global_guid, L"OsIndicationsSupported", &b, &size) == EFI_SUCCESS) { + Print(L"OsIndicationsSupported: %d\n", (UINT64)*b); + FreePool(b); + } + Print(L"\n"); + + Print(L"timeout: %d\n", config->timeout_sec); + if (config->timeout_sec_efivar >= 0) + Print(L"timeout (EFI var): %d\n", config->timeout_sec_efivar); + Print(L"timeout (config): %d\n", config->timeout_sec_config); + if (config->entry_default_pattern) + Print(L"default pattern: '%s'\n", config->entry_default_pattern); + if (config->splash) + Print(L"splash '%s'\n", config->splash); + if (config->background) + Print(L"background '#%02x%02x%02x'\n", + config->background->Red, + config->background->Green, + config->background->Blue); + Print(L"\n"); + + Print(L"config entry count: %d\n", config->entry_count); + Print(L"entry selected idx: %d\n", config->idx_default); + if (config->idx_default_efivar >= 0) + Print(L"entry EFI var idx: %d\n", config->idx_default_efivar); + Print(L"\n"); + + if (efivar_get_int(L"LoaderConfigTimeout", &i) == EFI_SUCCESS) + Print(L"LoaderConfigTimeout: %d\n", i); + if (config->entry_oneshot) + Print(L"LoaderEntryOneShot: %s\n", config->entry_oneshot); + if (efivar_get(L"LoaderDeviceIdentifier", &s) == EFI_SUCCESS) { + Print(L"LoaderDeviceIdentifier: %s\n", s); + FreePool(s); + } + if (efivar_get(L"LoaderDevicePartUUID", &s) == EFI_SUCCESS) { + Print(L"LoaderDevicePartUUID: %s\n", s); + FreePool(s); + } + if (efivar_get(L"LoaderEntryDefault", &s) == EFI_SUCCESS) { + Print(L"LoaderEntryDefault: %s\n", s); + FreePool(s); + } + + Print(L"\n--- press key ---\n\n"); + console_key_read(&key, TRUE); + + for (i = 0; i < config->entry_count; i++) { + ConfigEntry *entry; + + if (key == KEYPRESS(0, SCAN_ESC, 0) || key == KEYPRESS(0, 0, 'q')) + break; + + entry = config->entries[i]; + + if (entry->splash) { + err = graphics_splash(root_dir, entry->splash, config->background); + if (!EFI_ERROR(err)) { + console_key_read(&key, TRUE); + graphics_mode(FALSE); + } + } + + Print(L"config entry: %d/%d\n", i+1, config->entry_count); + if (entry->file) + Print(L"file '%s'\n", entry->file); + Print(L"title show '%s'\n", entry->title_show); + if (entry->title) + Print(L"title '%s'\n", entry->title); + if (entry->version) + Print(L"version '%s'\n", entry->version); + if (entry->machine_id) + Print(L"machine-id '%s'\n", entry->machine_id); + if (entry->device) { + EFI_DEVICE_PATH *device_path; + CHAR16 *str; + + device_path = DevicePathFromHandle(entry->device); + if (device_path) { + str = DevicePathToStr(device_path); + Print(L"device handle '%s'\n", str); + FreePool(str); + } + } + if (entry->loader) + Print(L"loader '%s'\n", entry->loader); + if (entry->options) + Print(L"options '%s'\n", entry->options); + if (entry->splash) + Print(L"splash '%s'\n", entry->splash); + Print(L"auto-select %s\n", entry->no_autoselect ? L"no" : L"yes"); + if (entry->call) + Print(L"internal call yes\n"); + + Print(L"\n--- press key ---\n\n"); + console_key_read(&key, TRUE); + } + + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); +} + +static BOOLEAN menu_run(Config *config, ConfigEntry **chosen_entry, EFI_FILE *root_dir, CHAR16 *loaded_image_path) { + EFI_STATUS err; + UINTN visible_max; + UINTN idx_highlight; + UINTN idx_highlight_prev; + UINTN idx_first; + UINTN idx_last; + BOOLEAN refresh; + BOOLEAN highlight; + UINTN i; + UINTN line_width; + CHAR16 **lines; + UINTN x_start; + UINTN y_start; + UINTN x_max; + UINTN y_max; + CHAR16 *status; + CHAR16 *clearline; + INTN timeout_remain; + INT16 idx; + BOOLEAN exit = FALSE; + BOOLEAN run = TRUE; + BOOLEAN wait = FALSE; + + graphics_mode(FALSE); + uefi_call_wrapper(ST->ConIn->Reset, 2, ST->ConIn, FALSE); + uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, FALSE); + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + + /* draw a single character to make ClearScreen work on some firmware */ + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L" "); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + + err = uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut, ST->ConOut->Mode->Mode, &x_max, &y_max); + if (EFI_ERROR(err)) { + x_max = 80; + y_max = 25; + } + + /* we check 10 times per second for a keystroke */ + if (config->timeout_sec > 0) + timeout_remain = config->timeout_sec * 10; + else + timeout_remain = -1; + + idx_highlight = config->idx_default; + idx_highlight_prev = 0; + + visible_max = y_max - 2; + + if ((UINTN)config->idx_default >= visible_max) + idx_first = config->idx_default-1; + else + idx_first = 0; + + idx_last = idx_first + visible_max-1; + + refresh = TRUE; + highlight = FALSE; + + /* length of the longest entry */ + line_width = 5; + for (i = 0; i < config->entry_count; i++) { + UINTN entry_len; + + entry_len = StrLen(config->entries[i]->title_show); + if (line_width < entry_len) + line_width = entry_len; + } + if (line_width > x_max-6) + line_width = x_max-6; + + /* offsets to center the entries on the screen */ + x_start = (x_max - (line_width)) / 2; + if (config->entry_count < visible_max) + y_start = ((visible_max - config->entry_count) / 2) + 1; + else + y_start = 0; + + /* menu entries title lines */ + lines = AllocatePool(sizeof(CHAR16 *) * config->entry_count); + for (i = 0; i < config->entry_count; i++) { + UINTN j, k; + + lines[i] = AllocatePool(((x_max+1) * sizeof(CHAR16))); + for (j = 0; j < x_start; j++) + lines[i][j] = ' '; + + for (k = 0; config->entries[i]->title_show[k] != '\0' && j < x_max; j++, k++) + lines[i][j] = config->entries[i]->title_show[k]; + + for (; j < x_max; j++) + lines[i][j] = ' '; + lines[i][x_max] = '\0'; + } + + status = NULL; + clearline = AllocatePool((x_max+1) * sizeof(CHAR16)); + for (i = 0; i < x_max; i++) + clearline[i] = ' '; + clearline[i] = 0; + + while (!exit) { + UINT64 key; + + if (refresh) { + for (i = 0; i < config->entry_count; i++) { + if (i < idx_first || i > idx_last) + continue; + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_start + i - idx_first); + if (i == idx_highlight) + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, + EFI_BLACK|EFI_BACKGROUND_LIGHTGRAY); + else + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, + EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, lines[i]); + if ((INTN)i == config->idx_default_efivar) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, x_start-3, y_start + i - idx_first); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"=>"); + } + } + refresh = FALSE; + } else if (highlight) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_start + idx_highlight_prev - idx_first); + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, lines[idx_highlight_prev]); + if ((INTN)idx_highlight_prev == config->idx_default_efivar) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, x_start-3, y_start + idx_highlight_prev - idx_first); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"=>"); + } + + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_start + idx_highlight - idx_first); + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_BLACK|EFI_BACKGROUND_LIGHTGRAY); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, lines[idx_highlight]); + if ((INTN)idx_highlight == config->idx_default_efivar) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, x_start-3, y_start + idx_highlight - idx_first); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"=>"); + } + highlight = FALSE; + } + + if (timeout_remain > 0) { + FreePool(status); + status = PoolPrint(L"Boot in %d sec.", (timeout_remain + 5) / 10); + } + + /* print status at last line of screen */ + if (status) { + UINTN len; + UINTN x; + + /* center line */ + len = StrLen(status); + if (len < x_max) + x = (x_max - len) / 2; + else + x = 0; + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline + (x_max - x)); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, status); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1 + x + len); + } + + err = console_key_read(&key, wait); + if (EFI_ERROR(err)) { + /* timeout reached */ + if (timeout_remain == 0) { + exit = TRUE; + break; + } + + /* sleep and update status */ + if (timeout_remain > 0) { + uefi_call_wrapper(BS->Stall, 1, 100 * 1000); + timeout_remain--; + continue; + } + + /* timeout disabled, wait for next key */ + wait = TRUE; + continue; + } + + timeout_remain = -1; + + /* clear status after keystroke */ + if (status) { + FreePool(status); + status = NULL; + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1); + } + + idx_highlight_prev = idx_highlight; + + switch (key) { + case KEYPRESS(0, SCAN_UP, 0): + case KEYPRESS(0, 0, 'k'): + if (idx_highlight > 0) + idx_highlight--; + break; + + case KEYPRESS(0, SCAN_DOWN, 0): + case KEYPRESS(0, 0, 'j'): + if (idx_highlight < config->entry_count-1) + idx_highlight++; + break; + + case KEYPRESS(0, SCAN_HOME, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, '<'): + if (idx_highlight > 0) { + refresh = TRUE; + idx_highlight = 0; + } + break; + + case KEYPRESS(0, SCAN_END, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, '>'): + if (idx_highlight < config->entry_count-1) { + refresh = TRUE; + idx_highlight = config->entry_count-1; + } + break; + + case KEYPRESS(0, SCAN_PAGE_UP, 0): + if (idx_highlight > visible_max) + idx_highlight -= visible_max; + else + idx_highlight = 0; + break; + + case KEYPRESS(0, SCAN_PAGE_DOWN, 0): + idx_highlight += visible_max; + if (idx_highlight > config->entry_count-1) + idx_highlight = config->entry_count-1; + break; + + case KEYPRESS(0, 0, CHAR_LINEFEED): + case KEYPRESS(0, 0, CHAR_CARRIAGE_RETURN): + exit = TRUE; + break; + + case KEYPRESS(0, SCAN_F1, 0): + case KEYPRESS(0, 0, 'h'): + case KEYPRESS(0, 0, '?'): + status = StrDuplicate(L"(d)efault, (t/T)timeout, (e)dit, (v)ersion (Q)uit (P)rint (h)elp"); + break; + + case KEYPRESS(0, 0, 'Q'): + exit = TRUE; + run = FALSE; + break; + + case KEYPRESS(0, 0, 'd'): + if (config->idx_default_efivar != (INTN)idx_highlight) { + /* store the selected entry in a persistent EFI variable */ + efivar_set(L"LoaderEntryDefault", config->entries[idx_highlight]->file, TRUE); + config->idx_default_efivar = idx_highlight; + status = StrDuplicate(L"Default boot entry selected."); + } else { + /* clear the default entry EFI variable */ + efivar_set(L"LoaderEntryDefault", NULL, TRUE); + config->idx_default_efivar = -1; + status = StrDuplicate(L"Default boot entry cleared."); + } + refresh = TRUE; + break; + + case KEYPRESS(0, 0, '-'): + case KEYPRESS(0, 0, 'T'): + if (config->timeout_sec_efivar > 0) { + config->timeout_sec_efivar--; + efivar_set_int(L"LoaderConfigTimeout", config->timeout_sec_efivar, TRUE); + if (config->timeout_sec_efivar > 0) + status = PoolPrint(L"Menu timeout set to %d sec.", config->timeout_sec_efivar); + else + status = StrDuplicate(L"Menu disabled. Hold down key at bootup to show menu."); + } else if (config->timeout_sec_efivar <= 0){ + config->timeout_sec_efivar = -1; + efivar_set(L"LoaderConfigTimeout", NULL, TRUE); + if (config->timeout_sec_config > 0) + status = PoolPrint(L"Menu timeout of %d sec is defined by configuration file.", + config->timeout_sec_config); + else + status = StrDuplicate(L"Menu disabled. Hold down key at bootup to show menu."); + } + break; + + case KEYPRESS(0, 0, '+'): + case KEYPRESS(0, 0, 't'): + if (config->timeout_sec_efivar == -1 && config->timeout_sec_config == 0) + config->timeout_sec_efivar++; + config->timeout_sec_efivar++; + efivar_set_int(L"LoaderConfigTimeout", config->timeout_sec_efivar, TRUE); + if (config->timeout_sec_efivar > 0) + status = PoolPrint(L"Menu timeout set to %d sec.", + config->timeout_sec_efivar); + else + status = StrDuplicate(L"Menu disabled. Hold down key at bootup to show menu."); + break; + + case KEYPRESS(0, 0, 'e'): + /* only the options of configured entries can be edited */ + if (config->entries[idx_highlight]->type == LOADER_UNDEFINED) + break; + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1); + if (line_edit(config->entries[idx_highlight]->options, &config->options_edit, x_max-1, y_max-1)) + exit = TRUE; + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1); + break; + + case KEYPRESS(0, 0, 'v'): + status = PoolPrint(L"gummiboot " VERSION " (" MACHINE_TYPE_NAME "), UEFI Specification %d.%02d, Vendor %s %d.%02d", + ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff, + ST->FirmwareVendor, ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); + break; + + case KEYPRESS(0, 0, 'P'): + print_status(config, root_dir, loaded_image_path); + refresh = TRUE; + break; + + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'l'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('l')): + refresh = TRUE; + break; + + default: + /* jump with a hotkey directly to a matching entry */ + idx = entry_lookup_key(config, idx_highlight+1, KEYCHAR(key)); + if (idx < 0) + break; + idx_highlight = idx; + refresh = TRUE; + } + + if (idx_highlight > idx_last) { + idx_last = idx_highlight; + idx_first = 1 + idx_highlight - visible_max; + refresh = TRUE; + } + if (idx_highlight < idx_first) { + idx_first = idx_highlight; + idx_last = idx_highlight + visible_max-1; + refresh = TRUE; + } + + idx_last = idx_first + visible_max-1; + + if (!refresh && idx_highlight != idx_highlight_prev) + highlight = TRUE; + } + + *chosen_entry = config->entries[idx_highlight]; + + for (i = 0; i < config->entry_count; i++) + FreePool(lines[i]); + FreePool(lines); + FreePool(clearline); + + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_WHITE|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + return run; +} + +static VOID config_add_entry(Config *config, ConfigEntry *entry) { + if ((config->entry_count & 15) == 0) { + UINTN i; + + i = config->entry_count + 16; + if (config->entry_count == 0) + config->entries = AllocatePool(sizeof(VOID *) * i); + else + config->entries = ReallocatePool(config->entries, + sizeof(VOID *) * config->entry_count, sizeof(VOID *) * i); + } + config->entries[config->entry_count++] = entry; +} + +static VOID config_entry_free(ConfigEntry *entry) { + FreePool(entry->title_show); + FreePool(entry->title); + FreePool(entry->machine_id); + FreePool(entry->loader); + FreePool(entry->options); +} + +static BOOLEAN is_digit(CHAR16 c) +{ + return (c >= '0') && (c <= '9'); +} + +static UINTN c_order(CHAR16 c) +{ + if (c == '\0') + return 0; + if (is_digit(c)) + return 0; + else if ((c >= 'a') && (c <= 'z')) + return c; + else + return c + 0x10000; +} + +static INTN str_verscmp(CHAR16 *s1, CHAR16 *s2) +{ + CHAR16 *os1 = s1; + CHAR16 *os2 = s2; + + while (*s1 || *s2) { + INTN first; + + while ((*s1 && !is_digit(*s1)) || (*s2 && !is_digit(*s2))) { + INTN order; + + order = c_order(*s1) - c_order(*s2); + if (order) + return order; + s1++; + s2++; + } + + while (*s1 == '0') + s1++; + while (*s2 == '0') + s2++; + + first = 0; + while (is_digit(*s1) && is_digit(*s2)) { + if (first == 0) + first = *s1 - *s2; + s1++; + s2++; + } + + if (is_digit(*s1)) + return 1; + if (is_digit(*s2)) + return -1; + + if (first) + return first; + } + + return StrCmp(os1, os2); +} + +static CHAR8 *line_get_key_value(CHAR8 *content, CHAR8 *sep, UINTN *pos, CHAR8 **key_ret, CHAR8 **value_ret) { + CHAR8 *line; + UINTN linelen; + CHAR8 *value; + +skip: + line = content + *pos; + if (*line == '\0') + return NULL; + + linelen = 0; + while (line[linelen] && !strchra((CHAR8 *)"\n\r", line[linelen])) + linelen++; + + /* move pos to next line */ + *pos += linelen; + if (content[*pos]) + (*pos)++; + + /* empty line */ + if (linelen == 0) + goto skip; + + /* terminate line */ + line[linelen] = '\0'; + + /* remove leading whitespace */ + while (strchra((CHAR8 *)" \t", *line)) { + line++; + linelen--; + } + + /* remove trailing whitespace */ + while (linelen > 0 && strchra(sep, line[linelen-1])) + linelen--; + line[linelen] = '\0'; + + if (*line == '#') + goto skip; + + /* split key/value */ + value = line; + while (*value && !strchra(sep, *value)) + value++; + if (*value == '\0') + goto skip; + *value = '\0'; + value++; + while (*value && strchra(sep, *value)) + value++; + + /* unquote */ + if (value[0] == '\"' && line[linelen-1] == '\"') { + value++; + line[linelen-1] = '\0'; + } + + *key_ret = line; + *value_ret = value; + return line; +} + +static VOID config_defaults_load_from_file(Config *config, CHAR8 *content) { + CHAR8 *line; + UINTN pos = 0; + CHAR8 *key, *value; + + line = content; + while ((line = line_get_key_value(content, (CHAR8 *)" \t", &pos, &key, &value))) { + if (strcmpa((CHAR8 *)"timeout", key) == 0) { + CHAR16 *s; + + s = stra_to_str(value); + config->timeout_sec_config = Atoi(s); + config->timeout_sec = config->timeout_sec_config; + FreePool(s); + continue; + } + + if (strcmpa((CHAR8 *)"default", key) == 0) { + FreePool(config->entry_default_pattern); + config->entry_default_pattern = stra_to_str(value); + StrLwr(config->entry_default_pattern); + continue; + } + + if (strcmpa((CHAR8 *)"splash", key) == 0) { + FreePool(config->splash); + config->splash = stra_to_path(value); + continue; + } + + if (strcmpa((CHAR8 *)"background", key) == 0) { + CHAR16 c[3]; + + /* accept #RRGGBB hex notation */ + if (value[0] != '#') + continue; + if (value[7] != '\0') + continue; + + FreePool(config->background); + config->background = AllocateZeroPool(sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); + if (!config->background) + continue; + + c[0] = value[1]; + c[1] = value[2]; + c[2] = '\0'; + config->background->Red = xtoi(c); + + c[0] = value[3]; + c[1] = value[4]; + config->background->Green = xtoi(c); + + c[0] = value[5]; + c[1] = value[6]; + config->background->Blue = xtoi(c); + continue; + } + } +} + +static VOID config_entry_add_from_file(Config *config, EFI_HANDLE *device, CHAR16 *file, CHAR8 *content, CHAR16 *loaded_image_path) { + ConfigEntry *entry; + CHAR8 *line; + UINTN pos = 0; + CHAR8 *key, *value; + UINTN len; + CHAR16 *initrd = NULL; + + entry = AllocateZeroPool(sizeof(ConfigEntry)); + + line = content; + while ((line = line_get_key_value(content, (CHAR8 *)" \t", &pos, &key, &value))) { + if (strcmpa((CHAR8 *)"title", key) == 0) { + FreePool(entry->title); + entry->title = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"version", key) == 0) { + FreePool(entry->version); + entry->version = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"machine-id", key) == 0) { + FreePool(entry->machine_id); + entry->machine_id = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"linux", key) == 0) { + FreePool(entry->loader); + entry->type = LOADER_LINUX; + entry->loader = stra_to_path(value); + entry->key = 'l'; + continue; + } + + if (strcmpa((CHAR8 *)"efi", key) == 0) { + entry->type = LOADER_EFI; + FreePool(entry->loader); + entry->loader = stra_to_path(value); + + /* do not add an entry for ourselves */ + if (StriCmp(entry->loader, loaded_image_path) == 0) { + entry->type = LOADER_UNDEFINED; + break; + } + continue; + } + + if (strcmpa((CHAR8 *)"architecture", key) == 0) { + /* do not add an entry for an EFI image of architecture not matching with that of the gummiboot image */ + if (strcmpa((CHAR8 *)MACHINE_TYPE_NAME, value) != 0) { + entry->type = LOADER_UNDEFINED; + break; + } + continue; + } + + if (strcmpa((CHAR8 *)"initrd", key) == 0) { + CHAR16 *new; + + new = stra_to_path(value); + if (initrd) { + CHAR16 *s; + + s = PoolPrint(L"%s initrd=%s", initrd, new); + FreePool(initrd); + initrd = s; + } else + initrd = PoolPrint(L"initrd=%s", new); + FreePool(new); + continue; + } + + if (strcmpa((CHAR8 *)"options", key) == 0) { + CHAR16 *new; + + new = stra_to_str(value); + if (entry->options) { + CHAR16 *s; + + s = PoolPrint(L"%s %s", entry->options, new); + FreePool(entry->options); + entry->options = s; + } else { + entry->options = new; + new = NULL; + } + FreePool(new); + continue; + } + + if (strcmpa((CHAR8 *)"splash", key) == 0) { + FreePool(entry->splash); + entry->splash = stra_to_path(value); + continue; + } + } + + if (entry->type == LOADER_UNDEFINED) { + config_entry_free(entry); + FreePool(initrd); + FreePool(entry); + return; + } + + /* add initrd= to options */ + if (entry->type == LOADER_LINUX && initrd) { + if (entry->options) { + CHAR16 *s; + + s = PoolPrint(L"%s %s", initrd, entry->options); + FreePool(entry->options); + entry->options = s; + } else { + entry->options = initrd; + initrd = NULL; + } + } + FreePool(initrd); + + if (entry->machine_id) { + CHAR16 *var; + + /* append additional options from EFI variables for this machine-id */ + var = PoolPrint(L"LoaderEntryOptions-%s", entry->machine_id); + if (var) { + CHAR16 *s; + + if (efivar_get(var, &s) == EFI_SUCCESS) { + if (entry->options) { + CHAR16 *s2; + + s2 = PoolPrint(L"%s %s", entry->options, s); + FreePool(entry->options); + entry->options = s2; + } else + entry->options = s; + } + FreePool(var); + } + + var = PoolPrint(L"LoaderEntryOptionsOneShot-%s", entry->machine_id); + if (var) { + CHAR16 *s; + + if (efivar_get(var, &s) == EFI_SUCCESS) { + if (entry->options) { + CHAR16 *s2; + + s2 = PoolPrint(L"%s %s", entry->options, s); + FreePool(entry->options); + entry->options = s2; + } else + entry->options = s; + efivar_set(var, NULL, TRUE); + } + FreePool(var); + } + } + + entry->device = device; + entry->file = StrDuplicate(file); + len = StrLen(entry->file); + /* remove ".conf" */ + if (len > 5) + entry->file[len - 5] = '\0'; + StrLwr(entry->file); + + config_add_entry(config, entry); +} + +static VOID config_load(Config *config, EFI_HANDLE *device, EFI_FILE *root_dir, CHAR16 *loaded_image_path) { + EFI_FILE_HANDLE entries_dir; + EFI_STATUS err; + CHAR8 *content = NULL; + UINTN sec; + UINTN len; + UINTN i; + + len = file_read(root_dir, L"\\loader\\loader.conf", 0, 0, &content); + if (len > 0) + config_defaults_load_from_file(config, content); + FreePool(content); + + err = efivar_get_int(L"LoaderConfigTimeout", &sec); + if (!EFI_ERROR(err)) { + config->timeout_sec_efivar = sec; + config->timeout_sec = sec; + } else + config->timeout_sec_efivar = -1; + + err = uefi_call_wrapper(root_dir->Open, 5, root_dir, &entries_dir, L"\\loader\\entries", EFI_FILE_MODE_READ, 0ULL); + if (!EFI_ERROR(err)) { + for (;;) { + CHAR16 buf[256]; + UINTN bufsize; + EFI_FILE_INFO *f; + CHAR8 *content = NULL; + UINTN len; + + bufsize = sizeof(buf); + err = uefi_call_wrapper(entries_dir->Read, 3, entries_dir, &bufsize, buf); + if (bufsize == 0 || EFI_ERROR(err)) + break; + + f = (EFI_FILE_INFO *) buf; + if (f->FileName[0] == '.') + continue; + if (f->Attribute & EFI_FILE_DIRECTORY) + continue; + len = StrLen(f->FileName); + if (len < 6) + continue; + if (StriCmp(f->FileName + len - 5, L".conf") != 0) + continue; + + len = file_read(entries_dir, f->FileName, 0, 0, &content); + if (len > 0) + config_entry_add_from_file(config, device, f->FileName, content, loaded_image_path); + FreePool(content); + } + uefi_call_wrapper(entries_dir->Close, 1, entries_dir); + } + + /* sort entries after version number */ + for (i = 1; i < config->entry_count; i++) { + BOOLEAN more; + UINTN k; + + more = FALSE; + for (k = 0; k < config->entry_count - i; k++) { + ConfigEntry *entry; + + if (str_verscmp(config->entries[k]->file, config->entries[k+1]->file) <= 0) + continue; + entry = config->entries[k]; + config->entries[k] = config->entries[k+1]; + config->entries[k+1] = entry; + more = TRUE; + } + if (!more) + break; + } +} + +static VOID config_default_entry_select(Config *config) { + CHAR16 *var; + EFI_STATUS err; + UINTN i; + + /* + * The EFI variable to specify a boot entry for the next, and only the + * next reboot. The variable is always cleared directly after it is read. + */ + err = efivar_get(L"LoaderEntryOneShot", &var); + if (!EFI_ERROR(err)) { + BOOLEAN found = FALSE; + + for (i = 0; i < config->entry_count; i++) { + if (StrCmp(config->entries[i]->file, var) == 0) { + config->idx_default = i; + found = TRUE; + break; + } + } + + config->entry_oneshot = StrDuplicate(var); + efivar_set(L"LoaderEntryOneShot", NULL, TRUE); + FreePool(var); + if (found) + return; + } + + /* + * The EFI variable to select the default boot entry overrides the + * configured pattern. The variable can be set and cleared by pressing + * the 'd' key in the loader selection menu, the entry is marked with + * an '*'. + */ + err = efivar_get(L"LoaderEntryDefault", &var); + if (!EFI_ERROR(err)) { + BOOLEAN found = FALSE; + + for (i = 0; i < config->entry_count; i++) { + if (StrCmp(config->entries[i]->file, var) == 0) { + config->idx_default = i; + config->idx_default_efivar = i; + found = TRUE; + break; + } + } + FreePool(var); + if (found) + return; + } + config->idx_default_efivar = -1; + + if (config->entry_count == 0) + return; + + /* + * Match the pattern from the end of the list to the start, find last + * entry (largest number) matching the given pattern. + */ + if (config->entry_default_pattern) { + i = config->entry_count; + while (i--) { + if (config->entries[i]->no_autoselect) + continue; + if (MetaiMatch(config->entries[i]->file, config->entry_default_pattern)) { + config->idx_default = i; + return; + } + } + } + + /* select the last suitable entry */ + i = config->entry_count; + while (i--) { + if (config->entries[i]->no_autoselect) + continue; + config->idx_default = i; + return; + } + + /* no entry found */ + config->idx_default = -1; +} + +/* generate a unique title, avoiding non-distinguishable menu entries */ +static VOID config_title_generate(Config *config) { + UINTN i, k; + BOOLEAN unique; + + /* set title */ + for (i = 0; i < config->entry_count; i++) { + CHAR16 *title; + + FreePool(config->entries[i]->title_show); + title = config->entries[i]->title; + if (!title) + title = config->entries[i]->file; + config->entries[i]->title_show = StrDuplicate(title); + } + + unique = TRUE; + for (i = 0; i < config->entry_count; i++) { + for (k = 0; k < config->entry_count; k++) { + if (i == k) + continue; + if (StrCmp(config->entries[i]->title_show, config->entries[k]->title_show) != 0) + continue; + + unique = FALSE; + config->entries[i]->non_unique = TRUE; + config->entries[k]->non_unique = TRUE; + } + } + if (unique) + return; + + /* add version to non-unique titles */ + for (i = 0; i < config->entry_count; i++) { + CHAR16 *s; + + if (!config->entries[i]->non_unique) + continue; + if (!config->entries[i]->version) + continue; + + s = PoolPrint(L"%s (%s)", config->entries[i]->title_show, config->entries[i]->version); + FreePool(config->entries[i]->title_show); + config->entries[i]->title_show = s; + config->entries[i]->non_unique = FALSE; + } + + unique = TRUE; + for (i = 0; i < config->entry_count; i++) { + for (k = 0; k < config->entry_count; k++) { + if (i == k) + continue; + if (StrCmp(config->entries[i]->title_show, config->entries[k]->title_show) != 0) + continue; + + unique = FALSE; + config->entries[i]->non_unique = TRUE; + config->entries[k]->non_unique = TRUE; + } + } + if (unique) + return; + + /* add machine-id to non-unique titles */ + for (i = 0; i < config->entry_count; i++) { + CHAR16 *s; + CHAR16 *m; + + if (!config->entries[i]->non_unique) + continue; + if (!config->entries[i]->machine_id) + continue; + + m = StrDuplicate(config->entries[i]->machine_id); + m[8] = '\0'; + s = PoolPrint(L"%s (%s)", config->entries[i]->title_show, m); + FreePool(config->entries[i]->title_show); + config->entries[i]->title_show = s; + config->entries[i]->non_unique = FALSE; + FreePool(m); + } + + unique = TRUE; + for (i = 0; i < config->entry_count; i++) { + for (k = 0; k < config->entry_count; k++) { + if (i == k) + continue; + if (StrCmp(config->entries[i]->title_show, config->entries[k]->title_show) != 0) + continue; + + unique = FALSE; + config->entries[i]->non_unique = TRUE; + config->entries[k]->non_unique = TRUE; + } + } + if (unique) + return; + + /* add file name to non-unique titles */ + for (i = 0; i < config->entry_count; i++) { + CHAR16 *s; + + if (!config->entries[i]->non_unique) + continue; + s = PoolPrint(L"%s (%s)", config->entries[i]->title_show, config->entries[i]->file); + FreePool(config->entries[i]->title_show); + config->entries[i]->title_show = s; + config->entries[i]->non_unique = FALSE; + } +} + +static BOOLEAN config_entry_add_call(Config *config, CHAR16 *title, EFI_STATUS (*call)(VOID)) { + ConfigEntry *entry; + + entry = AllocateZeroPool(sizeof(ConfigEntry)); + entry->title = StrDuplicate(title); + entry->call = call; + entry->no_autoselect = TRUE; + config_add_entry(config, entry); + return TRUE; +} + +static ConfigEntry *config_entry_add_loader(Config *config, EFI_HANDLE *device, + enum loader_type type,CHAR16 *file, CHAR16 key, CHAR16 *title, CHAR16 *loader) { + ConfigEntry *entry; + + entry = AllocateZeroPool(sizeof(ConfigEntry)); + entry->type = type; + entry->title = StrDuplicate(title); + entry->device = device; + entry->loader = StrDuplicate(loader); + entry->file = StrDuplicate(file); + StrLwr(entry->file); + entry->key = key; + config_add_entry(config, entry); + + return entry; +} + +static BOOLEAN config_entry_add_loader_auto(Config *config, EFI_HANDLE *device, EFI_FILE *root_dir, CHAR16 *loaded_image_path, + CHAR16 *file, CHAR16 key, CHAR16 *title, CHAR16 *loader) { + EFI_FILE_HANDLE handle; + ConfigEntry *entry; + EFI_STATUS err; + + /* do not add an entry for ourselves */ + if (loaded_image_path && StriCmp(loader, loaded_image_path) == 0) + return FALSE; + + /* check existence */ + err = uefi_call_wrapper(root_dir->Open, 5, root_dir, &handle, loader, EFI_FILE_MODE_READ, 0ULL); + if (EFI_ERROR(err)) + return FALSE; + uefi_call_wrapper(handle->Close, 1, handle); + + entry = config_entry_add_loader(config, device, LOADER_UNDEFINED, file, key, title, loader); + if (!entry) + return FALSE; + + /* do not boot right away into auto-detected entries */ + entry->no_autoselect = TRUE; + + /* do not show a splash; they do not need one, or they draw their own */ + entry->splash = StrDuplicate(L""); + + /* export identifiers of automatically added entries */ + if (config->entries_auto) { + CHAR16 *s; + + s = PoolPrint(L"%s %s", config->entries_auto, file); + FreePool(config->entries_auto); + config->entries_auto = s; + } else + config->entries_auto = StrDuplicate(file); + + return TRUE; +} + +static VOID config_entry_add_osx(Config *config) { + EFI_STATUS err; + UINTN handle_count = 0; + EFI_HANDLE *handles = NULL; + + err = LibLocateHandle(ByProtocol, &FileSystemProtocol, NULL, &handle_count, &handles); + if (!EFI_ERROR(err)) { + UINTN i; + + for (i = 0; i < handle_count; i++) { + EFI_FILE *root; + BOOLEAN found; + + root = LibOpenRoot(handles[i]); + if (!root) + continue; + found = config_entry_add_loader_auto(config, handles[i], root, NULL, L"auto-osx", 'a', L"OS X", + L"\\System\\Library\\CoreServices\\boot.efi"); + uefi_call_wrapper(root->Close, 1, root); + if (found) + break; + } + + FreePool(handles); + } +} + +static VOID config_entry_add_linux( Config *config, EFI_LOADED_IMAGE *loaded_image, EFI_FILE *root_dir) { + EFI_FILE_HANDLE linux_dir; + EFI_STATUS err; + + err = uefi_call_wrapper(root_dir->Open, 5, root_dir, &linux_dir, L"\\EFI\\Linux", EFI_FILE_MODE_READ, 0ULL); + if (!EFI_ERROR(err)) { + for (;;) { + CHAR16 buf[256]; + UINTN bufsize; + EFI_FILE_INFO *f; + CHAR8 *sections[] = { + (UINT8 *)".osrel", + NULL + }; + UINTN offs[ELEMENTSOF(sections)-1] = {}; + UINTN szs[ELEMENTSOF(sections)-1] = {}; + UINTN addrs[ELEMENTSOF(sections)-1] = {}; + CHAR8 *content = NULL; + UINTN len; + CHAR8 *line; + UINTN pos = 0; + CHAR8 *key, *value; + CHAR16 *os_name = NULL; + CHAR16 *os_id = NULL; + CHAR16 *os_version = NULL; + + bufsize = sizeof(buf); + err = uefi_call_wrapper(linux_dir->Read, 3, linux_dir, &bufsize, buf); + if (bufsize == 0 || EFI_ERROR(err)) + break; + + f = (EFI_FILE_INFO *) buf; + if (f->FileName[0] == '.') + continue; + if (f->Attribute & EFI_FILE_DIRECTORY) + continue; + len = StrLen(f->FileName); + if (len < 5) + continue; + if (StriCmp(f->FileName + len - 4, L".efi") != 0) + continue; + + /* look for an .osrel section in the .efi binary */ + err = pefile_locate_sections(linux_dir, f->FileName, sections, addrs, offs, szs); + if (EFI_ERROR(err)) + continue; + + len = file_read(linux_dir, f->FileName, offs[0], szs[0], &content); + if (len <= 0) + continue; + + /* read properties from the embedded os-release file */ + line = content; + while ((line = line_get_key_value(content, (CHAR8 *)"=", &pos, &key, &value))) { + if (strcmpa((CHAR8 *)"PRETTY_NAME", key) == 0) { + os_name = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"ID", key) == 0) { + os_id = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"VERSION_ID", key) == 0) { + os_version = stra_to_str(value); + continue; + } + } + + if (os_name && os_id && os_version) { + CHAR16 *conf; + CHAR16 *path; + + conf = PoolPrint(L"%s-%s", os_id, os_version); + path = PoolPrint(L"\\EFI\\Linux\\%s", f->FileName); + config_entry_add_loader(config, loaded_image->DeviceHandle, LOADER_LINUX, conf, 'l', os_name, path); + FreePool(conf); + FreePool(path); + FreePool(os_name); + FreePool(os_id); + FreePool(os_version); + } + + FreePool(content); + } + uefi_call_wrapper(linux_dir->Close, 1, linux_dir); + } +} + +static EFI_STATUS image_start(EFI_HANDLE parent_image, const Config *config, const ConfigEntry *entry) { + EFI_HANDLE image; + EFI_DEVICE_PATH *path; + CHAR16 *options; + EFI_STATUS err; + + path = FileDevicePath(entry->device, entry->loader); + if (!path) { + Print(L"Error getting device path."); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return EFI_INVALID_PARAMETER; + } + + err = uefi_call_wrapper(BS->LoadImage, 6, FALSE, parent_image, path, NULL, 0, &image); + if (EFI_ERROR(err)) { + Print(L"Error loading %s: %r", entry->loader, err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out; + } + + if (config->options_edit) + options = config->options_edit; + else if (entry->options) + options = entry->options; + else + options = NULL; + if (options) { + EFI_LOADED_IMAGE *loaded_image; + + err = uefi_call_wrapper(BS->OpenProtocol, 6, image, &LoadedImageProtocol, (VOID **)&loaded_image, + parent_image, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL); + if (EFI_ERROR(err)) { + Print(L"Error getting LoadedImageProtocol handle: %r", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out_unload; + } + loaded_image->LoadOptions = options; + loaded_image->LoadOptionsSize = (StrLen(loaded_image->LoadOptions)+1) * sizeof(CHAR16); + } + + efivar_set_time_usec(L"LoaderTimeExecUSec", 0); + err = uefi_call_wrapper(BS->StartImage, 3, image, NULL, NULL); +out_unload: + uefi_call_wrapper(BS->UnloadImage, 1, image); +out: + FreePool(path); + return err; +} + +static EFI_STATUS reboot_into_firmware(VOID) { + CHAR8 *b; + UINTN size; + UINT64 osind; + EFI_STATUS err; + + osind = EFI_OS_INDICATIONS_BOOT_TO_FW_UI; + + err = efivar_get_raw(&global_guid, L"OsIndications", &b, &size); + if (!EFI_ERROR(err)) + osind |= (UINT64)*b; + FreePool(b); + + err = efivar_set_raw(&global_guid, L"OsIndications", (CHAR8 *)&osind, sizeof(UINT64), TRUE); + if (EFI_ERROR(err)) + return err; + + err = uefi_call_wrapper(RT->ResetSystem, 4, EfiResetCold, EFI_SUCCESS, 0, NULL); + Print(L"Error calling ResetSystem: %r", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return err; +} + +static VOID config_free(Config *config) { + UINTN i; + + for (i = 0; i < config->entry_count; i++) + config_entry_free(config->entries[i]); + FreePool(config->entries); + FreePool(config->entry_default_pattern); + FreePool(config->options_edit); + FreePool(config->entry_oneshot); + FreePool(config->entries_auto); + FreePool(config->splash); + FreePool(config->background); +} + +EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *sys_table) { + CHAR16 *s; + CHAR8 *b; + UINTN size; + EFI_LOADED_IMAGE *loaded_image; + EFI_FILE *root_dir; + CHAR16 *loaded_image_path; + EFI_DEVICE_PATH *device_path; + EFI_STATUS err; + Config config; + UINT64 init_usec; + BOOLEAN menu = FALSE; + + InitializeLib(image, sys_table); + init_usec = time_usec(); + efivar_set_time_usec(L"LoaderTimeInitUSec", init_usec); + efivar_set(L"LoaderInfo", L"gummiboot " VERSION, FALSE); + s = PoolPrint(L"%s %d.%02d", ST->FirmwareVendor, ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); + efivar_set(L"LoaderFirmwareInfo", s, FALSE); + FreePool(s); + s = PoolPrint(L"UEFI %d.%02d", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff); + efivar_set(L"LoaderFirmwareType", s, FALSE); + FreePool(s); + + err = uefi_call_wrapper(BS->OpenProtocol, 6, image, &LoadedImageProtocol, (VOID **)&loaded_image, + image, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL); + if (EFI_ERROR(err)) { + Print(L"Error getting a LoadedImageProtocol handle: %r ", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return err; + } + + /* export the device path this image is started from */ + device_path = DevicePathFromHandle(loaded_image->DeviceHandle); + if (device_path) { + CHAR16 *str; + EFI_DEVICE_PATH *path, *paths; + + str = DevicePathToStr(device_path); + efivar_set(L"LoaderDeviceIdentifier", str, FALSE); + FreePool(str); + + paths = UnpackDevicePath(device_path); + for (path = paths; !IsDevicePathEnd(path); path = NextDevicePathNode(path)) { + HARDDRIVE_DEVICE_PATH *drive; + CHAR16 uuid[37]; + + if (DevicePathType(path) != MEDIA_DEVICE_PATH) + continue; + if (DevicePathSubType(path) != MEDIA_HARDDRIVE_DP) + continue; + drive = (HARDDRIVE_DEVICE_PATH *)path; + if (drive->SignatureType != SIGNATURE_TYPE_GUID) + continue; + + GuidToString(uuid, (EFI_GUID *)&drive->Signature); + efivar_set(L"LoaderDevicePartUUID", uuid, FALSE); + break; + } + FreePool(paths); + } + + root_dir = LibOpenRoot(loaded_image->DeviceHandle); + if (!root_dir) { + Print(L"Unable to open root directory: %r ", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return EFI_LOAD_ERROR; + } + + + /* the filesystem path to this image, to prevent adding ourselves to the menu */ + loaded_image_path = DevicePathToStr(loaded_image->FilePath); + efivar_set(L"LoaderImageIdentifier", loaded_image_path, FALSE); + + /* scan "\loader\entries\*.conf" files */ + ZeroMem(&config, sizeof(Config)); + config_load(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path); + + if (!config.background) { + config.background = AllocateZeroPool(sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); + if (StriCmp(L"Apple", ST->FirmwareVendor) == 0) { + config.background->Red = 0xc0; + config.background->Green = 0xc0; + config.background->Blue = 0xc0; + } + } + + /* if we find some well-known loaders, add them to the end of the list */ + config_entry_add_linux(&config, loaded_image, root_dir); + config_entry_add_loader_auto(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path, + L"auto-windows", 'w', L"Windows Boot Manager", L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi"); + config_entry_add_loader_auto(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path, + L"auto-efi-shell", 's', L"EFI Shell", L"\\shell" MACHINE_TYPE_NAME ".efi"); + config_entry_add_loader_auto(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path, + L"auto-efi-default", '\0', L"EFI Default Loader", L"\\EFI\\Boot\\boot" MACHINE_TYPE_NAME ".efi"); + config_entry_add_osx(&config); + efivar_set(L"LoaderEntriesAuto", config.entries_auto, FALSE); + + if (efivar_get_raw(&global_guid, L"OsIndicationsSupported", &b, &size) == EFI_SUCCESS) { + UINT64 osind = (UINT64)*b; + + if (osind & EFI_OS_INDICATIONS_BOOT_TO_FW_UI) + config_entry_add_call(&config, L"Reboot Into Firmware Interface", reboot_into_firmware); + FreePool(b); + } + + if (config.entry_count == 0) { + Print(L"No loader found. Configuration files in \\loader\\entries\\*.conf are needed."); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out; + } + + config_title_generate(&config); + + /* select entry by configured pattern or EFI LoaderDefaultEntry= variable*/ + config_default_entry_select(&config); + + /* if no configured entry to select from was found, enable the menu */ + if (config.idx_default == -1) { + config.idx_default = 0; + if (config.timeout_sec == 0) + config.timeout_sec = 10; + } + + /* select entry or show menu when key is pressed or timeout is set */ + if (config.timeout_sec == 0) { + UINT64 key; + + err = console_key_read(&key, FALSE); + if (!EFI_ERROR(err)) { + INT16 idx; + + /* find matching key in config entries */ + idx = entry_lookup_key(&config, config.idx_default, KEYCHAR(key)); + if (idx >= 0) + config.idx_default = idx; + else + menu = TRUE; + } + } else + menu = TRUE; + + for (;;) { + ConfigEntry *entry; + + entry = config.entries[config.idx_default]; + if (menu) { + efivar_set_time_usec(L"LoaderTimeMenuUSec", 0); + uefi_call_wrapper(BS->SetWatchdogTimer, 4, 0, 0x10000, 0, NULL); + if (!menu_run(&config, &entry, root_dir, loaded_image_path)) + break; + + /* run special entry like "reboot" */ + if (entry->call) { + entry->call(); + continue; + } + } else { + err = EFI_NOT_FOUND; + + /* splash from entry file */ + if (entry->splash) { + /* some entries disable the splash because they draw their own */ + if (entry->splash[0] == '\0') + err = EFI_SUCCESS; + else + err = graphics_splash(root_dir, entry->splash, config.background); + } + + /* splash from config file */ + if (EFI_ERROR(err) && config.splash) + err = graphics_splash(root_dir, config.splash, config.background); + + /* default splash */ + if (EFI_ERROR(err)) + graphics_splash(root_dir, L"\\EFI\\gummiboot\\splash.bmp", config.background); + } + + /* export the selected boot entry to the system */ + efivar_set(L"LoaderEntrySelected", entry->file, FALSE); + + uefi_call_wrapper(BS->SetWatchdogTimer, 4, 5 * 60, 0x10000, 0, NULL); + err = image_start(image, &config, entry); + + if (err == EFI_ACCESS_DENIED || err == EFI_SECURITY_VIOLATION) { + /* Platform is secure boot and requested image isn't + * trusted. Need to go back to prior boot system and + * install more keys or hashes. Signal failure by + * returning the error */ + Print(L"\nImage %s gives a security error\n", entry->title); + Print(L"Please enrol the hash or signature of %s\n", entry->loader); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out; + } + + menu = TRUE; + config.timeout_sec = 0; + } + err = EFI_SUCCESS; +out: + FreePool(loaded_image_path); + config_free(&config); + uefi_call_wrapper(root_dir->Close, 1, root_dir); + uefi_call_wrapper(BS->CloseProtocol, 4, image, &LoadedImageProtocol, image, NULL); + return err; +} diff --git a/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/setup/setup.c b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/setup/setup.c new file mode 100644 index 0000000..cb96a85 --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/disable-machine-id-logic/src/setup/setup.c @@ -0,0 +1,1445 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2013 Lennart Poettering + Copyright 2013 Kay Sievers + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "efivars.h" + +#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) +#define streq(a,b) (strcmp((a),(b)) == 0) +#define UUID_EMPTY ((uint8_t[16]) {}) + +static inline bool streq_ptr(const char *a, const char *b) { + if (a && b) + return streq(a, b); + if (!a && !b) + return true; + return false; +} + +static inline bool isempty(const char *p) { + return !p || !p[0]; +} + +static inline const char *strna(const char *s) { + return isempty(s) ? "n/a" : s; +} + +static int uuid_parse(const char *s, uint8_t uuid[16]) { + int u[16]; + int i; + + if (sscanf(s, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + &u[0], &u[1], &u[2], &u[3], &u[4], &u[5], &u[6], &u[7], + &u[8], &u[9], &u[10], &u[11], &u[12], &u[13], &u[14], &u[15]) != 16) + return -EINVAL; + + for (i = 0; i < 16; i++) + uuid[i] = u[i]; + + return 0; +} + +static int verify_esp(const char *p, uint32_t *part, uint64_t *pstart, uint64_t *psize, uint8_t uuid[16]) { + struct statfs sfs; + struct stat st, st2; + char *t; + blkid_probe b = NULL; + int r; + const char *v; + + if (statfs(p, &sfs) < 0) { + fprintf(stderr, "Failed to check file system type of %s: %m\n", p); + return -errno; + } + + if (sfs.f_type != 0x4d44) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + if (stat(p, &st) < 0) { + fprintf(stderr, "Failed to determine block device node of %s: %m\n", p); + return -errno; + } + + if (major(st.st_dev) == 0) { + fprintf(stderr, "Block device node of %p is invalid.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "%s/..", p); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = stat(t, &st2); + free(t); + if (r < 0) { + fprintf(stderr, "Failed to determine block device node of parent of %s: %m\n", p); + return -errno; + } + + if (st.st_dev == st2.st_dev) { + fprintf(stderr, "Directory %s is not the root of the EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "/dev/block/%u:%u", major(st.st_dev), minor(st.st_dev)); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + errno = 0; + b = blkid_new_probe_from_filename(t); + free(t); + if (!b) { + if (errno != 0) { + fprintf(stderr, "Failed to open file system %s: %m\n", p); + return -errno; + } + + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + blkid_probe_enable_superblocks(b, 1); + blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE); + blkid_probe_enable_partitions(b, 1); + blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS); + + errno = 0; + r = blkid_do_safeprobe(b); + if (r == -2) { + fprintf(stderr, "File system %s is ambigious.\n", p); + r = -ENODEV; + goto fail; + } else if (r == 1) { + fprintf(stderr, "File system %s does not contain a label.\n", p); + r = -ENODEV; + goto fail; + } else if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system %s: %s\n", p, strerror(-r)); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system type %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "vfat") != 0) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system after all.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SCHEME", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition scheme %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "gpt") != 0) { + fprintf(stderr, "File system %s is not on a GPT partition table.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition type UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "c12a7328-f81f-11d2-ba4b-00a0c93ec93b") != 0) { + r = -ENODEV; + fprintf(stderr, "File system %s is not an EFI System Partition (ESP).\n", p); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_UUID", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition entry UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + uuid_parse(v, uuid); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_NUMBER", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition number %s: %s\n", p, strerror(-r)); + goto fail; + } + *part = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_OFFSET", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition offset %s: %s\n", p, strerror(-r)); + goto fail; + } + *pstart = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SIZE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition size %s: %s\n", p, strerror(-r)); + goto fail; + } + *psize = strtoul(v, NULL, 10); + + blkid_free_probe(b); + return 0; +fail: + if (b) + blkid_free_probe(b); + return r; +} + +/* search for "#### LoaderInfo: gummiboot 31 ####" string inside the binary */ +static int get_file_version(FILE *f, char **v) { + struct stat st; + char *buf; + const char *s, *e; + char *x = NULL; + int r = 0; + + assert(f); + assert(v); + + if (fstat(fileno(f), &st) < 0) + return -errno; + + if (st.st_size < 27) + return 0; + + buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fileno(f), 0); + if (buf == MAP_FAILED) + return -errno; + + s = memmem(buf, st.st_size - 8, "#### LoaderInfo: ", 17); + if (!s) + goto finish; + s += 17; + + e = memmem(s, st.st_size - (s - buf), " ####", 5); + if (!e || e - s < 3) { + fprintf(stderr, "Malformed version string.\n"); + r = -EINVAL; + goto finish; + } + + x = strndup(s, e - s); + if (!x) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + r = 1; + +finish: + munmap(buf, st.st_size); + *v = x; + return r; +} + +static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".efi") != 0) + continue; + + if (prefix && strncasecmp(de->d_name, prefix, strlen(prefix)) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s/%s", esp_path, path, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0) + printf(" File: └─/%s/%s (%s)\n", path, de->d_name, v); + else + printf(" File: └─/%s/%s\n", path, de->d_name); + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + + free(p); + free(q); + return r; +} + +static int status_binaries(const char *esp_path, uint8_t partition[16]) { + int r; + + printf("Boot Loader Binaries:\n"); + + printf(" ESP: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + + r = enumerate_binaries(esp_path, "EFI/gummiboot", NULL); + if (r == 0) + fprintf(stderr, "Gummiboot not installed in ESP.\n"); + else if (r < 0) + return r; + + r = enumerate_binaries(esp_path, "EFI/Boot", "boot"); + if (r == 0) + fprintf(stderr, "No default/fallback boot loader installed in ESP.\n"); + else if (r < 0) + return r; + + printf("\n"); + return 0; +} + +static int print_efi_option(uint16_t id, bool in_order) { + char *title = NULL; + char *path = NULL; + uint8_t partition[16]; + bool active; + int r = 0; + + r = efi_get_boot_option(id, &title, partition, &path, &active); + if (r < 0) + goto finish; + + /* print only configured entries with partition information */ + if (!path || memcmp(partition, UUID_EMPTY, 16) == 0) + return 0; + + printf(" Title: %s\n", strna(title)); + printf(" ID: 0x%04X\n", id); + printf(" Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : ""); + printf(" Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + printf(" File: └─%s\n", path); + printf("\n"); + +finish: + free(title); + free(path); + return r; +} + +static int status_variables(void) { + int n_options, n_order; + uint16_t *options = NULL, *order = NULL; + int r, i; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, not showing EFI variables.\n"); + return 0; + } + + n_options = efi_get_boot_options(&options); + if (n_options < 0) { + if (n_options == -ENOENT) + fprintf(stderr, "Failed to access EFI variables, " + "efivarfs needs to be available at /sys/firmware/efi/efivars/.\n"); + else + fprintf(stderr, "Failed to read EFI boot entries: %s\n", strerror(-n_options)); + r = n_options; + goto finish; + } + + printf("Boot Loader Entries in EFI Variables:\n"); + n_order = efi_get_boot_order(&order); + if (n_order == -ENOENT) { + n_order = 0; + } else if (n_order < 0) { + fprintf(stderr, "Failed to read EFI boot order.\n"); + r = n_order; + goto finish; + } + + /* print entries in BootOrder first */ + for (i = 0; i < n_order; i++) + print_efi_option(order[i], true); + + /* print remaining entries */ + for (i = 0; i < n_options; i++) { + int j; + bool found = false; + + for (j = 0; j < n_order; j++) + if (options[i] == order[j]) { + found = true; + break; + } + + if (found) + continue; + + print_efi_option(options[i], false); + } + + r = 0; +finish: + free(options); + free(order); + + return r; +} + +static int compare_product(const char *a, const char *b) { + size_t x, y; + + assert(a); + assert(b); + + x = strcspn(a, " "); + y = strcspn(b, " "); + if (x != y) + return x < y ? -1 : x > y ? 1 : 0; + + return strncmp(a, b, x); +} + +static int compare_version(const char *a, const char *b) { + assert(a); + assert(b); + + a += strcspn(a, " "); + a += strspn(a, " "); + b += strcspn(b, " "); + b += strspn(b, " "); + + return strverscmp(a, b); +} + +static int version_check(FILE *f, const char *from, const char *to) { + FILE *g = NULL; + char *a = NULL, *b = NULL; + int r; + + assert(f); + assert(from); + assert(to); + + r = get_file_version(f, &a); + if (r < 0) + goto finish; + if (r == 0) { + r = -EINVAL; + fprintf(stderr, "Source file %s does not carry version information!\n", from); + goto finish; + } + + g = fopen(to, "re"); + if (!g) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + r = -errno; + fprintf(stderr, "Failed to open %s for reading: %m\n", to); + goto finish; + } + + r = get_file_version(g, &b); + if (r < 0) + goto finish; + if (r == 0 || compare_product(a, b) != 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's owned by another boot loader.\n", to); + goto finish; + } + + if (compare_version(a, b) < 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's a newer boot loader version already.\n", to); + goto finish; + } + + r = 0; + +finish: + free(a); + free(b); + if (g) + fclose(g); + return r; +} + +static int copy_file(const char *from, const char *to, bool force) { + FILE *f = NULL, *g = NULL; + char *p = NULL; + int r; + struct timespec t[2]; + struct stat st; + + assert(from); + assert(to); + + f = fopen(from, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", from); + return -errno; + } + + if (!force) { + /* If this is an update, then let's compare versions first */ + r = version_check(f, from, to); + if (r < 0) + goto finish; + } + + if (asprintf(&p, "%s~", to) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + g = fopen(p, "wxe"); + if (!g) { + /* Directory doesn't exist yet? Then let's skip this... */ + if (!force && errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to open %s for writing: %m\n", to); + r = -errno; + goto finish; + } + + rewind(f); + do { + size_t k; + uint8_t buf[32*1024]; + + k = fread(buf, 1, sizeof(buf), f); + if (ferror(f)) { + fprintf(stderr, "Failed to read %s: %m\n", from); + r = -errno; + goto finish; + } + if (k == 0) + break; + + fwrite(buf, 1, k, g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + } while (!feof(f)); + + fflush(g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + + r = fstat(fileno(f), &st); + if (r < 0) { + fprintf(stderr, "Failed to get file timestamps of %s: %m", from); + r = -errno; + goto finish; + } + + t[0] = st.st_atim; + t[1] = st.st_mtim; + + r = futimens(fileno(g), t); + if (r < 0) { + fprintf(stderr, "Failed to change file timestamps for %s: %m", p); + r = -errno; + goto finish; + } + + if (rename(p, to) < 0) { + fprintf(stderr, "Failed to rename %s to %s: %m\n", p, to); + r = -errno; + goto finish; + } + + fprintf(stderr, "Copied %s to %s.\n", from, to); + + free(p); + p = NULL; + r = 0; + +finish: + if (f) + fclose(f); + if (g) + fclose(g); + if (p) { + unlink(p); + free(p); + } + return r; +} + +static int normalize_filename_case(char *name) { + char *base_start; + char *base; + DIR *d; + struct dirent *de; + + base_start = strrchr(name, '/'); + base = base_start + 1; + + *base_start = 0; + d = opendir(name); + *base_start = '/'; + + if (d == NULL) + return -errno; + + while ((de = readdir(d))) { + /* Normalize (only) the base name of the given path */ + if (strcasecmp(de->d_name, base) == 0) { + strcpy(base, de->d_name); + break; + } + } + + closedir(d); + + return 0; +} + +static int mkdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (mkdir(p, 0700) < 0) { + if (errno != EEXIST) { + fprintf(stderr, "Failed to create %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Created %s.\n", p); + + free(p); + return 0; +} + +static int create_dirs(const char *esp_path) { + int r; + + r = mkdir_one(esp_path, "EFI"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/gummiboot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/Boot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader/entries"); + if (r < 0) + return r; + + return 0; +} + +static int copy_one_file(const char *esp_path, const char *name, bool force) { + char *p = NULL, *q = NULL, *v = NULL; + int r; + + if (asprintf(&p, GUMMIBOOTLIBDIR "/%s", name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + if (asprintf(&q, "%s/EFI/gummiboot/%s", esp_path, name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + r = copy_file(p, q, force); + + if (strncmp(name, "gummiboot", 9) == 0) { + int k; + + /* Create the EFI default boot loader name (specified for removable devices) */ + if (asprintf(&v, "%s/EFI/Boot/%s", esp_path, name + 5) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + normalize_filename_case(v); + + k = copy_file(p, v, force); + if (k < 0 && r == 0) { + r = k; + goto finish; + } + } + +finish: + free(p); + free(q); + free(v); + return r; +} + +static int install_binaries(const char *esp_path, bool force) { + struct dirent *de; + DIR *d; + 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(GUMMIBOOTLIBDIR); + if (!d) { + fprintf(stderr, "Failed to open "GUMMIBOOTLIBDIR": %m\n"); + return -errno; + } + + while ((de = readdir(d))) { + size_t n; + int k; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcmp(de->d_name + n - 4, ".efi") != 0) + continue; + + k = copy_one_file(esp_path, de->d_name, force); + if (k < 0 && r == 0) + r = k; + } + + closedir(d); + return r; +} + +static bool same_entry(uint16_t id, const uint8_t uuid[16], const char *path) { + char *opath = NULL; + uint8_t ouuid[16]; + int err; + bool same = false; + + err = efi_get_boot_option(id, NULL, ouuid, &opath, NULL); + if (err < 0) + return false; + if (memcmp(uuid, ouuid, 16) != 0) + goto finish; + + if (!streq_ptr(path, opath)) + goto finish; + + same = true; + +finish: + free(opath); + return same; +} + +static int find_slot(const uint8_t uuid[16], const char *path, uint16_t *id) { + uint16_t *options = NULL; + int n_options; + int i; + uint16_t new_id = 0; + bool existing = false; + + n_options = efi_get_boot_options(&options); + if (n_options < 0) + return n_options; + + /* find already existing gummiboot entry */ + for (i = 0; i < n_options; i++) + if (same_entry(options[i], uuid, path)) { + new_id = options[i]; + existing = true; + goto finish; + } + + /* find free slot in the sorted BootXXXX variable list */ + for (i = 0; i < n_options; i++) + if (i != options[i]) { + new_id = i; + goto finish; + } + + /* use the next one */ + if (i == 0xffff) + return -ENOSPC; + new_id = i; + +finish: + *id = new_id; + free(options); + return existing; +} + +static int insert_into_order(uint16_t slot, bool first) { + uint16_t *order = NULL; + uint16_t *new_order; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order <= 0) { + /* no entry, add us */ + err = efi_set_boot_order(&slot, 1); + goto finish; + } + + /* are we the first and only one? */ + if (n_order == 1 && order[0] == slot) + goto finish; + + /* are we already in the boot order? */ + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + /* we do not require to be the first one, all is fine */ + if (!first) + goto finish; + + /* move us to the first slot */ + memmove(&order[1], order, i * sizeof(uint16_t)); + order[0] = slot; + efi_set_boot_order(order, n_order); + goto finish; + } + + /* extend array */ + new_order = realloc(order, (n_order+1) * sizeof(uint16_t)); + if (!new_order) { + err = -ENOMEM; + goto finish; + } + order = new_order; + + /* add us to the top or end of the list */ + if (first) { + memmove(&order[1], order, n_order * sizeof(uint16_t)); + order[0] = slot; + } else + order[n_order] = slot; + + efi_set_boot_order(order, n_order+1); + +finish: + free(order); + return err; +} + +static int remove_from_order(uint16_t slot) { + uint16_t *order = NULL; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order < 0) + return n_order; + if (n_order == 0) + return 0; + + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + if (i+1 < n_order) + memmove(&order[i], &order[i+1], (n_order - i) * sizeof(uint16_t)); + efi_set_boot_order(order, n_order-1); + break; + } + + free(order); + return err; +} + +static int install_variables(const char *esp_path, + uint32_t part, uint64_t pstart, uint64_t psize, + const uint8_t uuid[16], const char *path, + bool first) { + char *p = NULL; + uint16_t *options = NULL; + uint16_t slot; + int r; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, skipping EFI variable setup.\n"); + return 0; + } + + if (asprintf(&p, "%s%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (access(p, F_OK) < 0) { + if (errno == ENOENT) + r = 0; + else + r = -errno; + goto finish; + } + + r = find_slot(uuid, path, &slot); + if (r < 0) { + if (r == -ENOENT) + fprintf(stderr, "Failed to access EFI variables. Is the \"efivarfs\" filesystem mounted?\n"); + else + fprintf(stderr, "Failed to determine current boot order: %s\n", strerror(-r)); + goto finish; + } + + if (first || r == false) { + r = efi_add_boot_option(slot, "Linux Boot Manager", + part, pstart, psize, + uuid, path); + if (r < 0) { + fprintf(stderr, "Failed to create EFI Boot variable entry: %s\n", strerror(-r)); + goto finish; + } + fprintf(stderr, "Created EFI boot entry \"Linux Boot Manager\".\n"); + } + + insert_into_order(slot, first); + +finish: + free(p); + free(options); + return r; +} + +static int delete_nftw(const char *path, const struct stat *sb, int typeflag, struct FTW *ftw) { + int r; + + if (typeflag == FTW_D || typeflag == FTW_DNR || typeflag == FTW_DP) + r = rmdir(path); + else + r = unlink(path); + + if (r < 0) + fprintf(stderr, "Failed to remove %s: %m\n", path); + else + fprintf(stderr, "Removed %s.\n", path); + + return 0; +} + +static int rm_rf(const char *p) { + nftw(p, delete_nftw, 20, FTW_DEPTH|FTW_MOUNT|FTW_PHYS); + return 0; +} + +static int remove_boot_efi(const char *esp_path) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/EFI/Boot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".EFI") != 0) + continue; + + if (strncasecmp(de->d_name, "Boot", 4) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s", p, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0 && strncmp(v, "gummiboot ", 10) == 0) { + + r = unlink(q); + if (r < 0) { + fprintf(stderr, "Failed to remove %s: %m\n", q); + r = -errno; + free(v); + goto finish; + } else + fprintf(stderr, "Removed %s.\n", q); + } + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + free(p); + free(q); + + return r; +} + +static int rmdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (rmdir(p) < 0) { + if (errno != ENOENT && errno != ENOTEMPTY) { + fprintf(stderr, "Failed to remove %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Removed %s.\n", p); + + free(p); + return 0; +} + + +static int remove_binaries(const char *esp_path) { + char *p; + int r, q; + + if (asprintf(&p, "%s/EFI/gummiboot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = rm_rf(p); + free(p); + + q = remove_boot_efi(esp_path); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader/entries"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/Boot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/gummiboot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI"); + if (q < 0 && r == 0) + r = q; + + return r; +} + +static int remove_variables(const uint8_t uuid[16], const char *path, bool in_order) { + uint16_t slot; + int r; + + if (!is_efi_boot()) + return 0; + + r = find_slot(uuid, path, &slot); + if (r != 1) + return 0; + + r = efi_remove_boot_option(slot); + if (r < 0) + return r; + + if (in_order) + remove_from_order(slot); + + return 0; +} + +static int install_loader_config(const char *esp_path) { + char *p = NULL; + char line[64]; + char *machine = NULL; + FILE *f; + + f = fopen("/etc/machine-id", "re"); + if (!f) + return -errno; + + if (fgets(line, sizeof(line), f) != NULL) { + char *s; + + s = strchr(line, '\n'); + if (s) + s[0] = '\0'; + if (strlen(line) == 32) + machine = line; + } + + fclose(f); + + if (!machine) + return -ESRCH; + + if (asprintf(&p, "%s/%s", esp_path, "loader/loader.conf") < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + f = fopen(p, "wxe"); + if (f) { + fprintf(f, "#timeout 3\n"); + fprintf(f, "default %s-*\n", machine); + fclose(f); + } + + free(p); + return 0; +} + +static int help(void) { + printf("%s [COMMAND] [OPTIONS...]\n" + "\n" + "Install, update or remove the Gummiboot EFI boot loader.\n\n" + " -h --help Show this help\n" + " --version Print version\n" + " --path=PATH Path to the EFI System Partition (ESP)\n" + " --no-variables Don't touch EFI variables\n" + "\n" + "Comands:\n" + " status Show status of installed Gummiboot and EFI variables\n" + " install Install Gummiboot to the ESP and EFI variables\n" + " update Update Gummiboot in the ESP and EFI variables\n" + " remove Remove Gummiboot from the ESP and EFI variables\n", + program_invocation_short_name); + + return 0; +} + +static const char *arg_path = NULL; +static bool arg_touch_variables = true; + +static int parse_argv(int argc, char *argv[]) { + enum { + ARG_PATH = 0x100, + ARG_VERSION, + ARG_NO_VARIABLES, + }; + + static const struct option options[] = { + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, ARG_VERSION }, + { "path", required_argument, NULL, ARG_PATH }, + { "no-variables", no_argument, NULL, ARG_NO_VARIABLES }, + { NULL, 0, NULL, 0 } + }; + + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) { + switch (c) { + + case 'h': + help(); + return 0; + + case ARG_VERSION: + printf(VERSION "\n"); + return 0; + + case ARG_PATH: + arg_path = optarg; + break; + + case ARG_NO_VARIABLES: + arg_touch_variables = false; + break; + + case '?': + return -EINVAL; + + default: + fprintf(stderr, "Unknown option code '%c'.\n", c); + return -EINVAL; + } + } + + return 1; +} + +int main(int argc, char*argv[]) { + enum action { + ACTION_STATUS, + ACTION_INSTALL, + ACTION_UPDATE, + ACTION_REMOVE + } arg_action = ACTION_STATUS; + + static const struct { + const char* verb; + enum action action; + } verbs[] = { + { "status", ACTION_STATUS }, + { "install", ACTION_INSTALL }, + { "update", ACTION_UPDATE }, + { "remove", ACTION_REMOVE }, + }; + + uint8_t uuid[16] = ""; + uint32_t part = 0; + uint64_t pstart = 0; + uint64_t psize = 0; + unsigned int i; + int q; + int r; + + r = parse_argv(argc, argv); + if (r <= 0) + goto finish; + + if (argv[optind]) { + for (i = 0; i < ELEMENTSOF(verbs); i++) { + if (!streq(argv[optind], verbs[i].verb)) + continue; + arg_action = verbs[i].action; + break; + } + if (i >= ELEMENTSOF(verbs)) { + fprintf(stderr, "Unknown operation %s\n", argv[optind]); + r = -EINVAL; + goto finish; + } + } + + if (!arg_path) + arg_path = "/boot/efi"; + + if (geteuid() != 0) { + fprintf(stderr, "Need to be root.\n"); + r = -EPERM; + goto finish; + } + + r = verify_esp(arg_path, &part, &pstart, &psize, uuid); + if (r == -ENODEV && !arg_path) + fprintf(stderr, "You might want to use --path= to indicate the path to your ESP, in case it is not mounted to /boot.\n"); + if (r < 0) + goto finish; + + switch (arg_action) { + case ACTION_STATUS: + r = status_binaries(arg_path, uuid); + if (r < 0) + goto finish; + + if (arg_touch_variables) + r = status_variables(); + break; + + case ACTION_INSTALL: + case ACTION_UPDATE: + umask(0002); + + r = install_binaries(arg_path, arg_action == ACTION_INSTALL); + if (r < 0) + goto finish; + + if (arg_action == ACTION_INSTALL) + install_loader_config(arg_path); + + if (arg_touch_variables) + r = install_variables(arg_path, + part, pstart, psize, uuid, + "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", + arg_action == ACTION_INSTALL); + break; + + case ACTION_REMOVE: + r = remove_binaries(arg_path); + + if (arg_touch_variables) { + q = remove_variables(uuid, "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", true); + if (q < 0 && r == 0) + r = q; + } + break; + } + +finish: + return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS; +} diff --git a/gummiboot-nomachineid-48/.pc/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch/src/setup/setup.c b/gummiboot-nomachineid-48/.pc/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch/src/setup/setup.c new file mode 100644 index 0000000..0cfaccf --- /dev/null +++ b/gummiboot-nomachineid-48/.pc/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch/src/setup/setup.c @@ -0,0 +1,1425 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2013 Lennart Poettering + Copyright 2013 Kay Sievers + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "efivars.h" + +#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) +#define streq(a,b) (strcmp((a),(b)) == 0) +#define UUID_EMPTY ((uint8_t[16]) {}) + +static inline bool streq_ptr(const char *a, const char *b) { + if (a && b) + return streq(a, b); + if (!a && !b) + return true; + return false; +} + +static inline bool isempty(const char *p) { + return !p || !p[0]; +} + +static inline const char *strna(const char *s) { + return isempty(s) ? "n/a" : s; +} + +static int uuid_parse(const char *s, uint8_t uuid[16]) { + int u[16]; + int i; + + if (sscanf(s, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + &u[0], &u[1], &u[2], &u[3], &u[4], &u[5], &u[6], &u[7], + &u[8], &u[9], &u[10], &u[11], &u[12], &u[13], &u[14], &u[15]) != 16) + return -EINVAL; + + for (i = 0; i < 16; i++) + uuid[i] = u[i]; + + return 0; +} + +static int verify_esp(const char *p, uint32_t *part, uint64_t *pstart, uint64_t *psize, uint8_t uuid[16]) { + struct statfs sfs; + struct stat st, st2; + char *t; + blkid_probe b = NULL; + int r; + const char *v; + + if (statfs(p, &sfs) < 0) { + fprintf(stderr, "Failed to check file system type of %s: %m\n", p); + return -errno; + } + + if (sfs.f_type != 0x4d44) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + if (stat(p, &st) < 0) { + fprintf(stderr, "Failed to determine block device node of %s: %m\n", p); + return -errno; + } + + if (major(st.st_dev) == 0) { + fprintf(stderr, "Block device node of %p is invalid.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "%s/..", p); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = stat(t, &st2); + free(t); + if (r < 0) { + fprintf(stderr, "Failed to determine block device node of parent of %s: %m\n", p); + return -errno; + } + + if (st.st_dev == st2.st_dev) { + fprintf(stderr, "Directory %s is not the root of the EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "/dev/block/%u:%u", major(st.st_dev), minor(st.st_dev)); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + errno = 0; + b = blkid_new_probe_from_filename(t); + free(t); + if (!b) { + if (errno != 0) { + fprintf(stderr, "Failed to open file system %s: %m\n", p); + return -errno; + } + + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + blkid_probe_enable_superblocks(b, 1); + blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE); + blkid_probe_enable_partitions(b, 1); + blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS); + + errno = 0; + r = blkid_do_safeprobe(b); + if (r == -2) { + fprintf(stderr, "File system %s is ambigious.\n", p); + r = -ENODEV; + goto fail; + } else if (r == 1) { + fprintf(stderr, "File system %s does not contain a label.\n", p); + r = -ENODEV; + goto fail; + } else if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system %s: %s\n", p, strerror(-r)); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system type %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "vfat") != 0) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system after all.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SCHEME", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition scheme %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "gpt") != 0) { + fprintf(stderr, "File system %s is not on a GPT partition table.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition type UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "c12a7328-f81f-11d2-ba4b-00a0c93ec93b") != 0) { + r = -ENODEV; + fprintf(stderr, "File system %s is not an EFI System Partition (ESP).\n", p); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_UUID", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition entry UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + uuid_parse(v, uuid); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_NUMBER", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition number %s: %s\n", p, strerror(-r)); + goto fail; + } + *part = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_OFFSET", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition offset %s: %s\n", p, strerror(-r)); + goto fail; + } + *pstart = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SIZE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition size %s: %s\n", p, strerror(-r)); + goto fail; + } + *psize = strtoul(v, NULL, 10); + + blkid_free_probe(b); + return 0; +fail: + if (b) + blkid_free_probe(b); + return r; +} + +/* search for "#### LoaderInfo: gummiboot 31 ####" string inside the binary */ +static int get_file_version(FILE *f, char **v) { + struct stat st; + char *buf; + const char *s, *e; + char *x = NULL; + int r = 0; + + assert(f); + assert(v); + + if (fstat(fileno(f), &st) < 0) + return -errno; + + if (st.st_size < 27) + return 0; + + buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fileno(f), 0); + if (buf == MAP_FAILED) + return -errno; + + s = memmem(buf, st.st_size - 8, "#### LoaderInfo: ", 17); + if (!s) + goto finish; + s += 17; + + e = memmem(s, st.st_size - (s - buf), " ####", 5); + if (!e || e - s < 3) { + fprintf(stderr, "Malformed version string.\n"); + r = -EINVAL; + goto finish; + } + + x = strndup(s, e - s); + if (!x) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + r = 1; + +finish: + munmap(buf, st.st_size); + *v = x; + return r; +} + +static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".efi") != 0) + continue; + + if (prefix && strncasecmp(de->d_name, prefix, strlen(prefix)) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s/%s", esp_path, path, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0) + printf(" File: └─/%s/%s (%s)\n", path, de->d_name, v); + else + printf(" File: └─/%s/%s\n", path, de->d_name); + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + + free(p); + free(q); + return r; +} + +static int status_binaries(const char *esp_path, uint8_t partition[16]) { + int r; + + printf("Boot Loader Binaries:\n"); + + printf(" ESP: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + + r = enumerate_binaries(esp_path, "EFI/gummiboot", NULL); + if (r == 0) + fprintf(stderr, "Gummiboot not installed in ESP.\n"); + else if (r < 0) + return r; + + r = enumerate_binaries(esp_path, "EFI/Boot", "boot"); + if (r == 0) + fprintf(stderr, "No default/fallback boot loader installed in ESP.\n"); + else if (r < 0) + return r; + + printf("\n"); + return 0; +} + +static int print_efi_option(uint16_t id, bool in_order) { + char *title = NULL; + char *path = NULL; + uint8_t partition[16]; + bool active; + int r = 0; + + r = efi_get_boot_option(id, &title, partition, &path, &active); + if (r < 0) + goto finish; + + /* print only configured entries with partition information */ + if (!path || memcmp(partition, UUID_EMPTY, 16) == 0) + return 0; + + printf(" Title: %s\n", strna(title)); + printf(" ID: 0x%04X\n", id); + printf(" Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : ""); + printf(" Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + printf(" File: └─%s\n", path); + printf("\n"); + +finish: + free(title); + free(path); + return r; +} + +static int status_variables(void) { + int n_options, n_order; + uint16_t *options = NULL, *order = NULL; + int r, i; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, not showing EFI variables.\n"); + return 0; + } + + n_options = efi_get_boot_options(&options); + if (n_options < 0) { + if (n_options == -ENOENT) + fprintf(stderr, "Failed to access EFI variables, " + "efivarfs needs to be available at /sys/firmware/efi/efivars/.\n"); + else + fprintf(stderr, "Failed to read EFI boot entries: %s\n", strerror(-n_options)); + r = n_options; + goto finish; + } + + printf("Boot Loader Entries in EFI Variables:\n"); + n_order = efi_get_boot_order(&order); + if (n_order == -ENOENT) { + n_order = 0; + } else if (n_order < 0) { + fprintf(stderr, "Failed to read EFI boot order.\n"); + r = n_order; + goto finish; + } + + /* print entries in BootOrder first */ + for (i = 0; i < n_order; i++) + print_efi_option(order[i], true); + + /* print remaining entries */ + for (i = 0; i < n_options; i++) { + int j; + bool found = false; + + for (j = 0; j < n_order; j++) + if (options[i] == order[j]) { + found = true; + break; + } + + if (found) + continue; + + print_efi_option(options[i], false); + } + + r = 0; +finish: + free(options); + free(order); + + return r; +} + +static int compare_product(const char *a, const char *b) { + size_t x, y; + + assert(a); + assert(b); + + x = strcspn(a, " "); + y = strcspn(b, " "); + if (x != y) + return x < y ? -1 : x > y ? 1 : 0; + + return strncmp(a, b, x); +} + +static int compare_version(const char *a, const char *b) { + assert(a); + assert(b); + + a += strcspn(a, " "); + a += strspn(a, " "); + b += strcspn(b, " "); + b += strspn(b, " "); + + return strverscmp(a, b); +} + +static int version_check(FILE *f, const char *from, const char *to) { + FILE *g = NULL; + char *a = NULL, *b = NULL; + int r; + + assert(f); + assert(from); + assert(to); + + r = get_file_version(f, &a); + if (r < 0) + goto finish; + if (r == 0) { + r = -EINVAL; + fprintf(stderr, "Source file %s does not carry version information!\n", from); + goto finish; + } + + g = fopen(to, "re"); + if (!g) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + r = -errno; + fprintf(stderr, "Failed to open %s for reading: %m\n", to); + goto finish; + } + + r = get_file_version(g, &b); + if (r < 0) + goto finish; + if (r == 0 || compare_product(a, b) != 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's owned by another boot loader.\n", to); + goto finish; + } + + if (compare_version(a, b) < 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's a newer boot loader version already.\n", to); + goto finish; + } + + r = 0; + +finish: + free(a); + free(b); + if (g) + fclose(g); + return r; +} + +static int copy_file(const char *from, const char *to, bool force) { + FILE *f = NULL, *g = NULL; + char *p = NULL; + int r; + struct timespec t[2]; + struct stat st; + + assert(from); + assert(to); + + f = fopen(from, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", from); + return -errno; + } + + if (!force) { + /* If this is an update, then let's compare versions first */ + r = version_check(f, from, to); + if (r < 0) + goto finish; + } + + if (asprintf(&p, "%s~", to) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + g = fopen(p, "wxe"); + if (!g) { + /* Directory doesn't exist yet? Then let's skip this... */ + if (!force && errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to open %s for writing: %m\n", to); + r = -errno; + goto finish; + } + + rewind(f); + do { + size_t k; + uint8_t buf[32*1024]; + + k = fread(buf, 1, sizeof(buf), f); + if (ferror(f)) { + fprintf(stderr, "Failed to read %s: %m\n", from); + r = -errno; + goto finish; + } + if (k == 0) + break; + + fwrite(buf, 1, k, g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + } while (!feof(f)); + + fflush(g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + + r = fstat(fileno(f), &st); + if (r < 0) { + fprintf(stderr, "Failed to get file timestamps of %s: %m", from); + r = -errno; + goto finish; + } + + t[0] = st.st_atim; + t[1] = st.st_mtim; + + r = futimens(fileno(g), t); + if (r < 0) { + fprintf(stderr, "Failed to change file timestamps for %s: %m", p); + r = -errno; + goto finish; + } + + if (rename(p, to) < 0) { + fprintf(stderr, "Failed to rename %s to %s: %m\n", p, to); + r = -errno; + goto finish; + } + + fprintf(stderr, "Copied %s to %s.\n", from, to); + + free(p); + p = NULL; + r = 0; + +finish: + if (f) + fclose(f); + if (g) + fclose(g); + if (p) { + unlink(p); + free(p); + } + return r; +} + +static char* strupper(char *s) { + char *p; + + for (p = s; *p; p++) + *p = toupper(*p); + + return s; +} + +static int mkdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (mkdir(p, 0700) < 0) { + if (errno != EEXIST) { + fprintf(stderr, "Failed to create %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Created %s.\n", p); + + free(p); + return 0; +} + +static int create_dirs(const char *esp_path) { + int r; + + r = mkdir_one(esp_path, "EFI"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/gummiboot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/Boot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader/entries"); + if (r < 0) + return r; + + return 0; +} + +static int copy_one_file(const char *esp_path, const char *name, bool force) { + char *p = NULL, *q = NULL, *v = NULL; + int r; + + if (asprintf(&p, GUMMIBOOTLIBDIR "/%s", name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + if (asprintf(&q, "%s/EFI/gummiboot/%s", esp_path, name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + r = copy_file(p, q, force); + + if (strncmp(name, "gummiboot", 9) == 0) { + int k; + + /* Create the EFI default boot loader name (specified for removable devices) */ + if (asprintf(&v, "%s/EFI/Boot/%s", esp_path, name + 5) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + strupper(strrchr(v, '/') + 1); + + k = copy_file(p, v, force); + if (k < 0 && r == 0) { + r = k; + goto finish; + } + } + +finish: + free(p); + free(q); + free(v); + return r; +} + +static int install_binaries(const char *esp_path, bool force) { + struct dirent *de; + DIR *d; + 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(GUMMIBOOTLIBDIR); + if (!d) { + fprintf(stderr, "Failed to open "GUMMIBOOTLIBDIR": %m\n"); + return -errno; + } + + while ((de = readdir(d))) { + size_t n; + int k; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcmp(de->d_name + n - 4, ".efi") != 0) + continue; + + k = copy_one_file(esp_path, de->d_name, force); + if (k < 0 && r == 0) + r = k; + } + + closedir(d); + return r; +} + +static bool same_entry(uint16_t id, const uint8_t uuid[16], const char *path) { + char *opath = NULL; + uint8_t ouuid[16]; + int err; + bool same = false; + + err = efi_get_boot_option(id, NULL, ouuid, &opath, NULL); + if (err < 0) + return false; + if (memcmp(uuid, ouuid, 16) != 0) + goto finish; + + if (!streq_ptr(path, opath)) + goto finish; + + same = true; + +finish: + free(opath); + return same; +} + +static int find_slot(const uint8_t uuid[16], const char *path, uint16_t *id) { + uint16_t *options = NULL; + int n_options; + int i; + uint16_t new_id = 0; + bool existing = false; + + n_options = efi_get_boot_options(&options); + if (n_options < 0) + return n_options; + + /* find already existing gummiboot entry */ + for (i = 0; i < n_options; i++) + if (same_entry(options[i], uuid, path)) { + new_id = options[i]; + existing = true; + goto finish; + } + + /* find free slot in the sorted BootXXXX variable list */ + for (i = 0; i < n_options; i++) + if (i != options[i]) { + new_id = i; + goto finish; + } + + /* use the next one */ + if (i == 0xffff) + return -ENOSPC; + new_id = i; + +finish: + *id = new_id; + free(options); + return existing; +} + +static int insert_into_order(uint16_t slot, bool first) { + uint16_t *order = NULL; + uint16_t *new_order; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order <= 0) { + /* no entry, add us */ + err = efi_set_boot_order(&slot, 1); + goto finish; + } + + /* are we the first and only one? */ + if (n_order == 1 && order[0] == slot) + goto finish; + + /* are we already in the boot order? */ + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + /* we do not require to be the first one, all is fine */ + if (!first) + goto finish; + + /* move us to the first slot */ + memmove(&order[1], order, i * sizeof(uint16_t)); + order[0] = slot; + efi_set_boot_order(order, n_order); + goto finish; + } + + /* extend array */ + new_order = realloc(order, (n_order+1) * sizeof(uint16_t)); + if (!new_order) { + err = -ENOMEM; + goto finish; + } + order = new_order; + + /* add us to the top or end of the list */ + if (first) { + memmove(&order[1], order, n_order * sizeof(uint16_t)); + order[0] = slot; + } else + order[n_order] = slot; + + efi_set_boot_order(order, n_order+1); + +finish: + free(order); + return err; +} + +static int remove_from_order(uint16_t slot) { + uint16_t *order = NULL; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order < 0) + return n_order; + if (n_order == 0) + return 0; + + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + if (i+1 < n_order) + memmove(&order[i], &order[i+1], (n_order - i) * sizeof(uint16_t)); + efi_set_boot_order(order, n_order-1); + break; + } + + free(order); + return err; +} + +static int install_variables(const char *esp_path, + uint32_t part, uint64_t pstart, uint64_t psize, + const uint8_t uuid[16], const char *path, + bool first) { + char *p = NULL; + uint16_t *options = NULL; + uint16_t slot; + int r; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, skipping EFI variable setup.\n"); + return 0; + } + + if (asprintf(&p, "%s%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (access(p, F_OK) < 0) { + if (errno == ENOENT) + r = 0; + else + r = -errno; + goto finish; + } + + r = find_slot(uuid, path, &slot); + if (r < 0) { + if (r == -ENOENT) + fprintf(stderr, "Failed to access EFI variables. Is the \"efivarfs\" filesystem mounted?\n"); + else + fprintf(stderr, "Failed to determine current boot order: %s\n", strerror(-r)); + goto finish; + } + + if (first || r == false) { + r = efi_add_boot_option(slot, "Linux Boot Manager", + part, pstart, psize, + uuid, path); + if (r < 0) { + fprintf(stderr, "Failed to create EFI Boot variable entry: %s\n", strerror(-r)); + goto finish; + } + fprintf(stderr, "Created EFI boot entry \"Linux Boot Manager\".\n"); + } + + insert_into_order(slot, first); + +finish: + free(p); + free(options); + return r; +} + +static int delete_nftw(const char *path, const struct stat *sb, int typeflag, struct FTW *ftw) { + int r; + + if (typeflag == FTW_D || typeflag == FTW_DNR || typeflag == FTW_DP) + r = rmdir(path); + else + r = unlink(path); + + if (r < 0) + fprintf(stderr, "Failed to remove %s: %m\n", path); + else + fprintf(stderr, "Removed %s.\n", path); + + return 0; +} + +static int rm_rf(const char *p) { + nftw(p, delete_nftw, 20, FTW_DEPTH|FTW_MOUNT|FTW_PHYS); + return 0; +} + +static int remove_boot_efi(const char *esp_path) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/EFI/Boot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".EFI") != 0) + continue; + + if (strncasecmp(de->d_name, "Boot", 4) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s", p, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0 && strncmp(v, "gummiboot ", 10) == 0) { + + r = unlink(q); + if (r < 0) { + fprintf(stderr, "Failed to remove %s: %m\n", q); + r = -errno; + free(v); + goto finish; + } else + fprintf(stderr, "Removed %s.\n", q); + } + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + free(p); + free(q); + + return r; +} + +static int rmdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (rmdir(p) < 0) { + if (errno != ENOENT && errno != ENOTEMPTY) { + fprintf(stderr, "Failed to remove %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Removed %s.\n", p); + + free(p); + return 0; +} + + +static int remove_binaries(const char *esp_path) { + char *p; + int r, q; + + if (asprintf(&p, "%s/EFI/gummiboot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = rm_rf(p); + free(p); + + q = remove_boot_efi(esp_path); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader/entries"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/Boot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/gummiboot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI"); + if (q < 0 && r == 0) + r = q; + + return r; +} + +static int remove_variables(const uint8_t uuid[16], const char *path, bool in_order) { + uint16_t slot; + int r; + + if (!is_efi_boot()) + return 0; + + r = find_slot(uuid, path, &slot); + if (r != 1) + return 0; + + r = efi_remove_boot_option(slot); + if (r < 0) + return r; + + if (in_order) + remove_from_order(slot); + + return 0; +} + +static int install_loader_config(const char *esp_path) { + char *p = NULL; + char line[64]; + char *machine = NULL; + FILE *f; + + f = fopen("/etc/machine-id", "re"); + if (!f) + return -errno; + + if (fgets(line, sizeof(line), f) != NULL) { + char *s; + + s = strchr(line, '\n'); + if (s) + s[0] = '\0'; + if (strlen(line) == 32) + machine = line; + } + + fclose(f); + + if (!machine) + return -ESRCH; + + if (asprintf(&p, "%s/%s", esp_path, "loader/loader.conf") < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + f = fopen(p, "wxe"); + if (f) { + fprintf(f, "#timeout 3\n"); + fprintf(f, "default %s-*\n", machine); + fclose(f); + } + + free(p); + return 0; +} + +static int help(void) { + printf("%s [COMMAND] [OPTIONS...]\n" + "\n" + "Install, update or remove the Gummiboot EFI boot loader.\n\n" + " -h --help Show this help\n" + " --version Print version\n" + " --path=PATH Path to the EFI System Partition (ESP)\n" + " --no-variables Don't touch EFI variables\n" + "\n" + "Comands:\n" + " status Show status of installed Gummiboot and EFI variables\n" + " install Install Gummiboot to the ESP and EFI variables\n" + " update Update Gummiboot in the ESP and EFI variables\n" + " remove Remove Gummiboot from the ESP and EFI variables\n", + program_invocation_short_name); + + return 0; +} + +static const char *arg_path = NULL; +static bool arg_touch_variables = true; + +static int parse_argv(int argc, char *argv[]) { + enum { + ARG_PATH = 0x100, + ARG_VERSION, + ARG_NO_VARIABLES, + }; + + static const struct option options[] = { + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, ARG_VERSION }, + { "path", required_argument, NULL, ARG_PATH }, + { "no-variables", no_argument, NULL, ARG_NO_VARIABLES }, + { NULL, 0, NULL, 0 } + }; + + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) { + switch (c) { + + case 'h': + help(); + return 0; + + case ARG_VERSION: + printf(VERSION "\n"); + return 0; + + case ARG_PATH: + arg_path = optarg; + break; + + case ARG_NO_VARIABLES: + arg_touch_variables = false; + break; + + case '?': + return -EINVAL; + + default: + fprintf(stderr, "Unknown option code '%c'.\n", c); + return -EINVAL; + } + } + + return 1; +} + +int main(int argc, char*argv[]) { + enum action { + ACTION_STATUS, + ACTION_INSTALL, + ACTION_UPDATE, + ACTION_REMOVE + } arg_action = ACTION_STATUS; + + static const struct { + const char* verb; + enum action action; + } verbs[] = { + { "status", ACTION_STATUS }, + { "install", ACTION_INSTALL }, + { "update", ACTION_UPDATE }, + { "remove", ACTION_REMOVE }, + }; + + uint8_t uuid[16] = ""; + uint32_t part = 0; + uint64_t pstart = 0; + uint64_t psize = 0; + unsigned int i; + int q; + int r; + + r = parse_argv(argc, argv); + if (r <= 0) + goto finish; + + if (argv[optind]) { + for (i = 0; i < ELEMENTSOF(verbs); i++) { + if (!streq(argv[optind], verbs[i].verb)) + continue; + arg_action = verbs[i].action; + break; + } + if (i >= ELEMENTSOF(verbs)) { + fprintf(stderr, "Unknown operation %s\n", argv[optind]); + r = -EINVAL; + goto finish; + } + } + + if (!arg_path) + arg_path = "/boot/efi"; + + if (geteuid() != 0) { + fprintf(stderr, "Need to be root.\n"); + r = -EPERM; + goto finish; + } + + r = verify_esp(arg_path, &part, &pstart, &psize, uuid); + if (r == -ENODEV && !arg_path) + fprintf(stderr, "You might want to use --path= to indicate the path to your ESP, in case it is not mounted to /boot.\n"); + if (r < 0) + goto finish; + + switch (arg_action) { + case ACTION_STATUS: + r = status_binaries(arg_path, uuid); + if (r < 0) + goto finish; + + if (arg_touch_variables) + r = status_variables(); + break; + + case ACTION_INSTALL: + case ACTION_UPDATE: + umask(0002); + + r = install_binaries(arg_path, arg_action == ACTION_INSTALL); + if (r < 0) + goto finish; + + if (arg_action == ACTION_INSTALL) + install_loader_config(arg_path); + + if (arg_touch_variables) + r = install_variables(arg_path, + part, pstart, psize, uuid, + "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", + arg_action == ACTION_INSTALL); + break; + + case ACTION_REMOVE: + r = remove_binaries(arg_path); + + if (arg_touch_variables) { + q = remove_variables(uuid, "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", true); + if (q < 0 && r == 0) + r = q; + } + break; + } + +finish: + return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS; +} diff --git a/gummiboot-nomachineid-48/.vimrc b/gummiboot-nomachineid-48/.vimrc new file mode 100644 index 0000000..366fbdc --- /dev/null +++ b/gummiboot-nomachineid-48/.vimrc @@ -0,0 +1,4 @@ +" 'set exrc' in ~/.vimrc will read .vimrc from the current directory +set tabstop=8 +set shiftwidth=8 +set expandtab diff --git a/gummiboot-nomachineid-48/LICENSE b/gummiboot-nomachineid-48/LICENSE new file mode 100644 index 0000000..4362b49 --- /dev/null +++ b/gummiboot-nomachineid-48/LICENSE @@ -0,0 +1,502 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/gummiboot-nomachineid-48/Makefile.am b/gummiboot-nomachineid-48/Makefile.am new file mode 100644 index 0000000..20f3580 --- /dev/null +++ b/gummiboot-nomachineid-48/Makefile.am @@ -0,0 +1,202 @@ +# +# This file is part of gummiboot +# +# Copyright (C) 2013 Karel Zak +# +# gummiboot is free software; you can redistribute it and/or modify it +# under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation; either version 2.1 of the License, or +# (at your option) any later version. +# +# gummiboot is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with systemd; If not, see . + +ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS} +AM_MAKEFLAGS = --no-print-directory + +gummibootlibdir = $(prefix)/lib/gummiboot + +AM_CPPFLAGS = -include config.h +AM_CFLAGS = \ + -D_GNU_SOURCE \ + -Wall \ + -Wextra \ + -Wmissing-prototypes \ + -Wno-unused-parameter +AM_LDFLAGS = + +EXTRA_DIST = autogen.sh README LICENSE +CLEANFILES = + +# ------------------------------------------------------------------------------ +if HAVE_BLKID +bin_PROGRAMS = gummiboot + +gummiboot_SOURCES = \ + src/setup/setup.c \ + src/setup/efivars.c \ + src/setup/efivars.h + +gummiboot_CPPFLAGS = \ + $(AM_CPPFLAGS) \ + -DMACHINE_TYPE_NAME=\"$(MACHINE_TYPE_NAME)\" \ + -DGUMMIBOOTLIBDIR=\"$(gummibootlibdir)\" + +gummiboot_CFLAGS = \ + $(AM_CFLAGS) \ + $(BLKID_CFLAGS) + +gummiboot_LDADD = \ + $(BLKID_LIBS) +endif + +if ENABLE_MANPAGES +%.8: %.xml + $(AM_V_GEN)$(XSLTPROC) -o $@ --nonet \ + --stringparam man.output.quietly 1 \ + --stringparam man.th.extra1.suppress 1 \ + --stringparam man.authors.section.enabled 0 \ + --stringparam man.copyright.section.enabled 0 \ + http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl $< + +dist_man_MANS = man/gummiboot.8 +endif + +EXTRA_DIST += man/gummiboot.xml +CLEANFILES += man/gummiboot.8 + +# ------------------------------------------------------------------------------ +# EFI compilation -- this part of the build system uses custom make rules and +# bypasses regular automake to provide absolute control on compiler and linker +# flags. +efi_cppflags = \ + $(EFI_CPPFLAGS) \ + -I$(top_builddir) -include config.h \ + -I$(EFI_INC_DIR)/efi \ + -I$(EFI_INC_DIR)/efi/$(ARCH) \ + -DMACHINE_TYPE_NAME=\"$(MACHINE_TYPE_NAME)\" + +efi_cflags = \ + $(EFI_CFLAGS) \ + -Wall \ + -Wextra \ + -nostdinc \ + -ggdb -O0 \ + -fpic \ + -fshort-wchar \ + -nostdinc \ + -ffreestanding \ + -fno-strict-aliasing \ + -fno-stack-protector \ + -Wsign-compare \ + -mno-sse \ + -mno-mmx + +if ARCH_X86_64 +efi_cflags += \ + -mno-red-zone \ + -DEFI_FUNCTION_WRAPPER \ + -DGNU_EFI_USE_MS_ABI +endif + +efi_ldflags = \ + $(EFI_LDLAGS) \ + -T $(EFI_LDS_DIR)/elf_$(ARCH)_efi.lds \ + -shared \ + -Bsymbolic \ + -nostdlib \ + -znocombreloc \ + -L $(EFI_LIB_DIR) \ + $(EFI_LDS_DIR)/crt0-efi-$(ARCH).o + +# ------------------------------------------------------------------------------ +gummiboot_headers = \ + src/efi/util.h \ + src/efi/console.h \ + src/efi/graphics.h \ + src/efi/pefile.h + +gummiboot_sources = \ + src/efi/util.c \ + src/efi/console.c \ + src/efi/graphics.c \ + src/efi/pefile.c \ + src/efi/gummiboot.c + +gummiboot_objects = $(addprefix $(top_builddir)/,$(gummiboot_sources:.c=.o)) +gummiboot_solib = $(top_builddir)/src/efi/gummiboot.so +gummiboot = gummiboot$(MACHINE_TYPE_NAME).efi + +gummibootlib_DATA = $(gummiboot) +CLEANFILES += $(gummiboot_objects) $(gummiboot_solib) $(gummiboot) +EXTRA_DIST += $(gummiboot_sources) $(gummiboot_headers) + +$(top_builddir)/src/efi/%.o: $(top_srcdir)/src/efi/%.c $(addprefix $(top_srcdir)/,$(gummiboot_headers)) + @$(MKDIR_P) $(top_builddir)/src/efi/ + $(AM_V_CC)$(EFI_CC) $(efi_cppflags) $(efi_cflags) -c $< -o $@ + +$(gummiboot_solib): $(gummiboot_objects) + $(AM_V_CCLD)$(LD) $(efi_ldflags) $(gummiboot_objects) \ + -o $@ -lefi -lgnuefi $(shell $(CC) -print-libgcc-file-name); \ + nm -D -u $@ | grep ' U ' && exit 1 || : +.DELETE_ON_ERROR: $(gummboot_solib) + +$(gummiboot): $(gummiboot_solib) + $(AM_V_GEN) objcopy -j .text -j .sdata -j .data -j .dynamic \ + -j .dynsym -j .rel -j .rela -j .reloc \ + --target=efi-app-$(ARCH) $< $@ + +# ------------------------------------------------------------------------------ +stub_headers = \ + src/efi/util.h \ + src/efi/pefile.h \ + src/efi/linux.h + +stub_sources = \ + src/efi/util.c \ + src/efi/pefile.c \ + src/efi/linux.c \ + src/efi/stub.c + +stub_objects = $(addprefix $(top_builddir)/,$(stub_sources:.c=.o)) +stub_solib = $(top_builddir)/src/efi/stub.so +stub = linux$(MACHINE_TYPE_NAME).efi.stub + +gummibootlib_DATA += $(stub) +CLEANFILES += $(stub_objects) $(stub_solib) $(stub) +EXTRA_DIST += $(stub_sources) $(stub_headers) + +$(top_builddir)/src/efi/%.o: $(top_srcdir)/src/efi/%.c $(addprefix $(top_srcdir)/,$(stub_headers)) + @$(MKDIR_P) $(top_builddir)/src/efi/ + $(AM_V_CC)$(EFI_CC) $(efi_cppflags) $(efi_cflags) -c $< -o $@ + +$(stub_solib): $(stub_objects) + $(AM_V_CCLD)$(LD) $(efi_ldflags) $(stub_objects) \ + -o $@ -lefi -lgnuefi $(shell $(CC) -print-libgcc-file-name); \ + nm -D -u $@ | grep ' U ' && exit 1 || : +.DELETE_ON_ERROR: $(gummboot_solib) + +$(stub): $(stub_solib) + $(AM_V_GEN) objcopy -j .text -j .sdata -j .data -j .dynamic \ + -j .dynsym -j .rel -j .rela -j .reloc \ + --target=efi-app-$(ARCH) $< $@ + +# ------------------------------------------------------------------------------ +CLEANFILES += test-disk.img +EXTRA_DIST += test/test-create-disk.sh + +test-disk.img: gummiboot$(MACHINE_TYPE_NAME).efi test/test-create-disk.sh + $(AM_V_GEN)test/test-create-disk.sh + +qemu: test-disk.img + $(QEMU) -machine accel=kvm -m 256 -bios $(QEMU_BIOS) -snapshot test-disk.img + +install-tree: all + rm -rf $(abs_srcdir)/install-tree + $(MAKE) install DESTDIR=$(abs_srcdir)/install-tree + tree $(abs_srcdir)/install-tree diff --git a/gummiboot-nomachineid-48/README b/gummiboot-nomachineid-48/README new file mode 100644 index 0000000..336eba4 --- /dev/null +++ b/gummiboot-nomachineid-48/README @@ -0,0 +1,26 @@ +gummiboot Simple UEFI boot manager + +gummiboot executes EFI images. The default entry is selected by a configured +pattern (glob) or an on-screen menu. + +gummiboot operates on the EFI System Partition (ESP) only. Configuration +file fragments, kernels, initrds, other EFI images need to reside on the +ESP. Linux kernels must be built with CONFIG_EFI_STUB to be able to be +directly executed as an EFI image. + +gummiboot reads simple and entirely generic configuration files; one file +per boot entry to select from. + +Pressing Space (or most other) keys during bootup will show an on-screen +menu with all configured entries to select from. Pressing enter on the +selected entry loads and starts the EFI image. +Pressing "e" on the entry menu shows and optionally edits the kernel command line. +If no timeout is configured and no key pressed during bootup, the default +entry is booted right away. + +Further documentation is available in the gummiboot wiki at: + http://freedesktop.org/wiki/Software/gummiboot + +Links: + http://www.freedesktop.org/wiki/Specifications/BootLoaderSpec + http://www.freedesktop.org/software/systemd/man/kernel-install.html diff --git a/gummiboot-nomachineid-48/TODO b/gummiboot-nomachineid-48/TODO new file mode 100644 index 0000000..e69de29 diff --git a/gummiboot-nomachineid-48/autogen.sh b/gummiboot-nomachineid-48/autogen.sh new file mode 100755 index 0000000..dfe9eba --- /dev/null +++ b/gummiboot-nomachineid-48/autogen.sh @@ -0,0 +1,36 @@ +#!/bin/sh + +# This file is part of gummiboot. +# +# gummiboot is free software; you can redistribute it and/or modify it +# under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation; either version 2.1 of the License, or +# (at your option) any later version. +# +# gummiboot is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with systemd; If not, see . + +set -e + +autoreconf --force --install --symlink + +args="\ +--prefix=/usr" + +if [ "x$1" = "xc" ]; then + ./configure $args + make clean +else + echo + echo "----------------------------------------------------------------" + echo "Initialized build system. For a common configuration please run:" + echo "----------------------------------------------------------------" + echo + echo "./configure $args" + echo +fi diff --git a/gummiboot-nomachineid-48/configure.ac b/gummiboot-nomachineid-48/configure.ac new file mode 100644 index 0000000..27bbe1d --- /dev/null +++ b/gummiboot-nomachineid-48/configure.ac @@ -0,0 +1,155 @@ +# +# This file is part of gummiboot. +# +# Copyright (C) 2013 Karel Zak +# +# gummiboot is free software; you can redistribute it and/or modify it +# under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation; either version 2.1 of the License, or +# (at your option) any later version. +# +# gummiboot is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with systemd; If not, see . + +AC_INIT([gummiboot], + [48], + [systemd-devel@lists.freedesktop.org], + [gummiboot], + [http://freedesktop.org/wiki/Software/gummiboot]) + +AC_CONFIG_SRCDIR([src/setup/setup.c]) +AC_CONFIG_MACRO_DIR([m4]) +AC_CONFIG_HEADERS([config.h]) +AC_CONFIG_AUX_DIR([build-aux]) +AC_PREFIX_DEFAULT([/usr]) + +AM_INIT_AUTOMAKE([foreign 1.11 -Wall -Wno-portability silent-rules tar-pax no-dist-gzip dist-xz subdir-objects]) +AM_SILENT_RULES([yes]) + +AC_CANONICAL_HOST +AC_SYS_LARGEFILE + +AC_PROG_CC + +dnl Don't try to use things like -std=c99 for efi compilation +EFI_CC=$CC +AC_SUBST([EFI_CC]) + +AC_PROG_CC_C99 +AM_PROG_CC_C_O +AC_PROG_GCC_TRADITIONAL + +AC_PROG_MKDIR_P +AC_PATH_PROG([XSLTPROC], [xsltproc]) + +dnl Define ARCH_ conditionals +SET_ARCH(IA32, i*86*) +SET_ARCH(X86_64, x86_64*) +SET_ARCH(IA64, ia64*) + +ARCH=`echo $host | sed "s/\(-\).*$//"` + +AM_COND_IF(ARCH_IA32, [ + ARCH=ia32 + MACHINE_TYPE_NAME=ia32]) + +AM_COND_IF(ARCH_X86_64, [ + MACHINE_TYPE_NAME=x64]) + +AC_SUBST([ARCH]) +AC_SUBST([MACHINE_TYPE_NAME]) + +# QEMU and OVMF UEFI firmware +AS_IF([test x"$cross_compiling" = "xyes"], [], [ + AC_PATH_PROG([QEMU], [qemu-system-x86_64]) + AC_CHECK_FILE([/usr/share/qemu/bios-ovmf.bin], [QEMU_BIOS=/usr/share/qemu/bios-ovmf.bin]) + AC_CHECK_FILE([/usr/share/qemu-ovmf/bios.bin], [QEMU_BIOS=/usr/share/qemu-ovmf/bios.bin]) + AC_SUBST([QEMU_BIOS]) +]) + +# ------------------------------------------------------------------------------ +dnl GNU EFI doesn't use relative paths: efi.h includes efibind.h which is in +dnl ${ARCH} relative to efi.h. I can't find a way to get AC_CHECK_HEADERS to +dnl add -I/usr/include/efi/${ARCH} to the conftest.c build. So, just test for +dnl efibind.h as the chances of efi.h not existing if it does are very low. +AC_CHECK_HEADER(efi/${ARCH}/efibind.h, [], + [AC_MSG_ERROR([*** GNU EFI header efibind.h not found])]) + +efiroot=$(echo $(cd /usr/lib/$(gcc -print-multi-os-directory); pwd)) +EFI_LIB_DIR="$efiroot" +AC_ARG_WITH(efi-libdir, + AS_HELP_STRING([--with-efi-libdir=PATH], [Path to efi lib directory]), + [EFI_LIB_DIR="$withval"], [EFI_LIB_DIR="$efiroot"] +) +AC_SUBST([EFI_LIB_DIR]) + +dnl extra objects and linker scripts +AC_ARG_WITH(efi-ldsdir, + AS_HELP_STRING([--with-efi-ldsdir=PATH], [Path to efi lds directory]), + [EFI_LDS_DIR="$withval"], + [ + for EFI_LDS_DIR in "${efiroot}/gnuefi" "${efiroot}"; do + for lds in ${EFI_LDS_DIR}/elf_${ARCH}_efi.lds; do + test -f ${lds} && break 2 + done + done + ] +) +AC_SUBST([EFI_LDS_DIR]) + +AC_ARG_WITH(efi-includedir, + AS_HELP_STRING([--with-efi-includedir=PATH], [Path to efi include directory]), + [EFI_INC_DIR="$withval"], [EFI_INC_DIR="/usr/include"] +) +AC_SUBST([EFI_INC_DIR]) + +# ------------------------------------------------------------------------------ +AC_ARG_ENABLE(blkid, AS_HELP_STRING([--disable-blkid], [disable blkid support])) +if test "x$enable_blkid" != "xno"; then + PKG_CHECK_MODULES(BLKID, [ blkid >= 2.20 ], + [AC_DEFINE(HAVE_BLKID, 1, [Define if blkid is available]) have_blkid=yes], have_blkid=no) + if test "x$have_blkid" = xno -a "x$enable_blkid" = xyes; then + AC_MSG_ERROR([*** blkid support requested but libraries not found]) + fi +fi +AM_CONDITIONAL(HAVE_BLKID, [test "$have_blkid" = "yes"]) + +# ------------------------------------------------------------------------------ +have_manpages=no +AC_ARG_ENABLE(manpages, AS_HELP_STRING([--disable-manpages], [disable manpages])) +AS_IF([test "x$enable_manpages" != xno], [ + AS_IF([test "x$enable_manpages" = xyes -a "x$XSLTPROC" = x], [ + AC_MSG_ERROR([*** Manpages requested but xsltproc not found]) + ]) + AS_IF([test "x$XSLTPROC" != x], [have_manpages=yes]) +]) +AM_CONDITIONAL(ENABLE_MANPAGES, [test "x$have_manpages" = "xyes"]) + +# ------------------------------------------------------------------------------ +AC_CONFIG_FILES([ + Makefile +]) + +AC_OUTPUT +AC_MSG_RESULT([ + $PACKAGE_NAME $VERSION + + prefix: ${prefix} + arch: $ARCH + EFI machine type: $MACHINE_TYPE_NAME + + EFI libdir: ${EFI_LIB_DIR} + EFI ldsdir: ${EFI_LDS_DIR} + EFI includedir: ${EFI_INC_DIR} + + blkid: ${have_blkid} + man pages: ${have_manpages} + + QEMU: ${QEMU} + QEMU OVMF: ${QEMU_BIOS} +]) diff --git a/gummiboot-nomachineid-48/debian/changelog b/gummiboot-nomachineid-48/debian/changelog new file mode 100644 index 0000000..0fbf20f --- /dev/null +++ b/gummiboot-nomachineid-48/debian/changelog @@ -0,0 +1,54 @@ +gummiboot-nomachineid (48-100) unstable; urgency=medium + * Strip out all features related to machine-id implementation (but not to its tolerability) + ** debian/control: Don't require dbus either + ** Current and future kernels will be installed to "{EFI partition}/linux-{version string}/" + instead of "{EFI partition}/{machine-id}/{version string}/" + * Update update-gummiboot(8) manpage with clearer facts and slight changes + * Update gummiboot(8) manpage with more relevant documentation links + * New manpage: gummiboot(5), explaining /etc/default/gummiboot + * If you can read this, you might be an above-average smart computer user + * debian/control: Self-promotion + * debian/control: Replaces inferior versions of "gummiboot" package + ** debian/control: Provides virtual "gummiboot" package + * debian/control: Updated description + + -- Riccardo Boninsegna Wed, 17 Jun 2015 22:00:00 +0200 + +gummiboot (48-2) unstable; urgency=medium + + * Replace systemd hard dependency for machine-id generation with dbus + (not ideal but maybe more tolerable?) -- Really closes #749706 ;) + + -- Riccardo Boninsegna Tue, 16 Jun 2015 21:51:40 +0200 + +gummiboot (48-1) unstable; urgency=medium + + * New (last) upstream release + * debian/control: Standards-Version: 3.9.6 + + -- Julian Andres Klode Tue, 12 May 2015 16:51:40 +0200 + +gummiboot (45-2) unstable; urgency=medium + + * debian/control: Make sure we build against gnu-efi 3.0v-5 + * Add a Built-Using for gnu-efi + + -- Julian Andres Klode Mon, 21 Jul 2014 13:38:36 +0200 + +gummiboot (45-1) unstable; urgency=medium + + [ Julian Andres Klode ] + * Normalize name cases bootx64.efi and friends (Closes: #745280) + * debian/control: Promote systemd from Recommends to Pre-Depends + (Closes: #749706) + * update-gummiboot: Ensure loader/entries is created (Closes: #745279) + * Build-Conflict with autoreconf2.13 (Closes: #754911) + * Build-Depend on gnu-efi (>= 3.0v-4~) or (<< 3.0v) to catch broken versions + + -- Julian Andres Klode Sat, 19 Jul 2014 14:38:44 +0200 + +gummiboot (44-1) unstable; urgency=low + + * Initial upload to Debian (Closes: #680265) + + -- Julian Andres Klode Thu, 10 Apr 2014 21:26:26 +0200 diff --git a/gummiboot-nomachineid-48/debian/compat b/gummiboot-nomachineid-48/debian/compat new file mode 100644 index 0000000..ec63514 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/compat @@ -0,0 +1 @@ +9 diff --git a/gummiboot-nomachineid-48/debian/control b/gummiboot-nomachineid-48/debian/control new file mode 100644 index 0000000..e0e97b1 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/control @@ -0,0 +1,35 @@ +Source: gummiboot-nomachineid +Section: admin +Priority: optional +Maintainer: Riccardo Boninsegna +Build-Depends: debhelper (>= 9), dh-autoreconf, docbook-xsl, gnu-efi (>= 3.0v-5~) | gnu-efi (<< 3.0v), libblkid-dev, pkg-config, xsltproc +Build-Conflicts: autoconf2.13 +Standards-Version: 3.9.6 +Vcs-Git: git://anonscm.debian.org/collab-maint/gummiboot.git +Vcs-Browser: http://anonscm.debian.org/gitweb/?p=collab-maint/gummiboot.git +Homepage: http://freedesktop.org/wiki/Software/gummiboot/ + +Package: gummiboot-nomachineid +Architecture: i386 amd64 x32 ia64 +Depends: ${misc:Depends}, ${shlibs:Depends} +Built-Using: ${misc:Built-Using} +Multi-Arch: foreign +Conflicts: gummiboot (<=48-10) +Replaces: gummiboot (<=48-10) +Provides: gummiboot +Description: UEFI bootloader + gummiboot is a simple UEFI bootloader which executes an EFI binary from a file-defined list. + It optionally allows for arguments to be passed to a Linux kernel. + . + In contrast to other bootloaders like grub, gummiboot requires all configuration files, + kernels, and ramdisks to reside on the ESP; Linux kernels also need to be built with CONFIG_EFI_STUB. + An advantage of this design is not requiring /boot to be on a plain partition if + you're using a setup not directly supported by GRUB, such as an encrypted root filesystem. + . + The Debian additions to this package take care of creating the configuration files and + copying the kernels to the ESP partition. It requires a mounted efivarfs for full functionality, + but will install just fine as the default boot loader (as used in Apple's graphical boot selector). + . + This fork of gummiboot removes (in a backwards-compatible way) support for the "machine-id" entry parameter, + as this package's maintainer deems such a feature unnecessary in a single-boot computer, + yet requires depending on systemd or dbus for an easy practical implementation. diff --git a/gummiboot-nomachineid-48/debian/copyright b/gummiboot-nomachineid-48/debian/copyright new file mode 100644 index 0000000..7f209ee --- /dev/null +++ b/gummiboot-nomachineid-48/debian/copyright @@ -0,0 +1,23 @@ +Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Source: http://cgit.freedesktop.org/gummiboot/ + +Files: debian/* +Copyright: © 2014 Julian Andres Klode +License: LGPL-2.1+ + +Files: * +Copyright: © 2012 Harald Hoyer + © 2012-2013 Kay Sievers + © 2013 Lennart Poettering + © 2013 Intel Corporation + © 2013 Karel Zak +License: LGPL-2.1+ + +License: LGPL-2.1+ + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + . + On Debian systems, the complete text of the GNU General Public License + can be found in file "/usr/share/common-licenses/LGPL-2.1". diff --git a/gummiboot-nomachineid-48/debian/gbp.conf b/gummiboot-nomachineid-48/debian/gbp.conf new file mode 100644 index 0000000..4b8f9b8 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/gbp.conf @@ -0,0 +1,5 @@ +[DEFAULT] +pristine-tar = True +sign-tags = True +patch-numbers = False +upstream-tag = %(version)s diff --git a/gummiboot-nomachineid-48/debian/gummiboot.5 b/gummiboot-nomachineid-48/debian/gummiboot.5 new file mode 100644 index 0000000..4752d92 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/gummiboot.5 @@ -0,0 +1,55 @@ +.\" Copyright (C) 2015 Riccardo Boninsegna +.TH gummiboot 5 "2015-6-17" "48-100" "gummiboot-nomachineid" +.SH NAME +/etc/default/gummiboot - Settings for +.BR update-gummiboot (8) +.SH SYNOPSIS +.B $EDITOR +.I /etc/default/gummiboot +.SH DESCRIPTION + +.I /etc/default/gummiboot +is a shell script which is automatically included in +.BR update-gummiboot (8) +to override its default settings. + +.SH FORMAT + +.B GUMMIBOOT_EFI= +.RS +Sets mount point of EFI system partition. +Defaults to +.IR "/boot/efi" . +.RE + +.B GUMMIBOOT_ROOT= +.RS +Sets the root partition of your GNU/Linux system. +Defaults to +.IR "an empty string" , +which makes +.B update-gummiboot +parse +.I /etc/fstab +for it. +.RE + +.B GUMMIBOOT_OPTIONS= +.RS +Sets arbitrary kernel arguments, that will supplement +.B initrd= +and +.B root= +. +Defaults to +.IR "ro quiet" . +.RE + +.SH SEE ALSO +.BR update-gummiboot (8) + +.SH AUTHOR +.I /etc/default/gummiboot +has been invented by Julian Andres Klode while porting gummiboot to the Debian project. + +Manpage written by Riccardo Boninsegna. diff --git a/gummiboot-nomachineid-48/debian/gummiboot.default b/gummiboot-nomachineid-48/debian/gummiboot.default new file mode 100644 index 0000000..828e622 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/gummiboot.default @@ -0,0 +1,11 @@ +# Run update-gummiboot after editing this file +# + +# The EFI boot partition +GUMMIBOOT_EFI="/boot/efi" + +# Set the root device. If not specified, this is read from /proc/cmdline +GUMMIBOOT_ROOT="" + +# Set the options to pass to the kernel command line +GUMMIBOOT_OPTIONS="ro quiet" diff --git a/gummiboot-nomachineid-48/debian/gummiboot.install b/gummiboot-nomachineid-48/debian/gummiboot.install new file mode 100644 index 0000000..a340745 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/gummiboot.install @@ -0,0 +1,2 @@ +debian/update-gummiboot usr/sbin +debian/zz-update-gummiboot etc/initramfs/post-update.d diff --git a/gummiboot-nomachineid-48/debian/gummiboot.links b/gummiboot-nomachineid-48/debian/gummiboot.links new file mode 100644 index 0000000..c2458db --- /dev/null +++ b/gummiboot-nomachineid-48/debian/gummiboot.links @@ -0,0 +1,2 @@ +usr/sbin/update-gummiboot etc/kernel/postinst.d/zz-update-gummiboot +usr/sbin/update-gummiboot etc/kernel/postrm.d/zz-update-gummiboot diff --git a/gummiboot-nomachineid-48/debian/gummiboot.manpages b/gummiboot-nomachineid-48/debian/gummiboot.manpages new file mode 100644 index 0000000..77fbd6a --- /dev/null +++ b/gummiboot-nomachineid-48/debian/gummiboot.manpages @@ -0,0 +1,2 @@ +debian/update-gummiboot.8 +debian/gummiboot.5 diff --git a/gummiboot-nomachineid-48/debian/gummiboot.postinst b/gummiboot-nomachineid-48/debian/gummiboot.postinst new file mode 100644 index 0000000..02fb99e --- /dev/null +++ b/gummiboot-nomachineid-48/debian/gummiboot.postinst @@ -0,0 +1,18 @@ +#!/bin/sh +# postinst script for gummiboot + +set -e + +. /etc/default/gummiboot + +if [ "$1" = "configure" -a "$2" = "" ]; then + for kernel in /boot/vmlinuz-*; do + update-gummiboot $(echo $kernel | cut -f2- -d-) + done +fi + +if [ "$1" = "configure" ]; then + gummiboot update --path="$GUMMIBOOT_EFI" || : +fi + +#DEBHELPER# diff --git a/gummiboot-nomachineid-48/debian/patches/Set-boot-efi-as-default-ESP-mount-point.patch b/gummiboot-nomachineid-48/debian/patches/Set-boot-efi-as-default-ESP-mount-point.patch new file mode 100644 index 0000000..98a7986 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/patches/Set-boot-efi-as-default-ESP-mount-point.patch @@ -0,0 +1,25 @@ +From: Julian Andres Klode +Date: Thu, 10 Apr 2014 16:17:39 +0200 +Subject: Set /boot/efi as default ESP mount point + +The Debian installer configures the ESP to be mounted at /boot/efi, +and not /boot, as gummiboot assumes. + +Forwarded: not-needed +--- + src/setup/setup.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/setup/setup.c b/src/setup/setup.c +index 6a4275a..0cfaccf 100644 +--- a/src/setup/setup.c ++++ b/src/setup/setup.c +@@ -1367,7 +1367,7 @@ int main(int argc, char*argv[]) { + } + + if (!arg_path) +- arg_path = "/boot"; ++ arg_path = "/boot/efi"; + + if (geteuid() != 0) { + fprintf(stderr, "Need to be root.\n"); diff --git a/gummiboot-nomachineid-48/debian/patches/disable-machine-id-logic b/gummiboot-nomachineid-48/debian/patches/disable-machine-id-logic new file mode 100644 index 0000000..e1aeba8 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/patches/disable-machine-id-logic @@ -0,0 +1,175 @@ +Description: Remove code related to machine-id + Makes the gummiboot(8) command not require /etc/machine-id (thus avoiding a Pre-Depends on systemd) + nor /var/lib/dbus/machine-id (thus avoiding a Depends on dbus). + . + In Debian-like OSes, also requires appropriate changes to update-gummiboot(8). + . + World's-least-dependencies mainstream boot loader? +Author: Riccardo Boninsegna +Forwarded: no +Last-Update: 2015-06-17 + +--- gummiboot-nomachineid-48.orig/README ++++ gummiboot-nomachineid-48/README +@@ -8,13 +8,13 @@ file fragments, kernels, initrds, other + ESP. Linux kernels must be built with CONFIG_EFI_STUB to be able to be + directly executed as an EFI image. + +-gummiboot reads simple and entirely generic configurion files; one file ++gummiboot reads simple and entirely generic configuration files; one file + per boot entry to select from. + + Pressing Space (or most other) keys during bootup will show an on-screen + menu with all configured entries to select from. Pressing enter on the + selected entry loads and starts the EFI image. +- ++Pressing "e" on the entry menu shows and optionally edits the kernel command line. + If no timeout is configured and no key pressed during bootup, the default + entry is booted right away. + +--- gummiboot-nomachineid-48.orig/man/gummiboot.xml ++++ gummiboot-nomachineid-48/man/gummiboot.xml +@@ -128,10 +128,7 @@ + + See Also + +- Gummiboot wiki +- Boot loader specification +- Systemd boot loader interface +- bootctl1 ++ Arch Linux Wiki: Gummiboot + + + +--- gummiboot-nomachineid-48.orig/src/efi/gummiboot.c ++++ gummiboot-nomachineid-48/src/efi/gummiboot.c +@@ -1239,45 +1239,7 @@ static VOID config_entry_add_from_file(C + } + FreePool(initrd); + +- if (entry->machine_id) { +- CHAR16 *var; +- +- /* append additional options from EFI variables for this machine-id */ +- var = PoolPrint(L"LoaderEntryOptions-%s", entry->machine_id); +- if (var) { +- CHAR16 *s; +- +- if (efivar_get(var, &s) == EFI_SUCCESS) { +- if (entry->options) { +- CHAR16 *s2; +- +- s2 = PoolPrint(L"%s %s", entry->options, s); +- FreePool(entry->options); +- entry->options = s2; +- } else +- entry->options = s; +- } +- FreePool(var); +- } +- +- var = PoolPrint(L"LoaderEntryOptionsOneShot-%s", entry->machine_id); +- if (var) { +- CHAR16 *s; +- +- if (efivar_get(var, &s) == EFI_SUCCESS) { +- if (entry->options) { +- CHAR16 *s2; +- +- s2 = PoolPrint(L"%s %s", entry->options, s); +- FreePool(entry->options); +- entry->options = s2; +- } else +- entry->options = s; +- efivar_set(var, NULL, TRUE); +- } +- FreePool(var); +- } +- } ++ /* machine-id handling code removed */ + + entry->device = device; + entry->file = StrDuplicate(file); +@@ -1511,24 +1473,7 @@ static VOID config_title_generate(Config + if (unique) + return; + +- /* add machine-id to non-unique titles */ +- for (i = 0; i < config->entry_count; i++) { +- CHAR16 *s; +- CHAR16 *m; +- +- if (!config->entries[i]->non_unique) +- continue; +- if (!config->entries[i]->machine_id) +- continue; +- +- m = StrDuplicate(config->entries[i]->machine_id); +- m[8] = '\0'; +- s = PoolPrint(L"%s (%s)", config->entries[i]->title_show, m); +- FreePool(config->entries[i]->title_show); +- config->entries[i]->title_show = s; +- config->entries[i]->non_unique = FALSE; +- FreePool(m); +- } ++ /* machine-id handling code removed */ + + unique = TRUE; + for (i = 0; i < config->entry_count; i++) { +--- gummiboot-nomachineid-48.orig/src/setup/setup.c ++++ gummiboot-nomachineid-48/src/setup/setup.c +@@ -1229,43 +1229,23 @@ static int remove_variables(const uint8_ + } + + static int install_loader_config(const char *esp_path) { +- char *p = NULL; +- char line[64]; +- char *machine = NULL; +- FILE *f; ++ /** Create default global preferences file */ ++ char *filename = NULL; ++ FILE *file; + +- f = fopen("/etc/machine-id", "re"); +- if (!f) +- return -errno; +- +- if (fgets(line, sizeof(line), f) != NULL) { +- char *s; +- +- s = strchr(line, '\n'); +- if (s) +- s[0] = '\0'; +- if (strlen(line) == 32) +- machine = line; +- } +- +- fclose(f); +- +- if (!machine) +- return -ESRCH; +- +- if (asprintf(&p, "%s/%s", esp_path, "loader/loader.conf") < 0) { +- fprintf(stderr, "Out of memory.\n"); ++ if (asprintf(&filename, "%s/%s", esp_path, "loader/loader.conf") < 0) { ++ fprintf(stderr, "Can't allocate memory for filename.\n"); + return -ENOMEM; + } + +- f = fopen(p, "wxe"); +- if (f) { +- fprintf(f, "#timeout 3\n"); +- fprintf(f, "default %s-*\n", machine); +- fclose(f); ++ file = fopen(filename, "wxe"); ++ if (file) { ++ fprintf(file, "#timeout 3\n"); ++ fclose(file); + } ++ else fprintf(stderr, "Warning: failed creating %s/loader/loader.conf\n", esp_path); + +- free(p); ++ free(filename); + return 0; + } + diff --git a/gummiboot-nomachineid-48/debian/patches/series b/gummiboot-nomachineid-48/debian/patches/series new file mode 100644 index 0000000..a7da49b --- /dev/null +++ b/gummiboot-nomachineid-48/debian/patches/series @@ -0,0 +1,3 @@ +Set-boot-efi-as-default-ESP-mount-point.patch +setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch +disable-machine-id-logic diff --git a/gummiboot-nomachineid-48/debian/patches/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch b/gummiboot-nomachineid-48/debian/patches/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch new file mode 100644 index 0000000..2d0dfc3 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/patches/setup-Normalize-the-boot-.efi-to-the-case-used-by-th.patch @@ -0,0 +1,68 @@ +From: Julian Andres Klode +Date: Tue, 3 Jun 2014 17:41:51 +0200 +Subject: setup: Normalize the boot*.efi to the case used by the file system + +Ensure that bootx64.efi and friends use the same case as the already +existing file to ensure that we correctly replace it on systems where +the ESP is mounted using utf8 (such as Debian). + +This also changes the default case of these files to lower case as +it completely replaces the strupper function. + +Bug-Debian: http://bugs.debian.org/745280 +--- + src/setup/setup.c | 32 ++++++++++++++++++++++++++------ + 1 file changed, 26 insertions(+), 6 deletions(-) + +diff --git a/src/setup/setup.c b/src/setup/setup.c +index 0cfaccf..cb96a85 100644 +--- a/src/setup/setup.c ++++ b/src/setup/setup.c +@@ -682,13 +682,33 @@ finish: + return r; + } + +-static char* strupper(char *s) { +- char *p; ++static int normalize_filename_case(char *name) { ++ char *base_start; ++ char *base; ++ DIR *d; ++ struct dirent *de; ++ ++ base_start = strrchr(name, '/'); ++ base = base_start + 1; ++ ++ *base_start = 0; ++ d = opendir(name); ++ *base_start = '/'; ++ ++ if (d == NULL) ++ return -errno; + +- for (p = s; *p; p++) +- *p = toupper(*p); ++ while ((de = readdir(d))) { ++ /* Normalize (only) the base name of the given path */ ++ if (strcasecmp(de->d_name, base) == 0) { ++ strcpy(base, de->d_name); ++ break; ++ } ++ } + +- return s; ++ closedir(d); ++ ++ return 0; + } + + static int mkdir_one(const char *prefix, const char *suffix) { +@@ -765,7 +785,7 @@ static int copy_one_file(const char *esp_path, const char *name, bool force) { + r = -ENOMEM; + goto finish; + } +- strupper(strrchr(v, '/') + 1); ++ normalize_filename_case(v); + + k = copy_file(p, v, force); + if (k < 0 && r == 0) { diff --git a/gummiboot-nomachineid-48/debian/rules b/gummiboot-nomachineid-48/debian/rules new file mode 100755 index 0000000..a98c06e --- /dev/null +++ b/gummiboot-nomachineid-48/debian/rules @@ -0,0 +1,10 @@ +#!/usr/bin/make -f +%: + dh $@ --with autoreconf + +override_dh_auto_configure: + dh_auto_configure -- --disable-silent-rules + +override_dh_gencontrol: + dh_gencontrol -- -Vmisc:Built-Using="$(shell dpkg-query -W \ + -f='$${source:Package} (= $${source:Version})' gnu-efi)" diff --git a/gummiboot-nomachineid-48/debian/source/format b/gummiboot-nomachineid-48/debian/source/format new file mode 100644 index 0000000..163aaf8 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/gummiboot-nomachineid-48/debian/update-gummiboot b/gummiboot-nomachineid-48/debian/update-gummiboot new file mode 100755 index 0000000..8009782 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/update-gummiboot @@ -0,0 +1,87 @@ +#!/bin/sh +# +# Edits © 2015 Riccardo Boninsegna +# Original © 2014 Julian Andres Klode +# + +set -e +set -u + +# TODO: This needs to be done more clever +determine_root() { + sed 's/#.*//g' /etc/fstab | awk '($2 == "/") {print $1}' +} + +install_kernel() { + install -D /boot/vmlinuz-$KERNEL $GUMMIBOOT_EFI/linux-$KERNEL/linux + if [ -e /boot/initrd.img-$KERNEL ]; then + install -D /boot/initrd.img-$KERNEL $GUMMIBOOT_EFI/linux-$KERNEL/initrd + fi +} + +install_entry() { + dir="$GUMMIBOOT_EFI/loader/entries/" + entry="$dir/linux-$KERNEL.conf" + options="root=$GUMMIBOOT_ROOT $GUMMIBOOT_OPTIONS" + + [ -e $dir ] || mkdir -p $dir + + cat > $entry << EOF +title $PRETTY_NAME +version $KERNEL +options $options +linux /linux-$KERNEL/linux +EOF + if [ -e $GUMMIBOOT_EFI/linux-$KERNEL/initrd ]; then + echo "initrd /linux-$KERNEL/initrd" >> $entry + fi +} + +do_install() { + if [ -z "$GUMMIBOOT_ROOT" ]; then + echo "ERROR: Cannot determine root partition, please set it in one of:" >&2 + echo " /etc/fstab" >&2 + echo " /etc/default/gummiboot" >&2 + exit 1 + fi + echo "Install $KERNEL to ESP" >&2 + install_kernel + install_entry +} + +do_remove() { + echo "Remove $KERNEL from ESP" >&2 + rm -r $GUMMIBOOT_EFI/linux-$KERNEL/ || true + rm $GUMMIBOOT_EFI/loader/entries/linux-$KERNEL.conf || true +} + + +# PROGRAM STARTS HERE +# Default options +GUMMIBOOT_EFI="/boot/efi" +GUMMIBOOT_ROOT="" +GUMMIBOOT_OPTIONS="ro quiet" + +# Override default options +if [ -e /etc/default/gummiboot ]; then + . /etc/default/gummiboot +fi + +if [ -z "$GUMMIBOOT_ROOT" ] ; then + GUMMIBOOT_ROOT="$(determine_root)" +fi + +# Load PRETTY_NAME +. /etc/os-release + +# Decide what to do +if [ "$#" -lt 1 ]; then + KERNEL="$(uname -r)" +else + KERNEL="$1" +fi +if [ -e /boot/vmlinuz-$KERNEL ]; then + do_install +else + do_remove +fi diff --git a/gummiboot-nomachineid-48/debian/watch b/gummiboot-nomachineid-48/debian/watch new file mode 100644 index 0000000..b48e268 --- /dev/null +++ b/gummiboot-nomachineid-48/debian/watch @@ -0,0 +1,2 @@ +version=3 +http://cgit.freedesktop.org/gummiboot/ /gummiboot/snapshot/gummiboot-([\d+\.]+)\.tar\.gz diff --git a/gummiboot-nomachineid-48/debian/zz-update-gummiboot b/gummiboot-nomachineid-48/debian/zz-update-gummiboot new file mode 100755 index 0000000..727f31d --- /dev/null +++ b/gummiboot-nomachineid-48/debian/zz-update-gummiboot @@ -0,0 +1,10 @@ +#!/bin/sh +case "$DPKG_MAINTSCRIPT_PACKAGE" in + linux-image-*) + # update-gummiboot will be run by the kernel hooks later on + exit 0 + ;; + *) + update-gummiboot "$1" + ;; +esac diff --git a/gummiboot-nomachineid-48/m4/arch.m4 b/gummiboot-nomachineid-48/m4/arch.m4 new file mode 100644 index 0000000..f17b427 --- /dev/null +++ b/gummiboot-nomachineid-48/m4/arch.m4 @@ -0,0 +1,13 @@ + +dnl SET_ARCH(ARCHNAME, PATTERN) +dnl +dnl Define ARCH_ condition if the pattern match with the current +dnl architecture +dnl +AC_DEFUN([SET_ARCH], [ + cpu_$1=false + case "$host" in + $2) cpu_$1=true ;; + esac + AM_CONDITIONAL(AS_TR_CPP(ARCH_$1), [test "x$cpu_$1" = xtrue]) +]) diff --git a/gummiboot-nomachineid-48/man/gummiboot.xml b/gummiboot-nomachineid-48/man/gummiboot.xml new file mode 100644 index 0000000..d2ad92c --- /dev/null +++ b/gummiboot-nomachineid-48/man/gummiboot.xml @@ -0,0 +1,134 @@ + + + + + + + + gummiboot + gummiboot + + + + Developer + Kay + Sievers + kay@vrfy.org + + + + + + gummiboot + 8 + + + + gummiboot + Setup and manage Gummiboot Boot Manager + + + + + gummiboot OPTIONSstatus + + + gummiboot OPTIONSupdate + + + gummiboot OPTIONSinstall + + + gummiboot OPTIONSremove + + + + + Description + + gummiboot checks, updates, + installs or removes the boot loader from the current + system. + + gummiboot status checks and prints the + currently installed versions of the boot loader binaries and the + all current EFI boot variables. + + gummiboot update updates all installed + versions of gummiboot, if the current version is newer than the + version installed in the EFI system partition. This also includes + the EFI default/fallback loader at /EFI/Boot/boot*.efi. An + gummiboot entry in the EFI boot variables is created, if there + is no current entry. A created entry will be added to the end of + the boot order list. + + gummiboot install installs gummiboot into + the EFI system partition. A copy of gummiboot will be stored as + the EFI default/fallback loader at /EFI/Boot/boot*.efi. An gummiboot + entry in the EFI boot variables is created and added to the top + of the boot order list. + + gummiboot remove removes all installed + versions of gummiboot from the EFI system partition, and removes + gummiboot from the EFI boot variables. + + If no command is passed status is + implied. + + + + Options + The following options are understood: + + + + + + + Prints a short help + text and exits. + + + + + Path to the EFI system + partition. The default is /boot. + + + + + Do not touch the EFI boot + variables. + + + + + + Exit status + On success 0 is returned, a non-zero failure + code otherwise. + + + + See Also + + Arch Linux Wiki: Gummiboot + + + diff --git a/gummiboot-nomachineid-48/src/efi/console.c b/gummiboot-nomachineid-48/src/efi/console.c new file mode 100644 index 0000000..6206c80 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/console.c @@ -0,0 +1,141 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + */ + +#include +#include + +#include "util.h" +#include "console.h" + +#define EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID \ + { 0xdd9e7534, 0x7762, 0x4698, { 0x8c, 0x14, 0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa } } + +struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL; + +typedef EFI_STATUS (EFIAPI *EFI_INPUT_RESET_EX)( + struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This; + BOOLEAN ExtendedVerification; +); + +typedef UINT8 EFI_KEY_TOGGLE_STATE; + +typedef struct { + UINT32 KeyShiftState; + EFI_KEY_TOGGLE_STATE KeyToggleState; +} EFI_KEY_STATE; + +typedef struct { + EFI_INPUT_KEY Key; + EFI_KEY_STATE KeyState; +} EFI_KEY_DATA; + +typedef EFI_STATUS (EFIAPI *EFI_INPUT_READ_KEY_EX)( + struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This; + EFI_KEY_DATA *KeyData; +); + +typedef EFI_STATUS (EFIAPI *EFI_SET_STATE)( + struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This; + EFI_KEY_TOGGLE_STATE *KeyToggleState; +); + +typedef EFI_STATUS (EFIAPI *EFI_KEY_NOTIFY_FUNCTION)( + EFI_KEY_DATA *KeyData; +); + +typedef EFI_STATUS (EFIAPI *EFI_REGISTER_KEYSTROKE_NOTIFY)( + struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This; + EFI_KEY_DATA KeyData; + EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction; + VOID **NotifyHandle; +); + +typedef EFI_STATUS (EFIAPI *EFI_UNREGISTER_KEYSTROKE_NOTIFY)( + struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This; + VOID *NotificationHandle; +); + +typedef struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL { + EFI_INPUT_RESET_EX Reset; + EFI_INPUT_READ_KEY_EX ReadKeyStrokeEx; + EFI_EVENT WaitForKeyEx; + EFI_SET_STATE SetState; + EFI_REGISTER_KEYSTROKE_NOTIFY RegisterKeyNotify; + EFI_UNREGISTER_KEYSTROKE_NOTIFY UnregisterKeyNotify; +} EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL; + +EFI_STATUS console_key_read(UINT64 *key, BOOLEAN wait) { + EFI_GUID EfiSimpleTextInputExProtocolGuid = EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID; + static EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TextInputEx; + static BOOLEAN checked; + UINTN index; + EFI_INPUT_KEY k; + EFI_STATUS err; + + if (!checked) { + err = LibLocateProtocol(&EfiSimpleTextInputExProtocolGuid, (VOID **)&TextInputEx); + if (EFI_ERROR(err)) + TextInputEx = NULL; + + checked = TRUE; + } + + /* wait until key is pressed */ + if (wait) { + if (TextInputEx) + uefi_call_wrapper(BS->WaitForEvent, 3, 1, &TextInputEx->WaitForKeyEx, &index); + else + uefi_call_wrapper(BS->WaitForEvent, 3, 1, &ST->ConIn->WaitForKey, &index); + } + + if (TextInputEx) { + EFI_KEY_DATA keydata; + UINT64 keypress; + + err = uefi_call_wrapper(TextInputEx->ReadKeyStrokeEx, 2, TextInputEx, &keydata); + if (!EFI_ERROR(err)) { + UINT32 shift = 0; + + /* do not distinguish between left and right keys */ + if (keydata.KeyState.KeyShiftState & EFI_SHIFT_STATE_VALID) { + if (keydata.KeyState.KeyShiftState & (EFI_RIGHT_CONTROL_PRESSED|EFI_LEFT_CONTROL_PRESSED)) + shift |= EFI_CONTROL_PRESSED; + if (keydata.KeyState.KeyShiftState & (EFI_RIGHT_ALT_PRESSED|EFI_LEFT_ALT_PRESSED)) + shift |= EFI_ALT_PRESSED; + }; + + /* 32 bit modifier keys + 16 bit scan code + 16 bit unicode */ + keypress = KEYPRESS(shift, keydata.Key.ScanCode, keydata.Key.UnicodeChar); + if (keypress > 0) { + *key = keypress; + return 0; + } + } + } + + /* fallback for firmware which does not support SimpleTextInputExProtocol + * + * This is also called in case ReadKeyStrokeEx did not return a key, because + * some broken firmwares offer SimpleTextInputExProtocol, but never acually + * handle any key. */ + err = uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2, ST->ConIn, &k); + if (EFI_ERROR(err)) + return err; + + *key = KEYPRESS(0, k.ScanCode, k.UnicodeChar); + return 0; +} diff --git a/gummiboot-nomachineid-48/src/efi/console.h b/gummiboot-nomachineid-48/src/efi/console.h new file mode 100644 index 0000000..8c2a31a --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/console.h @@ -0,0 +1,34 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + */ + +#ifndef __GUMMIBOOT_CONSOLE_H +#define __GUMMIBOOT_CONSOLE_H + +#define EFI_SHIFT_STATE_VALID 0x80000000 +#define EFI_RIGHT_CONTROL_PRESSED 0x00000004 +#define EFI_LEFT_CONTROL_PRESSED 0x00000008 +#define EFI_RIGHT_ALT_PRESSED 0x00000010 +#define EFI_LEFT_ALT_PRESSED 0x00000020 + +#define EFI_CONTROL_PRESSED (EFI_RIGHT_CONTROL_PRESSED|EFI_LEFT_CONTROL_PRESSED) +#define EFI_ALT_PRESSED (EFI_RIGHT_ALT_PRESSED|EFI_LEFT_ALT_PRESSED) +#define KEYPRESS(keys, scan, uni) ((((UINT64)keys) << 32) | ((scan) << 16) | (uni)) +#define KEYCHAR(k) ((k) & 0xffff) +#define CHAR_CTRL(c) ((c) - 'a' + 1) + +EFI_STATUS console_key_read(UINT64 *key, BOOLEAN wait); +#endif diff --git a/gummiboot-nomachineid-48/src/efi/graphics.c b/gummiboot-nomachineid-48/src/efi/graphics.c new file mode 100644 index 0000000..11305b8 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/graphics.c @@ -0,0 +1,389 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + * Copyright (C) 2013 Intel Corporation + * Authored by Joonas Lahtinen + */ + +#include +#include + +#include "util.h" +#include "graphics.h" + +EFI_STATUS graphics_mode(BOOLEAN on) { + #define EFI_CONSOLE_CONTROL_PROTOCOL_GUID \ + { 0xf42f7782, 0x12e, 0x4c12, { 0x99, 0x56, 0x49, 0xf9, 0x43, 0x4, 0xf7, 0x21 } }; + + struct _EFI_CONSOLE_CONTROL_PROTOCOL; + + typedef enum { + EfiConsoleControlScreenText, + EfiConsoleControlScreenGraphics, + EfiConsoleControlScreenMaxValue, + } EFI_CONSOLE_CONTROL_SCREEN_MODE; + + typedef EFI_STATUS (EFIAPI *EFI_CONSOLE_CONTROL_PROTOCOL_GET_MODE)( + struct _EFI_CONSOLE_CONTROL_PROTOCOL *This, + EFI_CONSOLE_CONTROL_SCREEN_MODE *Mode, + BOOLEAN *UgaExists, + BOOLEAN *StdInLocked + ); + + typedef EFI_STATUS (EFIAPI *EFI_CONSOLE_CONTROL_PROTOCOL_SET_MODE)( + struct _EFI_CONSOLE_CONTROL_PROTOCOL *This, + EFI_CONSOLE_CONTROL_SCREEN_MODE Mode + ); + + typedef EFI_STATUS (EFIAPI *EFI_CONSOLE_CONTROL_PROTOCOL_LOCK_STD_IN)( + struct _EFI_CONSOLE_CONTROL_PROTOCOL *This, + CHAR16 *Password + ); + + typedef struct _EFI_CONSOLE_CONTROL_PROTOCOL { + EFI_CONSOLE_CONTROL_PROTOCOL_GET_MODE GetMode; + EFI_CONSOLE_CONTROL_PROTOCOL_SET_MODE SetMode; + EFI_CONSOLE_CONTROL_PROTOCOL_LOCK_STD_IN LockStdIn; + } EFI_CONSOLE_CONTROL_PROTOCOL; + + EFI_GUID ConsoleControlProtocolGuid = EFI_CONSOLE_CONTROL_PROTOCOL_GUID; + EFI_CONSOLE_CONTROL_PROTOCOL *ConsoleControl = NULL; + EFI_CONSOLE_CONTROL_SCREEN_MODE new; + EFI_CONSOLE_CONTROL_SCREEN_MODE current; + BOOLEAN uga_exists; + BOOLEAN stdin_locked; + EFI_STATUS err; + + err = LibLocateProtocol(&ConsoleControlProtocolGuid, (VOID **)&ConsoleControl); + if (EFI_ERROR(err)) { + /* console control protocol is nonstandard and might not exist. */ + return err == EFI_NOT_FOUND ? EFI_SUCCESS : err; + } + + /* check current mode */ + err = uefi_call_wrapper(ConsoleControl->GetMode, 4, ConsoleControl, ¤t, &uga_exists, &stdin_locked); + if (EFI_ERROR(err)) + return err; + + /* do not touch the mode */ + new = on ? EfiConsoleControlScreenGraphics : EfiConsoleControlScreenText; + if (new == current) + return EFI_SUCCESS; + + err = uefi_call_wrapper(ConsoleControl->SetMode, 2, ConsoleControl, new); + + /* some firmware enables the cursor when switching modes */ + uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, FALSE); + + return err; +} + +struct bmp_file { + CHAR8 signature[2]; + UINT32 size; + UINT16 reserved[2]; + UINT32 offset; +} __attribute__((packed)); + +/* we require at least BITMAPINFOHEADER, later versions are + accepted, but their features ignored */ +struct bmp_dib { + UINT32 size; + UINT32 x; + UINT32 y; + UINT16 planes; + UINT16 depth; + UINT32 compression; + UINT32 image_size; + INT32 x_pixel_meter; + INT32 y_pixel_meter; + UINT32 colors_used; + UINT32 colors_important; +} __attribute__((packed)); + +struct bmp_map { + UINT8 blue; + UINT8 green; + UINT8 red; + UINT8 reserved; +} __attribute__((packed)); + +EFI_STATUS bmp_parse_header(UINT8 *bmp, UINTN size, struct bmp_dib **ret_dib, + struct bmp_map **ret_map, UINT8 **pixmap) { + struct bmp_file *file; + struct bmp_dib *dib; + struct bmp_map *map; + UINTN row_size; + + if (size < sizeof(struct bmp_file) + sizeof(struct bmp_dib)) + return EFI_INVALID_PARAMETER; + + /* check file header */ + file = (struct bmp_file *)bmp; + if (file->signature[0] != 'B' || file->signature[1] != 'M') + return EFI_INVALID_PARAMETER; + if (file->size != size) + return EFI_INVALID_PARAMETER; + if (file->size < file->offset) + return EFI_INVALID_PARAMETER; + + /* check device-independent bitmap */ + dib = (struct bmp_dib *)(bmp + sizeof(struct bmp_file)); + if (dib->size < sizeof(struct bmp_dib)) + return EFI_UNSUPPORTED; + + switch (dib->depth) { + case 1: + case 4: + case 8: + case 24: + if (dib->compression != 0) + return EFI_UNSUPPORTED; + + break; + + case 16: + case 32: + if (dib->compression != 0 && dib->compression != 3) + return EFI_UNSUPPORTED; + + break; + + default: + return EFI_UNSUPPORTED; + } + + row_size = (((dib->depth * dib->x) + 31) / 32) * 4; + if (file->size - file->offset < dib->y * row_size) + return EFI_INVALID_PARAMETER; + if (row_size * dib->y > 64 * 1024 * 1024) + return EFI_INVALID_PARAMETER; + + /* check color table */ + map = (struct bmp_map *)(bmp + sizeof(struct bmp_file) + dib->size); + if (file->offset < sizeof(struct bmp_file) + dib->size) + return EFI_INVALID_PARAMETER; + + if (file->offset > sizeof(struct bmp_file) + dib->size) { + UINT32 map_count; + UINTN map_size; + + if (dib->colors_used) + map_count = dib->colors_used; + else { + switch (dib->depth) { + case 1: + case 4: + case 8: + map_count = 1 << dib->depth; + break; + + default: + map_count = 0; + break; + } + } + + map_size = file->offset - (sizeof(struct bmp_file) + dib->size); + if (map_size != sizeof(struct bmp_map) * map_count) + return EFI_INVALID_PARAMETER; + } + + *ret_map = map; + *ret_dib = dib; + *pixmap = bmp + file->offset; + + return EFI_SUCCESS; +} + +static VOID pixel_blend(UINT32 *dst, const UINT32 source) { + UINT32 alpha, src, src_rb, src_g, dst_rb, dst_g, rb, g; + + alpha = (source & 0xff); + + /* convert src from RGBA to XRGB */ + src = source >> 8; + + /* decompose into RB and G components */ + src_rb = (src & 0xff00ff); + src_g = (src & 0x00ff00); + + dst_rb = (*dst & 0xff00ff); + dst_g = (*dst & 0x00ff00); + + /* blend */ + rb = ((((src_rb - dst_rb) * alpha + 0x800080) >> 8) + dst_rb) & 0xff00ff; + g = ((((src_g - dst_g) * alpha + 0x008000) >> 8) + dst_g) & 0x00ff00; + + *dst = (rb | g); +} + +EFI_STATUS bmp_to_blt(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *buf, + struct bmp_dib *dib, struct bmp_map *map, + UINT8 *pixmap) { + UINT8 *in; + UINTN y; + + /* transform and copy pixels */ + in = pixmap; + for (y = 0; y < dib->y; y++) { + EFI_GRAPHICS_OUTPUT_BLT_PIXEL *out; + UINTN row_size; + UINTN x; + + out = &buf[(dib->y - y - 1) * dib->x]; + for (x = 0; x < dib->x; x++, in++, out++) { + switch (dib->depth) { + case 1: { + UINTN i; + + for (i = 0; i < 8 && x < dib->x; i++) { + out->Red = map[((*in) >> (7 - i)) & 1].red; + out->Green = map[((*in) >> (7 - i)) & 1].green; + out->Blue = map[((*in) >> (7 - i)) & 1].blue; + out++; + x++; + } + out--; + x--; + break; + } + + case 4: { + UINTN i; + + i = (*in) >> 4; + out->Red = map[i].red; + out->Green = map[i].green; + out->Blue = map[i].blue; + if (x < (dib->x - 1)) { + out++; + x++; + i = (*in) & 0x0f; + out->Red = map[i].red; + out->Green = map[i].green; + out->Blue = map[i].blue; + } + break; + } + + case 8: + out->Red = map[*in].red; + out->Green = map[*in].green; + out->Blue = map[*in].blue; + break; + + case 16: { + UINT16 i = *(UINT16 *) in; + + out->Red = (i & 0x7c00) >> 7; + out->Green = (i & 0x3e0) >> 2; + out->Blue = (i & 0x1f) << 3; + in += 1; + break; + } + + case 24: + out->Red = in[2]; + out->Green = in[1]; + out->Blue = in[0]; + in += 2; + break; + + case 32: { + UINT32 i = *(UINT32 *) in; + + pixel_blend((UINT32 *)out, i); + + in += 3; + break; + } + } + } + + /* add row padding; new lines always start at 32 bit boundary */ + row_size = in - pixmap; + in += ((row_size + 3) & ~3) - row_size; + } + + return EFI_SUCCESS; +} + +EFI_STATUS graphics_splash(EFI_FILE *root_dir, CHAR16 *path, + const EFI_GRAPHICS_OUTPUT_BLT_PIXEL *background) { + EFI_GUID GraphicsOutputProtocolGuid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID; + EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput = NULL; + UINT8 *content; + INTN len; + struct bmp_dib *dib; + struct bmp_map *map; + UINT8 *pixmap; + UINT64 blt_size; + VOID *blt = NULL; + UINTN x_pos = 0; + UINTN y_pos = 0; + EFI_STATUS err; + + err = LibLocateProtocol(&GraphicsOutputProtocolGuid, (VOID **)&GraphicsOutput); + if (EFI_ERROR(err)) + return err; + + len = file_read(root_dir, path, 0, 0, &content); + if (len < 0) + return EFI_LOAD_ERROR; + + err = bmp_parse_header(content, len, &dib, &map, &pixmap); + if (EFI_ERROR(err)) + goto err; + + if(dib->x < GraphicsOutput->Mode->Info->HorizontalResolution) + x_pos = (GraphicsOutput->Mode->Info->HorizontalResolution - dib->x) / 2; + if(dib->y < GraphicsOutput->Mode->Info->VerticalResolution) + y_pos = (GraphicsOutput->Mode->Info->VerticalResolution - dib->y) / 2; + + uefi_call_wrapper(GraphicsOutput->Blt, 10, GraphicsOutput, + (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)background, + EfiBltVideoFill, 0, 0, 0, 0, + GraphicsOutput->Mode->Info->HorizontalResolution, + GraphicsOutput->Mode->Info->VerticalResolution, 0); + + /* EFI buffer */ + blt_size = dib->x * dib->y * sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL); + blt = AllocatePool(blt_size); + if (!blt) + return EFI_OUT_OF_RESOURCES; + + err = uefi_call_wrapper(GraphicsOutput->Blt, 10, GraphicsOutput, + blt, EfiBltVideoToBltBuffer, x_pos, y_pos, 0, 0, + dib->x, dib->y, 0); + if (EFI_ERROR(err)) + goto err; + + err = bmp_to_blt(blt, dib, map, pixmap); + if (EFI_ERROR(err)) + goto err; + + err = graphics_mode(TRUE); + if (EFI_ERROR(err)) + goto err; + + err = uefi_call_wrapper(GraphicsOutput->Blt, 10, GraphicsOutput, + blt, EfiBltBufferToVideo, 0, 0, x_pos, y_pos, + dib->x, dib->y, 0); +err: + FreePool(blt); + FreePool(content); + return err; +} diff --git a/gummiboot-nomachineid-48/src/efi/graphics.h b/gummiboot-nomachineid-48/src/efi/graphics.h new file mode 100644 index 0000000..edec1f4 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/graphics.h @@ -0,0 +1,26 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + * Copyright (C) 2013 Intel Corporation + * Authored by Joonas Lahtinen + */ + +#ifndef __GUMMIBOOT_GRAPHICS_H +#define __GUMMIBOOT_GRAPHICS_H + +EFI_STATUS graphics_mode(BOOLEAN on); +EFI_STATUS graphics_splash(EFI_FILE *root_dir, CHAR16 *path, + const EFI_GRAPHICS_OUTPUT_BLT_PIXEL *background); +#endif diff --git a/gummiboot-nomachineid-48/src/efi/gummiboot.c b/gummiboot-nomachineid-48/src/efi/gummiboot.c new file mode 100644 index 0000000..fba9669 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/gummiboot.c @@ -0,0 +1,1982 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * Simple UEFI boot loader which executes configured EFI images, where the + * default entry is selected by a configured pattern (glob) or an on-screen + * menu. + * + * All gummiboot code is LGPL not GPL, to stay out of politics and to give + * the freedom of copying code from programs to possible future libraries. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + * + * "Any intelligent fool can make things bigger, more complex, and more violent." + * -- Albert Einstein + */ + +#include +#include + +#include "util.h" +#include "console.h" +#include "graphics.h" +#include "pefile.h" +#include "linux.h" + +#ifndef EFI_OS_INDICATIONS_BOOT_TO_FW_UI +#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI 0x0000000000000001ULL +#endif + +#ifndef EFI_SECURITY_VIOLATION +#define EFI_SECURITY_VIOLATION EFIERR(26) +#endif + +/* magic string to find in the binary image */ +static const char __attribute__((used)) magic[] = "#### LoaderInfo: gummiboot " VERSION " ####"; + +static const EFI_GUID global_guid = EFI_GLOBAL_VARIABLE; + +enum loader_type { + LOADER_UNDEFINED, + LOADER_EFI, + LOADER_LINUX +}; + +typedef struct { + CHAR16 *file; + CHAR16 *title_show; + CHAR16 *title; + CHAR16 *version; + CHAR16 *machine_id; + EFI_HANDLE *device; + enum loader_type type; + CHAR16 *loader; + CHAR16 *options; + CHAR16 *splash; + CHAR16 key; + EFI_STATUS (*call)(VOID); + BOOLEAN no_autoselect; + BOOLEAN non_unique; +} ConfigEntry; + +typedef struct { + ConfigEntry **entries; + UINTN entry_count; + INTN idx_default; + INTN idx_default_efivar; + UINTN timeout_sec; + UINTN timeout_sec_config; + INTN timeout_sec_efivar; + CHAR16 *entry_default_pattern; + CHAR16 *splash; + EFI_GRAPHICS_OUTPUT_BLT_PIXEL *background; + CHAR16 *entry_oneshot; + CHAR16 *options_edit; + CHAR16 *entries_auto; +} Config; + +static VOID cursor_left(UINTN *cursor, UINTN *first) +{ + if ((*cursor) > 0) + (*cursor)--; + else if ((*first) > 0) + (*first)--; +} + +static VOID cursor_right(UINTN *cursor, UINTN *first, UINTN x_max, UINTN len) +{ + if ((*cursor)+1 < x_max) + (*cursor)++; + else if ((*first) + (*cursor) < len) + (*first)++; +} + +static BOOLEAN line_edit(CHAR16 *line_in, CHAR16 **line_out, UINTN x_max, UINTN y_pos) { + CHAR16 *line; + UINTN size; + UINTN len; + UINTN first; + CHAR16 *print; + UINTN cursor; + UINTN clear; + BOOLEAN exit; + BOOLEAN enter; + + if (!line_in) + line_in = L""; + size = StrLen(line_in) + 1024; + line = AllocatePool(size * sizeof(CHAR16)); + StrCpy(line, line_in); + len = StrLen(line); + print = AllocatePool((x_max+1) * sizeof(CHAR16)); + + uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, TRUE); + + first = 0; + cursor = 0; + clear = 0; + enter = FALSE; + exit = FALSE; + while (!exit) { + EFI_STATUS err; + UINT64 key; + UINTN i; + + i = len - first; + if (i >= x_max-1) + i = x_max-1; + CopyMem(print, line + first, i * sizeof(CHAR16)); + while (clear > 0 && i < x_max-1) { + clear--; + print[i++] = ' '; + } + print[i] = '\0'; + + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_pos); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, print); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + + err = console_key_read(&key, TRUE); + if (EFI_ERROR(err)) + continue; + + switch (key) { + case KEYPRESS(0, SCAN_ESC, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'c'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'g'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('c')): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('g')): + exit = TRUE; + break; + + case KEYPRESS(0, SCAN_HOME, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'a'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('a')): + /* beginning-of-line */ + cursor = 0; + first = 0; + continue; + + case KEYPRESS(0, SCAN_END, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'e'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('e')): + /* end-of-line */ + cursor = len - first; + if (cursor+1 >= x_max) { + cursor = x_max-1; + first = len - (x_max-1); + } + continue; + + case KEYPRESS(0, SCAN_DOWN, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, 'f'): + case KEYPRESS(EFI_CONTROL_PRESSED, SCAN_RIGHT, 0): + /* forward-word */ + while (line[first + cursor] && line[first + cursor] == ' ') + cursor_right(&cursor, &first, x_max, len); + while (line[first + cursor] && line[first + cursor] != ' ') + cursor_right(&cursor, &first, x_max, len); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(0, SCAN_UP, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, 'b'): + case KEYPRESS(EFI_CONTROL_PRESSED, SCAN_LEFT, 0): + /* backward-word */ + if ((first + cursor) > 0 && line[first + cursor-1] == ' ') { + cursor_left(&cursor, &first); + while ((first + cursor) > 0 && line[first + cursor] == ' ') + cursor_left(&cursor, &first); + } + while ((first + cursor) > 0 && line[first + cursor-1] != ' ') + cursor_left(&cursor, &first); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(0, SCAN_RIGHT, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'f'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('f')): + /* forward-char */ + if (first + cursor == len) + continue; + cursor_right(&cursor, &first, x_max, len); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(0, SCAN_LEFT, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'b'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('b')): + /* backward-char */ + cursor_left(&cursor, &first); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + continue; + + case KEYPRESS(EFI_ALT_PRESSED, 0, 'd'): + /* kill-word */ + clear = 0; + for (i = first + cursor; i < len && line[i] == ' '; i++) + clear++; + for (; i < len && line[i] != ' '; i++) + clear++; + + for (i = first + cursor; i + clear < len; i++) + line[i] = line[i + clear]; + len -= clear; + line[len] = '\0'; + continue; + + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'w'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('w')): + case KEYPRESS(EFI_ALT_PRESSED, 0, CHAR_BACKSPACE): + /* backward-kill-word */ + clear = 0; + if ((first + cursor) > 0 && line[first + cursor-1] == ' ') { + cursor_left(&cursor, &first); + clear++; + while ((first + cursor) > 0 && line[first + cursor] == ' ') { + cursor_left(&cursor, &first); + clear++; + } + } + while ((first + cursor) > 0 && line[first + cursor-1] != ' ') { + cursor_left(&cursor, &first); + clear++; + } + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, cursor, y_pos); + + for (i = first + cursor; i + clear < len; i++) + line[i] = line[i + clear]; + len -= clear; + line[len] = '\0'; + continue; + + case KEYPRESS(0, SCAN_DELETE, 0): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'd'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('d')): + if (len == 0) + continue; + if (first + cursor == len) + continue; + for (i = first + cursor; i < len; i++) + line[i] = line[i+1]; + clear = 1; + len--; + continue; + + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'k'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('k')): + /* kill-line */ + line[first + cursor] = '\0'; + clear = len - (first + cursor); + len = first + cursor; + continue; + + case KEYPRESS(0, 0, CHAR_LINEFEED): + case KEYPRESS(0, 0, CHAR_CARRIAGE_RETURN): + if (StrCmp(line, line_in) != 0) { + *line_out = line; + line = NULL; + } + enter = TRUE; + exit = TRUE; + break; + + case KEYPRESS(0, 0, CHAR_BACKSPACE): + if (len == 0) + continue; + if (first == 0 && cursor == 0) + continue; + for (i = first + cursor-1; i < len; i++) + line[i] = line[i+1]; + clear = 1; + len--; + if (cursor > 0) + cursor--; + if (cursor > 0 || first == 0) + continue; + /* show full line if it fits */ + if (len < x_max) { + cursor = first; + first = 0; + continue; + } + /* jump left to see what we delete */ + if (first > 10) { + first -= 10; + cursor = 10; + } else { + cursor = first; + first = 0; + } + continue; + + case KEYPRESS(0, 0, ' ') ... KEYPRESS(0, 0, '~'): + case KEYPRESS(0, 0, 0x80) ... KEYPRESS(0, 0, 0xffff): + if (len+1 == size) + continue; + for (i = len; i > first + cursor; i--) + line[i] = line[i-1]; + line[first + cursor] = KEYCHAR(key); + len++; + line[len] = '\0'; + if (cursor+1 < x_max) + cursor++; + else if (first + cursor < len) + first++; + continue; + } + } + + uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, FALSE); + FreePool(print); + FreePool(line); + return enter; +} + +static UINTN entry_lookup_key(Config *config, UINTN start, CHAR16 key) { + UINTN i; + + if (key == 0) + return -1; + + /* select entry by number key */ + if (key >= '1' && key <= '9') { + i = key - '0'; + if (i > config->entry_count) + i = config->entry_count; + return i-1; + } + + /* find matching key in config entries */ + for (i = start; i < config->entry_count; i++) + if (config->entries[i]->key == key) + return i; + + for (i = 0; i < start; i++) + if (config->entries[i]->key == key) + return i; + + return -1; +} + +static VOID print_status(Config *config, EFI_FILE *root_dir, CHAR16 *loaded_image_path) { + UINT64 key; + UINTN i; + CHAR16 *s; + CHAR8 *b; + UINTN x; + UINTN y; + UINTN size; + EFI_STATUS err; + UINTN color = 0; + const EFI_GRAPHICS_OUTPUT_BLT_PIXEL *pixel = config->background; + + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + + /* show splash and wait for key */ + for (;;) { + static const EFI_GRAPHICS_OUTPUT_BLT_PIXEL colors[] = { + { .Red = 0xff, .Green = 0xff, .Blue = 0xff }, + { .Red = 0xc0, .Green = 0xc0, .Blue = 0xc0 }, + { .Red = 0xff, .Green = 0, .Blue = 0 }, + { .Red = 0, .Green = 0xff, .Blue = 0 }, + { .Red = 0, .Green = 0, .Blue = 0xff }, + { .Red = 0, .Green = 0, .Blue = 0 }, + }; + + err = EFI_NOT_FOUND; + if (config->splash) + err = graphics_splash(root_dir, config->splash, pixel); + if (EFI_ERROR(err)) + err = graphics_splash(root_dir, L"\\EFI\\gummiboot\\splash.bmp", pixel); + if (EFI_ERROR(err)) + break; + + /* 'b' rotates through background colors */ + console_key_read(&key, TRUE); + if (key == KEYPRESS(0, 0, 'b')) { + pixel = &colors[color++]; + if (color == ELEMENTSOF(colors)) + color = 0; + + continue; + } + + graphics_mode(FALSE); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + break; + } + + Print(L"gummiboot version: " VERSION "\n"); + Print(L"gummiboot architecture: " MACHINE_TYPE_NAME "\n"); + Print(L"loaded image: %s\n", loaded_image_path); + Print(L"UEFI specification: %d.%02d\n", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff); + Print(L"firmware vendor: %s\n", ST->FirmwareVendor); + Print(L"firmware version: %d.%02d\n", ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); + + if (uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut, ST->ConOut->Mode->Mode, &x, &y) == EFI_SUCCESS) + Print(L"console size: %d x %d\n", x, y); + + if (efivar_get_raw(&global_guid, L"SecureBoot", &b, &size) == EFI_SUCCESS) { + Print(L"SecureBoot: %s\n", *b > 0 ? L"enabled" : L"disabled"); + FreePool(b); + } + + if (efivar_get_raw(&global_guid, L"SetupMode", &b, &size) == EFI_SUCCESS) { + Print(L"SetupMode: %s\n", *b > 0 ? L"setup" : L"user"); + FreePool(b); + } + + if (efivar_get_raw(&global_guid, L"OsIndicationsSupported", &b, &size) == EFI_SUCCESS) { + Print(L"OsIndicationsSupported: %d\n", (UINT64)*b); + FreePool(b); + } + Print(L"\n"); + + Print(L"timeout: %d\n", config->timeout_sec); + if (config->timeout_sec_efivar >= 0) + Print(L"timeout (EFI var): %d\n", config->timeout_sec_efivar); + Print(L"timeout (config): %d\n", config->timeout_sec_config); + if (config->entry_default_pattern) + Print(L"default pattern: '%s'\n", config->entry_default_pattern); + if (config->splash) + Print(L"splash '%s'\n", config->splash); + if (config->background) + Print(L"background '#%02x%02x%02x'\n", + config->background->Red, + config->background->Green, + config->background->Blue); + Print(L"\n"); + + Print(L"config entry count: %d\n", config->entry_count); + Print(L"entry selected idx: %d\n", config->idx_default); + if (config->idx_default_efivar >= 0) + Print(L"entry EFI var idx: %d\n", config->idx_default_efivar); + Print(L"\n"); + + if (efivar_get_int(L"LoaderConfigTimeout", &i) == EFI_SUCCESS) + Print(L"LoaderConfigTimeout: %d\n", i); + if (config->entry_oneshot) + Print(L"LoaderEntryOneShot: %s\n", config->entry_oneshot); + if (efivar_get(L"LoaderDeviceIdentifier", &s) == EFI_SUCCESS) { + Print(L"LoaderDeviceIdentifier: %s\n", s); + FreePool(s); + } + if (efivar_get(L"LoaderDevicePartUUID", &s) == EFI_SUCCESS) { + Print(L"LoaderDevicePartUUID: %s\n", s); + FreePool(s); + } + if (efivar_get(L"LoaderEntryDefault", &s) == EFI_SUCCESS) { + Print(L"LoaderEntryDefault: %s\n", s); + FreePool(s); + } + + Print(L"\n--- press key ---\n\n"); + console_key_read(&key, TRUE); + + for (i = 0; i < config->entry_count; i++) { + ConfigEntry *entry; + + if (key == KEYPRESS(0, SCAN_ESC, 0) || key == KEYPRESS(0, 0, 'q')) + break; + + entry = config->entries[i]; + + if (entry->splash) { + err = graphics_splash(root_dir, entry->splash, config->background); + if (!EFI_ERROR(err)) { + console_key_read(&key, TRUE); + graphics_mode(FALSE); + } + } + + Print(L"config entry: %d/%d\n", i+1, config->entry_count); + if (entry->file) + Print(L"file '%s'\n", entry->file); + Print(L"title show '%s'\n", entry->title_show); + if (entry->title) + Print(L"title '%s'\n", entry->title); + if (entry->version) + Print(L"version '%s'\n", entry->version); + if (entry->machine_id) + Print(L"machine-id '%s'\n", entry->machine_id); + if (entry->device) { + EFI_DEVICE_PATH *device_path; + CHAR16 *str; + + device_path = DevicePathFromHandle(entry->device); + if (device_path) { + str = DevicePathToStr(device_path); + Print(L"device handle '%s'\n", str); + FreePool(str); + } + } + if (entry->loader) + Print(L"loader '%s'\n", entry->loader); + if (entry->options) + Print(L"options '%s'\n", entry->options); + if (entry->splash) + Print(L"splash '%s'\n", entry->splash); + Print(L"auto-select %s\n", entry->no_autoselect ? L"no" : L"yes"); + if (entry->call) + Print(L"internal call yes\n"); + + Print(L"\n--- press key ---\n\n"); + console_key_read(&key, TRUE); + } + + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); +} + +static BOOLEAN menu_run(Config *config, ConfigEntry **chosen_entry, EFI_FILE *root_dir, CHAR16 *loaded_image_path) { + EFI_STATUS err; + UINTN visible_max; + UINTN idx_highlight; + UINTN idx_highlight_prev; + UINTN idx_first; + UINTN idx_last; + BOOLEAN refresh; + BOOLEAN highlight; + UINTN i; + UINTN line_width; + CHAR16 **lines; + UINTN x_start; + UINTN y_start; + UINTN x_max; + UINTN y_max; + CHAR16 *status; + CHAR16 *clearline; + INTN timeout_remain; + INT16 idx; + BOOLEAN exit = FALSE; + BOOLEAN run = TRUE; + BOOLEAN wait = FALSE; + + graphics_mode(FALSE); + uefi_call_wrapper(ST->ConIn->Reset, 2, ST->ConIn, FALSE); + uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, FALSE); + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + + /* draw a single character to make ClearScreen work on some firmware */ + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L" "); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + + err = uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut, ST->ConOut->Mode->Mode, &x_max, &y_max); + if (EFI_ERROR(err)) { + x_max = 80; + y_max = 25; + } + + /* we check 10 times per second for a keystroke */ + if (config->timeout_sec > 0) + timeout_remain = config->timeout_sec * 10; + else + timeout_remain = -1; + + idx_highlight = config->idx_default; + idx_highlight_prev = 0; + + visible_max = y_max - 2; + + if ((UINTN)config->idx_default >= visible_max) + idx_first = config->idx_default-1; + else + idx_first = 0; + + idx_last = idx_first + visible_max-1; + + refresh = TRUE; + highlight = FALSE; + + /* length of the longest entry */ + line_width = 5; + for (i = 0; i < config->entry_count; i++) { + UINTN entry_len; + + entry_len = StrLen(config->entries[i]->title_show); + if (line_width < entry_len) + line_width = entry_len; + } + if (line_width > x_max-6) + line_width = x_max-6; + + /* offsets to center the entries on the screen */ + x_start = (x_max - (line_width)) / 2; + if (config->entry_count < visible_max) + y_start = ((visible_max - config->entry_count) / 2) + 1; + else + y_start = 0; + + /* menu entries title lines */ + lines = AllocatePool(sizeof(CHAR16 *) * config->entry_count); + for (i = 0; i < config->entry_count; i++) { + UINTN j, k; + + lines[i] = AllocatePool(((x_max+1) * sizeof(CHAR16))); + for (j = 0; j < x_start; j++) + lines[i][j] = ' '; + + for (k = 0; config->entries[i]->title_show[k] != '\0' && j < x_max; j++, k++) + lines[i][j] = config->entries[i]->title_show[k]; + + for (; j < x_max; j++) + lines[i][j] = ' '; + lines[i][x_max] = '\0'; + } + + status = NULL; + clearline = AllocatePool((x_max+1) * sizeof(CHAR16)); + for (i = 0; i < x_max; i++) + clearline[i] = ' '; + clearline[i] = 0; + + while (!exit) { + UINT64 key; + + if (refresh) { + for (i = 0; i < config->entry_count; i++) { + if (i < idx_first || i > idx_last) + continue; + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_start + i - idx_first); + if (i == idx_highlight) + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, + EFI_BLACK|EFI_BACKGROUND_LIGHTGRAY); + else + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, + EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, lines[i]); + if ((INTN)i == config->idx_default_efivar) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, x_start-3, y_start + i - idx_first); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"=>"); + } + } + refresh = FALSE; + } else if (highlight) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_start + idx_highlight_prev - idx_first); + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, lines[idx_highlight_prev]); + if ((INTN)idx_highlight_prev == config->idx_default_efivar) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, x_start-3, y_start + idx_highlight_prev - idx_first); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"=>"); + } + + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_start + idx_highlight - idx_first); + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_BLACK|EFI_BACKGROUND_LIGHTGRAY); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, lines[idx_highlight]); + if ((INTN)idx_highlight == config->idx_default_efivar) { + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, x_start-3, y_start + idx_highlight - idx_first); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"=>"); + } + highlight = FALSE; + } + + if (timeout_remain > 0) { + FreePool(status); + status = PoolPrint(L"Boot in %d sec.", (timeout_remain + 5) / 10); + } + + /* print status at last line of screen */ + if (status) { + UINTN len; + UINTN x; + + /* center line */ + len = StrLen(status); + if (len < x_max) + x = (x_max - len) / 2; + else + x = 0; + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline + (x_max - x)); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, status); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1 + x + len); + } + + err = console_key_read(&key, wait); + if (EFI_ERROR(err)) { + /* timeout reached */ + if (timeout_remain == 0) { + exit = TRUE; + break; + } + + /* sleep and update status */ + if (timeout_remain > 0) { + uefi_call_wrapper(BS->Stall, 1, 100 * 1000); + timeout_remain--; + continue; + } + + /* timeout disabled, wait for next key */ + wait = TRUE; + continue; + } + + timeout_remain = -1; + + /* clear status after keystroke */ + if (status) { + FreePool(status); + status = NULL; + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1); + } + + idx_highlight_prev = idx_highlight; + + switch (key) { + case KEYPRESS(0, SCAN_UP, 0): + case KEYPRESS(0, 0, 'k'): + if (idx_highlight > 0) + idx_highlight--; + break; + + case KEYPRESS(0, SCAN_DOWN, 0): + case KEYPRESS(0, 0, 'j'): + if (idx_highlight < config->entry_count-1) + idx_highlight++; + break; + + case KEYPRESS(0, SCAN_HOME, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, '<'): + if (idx_highlight > 0) { + refresh = TRUE; + idx_highlight = 0; + } + break; + + case KEYPRESS(0, SCAN_END, 0): + case KEYPRESS(EFI_ALT_PRESSED, 0, '>'): + if (idx_highlight < config->entry_count-1) { + refresh = TRUE; + idx_highlight = config->entry_count-1; + } + break; + + case KEYPRESS(0, SCAN_PAGE_UP, 0): + if (idx_highlight > visible_max) + idx_highlight -= visible_max; + else + idx_highlight = 0; + break; + + case KEYPRESS(0, SCAN_PAGE_DOWN, 0): + idx_highlight += visible_max; + if (idx_highlight > config->entry_count-1) + idx_highlight = config->entry_count-1; + break; + + case KEYPRESS(0, 0, CHAR_LINEFEED): + case KEYPRESS(0, 0, CHAR_CARRIAGE_RETURN): + exit = TRUE; + break; + + case KEYPRESS(0, SCAN_F1, 0): + case KEYPRESS(0, 0, 'h'): + case KEYPRESS(0, 0, '?'): + status = StrDuplicate(L"(d)efault, (t/T)timeout, (e)dit, (v)ersion (Q)uit (P)rint (h)elp"); + break; + + case KEYPRESS(0, 0, 'Q'): + exit = TRUE; + run = FALSE; + break; + + case KEYPRESS(0, 0, 'd'): + if (config->idx_default_efivar != (INTN)idx_highlight) { + /* store the selected entry in a persistent EFI variable */ + efivar_set(L"LoaderEntryDefault", config->entries[idx_highlight]->file, TRUE); + config->idx_default_efivar = idx_highlight; + status = StrDuplicate(L"Default boot entry selected."); + } else { + /* clear the default entry EFI variable */ + efivar_set(L"LoaderEntryDefault", NULL, TRUE); + config->idx_default_efivar = -1; + status = StrDuplicate(L"Default boot entry cleared."); + } + refresh = TRUE; + break; + + case KEYPRESS(0, 0, '-'): + case KEYPRESS(0, 0, 'T'): + if (config->timeout_sec_efivar > 0) { + config->timeout_sec_efivar--; + efivar_set_int(L"LoaderConfigTimeout", config->timeout_sec_efivar, TRUE); + if (config->timeout_sec_efivar > 0) + status = PoolPrint(L"Menu timeout set to %d sec.", config->timeout_sec_efivar); + else + status = StrDuplicate(L"Menu disabled. Hold down key at bootup to show menu."); + } else if (config->timeout_sec_efivar <= 0){ + config->timeout_sec_efivar = -1; + efivar_set(L"LoaderConfigTimeout", NULL, TRUE); + if (config->timeout_sec_config > 0) + status = PoolPrint(L"Menu timeout of %d sec is defined by configuration file.", + config->timeout_sec_config); + else + status = StrDuplicate(L"Menu disabled. Hold down key at bootup to show menu."); + } + break; + + case KEYPRESS(0, 0, '+'): + case KEYPRESS(0, 0, 't'): + if (config->timeout_sec_efivar == -1 && config->timeout_sec_config == 0) + config->timeout_sec_efivar++; + config->timeout_sec_efivar++; + efivar_set_int(L"LoaderConfigTimeout", config->timeout_sec_efivar, TRUE); + if (config->timeout_sec_efivar > 0) + status = PoolPrint(L"Menu timeout set to %d sec.", + config->timeout_sec_efivar); + else + status = StrDuplicate(L"Menu disabled. Hold down key at bootup to show menu."); + break; + + case KEYPRESS(0, 0, 'e'): + /* only the options of configured entries can be edited */ + if (config->entries[idx_highlight]->type == LOADER_UNDEFINED) + break; + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTGRAY|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1); + if (line_edit(config->entries[idx_highlight]->options, &config->options_edit, x_max-1, y_max-1)) + exit = TRUE; + uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, 0, y_max-1); + uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, clearline+1); + break; + + case KEYPRESS(0, 0, 'v'): + status = PoolPrint(L"gummiboot " VERSION " (" MACHINE_TYPE_NAME "), UEFI Specification %d.%02d, Vendor %s %d.%02d", + ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff, + ST->FirmwareVendor, ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); + break; + + case KEYPRESS(0, 0, 'P'): + print_status(config, root_dir, loaded_image_path); + refresh = TRUE; + break; + + case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'l'): + case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('l')): + refresh = TRUE; + break; + + default: + /* jump with a hotkey directly to a matching entry */ + idx = entry_lookup_key(config, idx_highlight+1, KEYCHAR(key)); + if (idx < 0) + break; + idx_highlight = idx; + refresh = TRUE; + } + + if (idx_highlight > idx_last) { + idx_last = idx_highlight; + idx_first = 1 + idx_highlight - visible_max; + refresh = TRUE; + } + if (idx_highlight < idx_first) { + idx_first = idx_highlight; + idx_last = idx_highlight + visible_max-1; + refresh = TRUE; + } + + idx_last = idx_first + visible_max-1; + + if (!refresh && idx_highlight != idx_highlight_prev) + highlight = TRUE; + } + + *chosen_entry = config->entries[idx_highlight]; + + for (i = 0; i < config->entry_count; i++) + FreePool(lines[i]); + FreePool(lines); + FreePool(clearline); + + uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_WHITE|EFI_BACKGROUND_BLACK); + uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut); + return run; +} + +static VOID config_add_entry(Config *config, ConfigEntry *entry) { + if ((config->entry_count & 15) == 0) { + UINTN i; + + i = config->entry_count + 16; + if (config->entry_count == 0) + config->entries = AllocatePool(sizeof(VOID *) * i); + else + config->entries = ReallocatePool(config->entries, + sizeof(VOID *) * config->entry_count, sizeof(VOID *) * i); + } + config->entries[config->entry_count++] = entry; +} + +static VOID config_entry_free(ConfigEntry *entry) { + FreePool(entry->title_show); + FreePool(entry->title); + FreePool(entry->machine_id); + FreePool(entry->loader); + FreePool(entry->options); +} + +static BOOLEAN is_digit(CHAR16 c) +{ + return (c >= '0') && (c <= '9'); +} + +static UINTN c_order(CHAR16 c) +{ + if (c == '\0') + return 0; + if (is_digit(c)) + return 0; + else if ((c >= 'a') && (c <= 'z')) + return c; + else + return c + 0x10000; +} + +static INTN str_verscmp(CHAR16 *s1, CHAR16 *s2) +{ + CHAR16 *os1 = s1; + CHAR16 *os2 = s2; + + while (*s1 || *s2) { + INTN first; + + while ((*s1 && !is_digit(*s1)) || (*s2 && !is_digit(*s2))) { + INTN order; + + order = c_order(*s1) - c_order(*s2); + if (order) + return order; + s1++; + s2++; + } + + while (*s1 == '0') + s1++; + while (*s2 == '0') + s2++; + + first = 0; + while (is_digit(*s1) && is_digit(*s2)) { + if (first == 0) + first = *s1 - *s2; + s1++; + s2++; + } + + if (is_digit(*s1)) + return 1; + if (is_digit(*s2)) + return -1; + + if (first) + return first; + } + + return StrCmp(os1, os2); +} + +static CHAR8 *line_get_key_value(CHAR8 *content, CHAR8 *sep, UINTN *pos, CHAR8 **key_ret, CHAR8 **value_ret) { + CHAR8 *line; + UINTN linelen; + CHAR8 *value; + +skip: + line = content + *pos; + if (*line == '\0') + return NULL; + + linelen = 0; + while (line[linelen] && !strchra((CHAR8 *)"\n\r", line[linelen])) + linelen++; + + /* move pos to next line */ + *pos += linelen; + if (content[*pos]) + (*pos)++; + + /* empty line */ + if (linelen == 0) + goto skip; + + /* terminate line */ + line[linelen] = '\0'; + + /* remove leading whitespace */ + while (strchra((CHAR8 *)" \t", *line)) { + line++; + linelen--; + } + + /* remove trailing whitespace */ + while (linelen > 0 && strchra(sep, line[linelen-1])) + linelen--; + line[linelen] = '\0'; + + if (*line == '#') + goto skip; + + /* split key/value */ + value = line; + while (*value && !strchra(sep, *value)) + value++; + if (*value == '\0') + goto skip; + *value = '\0'; + value++; + while (*value && strchra(sep, *value)) + value++; + + /* unquote */ + if (value[0] == '\"' && line[linelen-1] == '\"') { + value++; + line[linelen-1] = '\0'; + } + + *key_ret = line; + *value_ret = value; + return line; +} + +static VOID config_defaults_load_from_file(Config *config, CHAR8 *content) { + CHAR8 *line; + UINTN pos = 0; + CHAR8 *key, *value; + + line = content; + while ((line = line_get_key_value(content, (CHAR8 *)" \t", &pos, &key, &value))) { + if (strcmpa((CHAR8 *)"timeout", key) == 0) { + CHAR16 *s; + + s = stra_to_str(value); + config->timeout_sec_config = Atoi(s); + config->timeout_sec = config->timeout_sec_config; + FreePool(s); + continue; + } + + if (strcmpa((CHAR8 *)"default", key) == 0) { + FreePool(config->entry_default_pattern); + config->entry_default_pattern = stra_to_str(value); + StrLwr(config->entry_default_pattern); + continue; + } + + if (strcmpa((CHAR8 *)"splash", key) == 0) { + FreePool(config->splash); + config->splash = stra_to_path(value); + continue; + } + + if (strcmpa((CHAR8 *)"background", key) == 0) { + CHAR16 c[3]; + + /* accept #RRGGBB hex notation */ + if (value[0] != '#') + continue; + if (value[7] != '\0') + continue; + + FreePool(config->background); + config->background = AllocateZeroPool(sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); + if (!config->background) + continue; + + c[0] = value[1]; + c[1] = value[2]; + c[2] = '\0'; + config->background->Red = xtoi(c); + + c[0] = value[3]; + c[1] = value[4]; + config->background->Green = xtoi(c); + + c[0] = value[5]; + c[1] = value[6]; + config->background->Blue = xtoi(c); + continue; + } + } +} + +static VOID config_entry_add_from_file(Config *config, EFI_HANDLE *device, CHAR16 *file, CHAR8 *content, CHAR16 *loaded_image_path) { + ConfigEntry *entry; + CHAR8 *line; + UINTN pos = 0; + CHAR8 *key, *value; + UINTN len; + CHAR16 *initrd = NULL; + + entry = AllocateZeroPool(sizeof(ConfigEntry)); + + line = content; + while ((line = line_get_key_value(content, (CHAR8 *)" \t", &pos, &key, &value))) { + if (strcmpa((CHAR8 *)"title", key) == 0) { + FreePool(entry->title); + entry->title = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"version", key) == 0) { + FreePool(entry->version); + entry->version = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"machine-id", key) == 0) { + FreePool(entry->machine_id); + entry->machine_id = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"linux", key) == 0) { + FreePool(entry->loader); + entry->type = LOADER_LINUX; + entry->loader = stra_to_path(value); + entry->key = 'l'; + continue; + } + + if (strcmpa((CHAR8 *)"efi", key) == 0) { + entry->type = LOADER_EFI; + FreePool(entry->loader); + entry->loader = stra_to_path(value); + + /* do not add an entry for ourselves */ + if (StriCmp(entry->loader, loaded_image_path) == 0) { + entry->type = LOADER_UNDEFINED; + break; + } + continue; + } + + if (strcmpa((CHAR8 *)"architecture", key) == 0) { + /* do not add an entry for an EFI image of architecture not matching with that of the gummiboot image */ + if (strcmpa((CHAR8 *)MACHINE_TYPE_NAME, value) != 0) { + entry->type = LOADER_UNDEFINED; + break; + } + continue; + } + + if (strcmpa((CHAR8 *)"initrd", key) == 0) { + CHAR16 *new; + + new = stra_to_path(value); + if (initrd) { + CHAR16 *s; + + s = PoolPrint(L"%s initrd=%s", initrd, new); + FreePool(initrd); + initrd = s; + } else + initrd = PoolPrint(L"initrd=%s", new); + FreePool(new); + continue; + } + + if (strcmpa((CHAR8 *)"options", key) == 0) { + CHAR16 *new; + + new = stra_to_str(value); + if (entry->options) { + CHAR16 *s; + + s = PoolPrint(L"%s %s", entry->options, new); + FreePool(entry->options); + entry->options = s; + } else { + entry->options = new; + new = NULL; + } + FreePool(new); + continue; + } + + if (strcmpa((CHAR8 *)"splash", key) == 0) { + FreePool(entry->splash); + entry->splash = stra_to_path(value); + continue; + } + } + + if (entry->type == LOADER_UNDEFINED) { + config_entry_free(entry); + FreePool(initrd); + FreePool(entry); + return; + } + + /* add initrd= to options */ + if (entry->type == LOADER_LINUX && initrd) { + if (entry->options) { + CHAR16 *s; + + s = PoolPrint(L"%s %s", initrd, entry->options); + FreePool(entry->options); + entry->options = s; + } else { + entry->options = initrd; + initrd = NULL; + } + } + FreePool(initrd); + + /* machine-id handling code removed */ + + entry->device = device; + entry->file = StrDuplicate(file); + len = StrLen(entry->file); + /* remove ".conf" */ + if (len > 5) + entry->file[len - 5] = '\0'; + StrLwr(entry->file); + + config_add_entry(config, entry); +} + +static VOID config_load(Config *config, EFI_HANDLE *device, EFI_FILE *root_dir, CHAR16 *loaded_image_path) { + EFI_FILE_HANDLE entries_dir; + EFI_STATUS err; + CHAR8 *content = NULL; + UINTN sec; + UINTN len; + UINTN i; + + len = file_read(root_dir, L"\\loader\\loader.conf", 0, 0, &content); + if (len > 0) + config_defaults_load_from_file(config, content); + FreePool(content); + + err = efivar_get_int(L"LoaderConfigTimeout", &sec); + if (!EFI_ERROR(err)) { + config->timeout_sec_efivar = sec; + config->timeout_sec = sec; + } else + config->timeout_sec_efivar = -1; + + err = uefi_call_wrapper(root_dir->Open, 5, root_dir, &entries_dir, L"\\loader\\entries", EFI_FILE_MODE_READ, 0ULL); + if (!EFI_ERROR(err)) { + for (;;) { + CHAR16 buf[256]; + UINTN bufsize; + EFI_FILE_INFO *f; + CHAR8 *content = NULL; + UINTN len; + + bufsize = sizeof(buf); + err = uefi_call_wrapper(entries_dir->Read, 3, entries_dir, &bufsize, buf); + if (bufsize == 0 || EFI_ERROR(err)) + break; + + f = (EFI_FILE_INFO *) buf; + if (f->FileName[0] == '.') + continue; + if (f->Attribute & EFI_FILE_DIRECTORY) + continue; + len = StrLen(f->FileName); + if (len < 6) + continue; + if (StriCmp(f->FileName + len - 5, L".conf") != 0) + continue; + + len = file_read(entries_dir, f->FileName, 0, 0, &content); + if (len > 0) + config_entry_add_from_file(config, device, f->FileName, content, loaded_image_path); + FreePool(content); + } + uefi_call_wrapper(entries_dir->Close, 1, entries_dir); + } + + /* sort entries after version number */ + for (i = 1; i < config->entry_count; i++) { + BOOLEAN more; + UINTN k; + + more = FALSE; + for (k = 0; k < config->entry_count - i; k++) { + ConfigEntry *entry; + + if (str_verscmp(config->entries[k]->file, config->entries[k+1]->file) <= 0) + continue; + entry = config->entries[k]; + config->entries[k] = config->entries[k+1]; + config->entries[k+1] = entry; + more = TRUE; + } + if (!more) + break; + } +} + +static VOID config_default_entry_select(Config *config) { + CHAR16 *var; + EFI_STATUS err; + UINTN i; + + /* + * The EFI variable to specify a boot entry for the next, and only the + * next reboot. The variable is always cleared directly after it is read. + */ + err = efivar_get(L"LoaderEntryOneShot", &var); + if (!EFI_ERROR(err)) { + BOOLEAN found = FALSE; + + for (i = 0; i < config->entry_count; i++) { + if (StrCmp(config->entries[i]->file, var) == 0) { + config->idx_default = i; + found = TRUE; + break; + } + } + + config->entry_oneshot = StrDuplicate(var); + efivar_set(L"LoaderEntryOneShot", NULL, TRUE); + FreePool(var); + if (found) + return; + } + + /* + * The EFI variable to select the default boot entry overrides the + * configured pattern. The variable can be set and cleared by pressing + * the 'd' key in the loader selection menu, the entry is marked with + * an '*'. + */ + err = efivar_get(L"LoaderEntryDefault", &var); + if (!EFI_ERROR(err)) { + BOOLEAN found = FALSE; + + for (i = 0; i < config->entry_count; i++) { + if (StrCmp(config->entries[i]->file, var) == 0) { + config->idx_default = i; + config->idx_default_efivar = i; + found = TRUE; + break; + } + } + FreePool(var); + if (found) + return; + } + config->idx_default_efivar = -1; + + if (config->entry_count == 0) + return; + + /* + * Match the pattern from the end of the list to the start, find last + * entry (largest number) matching the given pattern. + */ + if (config->entry_default_pattern) { + i = config->entry_count; + while (i--) { + if (config->entries[i]->no_autoselect) + continue; + if (MetaiMatch(config->entries[i]->file, config->entry_default_pattern)) { + config->idx_default = i; + return; + } + } + } + + /* select the last suitable entry */ + i = config->entry_count; + while (i--) { + if (config->entries[i]->no_autoselect) + continue; + config->idx_default = i; + return; + } + + /* no entry found */ + config->idx_default = -1; +} + +/* generate a unique title, avoiding non-distinguishable menu entries */ +static VOID config_title_generate(Config *config) { + UINTN i, k; + BOOLEAN unique; + + /* set title */ + for (i = 0; i < config->entry_count; i++) { + CHAR16 *title; + + FreePool(config->entries[i]->title_show); + title = config->entries[i]->title; + if (!title) + title = config->entries[i]->file; + config->entries[i]->title_show = StrDuplicate(title); + } + + unique = TRUE; + for (i = 0; i < config->entry_count; i++) { + for (k = 0; k < config->entry_count; k++) { + if (i == k) + continue; + if (StrCmp(config->entries[i]->title_show, config->entries[k]->title_show) != 0) + continue; + + unique = FALSE; + config->entries[i]->non_unique = TRUE; + config->entries[k]->non_unique = TRUE; + } + } + if (unique) + return; + + /* add version to non-unique titles */ + for (i = 0; i < config->entry_count; i++) { + CHAR16 *s; + + if (!config->entries[i]->non_unique) + continue; + if (!config->entries[i]->version) + continue; + + s = PoolPrint(L"%s (%s)", config->entries[i]->title_show, config->entries[i]->version); + FreePool(config->entries[i]->title_show); + config->entries[i]->title_show = s; + config->entries[i]->non_unique = FALSE; + } + + unique = TRUE; + for (i = 0; i < config->entry_count; i++) { + for (k = 0; k < config->entry_count; k++) { + if (i == k) + continue; + if (StrCmp(config->entries[i]->title_show, config->entries[k]->title_show) != 0) + continue; + + unique = FALSE; + config->entries[i]->non_unique = TRUE; + config->entries[k]->non_unique = TRUE; + } + } + if (unique) + return; + + /* machine-id handling code removed */ + + unique = TRUE; + for (i = 0; i < config->entry_count; i++) { + for (k = 0; k < config->entry_count; k++) { + if (i == k) + continue; + if (StrCmp(config->entries[i]->title_show, config->entries[k]->title_show) != 0) + continue; + + unique = FALSE; + config->entries[i]->non_unique = TRUE; + config->entries[k]->non_unique = TRUE; + } + } + if (unique) + return; + + /* add file name to non-unique titles */ + for (i = 0; i < config->entry_count; i++) { + CHAR16 *s; + + if (!config->entries[i]->non_unique) + continue; + s = PoolPrint(L"%s (%s)", config->entries[i]->title_show, config->entries[i]->file); + FreePool(config->entries[i]->title_show); + config->entries[i]->title_show = s; + config->entries[i]->non_unique = FALSE; + } +} + +static BOOLEAN config_entry_add_call(Config *config, CHAR16 *title, EFI_STATUS (*call)(VOID)) { + ConfigEntry *entry; + + entry = AllocateZeroPool(sizeof(ConfigEntry)); + entry->title = StrDuplicate(title); + entry->call = call; + entry->no_autoselect = TRUE; + config_add_entry(config, entry); + return TRUE; +} + +static ConfigEntry *config_entry_add_loader(Config *config, EFI_HANDLE *device, + enum loader_type type,CHAR16 *file, CHAR16 key, CHAR16 *title, CHAR16 *loader) { + ConfigEntry *entry; + + entry = AllocateZeroPool(sizeof(ConfigEntry)); + entry->type = type; + entry->title = StrDuplicate(title); + entry->device = device; + entry->loader = StrDuplicate(loader); + entry->file = StrDuplicate(file); + StrLwr(entry->file); + entry->key = key; + config_add_entry(config, entry); + + return entry; +} + +static BOOLEAN config_entry_add_loader_auto(Config *config, EFI_HANDLE *device, EFI_FILE *root_dir, CHAR16 *loaded_image_path, + CHAR16 *file, CHAR16 key, CHAR16 *title, CHAR16 *loader) { + EFI_FILE_HANDLE handle; + ConfigEntry *entry; + EFI_STATUS err; + + /* do not add an entry for ourselves */ + if (loaded_image_path && StriCmp(loader, loaded_image_path) == 0) + return FALSE; + + /* check existence */ + err = uefi_call_wrapper(root_dir->Open, 5, root_dir, &handle, loader, EFI_FILE_MODE_READ, 0ULL); + if (EFI_ERROR(err)) + return FALSE; + uefi_call_wrapper(handle->Close, 1, handle); + + entry = config_entry_add_loader(config, device, LOADER_UNDEFINED, file, key, title, loader); + if (!entry) + return FALSE; + + /* do not boot right away into auto-detected entries */ + entry->no_autoselect = TRUE; + + /* do not show a splash; they do not need one, or they draw their own */ + entry->splash = StrDuplicate(L""); + + /* export identifiers of automatically added entries */ + if (config->entries_auto) { + CHAR16 *s; + + s = PoolPrint(L"%s %s", config->entries_auto, file); + FreePool(config->entries_auto); + config->entries_auto = s; + } else + config->entries_auto = StrDuplicate(file); + + return TRUE; +} + +static VOID config_entry_add_osx(Config *config) { + EFI_STATUS err; + UINTN handle_count = 0; + EFI_HANDLE *handles = NULL; + + err = LibLocateHandle(ByProtocol, &FileSystemProtocol, NULL, &handle_count, &handles); + if (!EFI_ERROR(err)) { + UINTN i; + + for (i = 0; i < handle_count; i++) { + EFI_FILE *root; + BOOLEAN found; + + root = LibOpenRoot(handles[i]); + if (!root) + continue; + found = config_entry_add_loader_auto(config, handles[i], root, NULL, L"auto-osx", 'a', L"OS X", + L"\\System\\Library\\CoreServices\\boot.efi"); + uefi_call_wrapper(root->Close, 1, root); + if (found) + break; + } + + FreePool(handles); + } +} + +static VOID config_entry_add_linux( Config *config, EFI_LOADED_IMAGE *loaded_image, EFI_FILE *root_dir) { + EFI_FILE_HANDLE linux_dir; + EFI_STATUS err; + + err = uefi_call_wrapper(root_dir->Open, 5, root_dir, &linux_dir, L"\\EFI\\Linux", EFI_FILE_MODE_READ, 0ULL); + if (!EFI_ERROR(err)) { + for (;;) { + CHAR16 buf[256]; + UINTN bufsize; + EFI_FILE_INFO *f; + CHAR8 *sections[] = { + (UINT8 *)".osrel", + NULL + }; + UINTN offs[ELEMENTSOF(sections)-1] = {}; + UINTN szs[ELEMENTSOF(sections)-1] = {}; + UINTN addrs[ELEMENTSOF(sections)-1] = {}; + CHAR8 *content = NULL; + UINTN len; + CHAR8 *line; + UINTN pos = 0; + CHAR8 *key, *value; + CHAR16 *os_name = NULL; + CHAR16 *os_id = NULL; + CHAR16 *os_version = NULL; + + bufsize = sizeof(buf); + err = uefi_call_wrapper(linux_dir->Read, 3, linux_dir, &bufsize, buf); + if (bufsize == 0 || EFI_ERROR(err)) + break; + + f = (EFI_FILE_INFO *) buf; + if (f->FileName[0] == '.') + continue; + if (f->Attribute & EFI_FILE_DIRECTORY) + continue; + len = StrLen(f->FileName); + if (len < 5) + continue; + if (StriCmp(f->FileName + len - 4, L".efi") != 0) + continue; + + /* look for an .osrel section in the .efi binary */ + err = pefile_locate_sections(linux_dir, f->FileName, sections, addrs, offs, szs); + if (EFI_ERROR(err)) + continue; + + len = file_read(linux_dir, f->FileName, offs[0], szs[0], &content); + if (len <= 0) + continue; + + /* read properties from the embedded os-release file */ + line = content; + while ((line = line_get_key_value(content, (CHAR8 *)"=", &pos, &key, &value))) { + if (strcmpa((CHAR8 *)"PRETTY_NAME", key) == 0) { + os_name = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"ID", key) == 0) { + os_id = stra_to_str(value); + continue; + } + + if (strcmpa((CHAR8 *)"VERSION_ID", key) == 0) { + os_version = stra_to_str(value); + continue; + } + } + + if (os_name && os_id && os_version) { + CHAR16 *conf; + CHAR16 *path; + + conf = PoolPrint(L"%s-%s", os_id, os_version); + path = PoolPrint(L"\\EFI\\Linux\\%s", f->FileName); + config_entry_add_loader(config, loaded_image->DeviceHandle, LOADER_LINUX, conf, 'l', os_name, path); + FreePool(conf); + FreePool(path); + FreePool(os_name); + FreePool(os_id); + FreePool(os_version); + } + + FreePool(content); + } + uefi_call_wrapper(linux_dir->Close, 1, linux_dir); + } +} + +static EFI_STATUS image_start(EFI_HANDLE parent_image, const Config *config, const ConfigEntry *entry) { + EFI_HANDLE image; + EFI_DEVICE_PATH *path; + CHAR16 *options; + EFI_STATUS err; + + path = FileDevicePath(entry->device, entry->loader); + if (!path) { + Print(L"Error getting device path."); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return EFI_INVALID_PARAMETER; + } + + err = uefi_call_wrapper(BS->LoadImage, 6, FALSE, parent_image, path, NULL, 0, &image); + if (EFI_ERROR(err)) { + Print(L"Error loading %s: %r", entry->loader, err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out; + } + + if (config->options_edit) + options = config->options_edit; + else if (entry->options) + options = entry->options; + else + options = NULL; + if (options) { + EFI_LOADED_IMAGE *loaded_image; + + err = uefi_call_wrapper(BS->OpenProtocol, 6, image, &LoadedImageProtocol, (VOID **)&loaded_image, + parent_image, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL); + if (EFI_ERROR(err)) { + Print(L"Error getting LoadedImageProtocol handle: %r", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out_unload; + } + loaded_image->LoadOptions = options; + loaded_image->LoadOptionsSize = (StrLen(loaded_image->LoadOptions)+1) * sizeof(CHAR16); + } + + efivar_set_time_usec(L"LoaderTimeExecUSec", 0); + err = uefi_call_wrapper(BS->StartImage, 3, image, NULL, NULL); +out_unload: + uefi_call_wrapper(BS->UnloadImage, 1, image); +out: + FreePool(path); + return err; +} + +static EFI_STATUS reboot_into_firmware(VOID) { + CHAR8 *b; + UINTN size; + UINT64 osind; + EFI_STATUS err; + + osind = EFI_OS_INDICATIONS_BOOT_TO_FW_UI; + + err = efivar_get_raw(&global_guid, L"OsIndications", &b, &size); + if (!EFI_ERROR(err)) + osind |= (UINT64)*b; + FreePool(b); + + err = efivar_set_raw(&global_guid, L"OsIndications", (CHAR8 *)&osind, sizeof(UINT64), TRUE); + if (EFI_ERROR(err)) + return err; + + err = uefi_call_wrapper(RT->ResetSystem, 4, EfiResetCold, EFI_SUCCESS, 0, NULL); + Print(L"Error calling ResetSystem: %r", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return err; +} + +static VOID config_free(Config *config) { + UINTN i; + + for (i = 0; i < config->entry_count; i++) + config_entry_free(config->entries[i]); + FreePool(config->entries); + FreePool(config->entry_default_pattern); + FreePool(config->options_edit); + FreePool(config->entry_oneshot); + FreePool(config->entries_auto); + FreePool(config->splash); + FreePool(config->background); +} + +EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *sys_table) { + CHAR16 *s; + CHAR8 *b; + UINTN size; + EFI_LOADED_IMAGE *loaded_image; + EFI_FILE *root_dir; + CHAR16 *loaded_image_path; + EFI_DEVICE_PATH *device_path; + EFI_STATUS err; + Config config; + UINT64 init_usec; + BOOLEAN menu = FALSE; + + InitializeLib(image, sys_table); + init_usec = time_usec(); + efivar_set_time_usec(L"LoaderTimeInitUSec", init_usec); + efivar_set(L"LoaderInfo", L"gummiboot " VERSION, FALSE); + s = PoolPrint(L"%s %d.%02d", ST->FirmwareVendor, ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); + efivar_set(L"LoaderFirmwareInfo", s, FALSE); + FreePool(s); + s = PoolPrint(L"UEFI %d.%02d", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff); + efivar_set(L"LoaderFirmwareType", s, FALSE); + FreePool(s); + + err = uefi_call_wrapper(BS->OpenProtocol, 6, image, &LoadedImageProtocol, (VOID **)&loaded_image, + image, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL); + if (EFI_ERROR(err)) { + Print(L"Error getting a LoadedImageProtocol handle: %r ", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return err; + } + + /* export the device path this image is started from */ + device_path = DevicePathFromHandle(loaded_image->DeviceHandle); + if (device_path) { + CHAR16 *str; + EFI_DEVICE_PATH *path, *paths; + + str = DevicePathToStr(device_path); + efivar_set(L"LoaderDeviceIdentifier", str, FALSE); + FreePool(str); + + paths = UnpackDevicePath(device_path); + for (path = paths; !IsDevicePathEnd(path); path = NextDevicePathNode(path)) { + HARDDRIVE_DEVICE_PATH *drive; + CHAR16 uuid[37]; + + if (DevicePathType(path) != MEDIA_DEVICE_PATH) + continue; + if (DevicePathSubType(path) != MEDIA_HARDDRIVE_DP) + continue; + drive = (HARDDRIVE_DEVICE_PATH *)path; + if (drive->SignatureType != SIGNATURE_TYPE_GUID) + continue; + + GuidToString(uuid, (EFI_GUID *)&drive->Signature); + efivar_set(L"LoaderDevicePartUUID", uuid, FALSE); + break; + } + FreePool(paths); + } + + root_dir = LibOpenRoot(loaded_image->DeviceHandle); + if (!root_dir) { + Print(L"Unable to open root directory: %r ", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return EFI_LOAD_ERROR; + } + + + /* the filesystem path to this image, to prevent adding ourselves to the menu */ + loaded_image_path = DevicePathToStr(loaded_image->FilePath); + efivar_set(L"LoaderImageIdentifier", loaded_image_path, FALSE); + + /* scan "\loader\entries\*.conf" files */ + ZeroMem(&config, sizeof(Config)); + config_load(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path); + + if (!config.background) { + config.background = AllocateZeroPool(sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); + if (StriCmp(L"Apple", ST->FirmwareVendor) == 0) { + config.background->Red = 0xc0; + config.background->Green = 0xc0; + config.background->Blue = 0xc0; + } + } + + /* if we find some well-known loaders, add them to the end of the list */ + config_entry_add_linux(&config, loaded_image, root_dir); + config_entry_add_loader_auto(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path, + L"auto-windows", 'w', L"Windows Boot Manager", L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi"); + config_entry_add_loader_auto(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path, + L"auto-efi-shell", 's', L"EFI Shell", L"\\shell" MACHINE_TYPE_NAME ".efi"); + config_entry_add_loader_auto(&config, loaded_image->DeviceHandle, root_dir, loaded_image_path, + L"auto-efi-default", '\0', L"EFI Default Loader", L"\\EFI\\Boot\\boot" MACHINE_TYPE_NAME ".efi"); + config_entry_add_osx(&config); + efivar_set(L"LoaderEntriesAuto", config.entries_auto, FALSE); + + if (efivar_get_raw(&global_guid, L"OsIndicationsSupported", &b, &size) == EFI_SUCCESS) { + UINT64 osind = (UINT64)*b; + + if (osind & EFI_OS_INDICATIONS_BOOT_TO_FW_UI) + config_entry_add_call(&config, L"Reboot Into Firmware Interface", reboot_into_firmware); + FreePool(b); + } + + if (config.entry_count == 0) { + Print(L"No loader found. Configuration files in \\loader\\entries\\*.conf are needed."); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out; + } + + config_title_generate(&config); + + /* select entry by configured pattern or EFI LoaderDefaultEntry= variable*/ + config_default_entry_select(&config); + + /* if no configured entry to select from was found, enable the menu */ + if (config.idx_default == -1) { + config.idx_default = 0; + if (config.timeout_sec == 0) + config.timeout_sec = 10; + } + + /* select entry or show menu when key is pressed or timeout is set */ + if (config.timeout_sec == 0) { + UINT64 key; + + err = console_key_read(&key, FALSE); + if (!EFI_ERROR(err)) { + INT16 idx; + + /* find matching key in config entries */ + idx = entry_lookup_key(&config, config.idx_default, KEYCHAR(key)); + if (idx >= 0) + config.idx_default = idx; + else + menu = TRUE; + } + } else + menu = TRUE; + + for (;;) { + ConfigEntry *entry; + + entry = config.entries[config.idx_default]; + if (menu) { + efivar_set_time_usec(L"LoaderTimeMenuUSec", 0); + uefi_call_wrapper(BS->SetWatchdogTimer, 4, 0, 0x10000, 0, NULL); + if (!menu_run(&config, &entry, root_dir, loaded_image_path)) + break; + + /* run special entry like "reboot" */ + if (entry->call) { + entry->call(); + continue; + } + } else { + err = EFI_NOT_FOUND; + + /* splash from entry file */ + if (entry->splash) { + /* some entries disable the splash because they draw their own */ + if (entry->splash[0] == '\0') + err = EFI_SUCCESS; + else + err = graphics_splash(root_dir, entry->splash, config.background); + } + + /* splash from config file */ + if (EFI_ERROR(err) && config.splash) + err = graphics_splash(root_dir, config.splash, config.background); + + /* default splash */ + if (EFI_ERROR(err)) + graphics_splash(root_dir, L"\\EFI\\gummiboot\\splash.bmp", config.background); + } + + /* export the selected boot entry to the system */ + efivar_set(L"LoaderEntrySelected", entry->file, FALSE); + + uefi_call_wrapper(BS->SetWatchdogTimer, 4, 5 * 60, 0x10000, 0, NULL); + err = image_start(image, &config, entry); + + if (err == EFI_ACCESS_DENIED || err == EFI_SECURITY_VIOLATION) { + /* Platform is secure boot and requested image isn't + * trusted. Need to go back to prior boot system and + * install more keys or hashes. Signal failure by + * returning the error */ + Print(L"\nImage %s gives a security error\n", entry->title); + Print(L"Please enrol the hash or signature of %s\n", entry->loader); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + goto out; + } + + menu = TRUE; + config.timeout_sec = 0; + } + err = EFI_SUCCESS; +out: + FreePool(loaded_image_path); + config_free(&config); + uefi_call_wrapper(root_dir->Close, 1, root_dir); + uefi_call_wrapper(BS->CloseProtocol, 4, image, &LoadedImageProtocol, image, NULL); + return err; +} diff --git a/gummiboot-nomachineid-48/src/efi/linux.c b/gummiboot-nomachineid-48/src/efi/linux.c new file mode 100644 index 0000000..26c5877 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/linux.c @@ -0,0 +1,128 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2015 Kay Sievers + */ + +#include +#include + +#include "util.h" +#include "linux.h" + +#define SETUP_MAGIC 0x53726448 /* "HdrS" */ +struct SetupHeader { + UINT8 boot_sector[0x01f1]; + UINT8 setup_secs; + UINT16 root_flags; + UINT32 sys_size; + UINT16 ram_size; + UINT16 video_mode; + UINT16 root_dev; + UINT16 signature; + UINT16 jump; + UINT32 header; + UINT16 version; + UINT16 su_switch; + UINT16 setup_seg; + UINT16 start_sys; + UINT16 kernel_ver; + UINT8 loader_id; + UINT8 load_flags; + UINT16 movesize; + UINT32 code32_start; + UINT32 ramdisk_start; + UINT32 ramdisk_len; + UINT32 bootsect_kludge; + UINT16 heap_end; + UINT8 ext_loader_ver; + UINT8 ext_loader_type; + UINT32 cmd_line_ptr; + UINT32 ramdisk_max; + UINT32 kernel_alignment; + UINT8 relocatable_kernel; + UINT8 min_alignment; + UINT16 xloadflags; + UINT32 cmdline_size; + UINT32 hardware_subarch; + UINT64 hardware_subarch_data; + UINT32 payload_offset; + UINT32 payload_length; + UINT64 setup_data; + UINT64 pref_address; + UINT32 init_size; + UINT32 handover_offset; +} __attribute__((packed)); + +#ifdef __x86_64__ +typedef VOID(*handover_f)(VOID *image, EFI_SYSTEM_TABLE *table, struct SetupHeader *setup); +static inline VOID linux_efi_handover(EFI_HANDLE image, struct SetupHeader *setup) { + handover_f handover; + + asm volatile ("cli"); + handover = (handover_f)((UINTN)setup->code32_start + 512 + setup->handover_offset); + handover(image, ST, setup); +} +#else +typedef VOID(*handover_f)(VOID *image, EFI_SYSTEM_TABLE *table, struct SetupHeader *setup) __attribute__((regparm(0))); +static inline VOID linux_efi_handover(EFI_HANDLE image, struct SetupHeader *setup) { + handover_f handover; + + handover = (handover_f)((UINTN)setup->code32_start + setup->handover_offset); + handover(image, ST, setup); +} +#endif + +EFI_STATUS linux_exec(EFI_HANDLE *image, + CHAR8 *cmdline, UINTN linux_addr, + UINTN initrd_addr, UINTN initrd_size) { + struct SetupHeader *image_setup; + struct SetupHeader *boot_setup; + EFI_PHYSICAL_ADDRESS addr; + EFI_STATUS err; + + image_setup = (struct SetupHeader *)(linux_addr); + if (image_setup->signature != 0xAA55 || image_setup->header != SETUP_MAGIC) + return EFI_LOAD_ERROR; + + if (image_setup->version < 0x20b || !image_setup->relocatable_kernel) + return EFI_LOAD_ERROR; + + addr = 0x3fffffff; + err = uefi_call_wrapper(BS->AllocatePages, 4, AllocateMaxAddress, EfiLoaderData, + EFI_SIZE_TO_PAGES(0x4000), &addr); + if (EFI_ERROR(err)) + return err; + boot_setup = (struct SetupHeader *)(UINTN)addr; + ZeroMem(boot_setup, 0x4000); + CopyMem(boot_setup, image_setup, sizeof(struct SetupHeader)); + boot_setup->loader_id = 0xff; + + boot_setup->code32_start = (UINT32)linux_addr + (image_setup->setup_secs+1) * 512; + + if (cmdline) { + addr = 0xA0000; + err = uefi_call_wrapper(BS->AllocatePages, 4, AllocateMaxAddress, EfiLoaderData, + EFI_SIZE_TO_PAGES(strlena(cmdline) + 1), &addr); + if (EFI_ERROR(err)) + return err; + CopyMem((VOID *)(UINTN)addr, cmdline, strlena(cmdline) + 1); + boot_setup->cmd_line_ptr = (UINT32)addr; + } + + boot_setup->ramdisk_start = (UINT32)initrd_addr; + boot_setup->ramdisk_len = (UINT32)initrd_size; + + linux_efi_handover(image, boot_setup); + return EFI_LOAD_ERROR; +} diff --git a/gummiboot-nomachineid-48/src/efi/linux.h b/gummiboot-nomachineid-48/src/efi/linux.h new file mode 100644 index 0000000..020c728 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/linux.h @@ -0,0 +1,23 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2015 Kay Sievers + */ + +#ifndef __GUMMIBOOT_kernel_H +#define __GUMMIBOOT_kernel_H + +EFI_STATUS linux_exec(EFI_HANDLE *image, + CHAR8 *cmdline, UINTN linux_addr, + UINTN initrd_addr, UINTN initrd_size); +#endif diff --git a/gummiboot-nomachineid-48/src/efi/pefile.c b/gummiboot-nomachineid-48/src/efi/pefile.c new file mode 100644 index 0000000..e6fedbc --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/pefile.c @@ -0,0 +1,172 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2015 Kay Sievers + */ + +#include +#include + +#include "util.h" +#include "pefile.h" + +struct DosFileHeader { + UINT8 Magic[2]; + UINT16 LastSize; + UINT16 nBlocks; + UINT16 nReloc; + UINT16 HdrSize; + UINT16 MinAlloc; + UINT16 MaxAlloc; + UINT16 ss; + UINT16 sp; + UINT16 Checksum; + UINT16 ip; + UINT16 cs; + UINT16 RelocPos; + UINT16 nOverlay; + UINT16 reserved[4]; + UINT16 OEMId; + UINT16 OEMInfo; + UINT16 reserved2[10]; + UINT32 ExeHeader; +} __attribute__((packed)); + +#define PE_HEADER_MACHINE_I386 0x014c +#define PE_HEADER_MACHINE_X64 0x8664 +struct PeFileHeader { + UINT16 Machine; + UINT16 NumberOfSections; + UINT32 TimeDateStamp; + UINT32 PointerToSymbolTable; + UINT32 NumberOfSymbols; + UINT16 SizeOfOptionalHeader; + UINT16 Characteristics; +} __attribute__((packed)); + +struct PeSectionHeader { + UINT8 Name[8]; + UINT32 VirtualSize; + UINT32 VirtualAddress; + UINT32 SizeOfRawData; + UINT32 PointerToRawData; + UINT32 PointerToRelocations; + UINT32 PointerToLinenumbers; + UINT16 NumberOfRelocations; + UINT16 NumberOfLinenumbers; + UINT32 Characteristics; +} __attribute__((packed)); + + +EFI_STATUS pefile_locate_sections(EFI_FILE *dir, CHAR16 *path, CHAR8 **sections, UINTN *addrs, UINTN *offsets, UINTN *sizes) { + EFI_FILE_HANDLE handle; + struct DosFileHeader dos; + uint8_t magic[4]; + struct PeFileHeader pe; + UINTN len; + UINTN i; + EFI_STATUS err; + + err = uefi_call_wrapper(dir->Open, 5, dir, &handle, path, EFI_FILE_MODE_READ, 0ULL); + if (EFI_ERROR(err)) + return err; + + /* MS-DOS stub */ + len = sizeof(dos); + err = uefi_call_wrapper(handle->Read, 3, handle, &len, &dos); + if (EFI_ERROR(err)) + goto out; + if (len != sizeof(dos)) { + err = EFI_LOAD_ERROR; + goto out; + } + + if (CompareMem(dos.Magic, "MZ", 2) != 0) { + err = EFI_LOAD_ERROR; + goto out; + } + + err = uefi_call_wrapper(handle->SetPosition, 2, handle, dos.ExeHeader); + if (EFI_ERROR(err)) + goto out; + + /* PE header */ + len = sizeof(magic); + err = uefi_call_wrapper(handle->Read, 3, handle, &len, &magic); + if (EFI_ERROR(err)) + goto out; + if (len != sizeof(magic)) { + err = EFI_LOAD_ERROR; + goto out; + } + + if (CompareMem(magic, "PE\0\0", 2) != 0) { + err = EFI_LOAD_ERROR; + goto out; + } + + len = sizeof(pe); + err = uefi_call_wrapper(handle->Read, 3, handle, &len, &pe); + if (EFI_ERROR(err)) + goto out; + if (len != sizeof(pe)) { + err = EFI_LOAD_ERROR; + goto out; + } + + /* PE32+ Subsystem type */ + if (pe.Machine != PE_HEADER_MACHINE_X64 && + pe.Machine != PE_HEADER_MACHINE_I386) { + err = EFI_LOAD_ERROR; + goto out; + } + + if (pe.NumberOfSections > 96) { + err = EFI_LOAD_ERROR; + goto out; + } + + /* the sections start directly after the headers */ + err = uefi_call_wrapper(handle->SetPosition, 2, handle, dos.ExeHeader + sizeof(magic) + sizeof(pe) + pe.SizeOfOptionalHeader); + if (EFI_ERROR(err)) + goto out; + + for (i = 0; i < pe.NumberOfSections; i++) { + struct PeSectionHeader sect; + UINTN j; + + len = sizeof(sect); + err = uefi_call_wrapper(handle->Read, 3, handle, &len, §); + if (EFI_ERROR(err)) + goto out; + if (len != sizeof(sect)) { + err = EFI_LOAD_ERROR; + goto out; + } + for (j = 0; sections[j]; j++) { + if (CompareMem(sect.Name, sections[j], strlena(sections[j])) != 0) + continue; + + if (addrs) + addrs[j] = (UINTN)sect.VirtualAddress; + if (offsets) + offsets[j] = (UINTN)sect.PointerToRawData; + if (sizes) + sizes[j] = (UINTN)sect.VirtualSize; + } + } + +out: + uefi_call_wrapper(handle->Close, 1, handle); + return err; +} diff --git a/gummiboot-nomachineid-48/src/efi/pefile.h b/gummiboot-nomachineid-48/src/efi/pefile.h new file mode 100644 index 0000000..3adf1b0 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/pefile.h @@ -0,0 +1,22 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2015 Kay Sievers + */ + +#ifndef __GUMMIBOOT_PEFILE_H +#define __GUMMIBOOT_PEFILE_H + +EFI_STATUS pefile_locate_sections(EFI_FILE *dir, CHAR16 *path, + CHAR8 **sections, UINTN *addrs, UINTN *offsets, UINTN *sizes); +#endif diff --git a/gummiboot-nomachineid-48/src/efi/stub.c b/gummiboot-nomachineid-48/src/efi/stub.c new file mode 100644 index 0000000..51d215f --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/stub.c @@ -0,0 +1,102 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2015 Kay Sievers + */ + +#include +#include + +#include "util.h" +#include "pefile.h" +#include "linux.h" + +/* magic string to find in the binary image */ +static const char __attribute__((used)) magic[] = "#### LoaderInfo: stub " VERSION " ####"; + +static const EFI_GUID global_guid = EFI_GLOBAL_VARIABLE; + +EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *sys_table) { + EFI_LOADED_IMAGE *loaded_image; + EFI_FILE *root_dir; + CHAR16 *loaded_image_path; + CHAR8 *b; + UINTN size; + BOOLEAN secure = FALSE; + CHAR8 *sections[] = { + (UINT8 *)".cmdline", + (UINT8 *)".linux", + (UINT8 *)".initrd", + NULL + }; + UINTN addrs[ELEMENTSOF(sections)-1] = {}; + UINTN offs[ELEMENTSOF(sections)-1] = {}; + UINTN szs[ELEMENTSOF(sections)-1] = {}; + CHAR8 *cmdline = NULL; + EFI_STATUS err; + + InitializeLib(image, sys_table); + + err = uefi_call_wrapper(BS->OpenProtocol, 6, image, &LoadedImageProtocol, (VOID **)&loaded_image, + image, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL); + if (EFI_ERROR(err)) { + Print(L"Error getting a LoadedImageProtocol handle: %r ", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return err; + } + + root_dir = LibOpenRoot(loaded_image->DeviceHandle); + if (!root_dir) { + Print(L"Unable to open root directory: %r ", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return EFI_LOAD_ERROR; + } + + loaded_image_path = DevicePathToStr(loaded_image->FilePath); + + if (efivar_get_raw(&global_guid, L"SecureBoot", &b, &size) == EFI_SUCCESS) { + if (*b > 0) + secure = TRUE; + FreePool(b); + } + + err = pefile_locate_sections(root_dir, loaded_image_path, sections, addrs, offs, szs); + if (EFI_ERROR(err)) { + Print(L"Unable to locate embedded .linux section: %r ", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return err; + } + + if (szs[0] > 0) + cmdline = (CHAR8 *)(loaded_image->ImageBase + addrs[0]); + + /* if we are not in secure boot mode, accept a custom command line and replace the built-in one */ + if (!secure && loaded_image->LoadOptionsSize > 0) { + CHAR16 *options; + CHAR8 *line; + UINTN i; + + options = (CHAR16 *)loaded_image->LoadOptions; + line = AllocatePool((loaded_image->LoadOptionsSize / sizeof(CHAR16)) * sizeof(CHAR8)); + for (i = 0; i < loaded_image->LoadOptionsSize; i++) + line[i] = options[i]; + cmdline = line; + } + + err = linux_exec(image, cmdline, + (UINTN)loaded_image->ImageBase + addrs[1], + (UINTN)loaded_image->ImageBase + addrs[2], szs[2]); + + Print(L"Execution of embedded linux image failed: %r\n", err); + uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000); + return err; +} diff --git a/gummiboot-nomachineid-48/src/efi/util.c b/gummiboot-nomachineid-48/src/efi/util.c new file mode 100644 index 0000000..5678b50 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/util.c @@ -0,0 +1,322 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + */ + +#include +#include + +#include "util.h" + +/* + * Allocated random UUID, intended to be shared across tools that implement + * the (ESP)\loader\entries\-.conf convention and the + * associated EFI variables. + */ +static const EFI_GUID loader_guid = { 0x4a67b082, 0x0a4c, 0x41cf, {0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f} }; + +#ifdef __x86_64__ +UINT64 ticks_read(VOID) { + UINT64 a, d; + __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d)); + return (d << 32) | a; +} +#else +UINT64 ticks_read(VOID) { + UINT64 val; + __asm__ volatile ("rdtsc" : "=A" (val)); + return val; +} +#endif + +/* count TSC ticks during a millisecond delay */ +UINT64 ticks_freq(VOID) { + UINT64 ticks_start, ticks_end; + + ticks_start = ticks_read(); + uefi_call_wrapper(BS->Stall, 1, 1000); + ticks_end = ticks_read(); + + return (ticks_end - ticks_start) * 1000; +} + +UINT64 time_usec(VOID) { + UINT64 ticks; + static UINT64 freq; + + ticks = ticks_read(); + if (ticks == 0) + return 0; + + if (freq == 0) { + freq = ticks_freq(); + if (freq == 0) + return 0; + } + + return 1000 * 1000 * ticks / freq; +} + +EFI_STATUS efivar_set_raw(const EFI_GUID *vendor, CHAR16 *name, CHAR8 *buf, UINTN size, BOOLEAN persistent) { + UINT32 flags; + + flags = EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS; + if (persistent) + flags |= EFI_VARIABLE_NON_VOLATILE; + + return uefi_call_wrapper(RT->SetVariable, 5, name, (EFI_GUID *)vendor, flags, size, buf); +} + +EFI_STATUS efivar_set(CHAR16 *name, CHAR16 *value, BOOLEAN persistent) { + return efivar_set_raw(&loader_guid, name, (CHAR8 *)value, value ? (StrLen(value)+1) * sizeof(CHAR16) : 0, persistent); +} + +EFI_STATUS efivar_set_int(CHAR16 *name, UINTN i, BOOLEAN persistent) { + CHAR16 str[32]; + + SPrint(str, 32, L"%d", i); + return efivar_set(name, str, persistent); +} + +EFI_STATUS efivar_get(CHAR16 *name, CHAR16 **value) { + CHAR8 *buf; + CHAR16 *val; + UINTN size; + EFI_STATUS err; + + err = efivar_get_raw(&loader_guid, name, &buf, &size); + if (EFI_ERROR(err)) + return err; + + val = StrDuplicate((CHAR16 *)buf); + if (!val) { + FreePool(buf); + return EFI_OUT_OF_RESOURCES; + } + + *value = val; + return EFI_SUCCESS; +} + +EFI_STATUS efivar_get_int(CHAR16 *name, UINTN *i) { + CHAR16 *val; + EFI_STATUS err; + + err = efivar_get(name, &val); + if (!EFI_ERROR(err)) { + *i = Atoi(val); + FreePool(val); + } + return err; +} + +EFI_STATUS efivar_get_raw(const EFI_GUID *vendor, CHAR16 *name, CHAR8 **buffer, UINTN *size) { + CHAR8 *buf; + UINTN l; + EFI_STATUS err; + + l = sizeof(CHAR16 *) * EFI_MAXIMUM_VARIABLE_SIZE; + buf = AllocatePool(l); + if (!buf) + return EFI_OUT_OF_RESOURCES; + + err = uefi_call_wrapper(RT->GetVariable, 5, name, (EFI_GUID *)vendor, NULL, &l, buf); + if (!EFI_ERROR(err)) { + *buffer = buf; + if (size) + *size = l; + } else + FreePool(buf); + return err; + +} + +VOID efivar_set_time_usec(CHAR16 *name, UINT64 usec) { + CHAR16 str[32]; + + if (usec == 0) + usec = time_usec(); + if (usec == 0) + return; + + SPrint(str, 32, L"%ld", usec); + efivar_set(name, str, FALSE); +} + +static INTN utf8_to_16(CHAR8 *stra, CHAR16 *c) { + CHAR16 unichar; + UINTN len; + UINTN i; + + if (stra[0] < 0x80) + len = 1; + else if ((stra[0] & 0xe0) == 0xc0) + len = 2; + else if ((stra[0] & 0xf0) == 0xe0) + len = 3; + else if ((stra[0] & 0xf8) == 0xf0) + len = 4; + else if ((stra[0] & 0xfc) == 0xf8) + len = 5; + else if ((stra[0] & 0xfe) == 0xfc) + len = 6; + else + return -1; + + switch (len) { + case 1: + unichar = stra[0]; + break; + case 2: + unichar = stra[0] & 0x1f; + break; + case 3: + unichar = stra[0] & 0x0f; + break; + case 4: + unichar = stra[0] & 0x07; + break; + case 5: + unichar = stra[0] & 0x03; + break; + case 6: + unichar = stra[0] & 0x01; + break; + } + + for (i = 1; i < len; i++) { + if ((stra[i] & 0xc0) != 0x80) + return -1; + unichar <<= 6; + unichar |= stra[i] & 0x3f; + } + + *c = unichar; + return len; +} + +CHAR16 *stra_to_str(CHAR8 *stra) { + UINTN strlen; + UINTN len; + UINTN i; + CHAR16 *str; + + len = strlena(stra); + str = AllocatePool((len + 1) * sizeof(CHAR16)); + + strlen = 0; + i = 0; + while (i < len) { + INTN utf8len; + + utf8len = utf8_to_16(stra + i, str + strlen); + if (utf8len <= 0) { + /* invalid utf8 sequence, skip the garbage */ + i++; + continue; + } + + strlen++; + i += utf8len; + } + str[strlen] = '\0'; + return str; +} + +CHAR16 *stra_to_path(CHAR8 *stra) { + CHAR16 *str; + UINTN strlen; + UINTN len; + UINTN i; + + len = strlena(stra); + str = AllocatePool((len + 2) * sizeof(CHAR16)); + + str[0] = '\\'; + strlen = 1; + i = 0; + while (i < len) { + INTN utf8len; + + utf8len = utf8_to_16(stra + i, str + strlen); + if (utf8len <= 0) { + /* invalid utf8 sequence, skip the garbage */ + i++; + continue; + } + + if (str[strlen] == '/') + str[strlen] = '\\'; + if (str[strlen] == '\\' && str[strlen-1] == '\\') { + /* skip double slashes */ + i += utf8len; + continue; + } + + strlen++; + i += utf8len; + } + str[strlen] = '\0'; + return str; +} + +CHAR8 *strchra(CHAR8 *s, CHAR8 c) { + do { + if (*s == c) + return s; + } while (*s++); + return NULL; +} + +INTN file_read(EFI_FILE_HANDLE dir, CHAR16 *name, UINTN off, UINTN size, CHAR8 **content) { + EFI_FILE_HANDLE handle; + CHAR8 *buf; + UINTN buflen; + EFI_STATUS err; + UINTN len; + + err = uefi_call_wrapper(dir->Open, 5, dir, &handle, name, EFI_FILE_MODE_READ, 0ULL); + if (EFI_ERROR(err)) + return err; + + if (size == 0) { + EFI_FILE_INFO *info; + + info = LibFileInfo(handle); + buflen = info->FileSize+1; + FreePool(info); + } else + buflen = size; + + if (off > 0) { + err = uefi_call_wrapper(handle->SetPosition, 2, handle, off); + if (EFI_ERROR(err)) + return err; + } + + buf = AllocatePool(buflen); + err = uefi_call_wrapper(handle->Read, 3, handle, &buflen, buf); + if (!EFI_ERROR(err)) { + buf[buflen] = '\0'; + *content = buf; + len = buflen; + } else { + len = err; + FreePool(buf); + } + + uefi_call_wrapper(handle->Close, 1, handle); + return len; +} diff --git a/gummiboot-nomachineid-48/src/efi/util.h b/gummiboot-nomachineid-48/src/efi/util.h new file mode 100644 index 0000000..91757c4 --- /dev/null +++ b/gummiboot-nomachineid-48/src/efi/util.h @@ -0,0 +1,44 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/* + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * Copyright (C) 2012-2013 Kay Sievers + * Copyright (C) 2012 Harald Hoyer + */ + +#ifndef __GUMMIBOOT_UTIL_H +#define __GUMMIBOOT_UTIL_H + +#include +#include + +#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) + +UINT64 ticks_read(void); +UINT64 ticks_freq(void); +UINT64 time_usec(void); + +EFI_STATUS efivar_set(CHAR16 *name, CHAR16 *value, BOOLEAN persistent); +EFI_STATUS efivar_set_raw(const EFI_GUID *vendor, CHAR16 *name, CHAR8 *buf, UINTN size, BOOLEAN persistent); +EFI_STATUS efivar_set_int(CHAR16 *name, UINTN i, BOOLEAN persistent); +VOID efivar_set_time_usec(CHAR16 *name, UINT64 usec); + +EFI_STATUS efivar_get(CHAR16 *name, CHAR16 **value); +EFI_STATUS efivar_get_raw(const EFI_GUID *vendor, CHAR16 *name, CHAR8 **buffer, UINTN *size); +EFI_STATUS efivar_get_int(CHAR16 *name, UINTN *i); + +CHAR8 *strchra(CHAR8 *s, CHAR8 c); +CHAR16 *stra_to_path(CHAR8 *stra); +CHAR16 *stra_to_str(CHAR8 *stra); + +INTN file_read(EFI_FILE_HANDLE dir, CHAR16 *name, UINTN off, UINTN size, CHAR8 **content); +#endif diff --git a/gummiboot-nomachineid-48/src/setup/efivars.c b/gummiboot-nomachineid-48/src/setup/efivars.c new file mode 100644 index 0000000..7123257 --- /dev/null +++ b/gummiboot-nomachineid-48/src/setup/efivars.c @@ -0,0 +1,647 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2013 Lennart Poettering + Copyright 2013 Kay Sievers + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "efivars.h" + +bool is_efi_boot(void) { + return access("/sys/firmware/efi", F_OK) >= 0; +} + +static int read_flag(const char *varname) { + int r; + void *v; + size_t s; + uint8_t b; + + r = efi_get_variable(EFI_VENDOR_GLOBAL, varname, &v, &s); + if (r < 0) + return r; + + if (s != 1) { + r = -EINVAL; + goto finish; + } + + b = *(uint8_t *)v; + r = b > 0; +finish: + free(v); + return r; +} + +int is_efi_secure_boot(void) { + return read_flag("SecureBoot"); +} + +int is_efi_secure_boot_setup_mode(void) { + return read_flag("SetupMode"); +} + +int efi_get_variable( + const uint8_t vendor[16], + const char *name, + void **value, + size_t *size) { + + int fd = -1; + char *p = NULL; + uint32_t a; + ssize_t n; + struct stat st; + void *b; + int r; + + assert(name); + assert(value); + assert(size); + + if (asprintf(&p, + "/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + name, + vendor[0], vendor[1], vendor[2], vendor[3], vendor[4], vendor[5], vendor[6], vendor[7], + vendor[8], vendor[9], vendor[10], vendor[11], vendor[12], vendor[13], vendor[14], vendor[15]) < 0) + return -ENOMEM; + + fd = open(p, O_RDONLY|O_NOCTTY|O_CLOEXEC); + if (fd < 0) { + r = -errno; + goto finish; + } + + if (fstat(fd, &st) < 0) { + r = -errno; + goto finish; + } + if (st.st_size < 4) { + r = -EIO; + goto finish; + } + if (st.st_size > 4*1024*1024 + 4) { + r = -E2BIG; + goto finish; + } + + n = read(fd, &a, sizeof(a)); + if (n < 0) { + r = errno; + goto finish; + } + if (n != sizeof(a)) { + r = -EIO; + goto finish; + } + + b = malloc(st.st_size - 4 + 2); + if (!b) { + r = -ENOMEM; + goto finish; + } + + n = read(fd, b, (size_t) st.st_size - 4); + if (n < 0) { + free(b); + r = errno; + goto finish; + } + if (n != (ssize_t) st.st_size - 4) { + free(b); + r = -EIO; + goto finish; + } + + /* Always NUL terminate (2 bytes, to protect UTF-16) */ + ((char*) b)[st.st_size - 4] = 0; + ((char*) b)[st.st_size - 4 + 1] = 0; + + *value = b; + *size = (size_t) st.st_size - 4; + r = 0; + +finish: + if (fd >= 0) + close(fd); + free(p); + return r; +} + +int efi_set_variable( + const uint8_t vendor[16], + const char *name, + const void *value, + size_t size) { + + struct var { + uint32_t attr; + char buf[]; + } __attribute__((packed)) *buf = NULL; + char *p = NULL; + int fd = -1; + int r; + + assert(vendor); + assert(name); + + if (asprintf(&p, + "/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + name, + vendor[0], vendor[1], vendor[2], vendor[3], vendor[4], vendor[5], vendor[6], vendor[7], + vendor[8], vendor[9], vendor[10], vendor[11], vendor[12], vendor[13], vendor[14], vendor[15]) < 0) + return -ENOMEM; + + if (size == 0) { + r = unlink(p); + goto finish; + } + + fd = open(p, O_WRONLY|O_CREAT|O_NOCTTY|O_CLOEXEC, 0644); + if (fd < 0) { + r = -errno; + goto finish; + } + + buf = malloc(sizeof(uint32_t) + size); + if (!buf) { + r = -errno; + goto finish; + } + + buf->attr = EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS; + memcpy(buf->buf, value, size); + + r = write(fd, buf, sizeof(uint32_t) + size); + if (r < 0) { + r = -errno; + goto finish; + } + + if ((size_t)r != sizeof(uint32_t) + size) { + r = -EIO; + goto finish; + } + +finish: + if (fd >= 0) + close(fd); + free(buf); + free(p); + return r; +} + +int efi_get_variable_string(const uint8_t vendor[16], const char *name, char **p) { + void *s = NULL; + size_t ss; + char *x; + int r; + + r = efi_get_variable(vendor, name, &s, &ss); + if (r < 0) + return r; + + x = utf16_to_utf8(s, ss); + free(s); + if (!x) + return -ENOMEM; + + *p = x; + return 0; +} + +static size_t utf16_size(const uint16_t *s) { + size_t l = 0; + + while (s[l] > 0) + l++; + + return (l+1) * sizeof(uint16_t); +} + +struct guid { + uint32_t u1; + uint16_t u2; + uint16_t u3; + uint8_t u4[8]; +} __attribute__((packed)); + +static void efi_guid_to_id128(const void *guid, uint8_t *bytes) { + const struct guid *uuid = guid; + + bytes[0] = (uuid->u1 >> 24) & 0xff; + bytes[1] = (uuid->u1 >> 16) & 0xff; + bytes[2] = (uuid->u1 >> 8) & 0xff; + bytes[3] = (uuid->u1) & 0xff; + bytes[4] = (uuid->u2 >> 8) & 0xff; + bytes[5] = (uuid->u2) & 0xff; + bytes[6] = (uuid->u3 >> 8) & 0xff; + bytes[7] = (uuid->u3) & 0xff; + memcpy(bytes+8, uuid->u4, sizeof(uuid->u4)); +} + +static void id128_to_efi_guid(const uint8_t *bytes, void *guid) { + struct guid *uuid = guid; + + uuid->u1 = bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]; + uuid->u2 = bytes[4] << 8 | bytes[5]; + uuid->u3 = bytes[6] << 8 | bytes[7]; + memcpy(uuid->u4, bytes+8, sizeof(uuid->u4)); +} + +char *tilt_backslashes(char *s) { + char *p; + + for (p = s; *p; p++) + if (*p == '\\') + *p = '/'; + + return s; +} + +uint16_t *tilt_slashes(uint16_t *s) { + uint16_t *p; + + for (p = s; *p; p++) + if (*p == '/') + *p = '\\'; + + return s; +} + +#define LOAD_OPTION_ACTIVE 0x00000001 +#define MEDIA_DEVICE_PATH 0x04 +#define MEDIA_HARDDRIVE_DP 0x01 +#define MEDIA_FILEPATH_DP 0x04 +#define SIGNATURE_TYPE_GUID 0x02 +#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02 +#define END_DEVICE_PATH_TYPE 0x7f +#define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xff + +struct boot_option { + uint32_t attr; + uint16_t path_len; + uint16_t title[]; +} __attribute__((packed)); + +struct drive_path { + uint32_t part_nr; + uint64_t part_start; + uint64_t part_size; + char signature[16]; + uint8_t mbr_type; + uint8_t signature_type; +} __attribute__((packed)); + +struct device_path { + uint8_t type; + uint8_t sub_type; + uint16_t length; + union { + uint16_t path[0]; + struct drive_path drive; + }; +} __attribute__((packed)); + +int efi_get_boot_option(uint16_t id, char **title, uint8_t part_uuid[16], char **path, bool *active) { + char boot_id[9]; + uint8_t *buf = NULL; + size_t l; + struct boot_option *header; + size_t title_size; + char *s = NULL; + char *p = NULL; + uint8_t p_uuid[16] = ""; + int err; + + snprintf(boot_id, sizeof(boot_id), "Boot%04X", id); + err = efi_get_variable(EFI_VENDOR_GLOBAL, boot_id, (void **) &buf, &l); + if (err < 0) + return err; + if (l < sizeof(struct boot_option)) { + err = -ENOENT; + goto err; + } + + header = (struct boot_option *) buf; + title_size = utf16_size(header->title); + if (title_size > l - offsetof(struct boot_option, title)) { + err = -EINVAL; + goto err; + } + + s = utf16_to_utf8(header->title, title_size); + if (!s) { + err = -ENOMEM; + goto err; + } + + if (header->path_len > 0) { + uint8_t *dbuf; + size_t dnext; + + dbuf = buf + offsetof(struct boot_option, title) + title_size; + dnext = 0; + while (dnext < header->path_len) { + struct device_path *dpath; + + dpath = (struct device_path *)(dbuf + dnext); + if (dpath->length < 4) + break; + + /* Type 0x7F – End of Hardware Device Path, Sub-Type 0xFF – End Entire Device Path */ + if (dpath->type == END_DEVICE_PATH_TYPE && dpath->sub_type == END_ENTIRE_DEVICE_PATH_SUBTYPE) + break; + + dnext += dpath->length; + + if (dpath->type != MEDIA_DEVICE_PATH) + continue; + + if (dpath->sub_type == MEDIA_HARDDRIVE_DP) { + /* GPT Partition Table */ + if (dpath->drive.mbr_type != MBR_TYPE_EFI_PARTITION_TABLE_HEADER) + continue; + + if (dpath->drive.signature_type != SIGNATURE_TYPE_GUID) + continue; + + efi_guid_to_id128(dpath->drive.signature, p_uuid); + continue; + } + + if (dpath->sub_type == MEDIA_FILEPATH_DP) { + p = utf16_to_utf8(dpath->path, dpath->length-4); + tilt_backslashes(p); + continue; + } + } + } + + if (title) + *title = s; + else + free(s); + + if (part_uuid) + memcpy(part_uuid, p_uuid, 16); + + if (path) + *path = p; + else + free(p); + + if (active) + *active = !!header->attr & LOAD_OPTION_ACTIVE; + + free(buf); + return 0; +err: + free(s); + free(p); + free(buf); + return err; +} + +static void to_utf16(uint16_t *dest, const char *src) { + int i; + + for (i = 0; src[i] != '\0'; i++) + dest[i] = src[i]; + dest[i] = '\0'; +} + +int efi_add_boot_option(uint16_t id, const char *title, + uint32_t part, uint64_t pstart, uint64_t psize, + const uint8_t part_uuid[16], + const char *path) { + char boot_id[9]; + char *buf; + size_t size; + size_t title_len; + size_t path_len; + struct boot_option *option; + struct device_path *devicep; + int err; + + title_len = (strlen(title)+1) * 2; + path_len = (strlen(path)+1) * 2; + + buf = calloc(sizeof(struct boot_option) + title_len + + sizeof(struct drive_path) + + sizeof(struct device_path) + path_len, 1); + if (!buf) { + err = -ENOMEM; + goto finish; + } + + /* header */ + option = (struct boot_option *)buf; + option->attr = LOAD_OPTION_ACTIVE; + option->path_len = offsetof(struct device_path, drive) + sizeof(struct drive_path) + + offsetof(struct device_path, path) + path_len + + offsetof(struct device_path, path); + to_utf16(option->title, title); + size = offsetof(struct boot_option, title) + title_len; + + /* partition info */ + devicep = (struct device_path *)(buf + size); + devicep->type = MEDIA_DEVICE_PATH; + devicep->sub_type = MEDIA_HARDDRIVE_DP; + devicep->length = offsetof(struct device_path, drive) + sizeof(struct drive_path); + devicep->drive.part_nr = part; + devicep->drive.part_start = pstart; + devicep->drive.part_size = psize; + devicep->drive.signature_type = SIGNATURE_TYPE_GUID; + devicep->drive.mbr_type = MBR_TYPE_EFI_PARTITION_TABLE_HEADER; + id128_to_efi_guid(part_uuid, devicep->drive.signature); + size += devicep->length; + + /* path to loader */ + devicep = (struct device_path *)(buf + size); + devicep->type = MEDIA_DEVICE_PATH; + devicep->sub_type = MEDIA_FILEPATH_DP; + devicep->length = offsetof(struct device_path, path) + path_len; + to_utf16(devicep->path, path); + tilt_slashes(devicep->path); + size += devicep->length; + + /* end of path */ + devicep = (struct device_path *)(buf + size); + devicep->type = END_DEVICE_PATH_TYPE; + devicep->sub_type = END_ENTIRE_DEVICE_PATH_SUBTYPE; + devicep->length = offsetof(struct device_path, path); + size += devicep->length; + + snprintf(boot_id, sizeof(boot_id), "Boot%04X", id); + err = efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, buf, size); + +finish: + free(buf); + return err; +} + +int efi_remove_boot_option(uint16_t id) { + char boot_id[9]; + + snprintf(boot_id, sizeof(boot_id), "Boot%04X", id); + return efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, 0); +} + +int efi_get_boot_order(uint16_t **order) { + void *buf; + size_t l; + int r; + + r = efi_get_variable(EFI_VENDOR_GLOBAL, "BootOrder", &buf, &l); + if (r < 0) + return r; + + if (l <= 0) { + free(buf); + return -ENOENT; + } + + if ((l % sizeof(uint16_t) > 0)) { + free(buf); + return -EINVAL; + } + + *order = buf; + return (int) (l / sizeof(uint16_t)); +} + +int efi_set_boot_order(uint16_t *order, size_t n) { + return efi_set_variable(EFI_VENDOR_GLOBAL, "BootOrder", order, n * sizeof(uint16_t)); +} + +static int boot_id_hex(const char s[4]) { + int i; + int id = 0; + + for (i = 0; i < 4; i++) + if (s[i] >= '0' && s[i] <= '9') + id |= (s[i] - '0') << (3 - i) * 4; + else if (s[i] >= 'A' && s[i] <= 'F') + id |= (s[i] - 'A' + 10) << (3 - i) * 4; + else + return -1; + + return id; +} + +static int cmp_uint16(const void *_a, const void *_b) { + const uint16_t *a = _a, *b = _b; + + return (int)*a - (int)*b; +} + +int efi_get_boot_options(uint16_t **options) { + DIR *dir; + struct dirent *de; + uint16_t *list = NULL; + int count = 0; + + assert(options); + + dir = opendir("/sys/firmware/efi/efivars/"); + if (!dir) + return -errno; + + while ((de = readdir(dir))) { + int id; + uint16_t *t; + + if (strncmp(de->d_name, "Boot", 4) != 0) + continue; + + if (strlen(de->d_name) != 45) + continue; + + if (strcmp(de->d_name + 8, "-8be4df61-93ca-11d2-aa0d-00e098032b8c") != 0) + continue; + + id = boot_id_hex(de->d_name + 4); + if (id < 0) + continue; + + t = realloc(list, (count + 1) * sizeof(uint16_t)); + if (!t) { + free(list); + closedir(dir); + return -ENOMEM; + } + list = t; + + list[count++] = id; + } + + closedir(dir); + qsort(list, count, sizeof(uint16_t), cmp_uint16); + *options = list; + + return count; +} + +char *utf16_to_utf8(const void *s, size_t length) { + char *r; + const uint8_t *f; + uint8_t *t; + + r = malloc((length*3+1)/2 + 1); + if (!r) + return NULL; + + t = (uint8_t*) r; + + for (f = s; f < (const uint8_t*) s + length; f += 2) { + uint16_t c; + + c = (f[1] << 8) | f[0]; + + if (c == 0) { + *t = 0; + return r; + } else if (c < 0x80) { + *(t++) = (uint8_t) c; + } else if (c < 0x800) { + *(t++) = (uint8_t) (0xc0 | (c >> 6)); + *(t++) = (uint8_t) (0x80 | (c & 0x3f)); + } else { + *(t++) = (uint8_t) (0xe0 | (c >> 12)); + *(t++) = (uint8_t) (0x80 | ((c >> 6) & 0x3f)); + *(t++) = (uint8_t) (0x80 | (c & 0x3f)); + } + } + + *t = 0; + + return r; +} diff --git a/gummiboot-nomachineid-48/src/setup/efivars.h b/gummiboot-nomachineid-48/src/setup/efivars.h new file mode 100644 index 0000000..dfe7355 --- /dev/null +++ b/gummiboot-nomachineid-48/src/setup/efivars.h @@ -0,0 +1,55 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +#pragma once + +/*** + This file is part of systemd. + + Copyright 2013 Lennart Poettering + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include + +#define EFI_VARIABLE_NON_VOLATILE 0x0000000000000001 +#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002 +#define EFI_VARIABLE_RUNTIME_ACCESS 0x0000000000000004 + +#define EFI_VENDOR_GLOBAL ((uint8_t[16]) { 0x8b,0xe4,0xdf,0x61,0x93,0xca,0x11,0xd2,0xaa,0x0d,0x00,0xe0,0x98,0x03,0x2b,0x8c }) +#define EFI_VENDOR_LOADER ((uint8_t[16]) { 0x4a,0x67,0xb0,0x82,0x0a,0x4c,0x41,0xcf,0xb6,0xc7,0x44,0x0b,0x29,0xbb,0x8c,0x4f }) + +bool is_efi_boot(void); +int is_efi_secure_boot(void); +int is_efi_secure_boot_setup_mode(void); +int efi_get_variable(const uint8_t vendor[16], const char *name, void **value, size_t *size); +int efi_set_variable( const uint8_t vendor[16], const char *name, const void *value, size_t size); +int efi_get_variable_string(const uint8_t vendor[16], const char *name, char **p); +int efi_get_boot_option(uint16_t id, char **title, uint8_t part_uuid[16], char **path, bool *active); + +int efi_get_boot_options(uint16_t **options); +int efi_add_boot_option(uint16_t id, const char *title, + uint32_t part, uint64_t pstart, uint64_t psize, + const uint8_t part_uuid[16], + const char *path); +int efi_remove_boot_option(uint16_t id); + +int efi_get_boot_order(uint16_t **order); +int efi_set_boot_order(uint16_t *order, size_t n); + +char *utf16_to_utf8(const void *s, size_t length); +char *tilt_backslashes(char *s); +uint16_t *tilt_slashes(uint16_t *s); diff --git a/gummiboot-nomachineid-48/src/setup/setup.c b/gummiboot-nomachineid-48/src/setup/setup.c new file mode 100644 index 0000000..e4142e9 --- /dev/null +++ b/gummiboot-nomachineid-48/src/setup/setup.c @@ -0,0 +1,1425 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2013 Lennart Poettering + Copyright 2013 Kay Sievers + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "efivars.h" + +#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) +#define streq(a,b) (strcmp((a),(b)) == 0) +#define UUID_EMPTY ((uint8_t[16]) {}) + +static inline bool streq_ptr(const char *a, const char *b) { + if (a && b) + return streq(a, b); + if (!a && !b) + return true; + return false; +} + +static inline bool isempty(const char *p) { + return !p || !p[0]; +} + +static inline const char *strna(const char *s) { + return isempty(s) ? "n/a" : s; +} + +static int uuid_parse(const char *s, uint8_t uuid[16]) { + int u[16]; + int i; + + if (sscanf(s, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + &u[0], &u[1], &u[2], &u[3], &u[4], &u[5], &u[6], &u[7], + &u[8], &u[9], &u[10], &u[11], &u[12], &u[13], &u[14], &u[15]) != 16) + return -EINVAL; + + for (i = 0; i < 16; i++) + uuid[i] = u[i]; + + return 0; +} + +static int verify_esp(const char *p, uint32_t *part, uint64_t *pstart, uint64_t *psize, uint8_t uuid[16]) { + struct statfs sfs; + struct stat st, st2; + char *t; + blkid_probe b = NULL; + int r; + const char *v; + + if (statfs(p, &sfs) < 0) { + fprintf(stderr, "Failed to check file system type of %s: %m\n", p); + return -errno; + } + + if (sfs.f_type != 0x4d44) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + if (stat(p, &st) < 0) { + fprintf(stderr, "Failed to determine block device node of %s: %m\n", p); + return -errno; + } + + if (major(st.st_dev) == 0) { + fprintf(stderr, "Block device node of %p is invalid.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "%s/..", p); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = stat(t, &st2); + free(t); + if (r < 0) { + fprintf(stderr, "Failed to determine block device node of parent of %s: %m\n", p); + return -errno; + } + + if (st.st_dev == st2.st_dev) { + fprintf(stderr, "Directory %s is not the root of the EFI System Partition (ESP) file system.\n", p); + return -ENODEV; + } + + r = asprintf(&t, "/dev/block/%u:%u", major(st.st_dev), minor(st.st_dev)); + if (r < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + errno = 0; + b = blkid_new_probe_from_filename(t); + free(t); + if (!b) { + if (errno != 0) { + fprintf(stderr, "Failed to open file system %s: %m\n", p); + return -errno; + } + + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + blkid_probe_enable_superblocks(b, 1); + blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE); + blkid_probe_enable_partitions(b, 1); + blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS); + + errno = 0; + r = blkid_do_safeprobe(b); + if (r == -2) { + fprintf(stderr, "File system %s is ambigious.\n", p); + r = -ENODEV; + goto fail; + } else if (r == 1) { + fprintf(stderr, "File system %s does not contain a label.\n", p); + r = -ENODEV; + goto fail; + } else if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system %s: %s\n", p, strerror(-r)); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe file system type %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "vfat") != 0) { + fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system after all.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SCHEME", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition scheme %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "gpt") != 0) { + fprintf(stderr, "File system %s is not on a GPT partition table.\n", p); + r = -ENODEV; + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition type UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + + if (strcmp(v, "c12a7328-f81f-11d2-ba4b-00a0c93ec93b") != 0) { + r = -ENODEV; + fprintf(stderr, "File system %s is not an EFI System Partition (ESP).\n", p); + goto fail; + } + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_UUID", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition entry UUID %s: %s\n", p, strerror(-r)); + goto fail; + } + uuid_parse(v, uuid); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_NUMBER", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition number %s: %s\n", p, strerror(-r)); + goto fail; + } + *part = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_OFFSET", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition offset %s: %s\n", p, strerror(-r)); + goto fail; + } + *pstart = strtoul(v, NULL, 10); + + errno = 0; + r = blkid_probe_lookup_value(b, "PART_ENTRY_SIZE", &v, NULL); + if (r != 0) { + r = errno ? -errno : -EIO; + fprintf(stderr, "Failed to probe partition size %s: %s\n", p, strerror(-r)); + goto fail; + } + *psize = strtoul(v, NULL, 10); + + blkid_free_probe(b); + return 0; +fail: + if (b) + blkid_free_probe(b); + return r; +} + +/* search for "#### LoaderInfo: gummiboot 31 ####" string inside the binary */ +static int get_file_version(FILE *f, char **v) { + struct stat st; + char *buf; + const char *s, *e; + char *x = NULL; + int r = 0; + + assert(f); + assert(v); + + if (fstat(fileno(f), &st) < 0) + return -errno; + + if (st.st_size < 27) + return 0; + + buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fileno(f), 0); + if (buf == MAP_FAILED) + return -errno; + + s = memmem(buf, st.st_size - 8, "#### LoaderInfo: ", 17); + if (!s) + goto finish; + s += 17; + + e = memmem(s, st.st_size - (s - buf), " ####", 5); + if (!e || e - s < 3) { + fprintf(stderr, "Malformed version string.\n"); + r = -EINVAL; + goto finish; + } + + x = strndup(s, e - s); + if (!x) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + r = 1; + +finish: + munmap(buf, st.st_size); + *v = x; + return r; +} + +static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".efi") != 0) + continue; + + if (prefix && strncasecmp(de->d_name, prefix, strlen(prefix)) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s/%s", esp_path, path, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0) + printf(" File: └─/%s/%s (%s)\n", path, de->d_name, v); + else + printf(" File: └─/%s/%s\n", path, de->d_name); + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + + free(p); + free(q); + return r; +} + +static int status_binaries(const char *esp_path, uint8_t partition[16]) { + int r; + + printf("Boot Loader Binaries:\n"); + + printf(" ESP: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + + r = enumerate_binaries(esp_path, "EFI/gummiboot", NULL); + if (r == 0) + fprintf(stderr, "Gummiboot not installed in ESP.\n"); + else if (r < 0) + return r; + + r = enumerate_binaries(esp_path, "EFI/Boot", "boot"); + if (r == 0) + fprintf(stderr, "No default/fallback boot loader installed in ESP.\n"); + else if (r < 0) + return r; + + printf("\n"); + return 0; +} + +static int print_efi_option(uint16_t id, bool in_order) { + char *title = NULL; + char *path = NULL; + uint8_t partition[16]; + bool active; + int r = 0; + + r = efi_get_boot_option(id, &title, partition, &path, &active); + if (r < 0) + goto finish; + + /* print only configured entries with partition information */ + if (!path || memcmp(partition, UUID_EMPTY, 16) == 0) + return 0; + + printf(" Title: %s\n", strna(title)); + printf(" ID: 0x%04X\n", id); + printf(" Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : ""); + printf(" Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", + partition[0], partition[1], partition[2], partition[3], partition[4], partition[5], partition[6], partition[7], + partition[8], partition[9], partition[10], partition[11], partition[12], partition[13], partition[14], partition[15]); + printf(" File: └─%s\n", path); + printf("\n"); + +finish: + free(title); + free(path); + return r; +} + +static int status_variables(void) { + int n_options, n_order; + uint16_t *options = NULL, *order = NULL; + int r, i; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, not showing EFI variables.\n"); + return 0; + } + + n_options = efi_get_boot_options(&options); + if (n_options < 0) { + if (n_options == -ENOENT) + fprintf(stderr, "Failed to access EFI variables, " + "efivarfs needs to be available at /sys/firmware/efi/efivars/.\n"); + else + fprintf(stderr, "Failed to read EFI boot entries: %s\n", strerror(-n_options)); + r = n_options; + goto finish; + } + + printf("Boot Loader Entries in EFI Variables:\n"); + n_order = efi_get_boot_order(&order); + if (n_order == -ENOENT) { + n_order = 0; + } else if (n_order < 0) { + fprintf(stderr, "Failed to read EFI boot order.\n"); + r = n_order; + goto finish; + } + + /* print entries in BootOrder first */ + for (i = 0; i < n_order; i++) + print_efi_option(order[i], true); + + /* print remaining entries */ + for (i = 0; i < n_options; i++) { + int j; + bool found = false; + + for (j = 0; j < n_order; j++) + if (options[i] == order[j]) { + found = true; + break; + } + + if (found) + continue; + + print_efi_option(options[i], false); + } + + r = 0; +finish: + free(options); + free(order); + + return r; +} + +static int compare_product(const char *a, const char *b) { + size_t x, y; + + assert(a); + assert(b); + + x = strcspn(a, " "); + y = strcspn(b, " "); + if (x != y) + return x < y ? -1 : x > y ? 1 : 0; + + return strncmp(a, b, x); +} + +static int compare_version(const char *a, const char *b) { + assert(a); + assert(b); + + a += strcspn(a, " "); + a += strspn(a, " "); + b += strcspn(b, " "); + b += strspn(b, " "); + + return strverscmp(a, b); +} + +static int version_check(FILE *f, const char *from, const char *to) { + FILE *g = NULL; + char *a = NULL, *b = NULL; + int r; + + assert(f); + assert(from); + assert(to); + + r = get_file_version(f, &a); + if (r < 0) + goto finish; + if (r == 0) { + r = -EINVAL; + fprintf(stderr, "Source file %s does not carry version information!\n", from); + goto finish; + } + + g = fopen(to, "re"); + if (!g) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + r = -errno; + fprintf(stderr, "Failed to open %s for reading: %m\n", to); + goto finish; + } + + r = get_file_version(g, &b); + if (r < 0) + goto finish; + if (r == 0 || compare_product(a, b) != 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's owned by another boot loader.\n", to); + goto finish; + } + + if (compare_version(a, b) < 0) { + r = -EEXIST; + fprintf(stderr, "Skipping %s, since it's a newer boot loader version already.\n", to); + goto finish; + } + + r = 0; + +finish: + free(a); + free(b); + if (g) + fclose(g); + return r; +} + +static int copy_file(const char *from, const char *to, bool force) { + FILE *f = NULL, *g = NULL; + char *p = NULL; + int r; + struct timespec t[2]; + struct stat st; + + assert(from); + assert(to); + + f = fopen(from, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", from); + return -errno; + } + + if (!force) { + /* If this is an update, then let's compare versions first */ + r = version_check(f, from, to); + if (r < 0) + goto finish; + } + + if (asprintf(&p, "%s~", to) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + g = fopen(p, "wxe"); + if (!g) { + /* Directory doesn't exist yet? Then let's skip this... */ + if (!force && errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to open %s for writing: %m\n", to); + r = -errno; + goto finish; + } + + rewind(f); + do { + size_t k; + uint8_t buf[32*1024]; + + k = fread(buf, 1, sizeof(buf), f); + if (ferror(f)) { + fprintf(stderr, "Failed to read %s: %m\n", from); + r = -errno; + goto finish; + } + if (k == 0) + break; + + fwrite(buf, 1, k, g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + } while (!feof(f)); + + fflush(g); + if (ferror(g)) { + fprintf(stderr, "Failed to write %s: %m\n", to); + r = -errno; + goto finish; + } + + r = fstat(fileno(f), &st); + if (r < 0) { + fprintf(stderr, "Failed to get file timestamps of %s: %m", from); + r = -errno; + goto finish; + } + + t[0] = st.st_atim; + t[1] = st.st_mtim; + + r = futimens(fileno(g), t); + if (r < 0) { + fprintf(stderr, "Failed to change file timestamps for %s: %m", p); + r = -errno; + goto finish; + } + + if (rename(p, to) < 0) { + fprintf(stderr, "Failed to rename %s to %s: %m\n", p, to); + r = -errno; + goto finish; + } + + fprintf(stderr, "Copied %s to %s.\n", from, to); + + free(p); + p = NULL; + r = 0; + +finish: + if (f) + fclose(f); + if (g) + fclose(g); + if (p) { + unlink(p); + free(p); + } + return r; +} + +static int normalize_filename_case(char *name) { + char *base_start; + char *base; + DIR *d; + struct dirent *de; + + base_start = strrchr(name, '/'); + base = base_start + 1; + + *base_start = 0; + d = opendir(name); + *base_start = '/'; + + if (d == NULL) + return -errno; + + while ((de = readdir(d))) { + /* Normalize (only) the base name of the given path */ + if (strcasecmp(de->d_name, base) == 0) { + strcpy(base, de->d_name); + break; + } + } + + closedir(d); + + return 0; +} + +static int mkdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (mkdir(p, 0700) < 0) { + if (errno != EEXIST) { + fprintf(stderr, "Failed to create %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Created %s.\n", p); + + free(p); + return 0; +} + +static int create_dirs(const char *esp_path) { + int r; + + r = mkdir_one(esp_path, "EFI"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/gummiboot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "EFI/Boot"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader"); + if (r < 0) + return r; + + r = mkdir_one(esp_path, "loader/entries"); + if (r < 0) + return r; + + return 0; +} + +static int copy_one_file(const char *esp_path, const char *name, bool force) { + char *p = NULL, *q = NULL, *v = NULL; + int r; + + if (asprintf(&p, GUMMIBOOTLIBDIR "/%s", name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + if (asprintf(&q, "%s/EFI/gummiboot/%s", esp_path, name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + r = copy_file(p, q, force); + + if (strncmp(name, "gummiboot", 9) == 0) { + int k; + + /* Create the EFI default boot loader name (specified for removable devices) */ + if (asprintf(&v, "%s/EFI/Boot/%s", esp_path, name + 5) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + normalize_filename_case(v); + + k = copy_file(p, v, force); + if (k < 0 && r == 0) { + r = k; + goto finish; + } + } + +finish: + free(p); + free(q); + free(v); + return r; +} + +static int install_binaries(const char *esp_path, bool force) { + struct dirent *de; + DIR *d; + 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(GUMMIBOOTLIBDIR); + if (!d) { + fprintf(stderr, "Failed to open "GUMMIBOOTLIBDIR": %m\n"); + return -errno; + } + + while ((de = readdir(d))) { + size_t n; + int k; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcmp(de->d_name + n - 4, ".efi") != 0) + continue; + + k = copy_one_file(esp_path, de->d_name, force); + if (k < 0 && r == 0) + r = k; + } + + closedir(d); + return r; +} + +static bool same_entry(uint16_t id, const uint8_t uuid[16], const char *path) { + char *opath = NULL; + uint8_t ouuid[16]; + int err; + bool same = false; + + err = efi_get_boot_option(id, NULL, ouuid, &opath, NULL); + if (err < 0) + return false; + if (memcmp(uuid, ouuid, 16) != 0) + goto finish; + + if (!streq_ptr(path, opath)) + goto finish; + + same = true; + +finish: + free(opath); + return same; +} + +static int find_slot(const uint8_t uuid[16], const char *path, uint16_t *id) { + uint16_t *options = NULL; + int n_options; + int i; + uint16_t new_id = 0; + bool existing = false; + + n_options = efi_get_boot_options(&options); + if (n_options < 0) + return n_options; + + /* find already existing gummiboot entry */ + for (i = 0; i < n_options; i++) + if (same_entry(options[i], uuid, path)) { + new_id = options[i]; + existing = true; + goto finish; + } + + /* find free slot in the sorted BootXXXX variable list */ + for (i = 0; i < n_options; i++) + if (i != options[i]) { + new_id = i; + goto finish; + } + + /* use the next one */ + if (i == 0xffff) + return -ENOSPC; + new_id = i; + +finish: + *id = new_id; + free(options); + return existing; +} + +static int insert_into_order(uint16_t slot, bool first) { + uint16_t *order = NULL; + uint16_t *new_order; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order <= 0) { + /* no entry, add us */ + err = efi_set_boot_order(&slot, 1); + goto finish; + } + + /* are we the first and only one? */ + if (n_order == 1 && order[0] == slot) + goto finish; + + /* are we already in the boot order? */ + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + /* we do not require to be the first one, all is fine */ + if (!first) + goto finish; + + /* move us to the first slot */ + memmove(&order[1], order, i * sizeof(uint16_t)); + order[0] = slot; + efi_set_boot_order(order, n_order); + goto finish; + } + + /* extend array */ + new_order = realloc(order, (n_order+1) * sizeof(uint16_t)); + if (!new_order) { + err = -ENOMEM; + goto finish; + } + order = new_order; + + /* add us to the top or end of the list */ + if (first) { + memmove(&order[1], order, n_order * sizeof(uint16_t)); + order[0] = slot; + } else + order[n_order] = slot; + + efi_set_boot_order(order, n_order+1); + +finish: + free(order); + return err; +} + +static int remove_from_order(uint16_t slot) { + uint16_t *order = NULL; + int n_order; + int i; + int err = 0; + + n_order = efi_get_boot_order(&order); + if (n_order < 0) + return n_order; + if (n_order == 0) + return 0; + + for (i = 0; i < n_order; i++) { + if (order[i] != slot) + continue; + + if (i+1 < n_order) + memmove(&order[i], &order[i+1], (n_order - i) * sizeof(uint16_t)); + efi_set_boot_order(order, n_order-1); + break; + } + + free(order); + return err; +} + +static int install_variables(const char *esp_path, + uint32_t part, uint64_t pstart, uint64_t psize, + const uint8_t uuid[16], const char *path, + bool first) { + char *p = NULL; + uint16_t *options = NULL; + uint16_t slot; + int r; + + if (!is_efi_boot()) { + fprintf(stderr, "Not booted with EFI, skipping EFI variable setup.\n"); + return 0; + } + + if (asprintf(&p, "%s%s", esp_path, path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (access(p, F_OK) < 0) { + if (errno == ENOENT) + r = 0; + else + r = -errno; + goto finish; + } + + r = find_slot(uuid, path, &slot); + if (r < 0) { + if (r == -ENOENT) + fprintf(stderr, "Failed to access EFI variables. Is the \"efivarfs\" filesystem mounted?\n"); + else + fprintf(stderr, "Failed to determine current boot order: %s\n", strerror(-r)); + goto finish; + } + + if (first || r == false) { + r = efi_add_boot_option(slot, "Linux Boot Manager", + part, pstart, psize, + uuid, path); + if (r < 0) { + fprintf(stderr, "Failed to create EFI Boot variable entry: %s\n", strerror(-r)); + goto finish; + } + fprintf(stderr, "Created EFI boot entry \"Linux Boot Manager\".\n"); + } + + insert_into_order(slot, first); + +finish: + free(p); + free(options); + return r; +} + +static int delete_nftw(const char *path, const struct stat *sb, int typeflag, struct FTW *ftw) { + int r; + + if (typeflag == FTW_D || typeflag == FTW_DNR || typeflag == FTW_DP) + r = rmdir(path); + else + r = unlink(path); + + if (r < 0) + fprintf(stderr, "Failed to remove %s: %m\n", path); + else + fprintf(stderr, "Removed %s.\n", path); + + return 0; +} + +static int rm_rf(const char *p) { + nftw(p, delete_nftw, 20, FTW_DEPTH|FTW_MOUNT|FTW_PHYS); + return 0; +} + +static int remove_boot_efi(const char *esp_path) { + struct dirent *de; + char *p = NULL, *q = NULL; + DIR *d = NULL; + int r = 0, c = 0; + + if (asprintf(&p, "%s/EFI/Boot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + d = opendir(p); + if (!d) { + if (errno == ENOENT) { + r = 0; + goto finish; + } + + fprintf(stderr, "Failed to read %s: %m\n", p); + r = -errno; + goto finish; + } + + while ((de = readdir(d))) { + char *v; + size_t n; + FILE *f; + + if (de->d_name[0] == '.') + continue; + + n = strlen(de->d_name); + if (n < 4 || strcasecmp(de->d_name + n - 4, ".EFI") != 0) + continue; + + if (strncasecmp(de->d_name, "Boot", 4) != 0) + continue; + + free(q); + q = NULL; + if (asprintf(&q, "%s/%s", p, de->d_name) < 0) { + fprintf(stderr, "Out of memory.\n"); + r = -ENOMEM; + goto finish; + } + + f = fopen(q, "re"); + if (!f) { + fprintf(stderr, "Failed to open %s for reading: %m\n", q); + r = -errno; + goto finish; + } + + r = get_file_version(f, &v); + fclose(f); + + if (r < 0) + goto finish; + + if (r > 0 && strncmp(v, "gummiboot ", 10) == 0) { + + r = unlink(q); + if (r < 0) { + fprintf(stderr, "Failed to remove %s: %m\n", q); + r = -errno; + free(v); + goto finish; + } else + fprintf(stderr, "Removed %s.\n", q); + } + + c++; + free(v); + } + + r = c; + +finish: + if (d) + closedir(d); + free(p); + free(q); + + return r; +} + +static int rmdir_one(const char *prefix, const char *suffix) { + char *p; + + if (asprintf(&p, "%s/%s", prefix, suffix) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + if (rmdir(p) < 0) { + if (errno != ENOENT && errno != ENOTEMPTY) { + fprintf(stderr, "Failed to remove %s: %m\n", p); + free(p); + return -errno; + } + } else + fprintf(stderr, "Removed %s.\n", p); + + free(p); + return 0; +} + + +static int remove_binaries(const char *esp_path) { + char *p; + int r, q; + + if (asprintf(&p, "%s/EFI/gummiboot", esp_path) < 0) { + fprintf(stderr, "Out of memory.\n"); + return -ENOMEM; + } + + r = rm_rf(p); + free(p); + + q = remove_boot_efi(esp_path); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader/entries"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "loader"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/Boot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI/gummiboot"); + if (q < 0 && r == 0) + r = q; + + q = rmdir_one(esp_path, "EFI"); + if (q < 0 && r == 0) + r = q; + + return r; +} + +static int remove_variables(const uint8_t uuid[16], const char *path, bool in_order) { + uint16_t slot; + int r; + + if (!is_efi_boot()) + return 0; + + r = find_slot(uuid, path, &slot); + if (r != 1) + return 0; + + r = efi_remove_boot_option(slot); + if (r < 0) + return r; + + if (in_order) + remove_from_order(slot); + + return 0; +} + +static int install_loader_config(const char *esp_path) { + /** Create default global preferences file */ + char *filename = NULL; + FILE *file; + + if (asprintf(&filename, "%s/%s", esp_path, "loader/loader.conf") < 0) { + fprintf(stderr, "Can't allocate memory for filename.\n"); + return -ENOMEM; + } + + file = fopen(filename, "wxe"); + if (file) { + fprintf(file, "#timeout 3\n"); + fclose(file); + } + else fprintf(stderr, "Warning: failed creating %s/loader/loader.conf\n", esp_path); + + free(filename); + return 0; +} + +static int help(void) { + printf("%s [COMMAND] [OPTIONS...]\n" + "\n" + "Install, update or remove the Gummiboot EFI boot loader.\n\n" + " -h --help Show this help\n" + " --version Print version\n" + " --path=PATH Path to the EFI System Partition (ESP)\n" + " --no-variables Don't touch EFI variables\n" + "\n" + "Comands:\n" + " status Show status of installed Gummiboot and EFI variables\n" + " install Install Gummiboot to the ESP and EFI variables\n" + " update Update Gummiboot in the ESP and EFI variables\n" + " remove Remove Gummiboot from the ESP and EFI variables\n", + program_invocation_short_name); + + return 0; +} + +static const char *arg_path = NULL; +static bool arg_touch_variables = true; + +static int parse_argv(int argc, char *argv[]) { + enum { + ARG_PATH = 0x100, + ARG_VERSION, + ARG_NO_VARIABLES, + }; + + static const struct option options[] = { + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, ARG_VERSION }, + { "path", required_argument, NULL, ARG_PATH }, + { "no-variables", no_argument, NULL, ARG_NO_VARIABLES }, + { NULL, 0, NULL, 0 } + }; + + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) { + switch (c) { + + case 'h': + help(); + return 0; + + case ARG_VERSION: + printf(VERSION "\n"); + return 0; + + case ARG_PATH: + arg_path = optarg; + break; + + case ARG_NO_VARIABLES: + arg_touch_variables = false; + break; + + case '?': + return -EINVAL; + + default: + fprintf(stderr, "Unknown option code '%c'.\n", c); + return -EINVAL; + } + } + + return 1; +} + +int main(int argc, char*argv[]) { + enum action { + ACTION_STATUS, + ACTION_INSTALL, + ACTION_UPDATE, + ACTION_REMOVE + } arg_action = ACTION_STATUS; + + static const struct { + const char* verb; + enum action action; + } verbs[] = { + { "status", ACTION_STATUS }, + { "install", ACTION_INSTALL }, + { "update", ACTION_UPDATE }, + { "remove", ACTION_REMOVE }, + }; + + uint8_t uuid[16] = ""; + uint32_t part = 0; + uint64_t pstart = 0; + uint64_t psize = 0; + unsigned int i; + int q; + int r; + + r = parse_argv(argc, argv); + if (r <= 0) + goto finish; + + if (argv[optind]) { + for (i = 0; i < ELEMENTSOF(verbs); i++) { + if (!streq(argv[optind], verbs[i].verb)) + continue; + arg_action = verbs[i].action; + break; + } + if (i >= ELEMENTSOF(verbs)) { + fprintf(stderr, "Unknown operation %s\n", argv[optind]); + r = -EINVAL; + goto finish; + } + } + + if (!arg_path) + arg_path = "/boot/efi"; + + if (geteuid() != 0) { + fprintf(stderr, "Need to be root.\n"); + r = -EPERM; + goto finish; + } + + r = verify_esp(arg_path, &part, &pstart, &psize, uuid); + if (r == -ENODEV && !arg_path) + fprintf(stderr, "You might want to use --path= to indicate the path to your ESP, in case it is not mounted to /boot.\n"); + if (r < 0) + goto finish; + + switch (arg_action) { + case ACTION_STATUS: + r = status_binaries(arg_path, uuid); + if (r < 0) + goto finish; + + if (arg_touch_variables) + r = status_variables(); + break; + + case ACTION_INSTALL: + case ACTION_UPDATE: + umask(0002); + + r = install_binaries(arg_path, arg_action == ACTION_INSTALL); + if (r < 0) + goto finish; + + if (arg_action == ACTION_INSTALL) + install_loader_config(arg_path); + + if (arg_touch_variables) + r = install_variables(arg_path, + part, pstart, psize, uuid, + "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", + arg_action == ACTION_INSTALL); + break; + + case ACTION_REMOVE: + r = remove_binaries(arg_path); + + if (arg_touch_variables) { + q = remove_variables(uuid, "/EFI/gummiboot/gummiboot" MACHINE_TYPE_NAME ".efi", true); + if (q < 0 && r == 0) + r = q; + } + break; + } + +finish: + return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS; +} diff --git a/gummiboot-nomachineid-48/test/gummiboot.svg b/gummiboot-nomachineid-48/test/gummiboot.svg new file mode 100644 index 0000000..aec7695 --- /dev/null +++ b/gummiboot-nomachineid-48/test/gummiboot.svg @@ -0,0 +1,1327 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gummiboot-nomachineid-48/test/splash.bmp b/gummiboot-nomachineid-48/test/splash.bmp new file mode 100644 index 0000000000000000000000000000000000000000..27247f7a22b61f5571ba5a6069c4fe52845d65cd GIT binary patch literal 289238 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

Kx6+UJioe$XggWrZTx7a4~LYp^VZYx&~ z+M-2Et$*eM>L91FUpCfhAkA#!@y{{MY^$xUb^RpLNb}|`rAGTwm+#ts;jPRR{;tiM zcb`?&!bdUkY##kHG3l$Z_yZq{C3cciyE-rlCx=V$zz56&Vw5zL&y{;dDb`ayN;z}I zd*T%5O-;HW7W>+LvBX_}Gt4RFaKtFjDQOpJs>r0P#<3?hd*1D6oA27n)!)LtZYu}B zf_(w|EOxWIJ-FspbkH}bt@<-twfdX3Wch8@)AtjrYkJgj3e%74IW(+|lta=!<5Rq* zt73_Jc%8S3M|v;fu77`?$9yYXf(L>JJ^&u@Yu0lrGan@_x`fK-*MMz{`tp^KdgNH0dm@3g+)ta zsXKXH7m?p@@;n+Dx9PowOYlJOzz5d@o>M*_<#STXn|n?vH>EmGu}ZTxVO23Xs_MD1 z*iARY61Uw!EJe-G{r?#q^Do1Deu@Lrv7l$nZ@Z4_LB*h7@;J|9--;#fy&{&}Ig9f_ zdCmG5=;H*mRR!kt7C~D+)PaP#dopm$!T55_b-Sgf4C?XyS>6=Mx=7EP zsf_}Ua7efW4}63@;92E!H<_%;r6p|GSwC8p)x+qVO3E9ta+IKOV^B)w|u!WSGDG zZuiUl-urp}aNpp8;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q z;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q z;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q e;DO+Q;DO+Q;DO+Q;DO+Q;DO+Q;DLX;2mUXkcAf(O literal 0 HcmV?d00001 diff --git a/gummiboot-nomachineid-48/test/test-create-disk.sh b/gummiboot-nomachineid-48/test/test-create-disk.sh new file mode 100755 index 0000000..9f176e9 --- /dev/null +++ b/gummiboot-nomachineid-48/test/test-create-disk.sh @@ -0,0 +1,43 @@ +#!/bin/bash -e + +# create GPT table with EFI System Partition +rm -f test-disk.img +dd if=/dev/null of=test-disk.img bs=1M seek=512 count=1 +parted --script test-disk.img "mklabel gpt" "mkpart ESP fat32 1MiB 511MiB" "set 1 boot on" + +# create FAT32 file system +LOOP=$(losetup --show -f -P test-disk.img) +mkfs.vfat -F32 ${LOOP}p1 +mkdir -p mnt +mount ${LOOP}p1 mnt + +# install gummiboot +mkdir -p mnt/EFI/{Boot,gummiboot} +cp gummibootx64.efi mnt/EFI/Boot/bootx64.efi +cp test/splash.bmp mnt/EFI/gummiboot/ + +[ -e /boot/shellx64.efi ] && cp /boot/shellx64.efi mnt/ + +mkdir mnt/EFI/Linux +echo "foo=yes bar=no debug" > mnt/cmdline.txt +objcopy \ + --add-section .osrel=/etc/os-release --change-section-vma .osrel=0x20000 \ + --add-section .cmdline=mnt/cmdline.txt --change-section-vma .cmdline=0x30000 \ + --add-section .linux=/boot/$(cat /etc/machine-id)/$(uname -r)/linux --change-section-vma .linux=0x40000 \ + --add-section .initrd=/boot/$(cat /etc/machine-id)/$(uname -r)/initrd --change-section-vma .initrd=0x3000000 \ + linuxx64.efi.stub mnt/EFI/Linux/linux-test.efi + +# install entries +mkdir -p mnt/loader/entries +echo -e "timeout 3\nsplash /EFI/gummiboot/splash.bmp\n" > mnt/loader/loader.conf +echo -e "title Test\nefi /test\n" > mnt/loader/entries/test.conf +echo -e "title Test2\nlinux /test2\noptions option=yes word number=1000 more\n" > mnt/loader/entries/test2.conf +echo -e "title Test3\nlinux /test3\n" > mnt/loader/entries/test3.conf +echo -e "title Test4\nlinux /test4\n" > mnt/loader/entries/test4.conf +echo -e "title Test5\nefi /test5\n" > mnt/loader/entries/test5.conf +echo -e "title Test6\nlinux /test6\n" > mnt/loader/entries/test6.conf + +sync +umount mnt +rmdir mnt +losetup -d $LOOP diff --git a/gummiboot-nomachineid_48.orig.tar.gz b/gummiboot-nomachineid_48.orig.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ad350daf1064682fe42b53320ad8e0ef185a9821 GIT binary patch literal 122945 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 gI;0c