[thirdparty/systemd.git] / src / shared / efivars.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  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 <http://www.gnu.org/licenses/>.
***/

#include <unistd.h>
#include <string.h>
#include <fcntl.h>

#include "efivars.h"
#include "fd-util.h"
#include "utf8.h"
#include "util.h"
#include "virt.h"

#ifdef ENABLE_EFI

#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
#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI    0x0000000000000001

struct boot_option {
        uint32_t attr;
        uint16_t path_len;
        uint16_t title[];
} _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;
} _packed_;

struct device_path {
        uint8_t type;
        uint8_t sub_type;
        uint16_t length;
        union {
                uint16_t path[0];
                struct drive_path drive;
        };
} _packed_;

bool is_efi_boot(void) {
        return access("/sys/firmware/efi", F_OK) >= 0;
}

static int read_flag(const char *varname) {
        int r;
        _cleanup_free_ void *v = NULL;
        size_t s;
        uint8_t b;

        r = efi_get_variable(EFI_VENDOR_GLOBAL, varname, NULL, &v, &s);
        if (r < 0)
                return r;

        if (s != 1)
                return -EINVAL;

        b = *(uint8_t *)v;
        r = b > 0;
        return r;
}

bool is_efi_secure_boot(void) {
        return read_flag("SecureBoot") > 0;
}

bool is_efi_secure_boot_setup_mode(void) {
        return read_flag("SetupMode") > 0;
}

int efi_reboot_to_firmware_supported(void) {
        int r;
        size_t s;
        uint64_t b;
        _cleanup_free_ void *v = NULL;

        if (!is_efi_boot() || detect_container() > 0)
                return -EOPNOTSUPP;

        r = efi_get_variable(EFI_VENDOR_GLOBAL, "OsIndicationsSupported", NULL, &v, &s);
        if (r < 0)
                return r;
        else if (s != sizeof(uint64_t))
                return -EINVAL;

        b = *(uint64_t *)v;
        b &= EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
        return b > 0 ? 0 : -EOPNOTSUPP;
}

static int get_os_indications(uint64_t *os_indication) {
        int r;
        size_t s;
        _cleanup_free_ void *v = NULL;

        r = efi_reboot_to_firmware_supported();
        if (r < 0)
                return r;

        r = efi_get_variable(EFI_VENDOR_GLOBAL, "OsIndications", NULL, &v, &s);
        if (r == -ENOENT) {
                /* Some firmware implementations that do support
                 * OsIndications and report that with
                 * OsIndicationsSupported will remove the
                 * OsIndications variable when it is unset. Let's
                 * pretend it's 0 then, to hide this implementation
                 * detail. Note that this call will return -ENOENT
                 * then only if the support for OsIndications is
                 * missing entirely, as determined by
                 * efi_reboot_to_firmware_supported() above. */
                *os_indication = 0;
                return 0;
        } else if (r < 0)
                return r;
        else if (s != sizeof(uint64_t))
                return -EINVAL;

        *os_indication = *(uint64_t *)v;
        return 0;
}

int efi_get_reboot_to_firmware(void) {
        int r;
        uint64_t b;

        r = get_os_indications(&b);
        if (r < 0)
                return r;

        return !!(b & EFI_OS_INDICATIONS_BOOT_TO_FW_UI);
}

int efi_set_reboot_to_firmware(bool value) {
        int r;
        uint64_t b, b_new;

        r = get_os_indications(&b);
        if (r < 0)
                return r;

        if (value)
                b_new = b | EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
        else
                b_new = b & ~EFI_OS_INDICATIONS_BOOT_TO_FW_UI;

        /* Avoid writing to efi vars store if we can due to firmware bugs. */
        if (b != b_new)
                return efi_set_variable(EFI_VENDOR_GLOBAL, "OsIndications", &b_new, sizeof(uint64_t));

        return 0;
}

int efi_get_variable(
                sd_id128_t vendor,
                const char *name,
                uint32_t *attribute,
                void **value,
                size_t *size) {

        _cleanup_close_ int fd = -1;
        _cleanup_free_ char *p = NULL;
        uint32_t a;
        ssize_t n;
        struct stat st;
        _cleanup_free_ void *buf = NULL;

        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, SD_ID128_FORMAT_VAL(vendor)) < 0)
                return -ENOMEM;

        fd = open(p, O_RDONLY|O_NOCTTY|O_CLOEXEC);
        if (fd < 0)
                return -errno;

        if (fstat(fd, &st) < 0)
                return -errno;
        if (st.st_size < 4)
                return -EIO;
        if (st.st_size > 4*1024*1024 + 4)
                return -E2BIG;

        n = read(fd, &a, sizeof(a));
        if (n < 0)
                return -errno;
        if (n != sizeof(a))
                return -EIO;

        buf = malloc(st.st_size - 4 + 2);
        if (!buf)
                return -ENOMEM;

        n = read(fd, buf, (size_t) st.st_size - 4);
        if (n < 0)
                return -errno;
        if (n != (ssize_t) st.st_size - 4)
                return -EIO;

        /* Always NUL terminate (2 bytes, to protect UTF-16) */
        ((char*) buf)[st.st_size - 4] = 0;
        ((char*) buf)[st.st_size - 4 + 1] = 0;

        *value = buf;
        buf = NULL;
        *size = (size_t) st.st_size - 4;

        if (attribute)
                *attribute = a;

        return 0;
}

