1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * EFI boot manager
4 *
5 * Copyright (c) 2017 Rob Clark
6 */
7
8 #include <common.h>
9 #include <charset.h>
10 #include <malloc.h>
11 #include <efi_loader.h>
12 #include <asm/unaligned.h>
13
14 static const struct efi_boot_services *bs;
15 static const struct efi_runtime_services *rs;
16
17 /*
18 * bootmgr implements the logic of trying to find a payload to boot
19 * based on the BootOrder + BootXXXX variables, and then loading it.
20 *
21 * TODO detecting a special key held (f9?) and displaying a boot menu
22 * like you would get on a PC would be clever.
23 *
24 * TODO if we had a way to write and persist variables after the OS
25 * has started, we'd also want to check OsIndications to see if we
26 * should do normal or recovery boot.
27 */
28
29
30 /* Parse serialized data and transform it into efi_load_option structure */
efi_deserialize_load_option(struct efi_load_option * lo,u8 * data)31 void efi_deserialize_load_option(struct efi_load_option *lo, u8 *data)
32 {
33 lo->attributes = get_unaligned_le32(data);
34 data += sizeof(u32);
35
36 lo->file_path_length = get_unaligned_le16(data);
37 data += sizeof(u16);
38
39 /* FIXME */
40 lo->label = (u16 *)data;
41 data += (u16_strlen(lo->label) + 1) * sizeof(u16);
42
43 /* FIXME */
44 lo->file_path = (struct efi_device_path *)data;
45 data += lo->file_path_length;
46
47 lo->optional_data = data;
48 }
49
50 /*
51 * Serialize efi_load_option structure into byte stream for BootXXXX.
52 * Return a size of allocated data.
53 */
efi_serialize_load_option(struct efi_load_option * lo,u8 ** data)54 unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data)
55 {
56 unsigned long label_len, option_len;
57 unsigned long size;
58 u8 *p;
59
60 label_len = (u16_strlen(lo->label) + 1) * sizeof(u16);
61 option_len = strlen((char *)lo->optional_data);
62
63 /* total size */
64 size = sizeof(lo->attributes);
65 size += sizeof(lo->file_path_length);
66 size += label_len;
67 size += lo->file_path_length;
68 size += option_len + 1;
69 p = malloc(size);
70 if (!p)
71 return 0;
72
73 /* copy data */
74 *data = p;
75 memcpy(p, &lo->attributes, sizeof(lo->attributes));
76 p += sizeof(lo->attributes);
77
78 memcpy(p, &lo->file_path_length, sizeof(lo->file_path_length));
79 p += sizeof(lo->file_path_length);
80
81 memcpy(p, lo->label, label_len);
82 p += label_len;
83
84 memcpy(p, lo->file_path, lo->file_path_length);
85 p += lo->file_path_length;
86
87 memcpy(p, lo->optional_data, option_len);
88 p += option_len;
89 *(char *)p = '\0';
90
91 return size;
92 }
93
94 /* free() the result */
get_var(u16 * name,const efi_guid_t * vendor,efi_uintn_t * size)95 static void *get_var(u16 *name, const efi_guid_t *vendor,
96 efi_uintn_t *size)
97 {
98 efi_guid_t *v = (efi_guid_t *)vendor;
99 efi_status_t ret;
100 void *buf = NULL;
101
102 *size = 0;
103 EFI_CALL(ret = rs->get_variable(name, v, NULL, size, buf));
104 if (ret == EFI_BUFFER_TOO_SMALL) {
105 buf = malloc(*size);
106 EFI_CALL(ret = rs->get_variable(name, v, NULL, size, buf));
107 }
108
109 if (ret != EFI_SUCCESS) {
110 free(buf);
111 *size = 0;
112 return NULL;
113 }
114
115 return buf;
116 }
117
118 /*
119 * Attempt to load load-option number 'n', returning device_path and file_path
120 * if successful. This checks that the EFI_LOAD_OPTION is active (enabled)
121 * and that the specified file to boot exists.
122 */
try_load_entry(uint16_t n,struct efi_device_path ** device_path,struct efi_device_path ** file_path)123 static void *try_load_entry(uint16_t n, struct efi_device_path **device_path,
124 struct efi_device_path **file_path)
125 {
126 struct efi_load_option lo;
127 u16 varname[] = L"Boot0000";
128 u16 hexmap[] = L"0123456789ABCDEF";
129 void *load_option, *image = NULL;
130 efi_uintn_t size;
131
132 varname[4] = hexmap[(n & 0xf000) >> 12];
133 varname[5] = hexmap[(n & 0x0f00) >> 8];
134 varname[6] = hexmap[(n & 0x00f0) >> 4];
135 varname[7] = hexmap[(n & 0x000f) >> 0];
136
137 load_option = get_var(varname, &efi_global_variable_guid, &size);
138 if (!load_option)
139 return NULL;
140
141 efi_deserialize_load_option(&lo, load_option);
142
143 if (lo.attributes & LOAD_OPTION_ACTIVE) {
144 efi_status_t ret;
145
146 debug("%s: trying to load \"%ls\" from %pD\n",
147 __func__, lo.label, lo.file_path);
148
149 ret = efi_load_image_from_path(lo.file_path, &image, &size);
150
151 if (ret != EFI_SUCCESS)
152 goto error;
153
154 printf("Booting: %ls\n", lo.label);
155 efi_dp_split_file_path(lo.file_path, device_path, file_path);
156 }
157
158 error:
159 free(load_option);
160
161 return image;
162 }
163
164 /*
165 * Attempt to load, in the order specified by BootOrder EFI variable, the
166 * available load-options, finding and returning the first one that can
167 * be loaded successfully.
168 */
efi_bootmgr_load(struct efi_device_path ** device_path,struct efi_device_path ** file_path)169 void *efi_bootmgr_load(struct efi_device_path **device_path,
170 struct efi_device_path **file_path)
171 {
172 uint16_t *bootorder;
173 efi_uintn_t size;
174 void *image = NULL;
175 int i, num;
176
177 bs = systab.boottime;
178 rs = systab.runtime;
179
180 bootorder = get_var(L"BootOrder", &efi_global_variable_guid, &size);
181 if (!bootorder) {
182 printf("BootOrder not defined\n");
183 goto error;
184 }
185
186 num = size / sizeof(uint16_t);
187 for (i = 0; i < num; i++) {
188 debug("%s: trying to load Boot%04X\n", __func__, bootorder[i]);
189 image = try_load_entry(bootorder[i], device_path, file_path);
190 if (image)
191 break;
192 }
193
194 free(bootorder);
195
196 error:
197 return image;
198 }
199