blob: 770c67abb98035250661d3378b71b24fcb511a00 [file] [log] [blame]
Tom Rini70df9d62018-05-07 17:02:21 -04001// SPDX-License-Identifier: GPL-2.0+
Rob Clark15f3d742017-09-13 18:05:37 -04002/*
3 * EFI utils
4 *
5 * Copyright (c) 2017 Rob Clark
Rob Clark15f3d742017-09-13 18:05:37 -04006 */
7
8#include <malloc.h>
9#include <charset.h>
10#include <efi_loader.h>
11
12#define READ_ONLY BIT(31)
13
14/*
15 * Mapping between EFI variables and u-boot variables:
16 *
17 * efi_$guid_$varname = {attributes}(type)value
18 *
19 * For example:
20 *
21 * efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported=
22 * "{ro,boot,run}(blob)0000000000000000"
23 * efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder=
24 * "(blob)00010000"
25 *
26 * The attributes are a comma separated list of these possible
27 * attributes:
28 *
29 * + ro - read-only
30 * + boot - boot-services access
31 * + run - runtime access
32 *
33 * NOTE: with current implementation, no variables are available after
34 * ExitBootServices, and all are persisted (if possible).
35 *
36 * If not specified, the attributes default to "{boot}".
37 *
38 * The required type is one of:
39 *
40 * + utf8 - raw utf8 string
41 * + blob - arbitrary length hex string
42 *
43 * Maybe a utf16 type would be useful to for a string value to be auto
44 * converted to utf16?
45 */
46
47#define MAX_VAR_NAME 31
48#define MAX_NATIVE_VAR_NAME \
49 (strlen("efi_xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx_") + \
50 (MAX_VAR_NAME * MAX_UTF8_PER_UTF16))
51
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070052static int hex(int ch)
Rob Clark15f3d742017-09-13 18:05:37 -040053{
54 if (ch >= 'a' && ch <= 'f')
55 return ch-'a'+10;
56 if (ch >= '0' && ch <= '9')
57 return ch-'0';
58 if (ch >= 'A' && ch <= 'F')
59 return ch-'A'+10;
60 return -1;
61}
62
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070063static int hex2mem(u8 *mem, const char *hexstr, int size)
Rob Clark15f3d742017-09-13 18:05:37 -040064{
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070065 int nibble;
66 int i;
Rob Clark15f3d742017-09-13 18:05:37 -040067
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070068 for (i = 0; i < size; i++) {
69 if (*hexstr == '\0')
Rob Clark15f3d742017-09-13 18:05:37 -040070 break;
71
72 nibble = hex(*hexstr);
73 if (nibble < 0)
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070074 return -1;
Rob Clark15f3d742017-09-13 18:05:37 -040075
76 *mem = nibble;
Rob Clark15f3d742017-09-13 18:05:37 -040077 hexstr++;
78
Rob Clark15f3d742017-09-13 18:05:37 -040079 nibble = hex(*hexstr);
80 if (nibble < 0)
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070081 return -1;
Rob Clark15f3d742017-09-13 18:05:37 -040082
83 *mem = (*mem << 4) | nibble;
Rob Clark15f3d742017-09-13 18:05:37 -040084 hexstr++;
85 mem++;
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070086 }
Rob Clark15f3d742017-09-13 18:05:37 -040087
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -070088 return i;
Rob Clark15f3d742017-09-13 18:05:37 -040089}
90
91static char *mem2hex(char *hexstr, const u8 *mem, int count)
92{
93 static const char hexchars[] = "0123456789abcdef";
94
95 while (count-- > 0) {
96 u8 ch = *mem++;
97 *hexstr++ = hexchars[ch >> 4];
98 *hexstr++ = hexchars[ch & 0xf];
99 }
100
101 return hexstr;
102}
103
Heinrich Schuchardtd6a6baa2018-05-17 07:57:05 +0200104static efi_status_t efi_to_native(char *native, u16 *variable_name,
105 efi_guid_t *vendor)
Rob Clark15f3d742017-09-13 18:05:37 -0400106{
107 size_t len;
108
Heinrich Schuchardt597f8f72018-08-31 21:31:26 +0200109 len = u16_strlen((u16 *)variable_name);
Rob Clark15f3d742017-09-13 18:05:37 -0400110 if (len >= MAX_VAR_NAME)
111 return EFI_DEVICE_ERROR;
112
113 native += sprintf(native, "efi_%pUl_", vendor);
114 native = (char *)utf16_to_utf8((u8 *)native, (u16 *)variable_name, len);
115 *native = '\0';
116
117 return EFI_SUCCESS;
118}
119
120static const char *prefix(const char *str, const char *prefix)
121{
122 size_t n = strlen(prefix);
123 if (!strncmp(prefix, str, n))
124 return str + n;
125 return NULL;
126}
127
128/* parse attributes part of variable value, if present: */
129static const char *parse_attr(const char *str, u32 *attrp)
130{
131 u32 attr = 0;
132 char sep = '{';
133
134 if (*str != '{') {
135 *attrp = EFI_VARIABLE_BOOTSERVICE_ACCESS;
136 return str;
137 }
138
139 while (*str == sep) {
140 const char *s;
141
142 str++;
143
144 if ((s = prefix(str, "ro"))) {
145 attr |= READ_ONLY;
146 } else if ((s = prefix(str, "boot"))) {
147 attr |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
148 } else if ((s = prefix(str, "run"))) {
149 attr |= EFI_VARIABLE_RUNTIME_ACCESS;
150 } else {
151 printf("invalid attribute: %s\n", str);
152 break;
153 }
154
155 str = s;
156 sep = ',';
157 }
158
159 str++;
160
161 *attrp = attr;
162
163 return str;
164}
165
166/* http://wiki.phoenix.com/wiki/index.php/EFI_RUNTIME_SERVICES#GetVariable.28.29 */
Heinrich Schuchardtd6a6baa2018-05-17 07:57:05 +0200167efi_status_t EFIAPI efi_get_variable(u16 *variable_name, efi_guid_t *vendor,
168 u32 *attributes, efi_uintn_t *data_size,
169 void *data)
Rob Clark15f3d742017-09-13 18:05:37 -0400170{
171 char native_name[MAX_NATIVE_VAR_NAME + 1];
172 efi_status_t ret;
173 unsigned long in_size;
174 const char *val, *s;
175 u32 attr;
176
Rob Clark238f88c2017-09-13 18:05:41 -0400177 EFI_ENTRY("\"%ls\" %pUl %p %p %p", variable_name, vendor, attributes,
Rob Clark15f3d742017-09-13 18:05:37 -0400178 data_size, data);
179
180 if (!variable_name || !vendor || !data_size)
181 return EFI_EXIT(EFI_INVALID_PARAMETER);
182
183 ret = efi_to_native(native_name, variable_name, vendor);
184 if (ret)
185 return EFI_EXIT(ret);
186
187 debug("%s: get '%s'\n", __func__, native_name);
188
189 val = env_get(native_name);
190 if (!val)
191 return EFI_EXIT(EFI_NOT_FOUND);
192
193 val = parse_attr(val, &attr);
194
195 in_size = *data_size;
196
197 if ((s = prefix(val, "(blob)"))) {
198 unsigned len = strlen(s);
199
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -0700200 /* number of hexadecimal digits must be even */
201 if (len & 1)
202 return EFI_EXIT(EFI_DEVICE_ERROR);
203
Rob Clark15f3d742017-09-13 18:05:37 -0400204 /* two characters per byte: */
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -0700205 len /= 2;
Rob Clark15f3d742017-09-13 18:05:37 -0400206 *data_size = len;
207
208 if (in_size < len)
209 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
210
211 if (!data)
212 return EFI_EXIT(EFI_INVALID_PARAMETER);
213
Ivan Gorinovd3ea6b72018-05-11 13:18:25 -0700214 if (hex2mem(data, s, len) != len)
Rob Clark15f3d742017-09-13 18:05:37 -0400215 return EFI_EXIT(EFI_DEVICE_ERROR);
216
217 debug("%s: got value: \"%s\"\n", __func__, s);
218 } else if ((s = prefix(val, "(utf8)"))) {
219 unsigned len = strlen(s) + 1;
220
221 *data_size = len;
222
223 if (in_size < len)
224 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
225
226 if (!data)
227 return EFI_EXIT(EFI_INVALID_PARAMETER);
228
229 memcpy(data, s, len);
230 ((char *)data)[len] = '\0';
231
232 debug("%s: got value: \"%s\"\n", __func__, (char *)data);
233 } else {
234 debug("%s: invalid value: '%s'\n", __func__, val);
235 return EFI_EXIT(EFI_DEVICE_ERROR);
236 }
237
238 if (attributes)
239 *attributes = attr & EFI_VARIABLE_MASK;
240
241 return EFI_EXIT(EFI_SUCCESS);
242}
243
244/* http://wiki.phoenix.com/wiki/index.php/EFI_RUNTIME_SERVICES#GetNextVariableName.28.29 */
Heinrich Schuchardtd6a6baa2018-05-17 07:57:05 +0200245efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size,
246 u16 *variable_name,
247 efi_guid_t *vendor)
Rob Clark15f3d742017-09-13 18:05:37 -0400248{
Rob Clark238f88c2017-09-13 18:05:41 -0400249 EFI_ENTRY("%p \"%ls\" %pUl", variable_name_size, variable_name, vendor);
Rob Clark15f3d742017-09-13 18:05:37 -0400250
251 return EFI_EXIT(EFI_DEVICE_ERROR);
252}
253
254/* http://wiki.phoenix.com/wiki/index.php/EFI_RUNTIME_SERVICES#SetVariable.28.29 */
Heinrich Schuchardtd6a6baa2018-05-17 07:57:05 +0200255efi_status_t EFIAPI efi_set_variable(u16 *variable_name, efi_guid_t *vendor,
256 u32 attributes, efi_uintn_t data_size,
257 void *data)
Rob Clark15f3d742017-09-13 18:05:37 -0400258{
259 char native_name[MAX_NATIVE_VAR_NAME + 1];
260 efi_status_t ret = EFI_SUCCESS;
261 char *val, *s;
262 u32 attr;
263
Heinrich Schuchardtd6a6baa2018-05-17 07:57:05 +0200264 EFI_ENTRY("\"%ls\" %pUl %x %zu %p", variable_name, vendor, attributes,
Rob Clark15f3d742017-09-13 18:05:37 -0400265 data_size, data);
266
267 if (!variable_name || !vendor)
268 return EFI_EXIT(EFI_INVALID_PARAMETER);
269
270 ret = efi_to_native(native_name, variable_name, vendor);
271 if (ret)
272 return EFI_EXIT(ret);
273
274#define ACCESS_ATTR (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)
275
276 if ((data_size == 0) || !(attributes & ACCESS_ATTR)) {
277 /* delete the variable: */
278 env_set(native_name, NULL);
279 return EFI_EXIT(EFI_SUCCESS);
280 }
281
282 val = env_get(native_name);
283 if (val) {
284 parse_attr(val, &attr);
285
286 if (attr & READ_ONLY)
287 return EFI_EXIT(EFI_WRITE_PROTECTED);
288 }
289
290 val = malloc(2 * data_size + strlen("{ro,run,boot}(blob)") + 1);
291 if (!val)
292 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
293
294 s = val;
295
296 /* store attributes: */
297 attributes &= (EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS);
298 s += sprintf(s, "{");
299 while (attributes) {
300 u32 attr = 1 << (ffs(attributes) - 1);
301
302 if (attr == EFI_VARIABLE_BOOTSERVICE_ACCESS)
303 s += sprintf(s, "boot");
304 else if (attr == EFI_VARIABLE_RUNTIME_ACCESS)
305 s += sprintf(s, "run");
306
307 attributes &= ~attr;
308 if (attributes)
309 s += sprintf(s, ",");
310 }
311 s += sprintf(s, "}");
312
313 /* store payload: */
314 s += sprintf(s, "(blob)");
315 s = mem2hex(s, data, data_size);
316 *s = '\0';
317
318 debug("%s: setting: %s=%s\n", __func__, native_name, val);
319
320 if (env_set(native_name, val))
321 ret = EFI_DEVICE_ERROR;
322
323 free(val);
324
325 return EFI_EXIT(ret);
326}