int efi_set_variable(
                sd_id128_t vendor,
                const char *name,
                const void *value,
                size_t size) {

        struct var {
                uint32_t attr;
                char buf[];
        } _packed_ * _cleanup_free_ buf = NULL;
        _cleanup_free_ char *p = NULL;
        _cleanup_close_ int fd = -1;

        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, SD_ID128_FORMAT_VAL(vendor)) < 0)
                return -ENOMEM;

        if (size == 0) {
                if (unlink(p) < 0)
                        return -errno;
                return 0;
        }

        fd = open(p, O_WRONLY|O_CREAT|O_NOCTTY|O_CLOEXEC, 0644);
        if (fd < 0)
                return -errno;

        buf = malloc(sizeof(uint32_t) + size);
        if (!buf)
                return -ENOMEM;

        buf->attr = EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS;
        memcpy(buf->buf, value, size);

        return loop_write(fd, buf, sizeof(uint32_t) + size, false);
}

int efi_get_variable_string(sd_id128_t vendor, const char *name, char **p) {
        _cleanup_free_ void *s = NULL;
        size_t ss = 0;
        int r;
        char *x;

        r = efi_get_variable(vendor, name, NULL, &s, &ss);
        if (r < 0)
                return r;

        x = utf16_to_utf8(s, ss);
        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);
}

static void efi_guid_to_id128(const void *guid, sd_id128_t *id128) {
        struct uuid {
                uint32_t u1;
                uint16_t u2;
                uint16_t u3;
                uint8_t u4[8];
        } _packed_;
        const struct uuid *uuid = guid;

        id128->bytes[0] = (uuid->u1 >> 24) & 0xff;
        id128->bytes[1] = (uuid->u1 >> 16) & 0xff;
        id128->bytes[2] = (uuid->u1 >> 8) & 0xff;
        id128->bytes[3] = (uuid->u1) & 0xff;
        id128->bytes[4] = (uuid->u2 >> 8) & 0xff;
        id128->bytes[5] = (uuid->u2) & 0xff;
        id128->bytes[6] = (uuid->u3 >> 8) & 0xff;
        id128->bytes[7] = (uuid->u3) & 0xff;
        memcpy(&id128->bytes[8], uuid->u4, sizeof(uuid->u4));
}

int efi_get_boot_option(
                uint16_t id,
                char **title,
                sd_id128_t *part_uuid,
                char **path,
                bool *active) {

        char boot_id[9];
        _cleanup_free_ uint8_t *buf = NULL;
        size_t l;
        struct boot_option *header;
        size_t title_size;
        _cleanup_free_ char *s = NULL, *p = NULL;
        sd_id128_t p_uuid = SD_ID128_NULL;
        int r;

        xsprintf(boot_id, "Boot%04X", id);
        r = efi_get_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, (void **)&buf, &l);
        if (r < 0)
                return r;
        if (l < sizeof(struct boot_option))
                return -ENOENT;

        header = (struct boot_option *)buf;
        title_size = utf16_size(header->title);
        if (title_size > l - offsetof(struct boot_option, title))
                return -EINVAL;

        if (title) {
                s = utf16_to_utf8(header->title, title_size);
                if (!s)
                        return -ENOMEM;
        }

        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;

                        /* Type 0x04 – Media Device Path */
                        if (dpath->type != MEDIA_DEVICE_PATH)
                                continue;

                        /* Sub-Type 1 – Hard Drive */
                        if (dpath->sub_type == MEDIA_HARDDRIVE_DP) {
                                /* 0x02 – GUID Partition Table */
                                if (dpath->drive.mbr_type != MBR_TYPE_EFI_PARTITION_TABLE_HEADER)
                                        continue;

                                /* 0x02 – GUID signature */
                                if (dpath->drive.signature_type != SIGNATURE_TYPE_GUID)
                                        continue;

                                if (part_uuid)
                                        efi_guid_to_id128(dpath->drive.signature, &p_uuid);
                                continue;
                        }

                        /* Sub-Type 4 – File Path */
                        if (dpath->sub_type == MEDIA_FILEPATH_DP && !p && path) {
                                p = utf16_to_utf8(dpath->path, dpath->length-4);
                                efi_tilt_backslashes(p);
                                continue;
                        }
                }
        }

        if (title) {
                *title = s;
                s = NULL;
        }
        if (part_uuid)
                *part_uuid = p_uuid;
        if (path) {
                *path = p;
                p = NULL;
        }
        if (active)
                *active = !!(header->attr & LOAD_OPTION_ACTIVE);

        return 0;
}

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';
}

struct guid {
        uint32_t u1;
        uint16_t u2;
        uint16_t u3;
        uint8_t u4[8];
} _packed_;

static void id128_to_efi_guid(sd_id128_t id, void *guid) {
        struct guid *uuid = guid;

        uuid->u1 = id.bytes[0] << 24 | id.bytes[1] << 16 | id.bytes[2] << 8 | id.bytes[3];
        uuid->u2 = id.bytes[4] << 8 | id.bytes[5];
        uuid->u3 = id.bytes[6] << 8 | id.bytes[7];
        memcpy(uuid->u4, id.bytes+8, sizeof(uuid->u4));
}

static uint16_t *tilt_slashes(uint16_t *s) {
        uint16_t *p;

        for (p = s; *p; p++)
                if (*p == '/')
                        *p = '\\';

        return s;
}

