1 // SPDX-License-Identifier: GPL-2.0+
5 * Copyright (c) 2017 Rob Clark
10 #include <efi_loader.h>
12 #include <environment.h>
16 #define READ_ONLY BIT(31)
19 * Mapping between EFI variables and u-boot variables:
21 * efi_$guid_$varname = {attributes}(type)value
25 * efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported=
26 * "{ro,boot,run}(blob)0000000000000000"
27 * efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder=
30 * The attributes are a comma separated list of these possible
34 * + boot - boot-services access
35 * + run - runtime access
37 * NOTE: with current implementation, no variables are available after
38 * ExitBootServices, and all are persisted (if possible).
40 * If not specified, the attributes default to "{boot}".
42 * The required type is one of:
44 * + utf8 - raw utf8 string
45 * + blob - arbitrary length hex string
47 * Maybe a utf16 type would be useful to for a string value to be auto
51 #define PREFIX_LEN (strlen("efi_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx_"))
54 * efi_to_native() - convert the UEFI variable name and vendor GUID to U-Boot
57 * The U-Boot variable name is a concatenation of prefix 'efi', the hexstring
58 * encoded vendor GUID, and the UTF-8 encoded UEFI variable name separated by
59 * underscores, e.g. 'efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder'.
61 * @native: pointer to pointer to U-Boot variable name
62 * @variable_name: UEFI variable name
63 * @vendor: vendor GUID
66 static efi_status_t efi_to_native(char **native, const u16 *variable_name,
67 const efi_guid_t *vendor)
72 len = PREFIX_LEN + utf16_utf8_strlen(variable_name) + 1;
73 *native = malloc(len);
75 return EFI_OUT_OF_RESOURCES;
78 pos += sprintf(pos, "efi_%pUl_", vendor);
79 utf16_utf8_strcpy(&pos, variable_name);
85 * prefix() - skip over prefix
87 * Skip over a prefix string.
89 * @str: string with prefix
90 * @prefix: prefix string
91 * Return: string without prefix, or NULL if prefix not found
93 static const char *prefix(const char *str, const char *prefix)
95 size_t n = strlen(prefix);
96 if (!strncmp(prefix, str, n))
102 * parse_attr() - decode attributes part of variable value
104 * Convert the string encoded attributes of a UEFI variable to a bit mask.
105 * TODO: Several attributes are not supported.
107 * @str: value of U-Boot variable
108 * @attrp: pointer to UEFI attributes
109 * Return: pointer to remainder of U-Boot variable value
111 static const char *parse_attr(const char *str, u32 *attrp)
117 *attrp = EFI_VARIABLE_BOOTSERVICE_ACCESS;
121 while (*str == sep) {
126 if ((s = prefix(str, "ro"))) {
128 } else if ((s = prefix(str, "boot"))) {
129 attr |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
130 } else if ((s = prefix(str, "run"))) {
131 attr |= EFI_VARIABLE_RUNTIME_ACCESS;
133 printf("invalid attribute: %s\n", str);
149 * efi_efi_get_variable() - retrieve value of a UEFI variable
151 * This function implements the GetVariable runtime service.
153 * See the Unified Extensible Firmware Interface (UEFI) specification for
156 * @variable_name: name of the variable
157 * @vendor: vendor GUID
158 * @attributes: attributes of the variable
159 * @data_size: size of the buffer to which the variable value is copied
160 * @data: buffer to which the variable value is copied
161 * Return: status code
163 efi_status_t EFIAPI efi_get_variable(u16 *variable_name,
164 const efi_guid_t *vendor, u32 *attributes,
165 efi_uintn_t *data_size, void *data)
169 unsigned long in_size;
173 EFI_ENTRY("\"%ls\" %pUl %p %p %p", variable_name, vendor, attributes,
176 if (!variable_name || !vendor || !data_size)
177 return EFI_EXIT(EFI_INVALID_PARAMETER);
179 ret = efi_to_native(&native_name, variable_name, vendor);
181 return EFI_EXIT(ret);
183 EFI_PRINT("get '%s'\n", native_name);
185 val = env_get(native_name);
188 return EFI_EXIT(EFI_NOT_FOUND);
190 val = parse_attr(val, &attr);
192 in_size = *data_size;
194 if ((s = prefix(val, "(blob)"))) {
195 size_t len = strlen(s);
197 /* number of hexadecimal digits must be even */
199 return EFI_EXIT(EFI_DEVICE_ERROR);
201 /* two characters per byte: */
206 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
209 return EFI_EXIT(EFI_INVALID_PARAMETER);
211 if (hex2bin(data, s, len))
212 return EFI_EXIT(EFI_DEVICE_ERROR);
214 EFI_PRINT("got value: \"%s\"\n", s);
215 } else if ((s = prefix(val, "(utf8)"))) {
216 unsigned len = strlen(s) + 1;
221 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
224 return EFI_EXIT(EFI_INVALID_PARAMETER);
226 memcpy(data, s, len);
227 ((char *)data)[len] = '\0';
229 EFI_PRINT("got value: \"%s\"\n", (char *)data);
231 EFI_PRINT("invalid value: '%s'\n", val);
232 return EFI_EXIT(EFI_DEVICE_ERROR);
236 *attributes = attr & EFI_VARIABLE_MASK;
238 return EFI_EXIT(EFI_SUCCESS);
241 static char *efi_variables_list;
242 static char *efi_cur_variable;
245 * parse_uboot_variable() - parse a u-boot variable and get uefi-related
247 * @variable: whole data of u-boot variable (ie. name=value)
248 * @variable_name_size: size of variable_name buffer in byte
249 * @variable_name: name of uefi variable in u16, null-terminated
250 * @vendor: vendor's guid
251 * @attributes: attributes
253 * A uefi variable is encoded into a u-boot variable as described above.
254 * This function parses such a u-boot variable and retrieve uefi-related
255 * information into respective parameters. In return, variable_name_size
256 * is the size of variable name including NULL.
258 * Return: EFI_SUCCESS if parsing is OK, EFI_NOT_FOUND when
259 the entire variable list has been returned,
260 otherwise non-zero status code
262 static efi_status_t parse_uboot_variable(char *variable,
263 efi_uintn_t *variable_name_size,
265 const efi_guid_t *vendor,
268 char *guid, *name, *end, c;
269 unsigned long name_len;
272 guid = strchr(variable, '_');
274 return EFI_INVALID_PARAMETER;
276 name = strchr(guid, '_');
278 return EFI_INVALID_PARAMETER;
280 end = strchr(name, '=');
282 return EFI_INVALID_PARAMETER;
284 name_len = end - name;
285 if (*variable_name_size < (name_len + 1)) {
286 *variable_name_size = name_len + 1;
287 return EFI_BUFFER_TOO_SMALL;
289 end++; /* point to value */
293 utf8_utf16_strncpy(&p, name, name_len);
294 variable_name[name_len] = 0;
295 *variable_name_size = name_len + 1;
299 *(name - 1) = '\0'; /* guid need be null-terminated here */
300 uuid_str_to_bin(guid, (unsigned char *)vendor, UUID_STR_FORMAT_GUID);
304 parse_attr(end, attributes);
310 * efi_get_next_variable_name() - enumerate the current variable names
311 * @variable_name_size: size of variable_name buffer in byte
312 * @variable_name: name of uefi variable's name in u16
313 * @vendor: vendor's guid
315 * This function implements the GetNextVariableName service.
317 * See the Unified Extensible Firmware Interface (UEFI) specification for
318 * details: http://wiki.phoenix.com/wiki/index.php/
319 * EFI_RUNTIME_SERVICES#GetNextVariableName.28.29
321 * Return: status code
323 efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size,
325 const efi_guid_t *vendor)
327 char *native_name, *variable;
328 ssize_t name_len, list_len;
330 char * const regexlist[] = {regex};
335 EFI_ENTRY("%p \"%ls\" %pUl", variable_name_size, variable_name, vendor);
337 if (!variable_name_size || !variable_name || !vendor)
338 return EFI_EXIT(EFI_INVALID_PARAMETER);
340 if (variable_name[0]) {
341 /* check null-terminated string */
342 for (i = 0; i < *variable_name_size; i++)
343 if (!variable_name[i])
345 if (i >= *variable_name_size)
346 return EFI_EXIT(EFI_INVALID_PARAMETER);
348 /* search for the last-returned variable */
349 ret = efi_to_native(&native_name, variable_name, vendor);
351 return EFI_EXIT(ret);
353 name_len = strlen(native_name);
354 for (variable = efi_variables_list; variable && *variable;) {
355 if (!strncmp(variable, native_name, name_len) &&
356 variable[name_len] == '=')
359 variable = strchr(variable, '\n');
365 if (!(variable && *variable))
366 return EFI_EXIT(EFI_INVALID_PARAMETER);
369 variable = strchr(variable, '\n');
372 if (!(variable && *variable))
373 return EFI_EXIT(EFI_NOT_FOUND);
376 *new search: free a list used in the previous search
378 free(efi_variables_list);
379 efi_variables_list = NULL;
380 efi_cur_variable = NULL;
382 snprintf(regex, 256, "efi_.*-.*-.*-.*-.*_.*");
383 list_len = hexport_r(&env_htab, '\n',
384 H_MATCH_REGEX | H_MATCH_KEY,
385 &efi_variables_list, 0, 1, regexlist);
386 /* 1 indicates that no match was found */
388 return EFI_EXIT(EFI_NOT_FOUND);
390 variable = efi_variables_list;
393 ret = parse_uboot_variable(variable, variable_name_size, variable_name,
394 vendor, &attributes);
396 return EFI_EXIT(ret);
400 * efi_efi_set_variable() - set value of a UEFI variable
402 * This function implements the SetVariable runtime service.
404 * See the Unified Extensible Firmware Interface (UEFI) specification for
407 * @variable_name: name of the variable
408 * @vendor: vendor GUID
409 * @attributes: attributes of the variable
410 * @data_size: size of the buffer with the variable value
411 * @data: buffer with the variable value
412 * Return: status code
414 efi_status_t EFIAPI efi_set_variable(u16 *variable_name,
415 const efi_guid_t *vendor, u32 attributes,
416 efi_uintn_t data_size, const void *data)
418 char *native_name = NULL, *val = NULL, *s;
419 efi_status_t ret = EFI_SUCCESS;
422 EFI_ENTRY("\"%ls\" %pUl %x %zu %p", variable_name, vendor, attributes,
425 if (!variable_name || !vendor) {
426 ret = EFI_INVALID_PARAMETER;
430 ret = efi_to_native(&native_name, variable_name, vendor);
434 #define ACCESS_ATTR (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)
436 if ((data_size == 0) || !(attributes & ACCESS_ATTR)) {
437 /* delete the variable: */
438 env_set(native_name, NULL);
443 val = env_get(native_name);
445 parse_attr(val, &attr);
447 if (attr & READ_ONLY) {
448 /* We should not free val */
450 ret = EFI_WRITE_PROTECTED;
455 val = malloc(2 * data_size + strlen("{ro,run,boot}(blob)") + 1);
457 ret = EFI_OUT_OF_RESOURCES;
465 * TODO: several attributes are not supported
467 attributes &= (EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS);
468 s += sprintf(s, "{");
470 u32 attr = 1 << (ffs(attributes) - 1);
472 if (attr == EFI_VARIABLE_BOOTSERVICE_ACCESS)
473 s += sprintf(s, "boot");
474 else if (attr == EFI_VARIABLE_RUNTIME_ACCESS)
475 s += sprintf(s, "run");
479 s += sprintf(s, ",");
481 s += sprintf(s, "}");
484 s += sprintf(s, "(blob)");
485 s = bin2hex(s, data, data_size);
488 EFI_PRINT("setting: %s=%s\n", native_name, val);
490 if (env_set(native_name, val))
491 ret = EFI_DEVICE_ERROR;
497 return EFI_EXIT(ret);