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