int efi_add_boot_option(uint16_t id, const char *title,
                        uint32_t part, uint64_t pstart, uint64_t psize,
                        sd_id128_t part_uuid, const char *path) {
        char boot_id[9];
        size_t size;
        size_t title_len;
        size_t path_len;
        struct boot_option *option;
        struct device_path *devicep;
        _cleanup_free_ char *buf = NULL;

        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)
                return -ENOMEM;

        /* 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;

        xsprintf(boot_id, "Boot%04X", id);
        return efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, buf, size);
}

int efi_remove_boot_option(uint16_t id) {
        char boot_id[9];

        xsprintf(boot_id, "Boot%04X", id);
        return efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, 0);
}

int efi_get_boot_order(uint16_t **order) {
        _cleanup_free_ void *buf = NULL;
        size_t l;
        int r;

        r = efi_get_variable(EFI_VENDOR_GLOBAL, "BootOrder", NULL, &buf, &l);
        if (r < 0)
                return r;

        if (l <= 0)
                return -ENOENT;

        if (l % sizeof(uint16_t) > 0 ||
            l / sizeof(uint16_t) > INT_MAX)
                return -EINVAL;

        *order = buf;
        buf = NULL;
        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 -EINVAL;

        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) {
        _cleanup_closedir_ DIR *dir = NULL;
        struct dirent *de;
        _cleanup_free_ uint16_t *list = NULL;
        size_t alloc = 0;
        int count = 0;

        assert(options);

        dir = opendir("/sys/firmware/efi/efivars/");
        if (!dir)
                return -errno;

        FOREACH_DIRENT(de, dir, return -errno) {
                int id;

                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;

                if (!GREEDY_REALLOC(list, alloc, count + 1))
                        return -ENOMEM;

                list[count++] = id;
        }

        qsort_safe(list, count, sizeof(uint16_t), cmp_uint16);

        *options = list;
        list = NULL;
        return count;
}

static int read_usec(sd_id128_t vendor, const char *name, usec_t *u) {
        _cleanup_free_ char *j = NULL;
        int r;
        uint64_t x = 0;

        assert(name);
        assert(u);

        r = efi_get_variable_string(EFI_VENDOR_LOADER, name, &j);
        if (r < 0)
                return r;

        r = safe_atou64(j, &x);
        if (r < 0)
                return r;

        *u = x;
        return 0;
}

int efi_loader_get_boot_usec(usec_t *firmware, usec_t *loader) {
        uint64_t x, y;
        int r;

        assert(firmware);
        assert(loader);

        r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeInitUSec", &x);
        if (r < 0)
                return r;

        r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeExecUSec", &y);
        if (r < 0)
                return r;

        if (y == 0 || y < x)
                return -EIO;

        if (y > USEC_PER_HOUR)
                return -EIO;

        *firmware = x;
        *loader = y;

        return 0;
}

int efi_loader_get_device_part_uuid(sd_id128_t *u) {
        _cleanup_free_ char *p = NULL;
        int r, parsed[16];

        r = efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderDevicePartUUID", &p);
        if (r < 0)
                return r;

        if (sscanf(p, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                   &parsed[0], &parsed[1], &parsed[2], &parsed[3],
                   &parsed[4], &parsed[5], &parsed[6], &parsed[7],
                   &parsed[8], &parsed[9], &parsed[10], &parsed[11],
                   &parsed[12], &parsed[13], &parsed[14], &parsed[15]) != 16)
                return -EIO;

        if (u) {
                unsigned i;

                for (i = 0; i < ELEMENTSOF(parsed); i++)
                        u->bytes[i] = parsed[i];
        }

        return 0;
}

#endif

char *efi_tilt_backslashes(char *s) {
        char *p;

        for (p = s; *p; p++)
                if (*p == '\\')
                        *p = '/';

        return s;
}
Commit	Line	Data
2e3d0692 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <unistd.h>
7b4d7cc0	23	#include <string.h>
2e3d0692 LP	24	#include <fcntl.h>
2e3d0692 LP	25
3ffd4af2 LP	26	#include "efivars.h"
3ffd4af2 LP	27	#include "fd-util.h"
2e3d0692	28	#include "utf8.h"
3ffd4af2	29	#include "util.h"
5bdf2243	30	#include "virt.h"
2e3d0692	31
b872e9a0 LP	32	#ifdef ENABLE_EFI
b872e9a0 LP	33
0974a682 KS	34	#define LOAD_OPTION_ACTIVE 0x00000001
	35	#define MEDIA_DEVICE_PATH 0x04
	36	#define MEDIA_HARDDRIVE_DP 0x01
	37	#define MEDIA_FILEPATH_DP 0x04
	38	#define SIGNATURE_TYPE_GUID 0x02
	39	#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02
	40	#define END_DEVICE_PATH_TYPE 0x7f
	41	#define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xff
5bdf2243	42	#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI 0x0000000000000001
0974a682 KS	43
	44	struct boot_option {
	45	uint32_t attr;
	46	uint16_t path_len;
	47	uint16_t title[];
885fdebc	48	} _packed_;
0974a682 KS	49
	50	struct drive_path {
	51	uint32_t part_nr;
	52	uint64_t part_start;
	53	uint64_t part_size;
	54	char signature[16];
	55	uint8_t mbr_type;
	56	uint8_t signature_type;
885fdebc	57	} _packed_;
0974a682 KS	58
	59	struct device_path {
	60	uint8_t type;
	61	uint8_t sub_type;
	62	uint16_t length;
	63	union {
	64	uint16_t path[0];
	65	struct drive_path drive;
	66	};
885fdebc	67	} _packed_;
0974a682	68
9cde64ff	69	bool is_efi_boot(void) {
34e5a31e LP	70	return access("/sys/firmware/efi", F_OK) >= 0;
	71	}
	72
bc6f2e7c KS	73	static int read_flag(const char *varname) {
bc6f2e7c KS	74	int r;
b47d419c	75	_cleanup_free_ void *v = NULL;
bc6f2e7c KS	76	size_t s;
	77	uint8_t b;
	78
	79	r = efi_get_variable(EFI_VENDOR_GLOBAL, varname, NULL, &v, &s);
	80	if (r < 0)
	81	return r;
	82
b47d419c ZJS	83	if (s != 1)
b47d419c ZJS	84	return -EINVAL;
bc6f2e7c KS	85
	86	b = (uint8_t )v;
	87	r = b > 0;
bc6f2e7c KS	88	return r;
	89	}
	90
9df49b33 TG	91	bool is_efi_secure_boot(void) {
9df49b33 TG	92	return read_flag("SecureBoot") > 0;
bc6f2e7c KS	93	}
bc6f2e7c KS	94
9df49b33 TG	95	bool is_efi_secure_boot_setup_mode(void) {
9df49b33 TG	96	return read_flag("SetupMode") > 0;
bc6f2e7c KS	97	}
bc6f2e7c KS	98
5bdf2243 JJ	99	int efi_reboot_to_firmware_supported(void) {
	100	int r;
	101	size_t s;
	102	uint64_t b;
	103	_cleanup_free_ void *v = NULL;
	104
75f86906	105	if (!is_efi_boot() \|\| detect_container() > 0)
5bdf2243 JJ	106	return -EOPNOTSUPP;
	107
	108	r = efi_get_variable(EFI_VENDOR_GLOBAL, "OsIndicationsSupported", NULL, &v, &s);
	109	if (r < 0)
	110	return r;
	111	else if (s != sizeof(uint64_t))
	112	return -EINVAL;
	113
	114	b = (uint64_t )v;
	115	b &= EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
	116	return b > 0 ? 0 : -EOPNOTSUPP;
	117	}
	118
	119	static int get_os_indications(uint64_t *os_indication) {
	120	int r;
	121	size_t s;
	122	_cleanup_free_ void *v = NULL;
	123
	124	r = efi_reboot_to_firmware_supported();
	125	if (r < 0)
	126	return r;
	127
	128	r = efi_get_variable(EFI_VENDOR_GLOBAL, "OsIndications", NULL, &v, &s);
6b62bbbc LP	129	if (r == -ENOENT) {
	130	/* Some firmware implementations that do support
	131	* OsIndications and report that with
	132	* OsIndicationsSupported will remove the
	133	* OsIndications variable when it is unset. Let's
	134	* pretend it's 0 then, to hide this implementation
	135	* detail. Note that this call will return -ENOENT
	136	* then only if the support for OsIndications is
	137	* missing entirely, as determined by
	138	* efi_reboot_to_firmware_supported() above. */
	139	*os_indication = 0;
	140	return 0;
	141	} else if (r < 0)
5bdf2243 JJ	142	return r;
	143	else if (s != sizeof(uint64_t))
	144	return -EINVAL;
	145
	146	os_indication = (uint64_t *)v;
	147	return 0;
	148	}
	149
	150	int efi_get_reboot_to_firmware(void) {
	151	int r;
	152	uint64_t b;
	153
	154	r = get_os_indications(&b);
	155	if (r < 0)
	156	return r;
	157
	158	return !!(b & EFI_OS_INDICATIONS_BOOT_TO_FW_UI);
	159	}
	160
	161	int efi_set_reboot_to_firmware(bool value) {
	162	int r;
	163	uint64_t b, b_new;
	164
	165	r = get_os_indications(&b);
	166	if (r < 0)
	167	return r;
	168
	169	if (value)
	170	b_new = b \| EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
	171	else
	172	b_new = b & ~EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
	173
	174	/* Avoid writing to efi vars store if we can due to firmware bugs. */
	175	if (b != b_new)
	176	return efi_set_variable(EFI_VENDOR_GLOBAL, "OsIndications", &b_new, sizeof(uint64_t));
	177
	178	return 0;
	179	}
	180
9cde64ff LP	181	int efi_get_variable(
	182	sd_id128_t vendor,
	183	const char *name,
	184	uint32_t *attribute,
	185	void **value,
	186	size_t *size) {
	187
2e3d0692 LP	188	_cleanup_close_ int fd = -1;
	189	_cleanup_free_ char *p = NULL;
	190	uint32_t a;
	191	ssize_t n;
	192	struct stat st;
ad7bcf52	193	_cleanup_free_ void *buf = NULL;
2e3d0692 LP	194
	195	assert(name);
	196	assert(value);
	197	assert(size);
	198
	199	if (asprintf(&p,
	200	"/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
	201	name, SD_ID128_FORMAT_VAL(vendor)) < 0)
	202	return -ENOMEM;
	203
	204	fd = open(p, O_RDONLY\|O_NOCTTY\|O_CLOEXEC);
	205	if (fd < 0)
	206	return -errno;
	207
	208	if (fstat(fd, &st) < 0)
	209	return -errno;
	210	if (st.st_size < 4)
	211	return -EIO;
	212	if (st.st_size > 410241024 + 4)
	213	return -E2BIG;
	214
	215	n = read(fd, &a, sizeof(a));
	216	if (n < 0)
9cde64ff	217	return -errno;
2e3d0692 LP	218	if (n != sizeof(a))
	219	return -EIO;
	220
0797f232 ZJS	221	buf = malloc(st.st_size - 4 + 2);
0797f232 ZJS	222	if (!buf)
2e3d0692 LP	223	return -ENOMEM;
2e3d0692 LP	224
0797f232 ZJS	225	n = read(fd, buf, (size_t) st.st_size - 4);
0797f232 ZJS	226	if (n < 0)
742af54a	227	return -errno;
0797f232	228	if (n != (ssize_t) st.st_size - 4)
2e3d0692	229	return -EIO;
2e3d0692 LP	230
2e3d0692 LP	231	/* Always NUL terminate (2 bytes, to protect UTF-16) */
0797f232 ZJS	232	((char*) buf)[st.st_size - 4] = 0;
0797f232 ZJS	233	((char*) buf)[st.st_size - 4 + 1] = 0;
2e3d0692	234
0797f232 ZJS	235	*value = buf;
0797f232 ZJS	236	buf = NULL;
ff47c895	237	*size = (size_t) st.st_size - 4;
2e3d0692 LP	238
	239	if (attribute)
	240	*attribute = a;
	241
	242	return 0;
	243	}
	244
0974a682 KS	245	int efi_set_variable(
	246	sd_id128_t vendor,
	247	const char *name,
	248	const void *value,
	249	size_t size) {
	250
	251	struct var {
	252	uint32_t attr;
	253	char buf[];
b7749eb5 ZJS	254	} _packed_ * _cleanup_free_ buf = NULL;
	255	_cleanup_free_ char *p = NULL;
	256	_cleanup_close_ int fd = -1;
0974a682 KS	257
	258	assert(name);
	259
	260	if (asprintf(&p,
	261	"/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
	262	name, SD_ID128_FORMAT_VAL(vendor)) < 0)
	263	return -ENOMEM;
	264
	265	if (size == 0) {
b7749eb5 ZJS	266	if (unlink(p) < 0)
	267	return -errno;
	268	return 0;
0974a682 KS	269	}
	270
	271	fd = open(p, O_WRONLY\|O_CREAT\|O_NOCTTY\|O_CLOEXEC, 0644);
b7749eb5 ZJS	272	if (fd < 0)
b7749eb5 ZJS	273	return -errno;
0974a682 KS	274
0974a682 KS	275	buf = malloc(sizeof(uint32_t) + size);
b7749eb5 ZJS	276	if (!buf)
b7749eb5 ZJS	277	return -ENOMEM;
0974a682 KS	278
	279	buf->attr = EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS;
	280	memcpy(buf->buf, value, size);
	281
b7749eb5	282	return loop_write(fd, buf, sizeof(uint32_t) + size, false);
0974a682 KS	283	}
0974a682 KS	284
9cde64ff	285	int efi_get_variable_string(sd_id128_t vendor, const char name, char *p) {
7b4d7cc0	286	_cleanup_free_ void *s = NULL;
39883f62	287	size_t ss = 0;
9cde64ff LP	288	int r;
9cde64ff LP	289	char *x;
7b4d7cc0	290
9cde64ff LP	291	r = efi_get_variable(vendor, name, NULL, &s, &ss);
	292	if (r < 0)
	293	return r;
	294
	295	x = utf16_to_utf8(s, ss);
	296	if (!x)
	297	return -ENOMEM;
	298
	299	*p = x;
	300	return 0;
7b4d7cc0 KS	301	}
	302
	303	static size_t utf16_size(const uint16_t *s) {
	304	size_t l = 0;
	305
	306	while (s[l] > 0)
	307	l++;
9cde64ff	308
7b4d7cc0 KS	309	return (l+1) * sizeof(uint16_t);
	310	}
	311
	312	static void efi_guid_to_id128(const void guid, sd_id128_t id128) {
	313	struct uuid {
	314	uint32_t u1;
	315	uint16_t u2;
	316	uint16_t u3;
	317	uint8_t u4[8];
	318	} _packed_;
	319	const struct uuid *uuid = guid;
	320
	321	id128->bytes[0] = (uuid->u1 >> 24) & 0xff;
	322	id128->bytes[1] = (uuid->u1 >> 16) & 0xff;
	323	id128->bytes[2] = (uuid->u1 >> 8) & 0xff;
	324	id128->bytes[3] = (uuid->u1) & 0xff;
	325	id128->bytes[4] = (uuid->u2 >> 8) & 0xff;
	326	id128->bytes[5] = (uuid->u2) & 0xff;
	327	id128->bytes[6] = (uuid->u3 >> 8) & 0xff;
	328	id128->bytes[7] = (uuid->u3) & 0xff;
	329	memcpy(&id128->bytes[8], uuid->u4, sizeof(uuid->u4));
	330	}
	331
9cde64ff LP	332	int efi_get_boot_option(
	333	uint16_t id,
	334	char **title,
	335	sd_id128_t *part_uuid,
0974a682 KS	336	char **path,
0974a682 KS	337	bool *active) {
7b4d7cc0	338
9cde64ff LP	339	char boot_id[9];
9cde64ff LP	340	_cleanup_free_ uint8_t *buf = NULL;
7b4d7cc0 KS	341	size_t l;
	342	struct boot_option *header;
	343	size_t title_size;
b7749eb5	344	_cleanup_free_ char s = NULL, p = NULL;
7b4d7cc0	345	sd_id128_t p_uuid = SD_ID128_NULL;
a8436474	346	int r;
7b4d7cc0	347
b7749eb5	348	xsprintf(boot_id, "Boot%04X", id);
a8436474 ZJS	349	r = efi_get_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, (void **)&buf, &l);
	350	if (r < 0)
	351	return r;
7b4d7cc0 KS	352	if (l < sizeof(struct boot_option))
	353	return -ENOENT;
	354
	355	header = (struct boot_option *)buf;
	356	title_size = utf16_size(header->title);
	357	if (title_size > l - offsetof(struct boot_option, title))
	358	return -EINVAL;
	359
5483a186 ZJS	360	if (title) {
5483a186 ZJS	361	s = utf16_to_utf8(header->title, title_size);
b7749eb5 ZJS	362	if (!s)
b7749eb5 ZJS	363	return -ENOMEM;
7b4d7cc0 KS	364	}
	365
	366	if (header->path_len > 0) {
9cde64ff	367	uint8_t *dbuf;
7b4d7cc0 KS	368	size_t dnext;
	369
	370	dbuf = buf + offsetof(struct boot_option, title) + title_size;
	371	dnext = 0;
	372	while (dnext < header->path_len) {
	373	struct device_path *dpath;
	374
	375	dpath = (struct device_path *)(dbuf + dnext);
	376	if (dpath->length < 4)
	377	break;
	378
	379	/* Type 0x7F – End of Hardware Device Path, Sub-Type 0xFF – End Entire Device Path */
0974a682	380	if (dpath->type == END_DEVICE_PATH_TYPE && dpath->sub_type == END_ENTIRE_DEVICE_PATH_SUBTYPE)
7b4d7cc0 KS	381	break;
	382
	383	dnext += dpath->length;
	384
	385	/* Type 0x04 – Media Device Path */
0974a682	386	if (dpath->type != MEDIA_DEVICE_PATH)
7b4d7cc0 KS	387	continue;
	388
	389	/* Sub-Type 1 – Hard Drive */
0974a682	390	if (dpath->sub_type == MEDIA_HARDDRIVE_DP) {
7b4d7cc0	391	/* 0x02 – GUID Partition Table */
0974a682	392	if (dpath->drive.mbr_type != MBR_TYPE_EFI_PARTITION_TABLE_HEADER)
7b4d7cc0 KS	393	continue;
	394
	395	/* 0x02 – GUID signature */
0974a682	396	if (dpath->drive.signature_type != SIGNATURE_TYPE_GUID)
7b4d7cc0 KS	397	continue;
7b4d7cc0 KS	398
5483a186 ZJS	399	if (part_uuid)
5483a186 ZJS	400	efi_guid_to_id128(dpath->drive.signature, &p_uuid);
7b4d7cc0 KS	401	continue;
	402	}
	403
	404	/* Sub-Type 4 – File Path */
0974a682	405	if (dpath->sub_type == MEDIA_FILEPATH_DP && !p && path) {
7b4d7cc0	406	p = utf16_to_utf8(dpath->path, dpath->length-4);
0974a682	407	efi_tilt_backslashes(p);
7b4d7cc0 KS	408	continue;
	409	}
	410	}
	411	}
	412
b7749eb5	413	if (title) {
9cde64ff	414	*title = s;
b7749eb5 ZJS	415	s = NULL;
b7749eb5 ZJS	416	}
7b4d7cc0 KS	417	if (part_uuid)
7b4d7cc0 KS	418	*part_uuid = p_uuid;
b7749eb5	419	if (path) {
7b4d7cc0	420	*path = p;
b7749eb5 ZJS	421	p = NULL;
b7749eb5 ZJS	422	}
0974a682	423	if (active)
0aa3b783	424	*active = !!(header->attr & LOAD_OPTION_ACTIVE);
9cde64ff	425
7b4d7cc0	426	return 0;
7b4d7cc0 KS	427	}
7b4d7cc0 KS	428
0974a682 KS	429	static void to_utf16(uint16_t dest, const char src) {
	430	int i;
	431
	432	for (i = 0; src[i] != '\0'; i++)
	433	dest[i] = src[i];
	434	dest[i] = '\0';
	435	}
	436
	437	struct guid {
	438	uint32_t u1;
	439	uint16_t u2;
	440	uint16_t u3;
	441	uint8_t u4[8];
885fdebc	442	} _packed_;
0974a682 KS	443
	444	static void id128_to_efi_guid(sd_id128_t id, void *guid) {
	445	struct guid *uuid = guid;
	446
	447	uuid->u1 = id.bytes[0] << 24 \| id.bytes[1] << 16 \| id.bytes[2] << 8 \| id.bytes[3];
	448	uuid->u2 = id.bytes[4] << 8 \| id.bytes[5];
	449	uuid->u3 = id.bytes[6] << 8 \| id.bytes[7];
	450	memcpy(uuid->u4, id.bytes+8, sizeof(uuid->u4));
	451	}
	452
	453	static uint16_t tilt_slashes(uint16_t s) {
	454	uint16_t *p;
	455
	456	for (p = s; *p; p++)
	457	if (*p == '/')
	458	*p = '\\';
	459
	460	return s;
	461	}
	462
0974a682 KS	463	int efi_add_boot_option(uint16_t id, const char *title,
	464	uint32_t part, uint64_t pstart, uint64_t psize,
	465	sd_id128_t part_uuid, const char *path) {
	466	char boot_id[9];
0974a682 KS	467	size_t size;
	468	size_t title_len;
	469	size_t path_len;
	470	struct boot_option *option;
	471	struct device_path *devicep;
b7749eb5	472	_cleanup_free_ char *buf = NULL;
0974a682 KS	473
	474	title_len = (strlen(title)+1) * 2;
	475	path_len = (strlen(path)+1) * 2;
	476
	477	buf = calloc(sizeof(struct boot_option) + title_len +
	478	sizeof(struct drive_path) +
	479	sizeof(struct device_path) + path_len, 1);
b7749eb5 ZJS	480	if (!buf)
b7749eb5 ZJS	481	return -ENOMEM;
0974a682 KS	482
	483	/* header */
	484	option = (struct boot_option *)buf;
	485	option->attr = LOAD_OPTION_ACTIVE;
	486	option->path_len = offsetof(struct device_path, drive) + sizeof(struct drive_path) +
	487	offsetof(struct device_path, path) + path_len +
	488	offsetof(struct device_path, path);
	489	to_utf16(option->title, title);
	490	size = offsetof(struct boot_option, title) + title_len;
	491
	492	/* partition info */
	493	devicep = (struct device_path *)(buf + size);
	494	devicep->type = MEDIA_DEVICE_PATH;
	495	devicep->sub_type = MEDIA_HARDDRIVE_DP;
	496	devicep->length = offsetof(struct device_path, drive) + sizeof(struct drive_path);
	497	devicep->drive.part_nr = part;
	498	devicep->drive.part_start = pstart;
920b52e4	499	devicep->drive.part_size = psize;
0974a682 KS	500	devicep->drive.signature_type = SIGNATURE_TYPE_GUID;
	501	devicep->drive.mbr_type = MBR_TYPE_EFI_PARTITION_TABLE_HEADER;
	502	id128_to_efi_guid(part_uuid, devicep->drive.signature);
	503	size += devicep->length;
	504
	505	/* path to loader */
	506	devicep = (struct device_path *)(buf + size);
	507	devicep->type = MEDIA_DEVICE_PATH;
	508	devicep->sub_type = MEDIA_FILEPATH_DP;
	509	devicep->length = offsetof(struct device_path, path) + path_len;
	510	to_utf16(devicep->path, path);
	511	tilt_slashes(devicep->path);
	512	size += devicep->length;
	513
	514	/* end of path */
	515	devicep = (struct device_path *)(buf + size);
	516	devicep->type = END_DEVICE_PATH_TYPE;
	517	devicep->sub_type = END_ENTIRE_DEVICE_PATH_SUBTYPE;
	518	devicep->length = offsetof(struct device_path, path);
	519	size += devicep->length;
	520
b7749eb5 ZJS	521	xsprintf(boot_id, "Boot%04X", id);
b7749eb5 ZJS	522	return efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, buf, size);
0974a682 KS	523	}
	524
	525	int efi_remove_boot_option(uint16_t id) {
	526	char boot_id[9];
	527
b7749eb5	528	xsprintf(boot_id, "Boot%04X", id);
0974a682 KS	529	return efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, 0);
	530	}
	531
9cde64ff	532	int efi_get_boot_order(uint16_t **order) {
0797f232	533	_cleanup_free_ void *buf = NULL;
7b4d7cc0	534	size_t l;
9cde64ff	535	int r;
7b4d7cc0	536
9cde64ff LP	537	r = efi_get_variable(EFI_VENDOR_GLOBAL, "BootOrder", NULL, &buf, &l);
	538	if (r < 0)
	539	return r;
7b4d7cc0	540
0797f232	541	if (l <= 0)
7b4d7cc0	542	return -ENOENT;
7b4d7cc0	543
0797f232 ZJS	544	if (l % sizeof(uint16_t) > 0 \|\|
0797f232 ZJS	545	l / sizeof(uint16_t) > INT_MAX)
7b4d7cc0	546	return -EINVAL;
7b4d7cc0 KS	547
7b4d7cc0 KS	548	*order = buf;
0797f232	549	buf = NULL;
9cde64ff LP	550	return (int) (l / sizeof(uint16_t));
	551	}
	552
0974a682 KS	553	int efi_set_boot_order(uint16_t *order, size_t n) {
	554	return efi_set_variable(EFI_VENDOR_GLOBAL, "BootOrder", order, n * sizeof(uint16_t));
	555	}
	556
4d34c495 KS	557	static int boot_id_hex(const char s[4]) {
	558	int i;
	559	int id = 0;
	560
	561	for (i = 0; i < 4; i++)
	562	if (s[i] >= '0' && s[i] <= '9')
	563	id \|= (s[i] - '0') << (3 - i) * 4;
	564	else if (s[i] >= 'A' && s[i] <= 'F')
	565	id \|= (s[i] - 'A' + 10) << (3 - i) * 4;
	566	else
7e8185ef	567	return -EINVAL;
4d34c495 KS	568
	569	return id;
	570	}
	571
9db11a99 LP	572	static int cmp_uint16(const void _a, const void _b) {
	573	const uint16_t a = _a, b = _b;
	574
02a6fc3e	575	return (int)a - (int)b;
9db11a99 LP	576	}
9db11a99 LP	577
9cde64ff LP	578	int efi_get_boot_options(uint16_t **options) {
	579	_cleanup_closedir_ DIR *dir = NULL;
	580	struct dirent *de;
b7749eb5	581	_cleanup_free_ uint16_t *list = NULL;
7432b24b	582	size_t alloc = 0;
b7749eb5	583	int count = 0;
9cde64ff LP	584
	585	assert(options);
	586
	587	dir = opendir("/sys/firmware/efi/efivars/");
	588	if (!dir)
	589	return -errno;
	590
b7749eb5	591	FOREACH_DIRENT(de, dir, return -errno) {
4d34c495	592	int id;
9cde64ff LP	593
	594	if (strncmp(de->d_name, "Boot", 4) != 0)
	595	continue;
	596
4d34c495	597	if (strlen(de->d_name) != 45)
9cde64ff LP	598	continue;
	599
	600	if (strcmp(de->d_name + 8, "-8be4df61-93ca-11d2-aa0d-00e098032b8c") != 0)
	601	continue;
	602
4d34c495 KS	603	id = boot_id_hex(de->d_name + 4);
4d34c495 KS	604	if (id < 0)
9cde64ff LP	605	continue;
9cde64ff LP	606
7432b24b	607	if (!GREEDY_REALLOC(list, alloc, count + 1))
b7749eb5	608	return -ENOMEM;
9cde64ff	609
7432b24b	610	list[count++] = id;
9cde64ff LP	611	}
9cde64ff LP	612
7ff7394d	613	qsort_safe(list, count, sizeof(uint16_t), cmp_uint16);
9db11a99	614
9cde64ff	615	*options = list;
b7749eb5	616	list = NULL;
9cde64ff	617	return count;
7b4d7cc0 KS	618	}
7b4d7cc0 KS	619
5dbe9f53	620	static int read_usec(sd_id128_t vendor, const char name, usec_t u) {
2e3d0692	621	_cleanup_free_ char *j = NULL;
2e3d0692	622	int r;
39883f62	623	uint64_t x = 0;
2e3d0692 LP	624
	625	assert(name);
	626	assert(u);
	627
61cc634b	628	r = efi_get_variable_string(EFI_VENDOR_LOADER, name, &j);
2e3d0692 LP	629	if (r < 0)
	630	return r;
	631
2e3d0692 LP	632	r = safe_atou64(j, &x);
	633	if (r < 0)
	634	return r;
	635
5dbe9f53	636	*u = x;
2e3d0692 LP	637	return 0;
	638	}
	639
c51d84dc	640	int efi_loader_get_boot_usec(usec_t firmware, usec_t loader) {
2e3d0692 LP	641	uint64_t x, y;
2e3d0692 LP	642	int r;
2e3d0692 LP	643
	644	assert(firmware);
	645	assert(loader);
	646
e9cea16d	647	r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeInitUSec", &x);
2e3d0692 LP	648	if (r < 0)
	649	return r;
	650
e9cea16d	651	r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeExecUSec", &y);
2e3d0692 LP	652	if (r < 0)
	653	return r;
	654
	655	if (y == 0 \|\| y < x)
	656	return -EIO;
	657
	658	if (y > USEC_PER_HOUR)
	659	return -EIO;
	660
	661	*firmware = x;
	662	*loader = y;
	663
	664	return 0;
	665	}
	666
c51d84dc	667	int efi_loader_get_device_part_uuid(sd_id128_t *u) {
f4ce2b3e	668	_cleanup_free_ char *p = NULL;
f4ce2b3e	669	int r, parsed[16];
f4ce2b3e	670
61cc634b	671	r = efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderDevicePartUUID", &p);
f4ce2b3e LP	672	if (r < 0)
	673	return r;
	674
f4ce2b3e LP	675	if (sscanf(p, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
	676	&parsed[0], &parsed[1], &parsed[2], &parsed[3],
	677	&parsed[4], &parsed[5], &parsed[6], &parsed[7],
	678	&parsed[8], &parsed[9], &parsed[10], &parsed[11],
	679	&parsed[12], &parsed[13], &parsed[14], &parsed[15]) != 16)
	680	return -EIO;
	681
73b80ec2 LP	682	if (u) {
	683	unsigned i;
	684
	685	for (i = 0; i < ELEMENTSOF(parsed); i++)
	686	u->bytes[i] = parsed[i];
	687	}
f4ce2b3e LP	688
	689	return 0;
	690	}
b872e9a0 LP	691
b872e9a0 LP	692	#endif
b28ce7c6 TG	693
	694	char efi_tilt_backslashes(char s) {
	695	char *p;
	696
	697	for (p = s; *p; p++)
	698	if (*p == '\\')
	699	*p = '/';
	700
	701	return s;
	702	}