Difuse/u-boot
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Pull request for efi-2022-04-rc1-2

Browse source 
Documentation:
 
 * describe printf() format codes
 
 UEFI
 
 * enable more algorithms for UEFI image verification, e.g. SHA256-RSA2048
 
 General
 
 * simplify printing short texts for GUIDs
 * provide a unit test for printing GUIDs
 -----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCAAdFiEEbcT5xx8ppvoGt20zxIHbvCwFGsQFAmHoLnQACgkQxIHbvCwF
 GsQ25Q/9G5REcgmo9Hjv+2ri3VJJueIGRL1QeXDl84TxUYgYAtHj7zo/YaeacHKB
 RVBsQafU6vIuAq5YRJFKCSWCxjPJVUH9QO5QQz6RE14KoBh6OYUQP2wSf/+p6/sb
 47wfVtyAUEpCEz60eDj5EWrSPpH78BNW7MmKoTZWSgE1APaBTAHw/Uo6tnb52Qsv
 vQ73Q9R4s0hpsylVtmwIZ0udDcaJg3SQf/4glhnHxaUW/oMoRd0DU7Dnbbg2oxfd
 Y03J0zarqAdIjzNvADnUz6Ei2+H1TrzRe9tzhuXRuseZdANrUnzDIe6bdz+RCmkl
 sdBCmBDPoChosiAcaX9FkajaAi5XYpZ5Sitdpp9A8ZdVc0Lzr1XLbfLksJRM7WwM
 jSP/JDAGYzJqL86C4hrx46aERUuXgywf/vSM7UoG5OxbtMa/AqbHuXMOnd4jXGYD
 48fLlyMWlZ7+Kd4v3x9QlwSmM0LLsokn93JEWrJhJqFPzdHYUQifU2vlZmrJHWyS
 BjzCJxu+rCmXBO6wlcAvsF9V/kx5IO3CKIGn24UUt/wjSBu4VDO5oSzVseJxPBIQ
 vBV9qZfwKCk9U/F1VN43xvIKvcO+oK+pEE9FB5trffYGmHfSEmBwOq3LuHlyMpeJ
 L+TrJUsZstFtx0ZBmVB3YuERusb2z+x1osnifGJvUHCLqjCgvl0=
 =GoR6
 -----END PGP SIGNATURE-----

Merge tag 'efi-2022-04-rc1-2' of https://source.denx.de/u-boot/custodians/u-boot-efi

Pull request for efi-2022-04-rc1-2

Documentation:

* describe printf() format codes

UEFI

* enable more algorithms for UEFI image verification, e.g. SHA256-RSA2048

General

* simplify printing short texts for GUIDs
* provide a unit test for printing GUIDs
This commit is contained in:
Tom Rini 2022-01-22 15:43:36 -05:00
commit da158ec5f2
27 changed files with 480 additions and 284 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
arch/Kconfig
View file

@ -175,6 +175,7 @@ config SANDBOX
imply AVB_VERIFY imply AVB_VERIFY
imply LIBAVB imply LIBAVB
imply CMD_AVB imply CMD_AVB
imply PARTITION_TYPE_GUID
imply SCP03 imply SCP03
imply CMD_SCP03 imply CMD_SCP03
imply UDP_FUNCTION_FASTBOOT imply UDP_FUNCTION_FASTBOOT

160
cmd/efidebug.c
View file

@ -502,149 +502,6 @@ static int do_efi_show_drivers(struct cmd_tbl *cmdtp, int flag,
return CMD_RET_SUCCESS; return CMD_RET_SUCCESS;
} }
static const struct {
const char *text;
const efi_guid_t guid;
} guid_list[] = {
{
"Device Path",
EFI_DEVICE_PATH_PROTOCOL_GUID,
},
{
"Device Path To Text",
EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID,
},
{
"Device Path Utilities",
EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID,
},
{
"Unicode Collation 2",
EFI_UNICODE_COLLATION_PROTOCOL2_GUID,
},
{
"Driver Binding",
EFI_DRIVER_BINDING_PROTOCOL_GUID,
},
{
"Simple Text Input",
EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID,
},
{
"Simple Text Input Ex",
EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID,
},
{
"Simple Text Output",
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID,
},
{
"Block IO",
EFI_BLOCK_IO_PROTOCOL_GUID,
},
{
"Simple File System",
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID,
},
{
"Loaded Image",
EFI_LOADED_IMAGE_PROTOCOL_GUID,
},
{
"Graphics Output",
EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID,
},
{
"HII String",
EFI_HII_STRING_PROTOCOL_GUID,
},
{
"HII Database",
EFI_HII_DATABASE_PROTOCOL_GUID,
},
{
"HII Config Routing",
EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID,
},
{
"Load File2",
EFI_LOAD_FILE2_PROTOCOL_GUID,
},
{
"Random Number Generator",
EFI_RNG_PROTOCOL_GUID,
},
{
"Simple Network",
EFI_SIMPLE_NETWORK_PROTOCOL_GUID,
},
{
"PXE Base Code",
EFI_PXE_BASE_CODE_PROTOCOL_GUID,
},
{
"Device-Tree Fixup",
EFI_DT_FIXUP_PROTOCOL_GUID,
},
{
"System Partition",
PARTITION_SYSTEM_GUID
},
{
"Firmware Management",
EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GUID
},
/* Configuration table GUIDs */
{
"ACPI table",
EFI_ACPI_TABLE_GUID,
},
{
"EFI System Resource Table",
EFI_SYSTEM_RESOURCE_TABLE_GUID,
},
{
"device tree",
EFI_FDT_GUID,
},
{
"SMBIOS table",
SMBIOS_TABLE_GUID,
},
{
"Runtime properties",
EFI_RT_PROPERTIES_TABLE_GUID,
},
{
"TCG2 Final Events Table",
EFI_TCG2_FINAL_EVENTS_TABLE_GUID,
},
};
/**
* get_guid_text - get string of GUID
*
* Return description of GUID.
*
* @guid: GUID
* Return: description of GUID or NULL
*/
static const char *get_guid_text(const void *guid)
{
int i;
for (i = 0; i < ARRAY_SIZE(guid_list); i++) {
/*
* As guidcmp uses memcmp() we can safely accept unaligned
* GUIDs.
*/
if (!guidcmp(&guid_list[i].guid, guid))
return guid_list[i].text;
}
return NULL;
}
/** /**
* do_efi_show_handles() - show UEFI handles * do_efi_show_handles() - show UEFI handles
* *
@ -664,7 +521,6 @@ static int do_efi_show_handles(struct cmd_tbl *cmdtp, int flag,
efi_handle_t *handles; efi_handle_t *handles;
efi_guid_t **guid; efi_guid_t **guid;
efi_uintn_t num, count, i, j; efi_uintn_t num, count, i, j;
const char *guid_text;
efi_status_t ret; efi_status_t ret;
ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL, ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL,
@ -692,11 +548,7 @@ static int do_efi_show_handles(struct cmd_tbl *cmdtp, int flag,
else else
putc(' '); putc(' ');
guid_text = get_guid_text(guid[j]); printf("%pUs", guid[j]);
if (guid_text)
puts(guid_text);
else
printf("%pUl", guid[j]);
} }
putc('\n'); putc('\n');
} }
@ -873,14 +725,10 @@ static int do_efi_show_tables(struct cmd_tbl *cmdtp, int flag,
int argc, char *const argv[]) int argc, char *const argv[])
{ {
efi_uintn_t i; efi_uintn_t i;
const char *guid_str;
for (i = 0; i < systab.nr_tables; ++i) { for (i = 0; i < systab.nr_tables; ++i)
guid_str = get_guid_text(&systab.tables[i].guid); printf("%pUl (%pUs)\n",
if (!guid_str) &systab.tables[i].guid, &systab.tables[i].guid);
guid_str = "";
printf("%pUl %s\n", &systab.tables[i].guid, guid_str);
}
return CMD_RET_SUCCESS; return CMD_RET_SUCCESS;
} }

39
cmd/nvedit_efi.c
View file

@ -39,40 +39,6 @@ static const struct {
{EFI_VARIABLE_READ_ONLY, "RO"}, {EFI_VARIABLE_READ_ONLY, "RO"},
}; };
static const struct {
efi_guid_t guid;
char *text;
} efi_guid_text[] = {
/* signature database */
{EFI_GLOBAL_VARIABLE_GUID, "EFI_GLOBAL_VARIABLE_GUID"},
{EFI_IMAGE_SECURITY_DATABASE_GUID, "EFI_IMAGE_SECURITY_DATABASE_GUID"},
/* certificate type */
{EFI_CERT_SHA256_GUID, "EFI_CERT_SHA256_GUID"},
{EFI_CERT_X509_GUID, "EFI_CERT_X509_GUID"},
{EFI_CERT_TYPE_PKCS7_GUID, "EFI_CERT_TYPE_PKCS7_GUID"},
};
static const char unknown_guid[] = "";
/**
* efi_guid_to_str() - convert guid to readable name
*
* @guid: GUID
* Return: string for GUID
*
* convert guid to readable name
*/
static const char *efi_guid_to_str(const efi_guid_t *guid)
{
int i;
for (i = 0; i < ARRAY_SIZE(efi_guid_text); i++)
if (!guidcmp(guid, &efi_guid_text[i].guid))
return efi_guid_text[i].text;
return unknown_guid;
}
/** /**
* efi_dump_single_var() - show information about a UEFI variable * efi_dump_single_var() - show information about a UEFI variable
* *
@ -111,7 +77,7 @@ static void efi_dump_single_var(u16 *name, const efi_guid_t *guid, bool verbose)
goto out; goto out;
rtc_to_tm(time, &tm); rtc_to_tm(time, &tm);
printf("%ls:\n %pUl %s\n", name, guid, efi_guid_to_str(guid)); printf("%ls:\n %pUl (%pUs)\n", name, guid, guid);
if (attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) if (attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)
printf(" %04d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year, printf(" %04d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year,
tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
@ -497,8 +463,7 @@ int do_env_set_efi(struct cmd_tbl *cmdtp, int flag, int argc,
} }
if (verbose) { if (verbose) {
printf("GUID: %pUl %s\n", &guid, printf("GUID: %pUl (%pUs)\n", &guid, &guid);
efi_guid_to_str((const efi_guid_t *)&guid));
printf("Attributes: 0x%x\n", attributes); printf("Attributes: 0x%x\n", attributes);
} }

21
disk/part_efi.c
View file

@ -221,8 +221,7 @@ void part_print_efi(struct blk_desc *dev_desc)
ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
gpt_entry *gpt_pte = NULL; gpt_entry *gpt_pte = NULL;
int i = 0; int i = 0;
char uuid[UUID_STR_LEN + 1]; unsigned char *uuid;
unsigned char *uuid_bin;
/* This function validates AND fills in the GPT header and PTE */ /* This function validates AND fills in the GPT header and PTE */
if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1) if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
@ -245,17 +244,13 @@ void part_print_efi(struct blk_desc *dev_desc)
le64_to_cpu(gpt_pte[i].ending_lba), le64_to_cpu(gpt_pte[i].ending_lba),
print_efiname(&gpt_pte[i])); print_efiname(&gpt_pte[i]));
printf("\tattrs:\t0x%016llx\n", gpt_pte[i].attributes.raw); printf("\tattrs:\t0x%016llx\n", gpt_pte[i].attributes.raw);
uuid_bin = (unsigned char *)gpt_pte[i].partition_type_guid.b; uuid = (unsigned char *)gpt_pte[i].partition_type_guid.b;
uuid_bin_to_str(uuid_bin, uuid, UUID_STR_FORMAT_GUID); if (CONFIG_IS_ENABLED(PARTITION_TYPE_GUID))
printf("\ttype:\t%s\n", uuid); printf("\ttype:\t%pUl\n\t\t(%pUs)\n", uuid, uuid);
if (CONFIG_IS_ENABLED(PARTITION_TYPE_GUID)) { else
const char *type = uuid_guid_get_str(uuid_bin); printf("\ttype:\t%pUl\n", uuid);
if (type) uuid = (unsigned char *)gpt_pte[i].unique_partition_guid.b;
printf("\ttype:\t%s\n", type); printf("\tguid:\t%pUl\n", uuid);
}
uuid_bin = (unsigned char *)gpt_pte[i].unique_partition_guid.b;
uuid_bin_to_str(uuid_bin, uuid, UUID_STR_FORMAT_GUID);
printf("\tguid:\t%s\n", uuid);
} }
/* Remember to free pte */ /* Remember to free pte */

2
doc/build/gcc.rst vendored
View file

@ -59,7 +59,7 @@ For building U-Boot on Alpine Linux at least the following packages are needed:
.. code-block:: bash .. code-block:: bash
apk add alpine-sdk bc bison dtc flex linux-headers ncurses-dev \ apk add alpine-sdk bc bison dtc flex linux-headers ncurses-dev \
openssl-dev python3 py3-setuptools python3-dev sdl2 openssl-dev perl python3 py3-setuptools python3-dev sdl2-dev
Prerequisites Prerequisites
------------- -------------

1
doc/develop/index.rst
View file

@ -21,6 +21,7 @@ Implementation
logging logging
makefiles makefiles
menus menus
printf
uefi/index uefi/index
version version

199
doc/develop/printf.rst Normal file
View file

@ -0,0 +1,199 @@
.. SPDX-License-Identifier: GPL-2.0+
Printf() format codes
=====================
Each conversion specification consists of:
* leading '%' character
* zero or more flags
* an optional minimum field width
* an optional precision field preceded by '.'
* an optional length modifier
* a conversion specifier
Flags
-----
'space'
fill up with spaces to reach the specified length
\-
left justify
\+
add sign field of decimal conversion
#
convert to alternative form
* prepend 0 to octal output
* ignored for decimal output
* prepend 0X to hexadecimal output
0
fill up with zeroes to reach the specified length
Integer types
-------------
Length modifiers
''''''''''''''''
The optional length modifier specifies the size of the argument.
no modifier
bool, enum, short, int are passed as int
%h
convert to (unsigned) short before printing.
Only the low 16 bits are printed.
%hh
**not implemented**
%j
**not implemented**
%l
long
%ll, %L
long long
%t
ptr_diff_t
%z, %Z
size_t, ssize_t
Conversion specifiers
'''''''''''''''''''''
Conversion specifiers control the output.
%d
signed decimal
%u
unsigned decimal
%o
unsigned octal
%x
unsigned lower case hexadecimal
%X
unsigned upper case hexadecimal
The floating point conversion specifiers are not implemented:
* %a
* %A
* %e
* %E
* %f
* %F
* %g
* %G
The following tables shows the correct combinations of modifiers and specifiers
for the individual integer types.
=================== ==================
Type Format specifier
=================== ==================
bool %d, %x
char %d, %x
unsigned char %u, %x
short %d, %x
unsigned short %u, %x
int %d, %x
unsigned int %d, %x
long %ld, %lx
unsigned long %lu, %lx
long long %lld, %llx
unsigned long long %llu, %llx
off_t %llu, %llx
ptr_diff_t %td, %tx
fdt_addr_t %pa, see pointers
fdt_size_t %pa, see pointers
phys_addr_t %pa, see pointers
phys_size_t %pa, see pointers
resource_size_t %pa, see pointers
size_t %zu, %zx, %zX
ssize_t %zd, %zx, %zX
=================== ==================
Characters
----------
%%
a '%' character is written
%c
prints a single character
%lc
**not implemented**
Strings
-------
%s
prints a UTF-8 string (char \*)
%ls
prints a UTF-16 string (u16 \*)
Pointers
--------
%p
prints the address the pointer points to hexadecimally
%pa, %pap
prints the value of a phys_addr_t value that the pointer points to
preceded with 0x and zero padding according to the size of phys_addr_t.
The following types should be printed this way:
* fdt_addr_t
* fdt_size_t
* phys_addr_t
* phys_size_t
* resource_size_t
%pD
prints a UEFI device path
%pi4, %pI4
prints IPv4 address, e.g. '192.168.0.1'
%pm
prints MAC address without separators, e.g. '001122334455'
%pM
print MAC address colon separated, e.g. '00:01:02:03:04:05'
%pUb
prints GUID big endian, lower case
e.g. '00112233-4455-6677-8899-aabbccddeeff'
%pUB
prints GUID big endian, upper case
e.g. '00112233-4455-6677-8899-AABBCCDDEEFF'
%pUl
prints GUID little endian, lower case
e.g. '33221100-5544-7766-8899-aabbccddeeff'
%pUL
prints GUID little endian, upper case
e.g. '33221100-5544-7766-8899-AABBCCDDEEFF'
%pUs
prints text description of a GUID or if such is not known little endian,
lower case, e.g. 'system' for a GUID identifying an EFI system
partition.

12
include/efi_api.h
View file

@ -426,6 +426,18 @@ struct efi_runtime_services {
EFI_GUID(0x1e2ed096, 0x30e2, 0x4254, 0xbd, \ EFI_GUID(0x1e2ed096, 0x30e2, 0x4254, 0xbd, \
0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25) 0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25)
#define EFI_RNG_PROTOCOL_GUID \
EFI_GUID(0x3152bca5, 0xeade, 0x433d, 0x86, 0x2e, \
0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44)
#define EFI_DT_FIXUP_PROTOCOL_GUID \
EFI_GUID(0xe617d64c, 0xfe08, 0x46da, 0xf4, 0xdc, \
0xbb, 0xd5, 0x87, 0x0c, 0x73, 0x00)
#define EFI_TCG2_PROTOCOL_GUID \
EFI_GUID(0x607f766c, 0x7455, 0x42be, 0x93, \
0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f)
/** /**
* struct efi_configuration_table - EFI Configuration Table * struct efi_configuration_table - EFI Configuration Table
* *

4
include/efi_dt_fixup.h
View file

@ -7,10 +7,6 @@
#include <efi_api.h> #include <efi_api.h>
#define EFI_DT_FIXUP_PROTOCOL_GUID \
EFI_GUID(0xe617d64c, 0xfe08, 0x46da, 0xf4, 0xdc, \
0xbb, 0xd5, 0x87, 0x0c, 0x73, 0x00)
#define EFI_DT_FIXUP_PROTOCOL_REVISION 0x00010000 #define EFI_DT_FIXUP_PROTOCOL_REVISION 0x00010000
/* Add nodes and update properties */ /* Add nodes and update properties */

4
include/efi_rng.h
View file

@ -10,10 +10,6 @@
#include <efi_api.h> #include <efi_api.h>
/* EFI random number generation protocol related GUID definitions */ /* EFI random number generation protocol related GUID definitions */
#define EFI_RNG_PROTOCOL_GUID \
EFI_GUID(0x3152bca5, 0xeade, 0x433d, 0x86, 0x2e, \
0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44)
#define EFI_RNG_ALGORITHM_RAW \ #define EFI_RNG_ALGORITHM_RAW \
EFI_GUID(0xe43176d7, 0xb6e8, 0x4827, 0xb7, 0x84, \ EFI_GUID(0xe43176d7, 0xb6e8, 0x4827, 0xb7, 0x84, \
0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61) 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61)

4
include/efi_tcg2.h
View file

@ -19,10 +19,6 @@
#include <efi_api.h> #include <efi_api.h>
#include <tpm-v2.h> #include <tpm-v2.h>
#define EFI_TCG2_PROTOCOL_GUID \
EFI_GUID(0x607f766c, 0x7455, 0x42be, 0x93, \
0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f)
/* TPMV2 only */ /* TPMV2 only */
#define TCG2_EVENT_LOG_FORMAT_TCG_2 0x00000002 #define TCG2_EVENT_LOG_FORMAT_TCG_2 0x00000002
#define EFI_TCG2_EXTEND_ONLY 0x0000000000000001 #define EFI_TCG2_EXTEND_ONLY 0x0000000000000001

37
lib/crypto/public_key.c
View file

@ -97,6 +97,7 @@ int public_key_verify_signature(const struct public_key *pkey,
const struct public_key_signature *sig) const struct public_key_signature *sig)
{ {
struct image_sign_info info; struct image_sign_info info;
char algo[256];
int ret; int ret;
pr_devel("==>%s()\n", __func__); pr_devel("==>%s()\n", __func__);
@ -108,30 +109,26 @@ int public_key_verify_signature(const struct public_key *pkey,
return -EINVAL; return -EINVAL;
memset(&info, '\0', sizeof(info)); memset(&info, '\0', sizeof(info));
memset(algo, 0, sizeof(algo));
info.padding = image_get_padding_algo("pkcs-1.5"); info.padding = image_get_padding_algo("pkcs-1.5");
/* if (strcmp(sig->pkey_algo, "rsa")) {
* Note: image_get_[checksum|crypto]_algo takes a string pr_err("Encryption is not RSA: %s\n", sig->pkey_algo);
* argument like "<checksum>,<crypto>" return -ENOPKG;
* TODO: support other hash algorithms }
*/ ret = snprintf(algo, sizeof(algo), "%s,%s%d", sig->hash_algo,
if (strcmp(sig->pkey_algo, "rsa") || (sig->s_size * 8) != 2048) {
pr_warn("Encryption is not RSA2048: %s%d\n",
sig->pkey_algo, sig->s_size * 8); sig->pkey_algo, sig->s_size * 8);
return -ENOPKG;
} if (ret >= sizeof(algo))
if (!strcmp(sig->hash_algo, "sha1")) { return -EINVAL;
info.checksum = image_get_checksum_algo("sha1,rsa2048");
info.name = "sha1,rsa2048"; info.checksum = image_get_checksum_algo((const char *)algo);
} else if (!strcmp(sig->hash_algo, "sha256")) { info.name = (const char *)algo;
info.checksum = image_get_checksum_algo("sha256,rsa2048");
info.name = "sha256,rsa2048";
} else {
pr_warn("unknown msg digest algo: %s\n", sig->hash_algo);
return -ENOPKG;
}
info.crypto = image_get_crypto_algo(info.name); info.crypto = image_get_crypto_algo(info.name);
if (IS_ERR(info.checksum) || IS_ERR(info.crypto)) if (!info.checksum || !info.crypto) {
pr_err("<%s> not supported on image_get_(checksum|crypto)_algo()\n",
algo);
return -ENOPKG; return -ENOPKG;
}
info.key = pkey->key; info.key = pkey->key;
info.keylen = pkey->keylen; info.keylen = pkey->keylen;

26
lib/efi_loader/efi_boottime.c
View file

@ -747,7 +747,7 @@ efi_status_t EFIAPI efi_create_event_ex(uint32_t type, efi_uintn_t notify_tpl,
{ {
efi_status_t ret; efi_status_t ret;
EFI_ENTRY("%d, 0x%zx, %p, %p, %pUl", type, notify_tpl, notify_function, EFI_ENTRY("%d, 0x%zx, %p, %p, %pUs", type, notify_tpl, notify_function,
notify_context, event_group); notify_context, event_group);
/* /*
@ -1180,7 +1180,7 @@ static efi_status_t EFIAPI efi_install_protocol_interface(
{ {
efi_status_t r; efi_status_t r;
EFI_ENTRY("%p, %pUl, %d, %p", handle, protocol, protocol_interface_type, EFI_ENTRY("%p, %pUs, %d, %p", handle, protocol, protocol_interface_type,
protocol_interface); protocol_interface);
if (!handle || !protocol || if (!handle || !protocol ||
@ -1383,7 +1383,7 @@ static efi_status_t EFIAPI efi_uninstall_protocol_interface
{ {
efi_status_t ret; efi_status_t ret;
EFI_ENTRY("%p, %pUl, %p", handle, protocol, protocol_interface); EFI_ENTRY("%p, %pUs, %p", handle, protocol, protocol_interface);
ret = efi_uninstall_protocol(handle, protocol, protocol_interface); ret = efi_uninstall_protocol(handle, protocol, protocol_interface);
if (ret != EFI_SUCCESS) if (ret != EFI_SUCCESS)
@ -1418,7 +1418,7 @@ efi_status_t EFIAPI efi_register_protocol_notify(const efi_guid_t *protocol,
struct efi_register_notify_event *item; struct efi_register_notify_event *item;
efi_status_t ret = EFI_SUCCESS; efi_status_t ret = EFI_SUCCESS;
EFI_ENTRY("%pUl, %p, %p", protocol, event, registration); EFI_ENTRY("%pUs, %p, %p", protocol, event, registration);
if (!protocol || !event || !registration) { if (!protocol || !event || !registration) {
ret = EFI_INVALID_PARAMETER; ret = EFI_INVALID_PARAMETER;
@ -1601,7 +1601,7 @@ static efi_status_t EFIAPI efi_locate_handle_ext(
const efi_guid_t *protocol, void *search_key, const efi_guid_t *protocol, void *search_key,
efi_uintn_t *buffer_size, efi_handle_t *buffer) efi_uintn_t *buffer_size, efi_handle_t *buffer)
{ {
EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type, protocol, search_key, EFI_ENTRY("%d, %pUs, %p, %p, %p", search_type, protocol, search_key,
buffer_size, buffer); buffer_size, buffer);
return EFI_EXIT(efi_locate_handle(search_type, protocol, search_key, return EFI_EXIT(efi_locate_handle(search_type, protocol, search_key,
@ -1699,7 +1699,7 @@ static efi_status_t
EFIAPI efi_install_configuration_table_ext(const efi_guid_t *guid, EFIAPI efi_install_configuration_table_ext(const efi_guid_t *guid,
void *table) void *table)
{ {
EFI_ENTRY("%pUl, %p", guid, table); EFI_ENTRY("%pUs, %p", guid, table);
return EFI_EXIT(efi_install_configuration_table(guid, table)); return EFI_EXIT(efi_install_configuration_table(guid, table));
} }
@ -1814,7 +1814,7 @@ static efi_status_t EFIAPI efi_locate_device_path(
u8 *remainder; u8 *remainder;
efi_status_t ret; efi_status_t ret;
EFI_ENTRY("%pUl, %p, %p", protocol, device_path, device); EFI_ENTRY("%pUs, %p, %p", protocol, device_path, device);
if (!protocol || !device_path || !*device_path) { if (!protocol || !device_path || !*device_path) {
ret = EFI_INVALID_PARAMETER; ret = EFI_INVALID_PARAMETER;
@ -2303,7 +2303,7 @@ efi_status_t EFIAPI efi_close_protocol(efi_handle_t handle,
struct efi_open_protocol_info_item *pos; struct efi_open_protocol_info_item *pos;
efi_status_t r; efi_status_t r;
EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, agent_handle, EFI_ENTRY("%p, %pUs, %p, %p", handle, protocol, agent_handle,
controller_handle); controller_handle);
if (!efi_search_obj(agent_handle) || if (!efi_search_obj(agent_handle) ||
@ -2353,7 +2353,7 @@ static efi_status_t EFIAPI efi_open_protocol_information(
struct efi_open_protocol_info_item *item; struct efi_open_protocol_info_item *item;
efi_status_t r; efi_status_t r;
EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, entry_buffer, EFI_ENTRY("%p, %pUs, %p, %p", handle, protocol, entry_buffer,
entry_count); entry_count);
/* Check parameters */ /* Check parameters */
@ -2477,7 +2477,7 @@ efi_status_t EFIAPI efi_locate_handle_buffer(
efi_status_t r; efi_status_t r;
efi_uintn_t buffer_size = 0; efi_uintn_t buffer_size = 0;
EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type, protocol, search_key, EFI_ENTRY("%d, %pUs, %p, %p, %p", search_type, protocol, search_key,
no_handles, buffer); no_handles, buffer);
if (!no_handles || !buffer) { if (!no_handles || !buffer) {
@ -2523,7 +2523,7 @@ static efi_status_t EFIAPI efi_locate_protocol(const efi_guid_t *protocol,
efi_status_t ret; efi_status_t ret;
struct efi_object *efiobj; struct efi_object *efiobj;
EFI_ENTRY("%pUl, %p, %p", protocol, registration, protocol_interface); EFI_ENTRY("%pUs, %p, %p", protocol, registration, protocol_interface);
/* /*
* The UEFI spec explicitly requires a protocol even if a registration * The UEFI spec explicitly requires a protocol even if a registration
@ -2914,7 +2914,7 @@ static efi_status_t EFIAPI efi_open_protocol
struct efi_handler *handler; struct efi_handler *handler;
efi_status_t r = EFI_INVALID_PARAMETER; efi_status_t r = EFI_INVALID_PARAMETER;
EFI_ENTRY("%p, %pUl, %p, %p, %p, 0x%x", handle, protocol, EFI_ENTRY("%p, %pUs, %p, %p, %p, 0x%x", handle, protocol,
protocol_interface, agent_handle, controller_handle, protocol_interface, agent_handle, controller_handle,
attributes); attributes);
@ -3531,7 +3531,7 @@ static efi_status_t EFIAPI efi_reinstall_protocol_interface(
{ {
efi_status_t ret; efi_status_t ret;
EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, old_interface, EFI_ENTRY("%p, %pUs, %p, %p", handle, protocol, old_interface,
new_interface); new_interface);
/* Uninstall protocol but do not delete handle */ /* Uninstall protocol but do not delete handle */

6
lib/efi_loader/efi_capsule.c
View file

@ -453,7 +453,7 @@ static efi_status_t efi_capsule_update_firmware(
image->update_hardware_instance, image->update_hardware_instance,
handles, no_handles); handles, no_handles);
if (!fmp) { if (!fmp) {
log_err("FMP driver not found for firmware type %pUl, hardware instance %lld\n", log_err("FMP driver not found for firmware type %pUs, hardware instance %lld\n",
&image->update_image_type_id, &image->update_image_type_id,
image->update_hardware_instance); image->update_hardware_instance);
ret = EFI_UNSUPPORTED; ret = EFI_UNSUPPORTED;
@ -548,13 +548,13 @@ efi_status_t EFIAPI efi_update_capsule(
continue; continue;
} }
log_debug("Capsule[%d] (guid:%pUl)\n", log_debug("Capsule[%d] (guid:%pUs)\n",
i, &capsule->capsule_guid); i, &capsule->capsule_guid);
if (!guidcmp(&capsule->capsule_guid, if (!guidcmp(&capsule->capsule_guid,
&efi_guid_firmware_management_capsule_id)) { &efi_guid_firmware_management_capsule_id)) {
ret = efi_capsule_update_firmware(capsule); ret = efi_capsule_update_firmware(capsule);
} else { } else {
log_err("Unsupported capsule type: %pUl\n", log_err("Unsupported capsule type: %pUs\n",
&capsule->capsule_guid); &capsule->capsule_guid);
ret = EFI_UNSUPPORTED; ret = EFI_UNSUPPORTED;
} }

6
lib/efi_loader/efi_esrt.c
View file

@ -180,7 +180,7 @@ struct efi_system_resource_entry *esrt_find_entry(efi_guid_t *img_fw_class)
/* Check if the image with img_fw_class is already in the ESRT. */ /* Check if the image with img_fw_class is already in the ESRT. */
for (u32 idx = 0; idx < filled_entries; idx++) { for (u32 idx = 0; idx < filled_entries; idx++) {
if (!guidcmp(&entry[idx].fw_class, img_fw_class)) { if (!guidcmp(&entry[idx].fw_class, img_fw_class)) {
EFI_PRINT("ESRT found entry for image %pUl at index %u\n", EFI_PRINT("ESRT found entry for image %pUs at index %u\n",
img_fw_class, idx); img_fw_class, idx);
return &entry[idx]; return &entry[idx];
} }
@ -202,7 +202,7 @@ struct efi_system_resource_entry *esrt_find_entry(efi_guid_t *img_fw_class)
*/ */
esrt->fw_resource_count++; esrt->fw_resource_count++;
entry[filled_entries].fw_class = *img_fw_class; entry[filled_entries].fw_class = *img_fw_class;
EFI_PRINT("ESRT allocated new entry for image %pUl at index %u\n", EFI_PRINT("ESRT allocated new entry for image %pUs at index %u\n",
img_fw_class, filled_entries); img_fw_class, filled_entries);
return &entry[filled_entries]; return &entry[filled_entries];
@ -291,7 +291,7 @@ efi_status_t efi_esrt_add_from_fmp(struct efi_firmware_management_protocol *fmp)
EFI_PRINT("ESRT entry mismatches image_type\n"); EFI_PRINT("ESRT entry mismatches image_type\n");
} else { } else {
EFI_PRINT("ESRT failed to add entry for %pUl\n", EFI_PRINT("ESRT failed to add entry for %pUs\n",
&cur_img_info->image_type_id); &cur_img_info->image_type_id);
continue; continue;
} }

4
lib/efi_loader/efi_file.c
View file

@ -824,7 +824,7 @@ static efi_status_t EFIAPI efi_file_getinfo(struct efi_file_handle *file,
efi_status_t ret = EFI_SUCCESS; efi_status_t ret = EFI_SUCCESS;
u16 *dst; u16 *dst;
EFI_ENTRY("%p, %pUl, %p, %p", file, info_type, buffer_size, buffer); EFI_ENTRY("%p, %pUs, %p, %p", file, info_type, buffer_size, buffer);
if (!file || !info_type || !buffer_size || if (!file || !info_type || !buffer_size ||
(*buffer_size && !buffer)) { (*buffer_size && !buffer)) {
@ -924,7 +924,7 @@ static efi_status_t EFIAPI efi_file_setinfo(struct efi_file_handle *file,
struct file_handle *fh = to_fh(file); struct file_handle *fh = to_fh(file);
efi_status_t ret = EFI_UNSUPPORTED; efi_status_t ret = EFI_UNSUPPORTED;
EFI_ENTRY("%p, %pUl, %zu, %p", file, info_type, buffer_size, buffer); EFI_ENTRY("%p, %pUs, %zu, %p", file, info_type, buffer_size, buffer);
if (!guidcmp(info_type, &efi_file_info_guid)) { if (!guidcmp(info_type, &efi_file_info_guid)) {
struct efi_file_info *info = (struct efi_file_info *)buffer; struct efi_file_info *info = (struct efi_file_info *)buffer;

14
lib/efi_loader/efi_hii.c
View file

@ -372,7 +372,7 @@ add_packages(struct efi_hii_packagelist *hii,
end = ((void *)package_list) end = ((void *)package_list)
+ get_unaligned_le32(&package_list->package_length); + get_unaligned_le32(&package_list->package_length);
EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid, EFI_PRINT("package_list: %pUs (%u)\n", &package_list->package_list_guid,
get_unaligned_le32(&package_list->package_length)); get_unaligned_le32(&package_list->package_length));
package = ((void *)package_list) + sizeof(*package_list); package = ((void *)package_list) + sizeof(*package_list);
@ -504,7 +504,7 @@ update_package_list(const struct efi_hii_database_protocol *this,
if (!package_list) if (!package_list)
return EFI_EXIT(EFI_INVALID_PARAMETER); return EFI_EXIT(EFI_INVALID_PARAMETER);
EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid, EFI_PRINT("package_list: %pUs (%u)\n", &package_list->package_list_guid,
get_unaligned_le32(&package_list->package_length)); get_unaligned_le32(&package_list->package_length));
package = ((void *)package_list) + sizeof(*package_list); package = ((void *)package_list) + sizeof(*package_list);
@ -583,7 +583,7 @@ list_package_lists(const struct efi_hii_database_protocol *this,
int package_cnt, package_max; int package_cnt, package_max;
efi_status_t ret = EFI_NOT_FOUND; efi_status_t ret = EFI_NOT_FOUND;
EFI_ENTRY("%p, %u, %pUl, %p, %p", this, package_type, package_guid, EFI_ENTRY("%p, %u, %pUs, %p, %p", this, package_type, package_guid,
handle_buffer_length, handle); handle_buffer_length, handle);
if (!handle_buffer_length || if (!handle_buffer_length ||
@ -598,7 +598,7 @@ list_package_lists(const struct efi_hii_database_protocol *this,
goto out; goto out;
} }
EFI_PRINT("package type=%x, guid=%pUl, length=%zu\n", (int)package_type, EFI_PRINT("package type=%x, guid=%pUs, length=%zu\n", (int)package_type,
package_guid, *handle_buffer_length); package_guid, *handle_buffer_length);
package_cnt = 0; package_cnt = 0;
@ -658,7 +658,7 @@ register_package_notify(const struct efi_hii_database_protocol *this,
efi_uintn_t notify_type, efi_uintn_t notify_type,
efi_handle_t *notify_handle) efi_handle_t *notify_handle)
{ {
EFI_ENTRY("%p, %u, %pUl, %p, %zu, %p", this, package_type, EFI_ENTRY("%p, %u, %pUs, %p, %zu, %p", this, package_type,
package_guid, package_notify_fn, notify_type, package_guid, package_notify_fn, notify_type,
notify_handle); notify_handle);
@ -721,7 +721,7 @@ get_keyboard_layout(const struct efi_hii_database_protocol *this,
struct efi_keyboard_layout_data *layout_data; struct efi_keyboard_layout_data *layout_data;
u16 layout_length; u16 layout_length;
EFI_ENTRY("%p, %pUl, %p, %p", this, key_guid, keyboard_layout_length, EFI_ENTRY("%p, %pUs, %p, %p", this, key_guid, keyboard_layout_length,
keyboard_layout); keyboard_layout);
if (!keyboard_layout_length || if (!keyboard_layout_length ||
@ -756,7 +756,7 @@ static efi_status_t EFIAPI
set_keyboard_layout(const struct efi_hii_database_protocol *this, set_keyboard_layout(const struct efi_hii_database_protocol *this,
efi_guid_t *key_guid) efi_guid_t *key_guid)
{ {
EFI_ENTRY("%p, %pUl", this, key_guid); EFI_ENTRY("%p, %pUs", this, key_guid);
return EFI_EXIT(EFI_NOT_FOUND); return EFI_EXIT(EFI_NOT_FOUND);
} }

2
lib/efi_loader/efi_hii_config.c
View file

@ -88,7 +88,7 @@ get_alt_config(const struct efi_hii_config_routing_protocol *this,
const efi_string_t alt_cfg_id, const efi_string_t alt_cfg_id,
efi_string_t *alt_cfg_resp) efi_string_t *alt_cfg_resp)
{ {
EFI_ENTRY("%p, \"%ls\", %pUl, \"%ls\", %p, \"%ls\", %p", EFI_ENTRY("%p, \"%ls\", %pUs, \"%ls\", %p, \"%ls\", %p",
this, config_resp, guid, name, device_path, this, config_resp, guid, name, device_path,
alt_cfg_id, alt_cfg_resp); alt_cfg_id, alt_cfg_resp);

2
lib/efi_loader/efi_image_loader.c
View file

@ -676,7 +676,7 @@ static bool efi_image_authenticate(void *efi, size_t efi_size)
continue; continue;
} }
if (guidcmp(auth, &efi_guid_cert_type_pkcs7)) { if (guidcmp(auth, &efi_guid_cert_type_pkcs7)) {
EFI_PRINT("Certificate type not supported: %pUl\n", EFI_PRINT("Certificate type not supported: %pUs\n",
auth); auth);
continue; continue;
} }

2
lib/efi_loader/efi_rng.c
View file

@ -122,7 +122,7 @@ static efi_status_t EFIAPI getrng(struct efi_rng_protocol *this,
} }
if (rng_algorithm) { if (rng_algorithm) {
EFI_PRINT("RNG algorithm %pUl\n", rng_algorithm); EFI_PRINT("RNG algorithm %pUs\n", rng_algorithm);
if (guidcmp(rng_algorithm, &rng_raw_guid)) { if (guidcmp(rng_algorithm, &rng_raw_guid)) {
status = EFI_UNSUPPORTED; status = EFI_UNSUPPORTED;
goto back; goto back;

2
lib/efi_loader/efi_signature.c
View file

@ -174,7 +174,7 @@ bool efi_signature_lookup_digest(struct efi_image_regions *regs,
for (siglist = db; siglist; siglist = siglist->next) { for (siglist = db; siglist; siglist = siglist->next) {
/* TODO: support other hash algorithms */ /* TODO: support other hash algorithms */
if (guidcmp(&siglist->sig_type, &efi_guid_sha256)) { if (guidcmp(&siglist->sig_type, &efi_guid_sha256)) {
EFI_PRINT("Digest algorithm is not supported: %pUl\n", EFI_PRINT("Digest algorithm is not supported: %pUs\n",
&siglist->sig_type); &siglist->sig_type);
break; break;
} }

6
lib/efi_loader/efi_var_common.c
View file

@ -62,7 +62,7 @@ efi_status_t EFIAPI efi_get_variable(u16 *variable_name,
{ {
efi_status_t ret; efi_status_t ret;
EFI_ENTRY("\"%ls\" %pUl %p %p %p", variable_name, vendor, attributes, EFI_ENTRY("\"%ls\" %pUs %p %p %p", variable_name, vendor, attributes,
data_size, data); data_size, data);
ret = efi_get_variable_int(variable_name, vendor, attributes, ret = efi_get_variable_int(variable_name, vendor, attributes,
@ -96,7 +96,7 @@ efi_status_t EFIAPI efi_set_variable(u16 *variable_name,
{ {
efi_status_t ret; efi_status_t ret;
EFI_ENTRY("\"%ls\" %pUl %x %zu %p", variable_name, vendor, attributes, EFI_ENTRY("\"%ls\" %pUs %x %zu %p", variable_name, vendor, attributes,
data_size, data); data_size, data);
/* Make sure that the EFI_VARIABLE_READ_ONLY flag is not set */ /* Make sure that the EFI_VARIABLE_READ_ONLY flag is not set */
@ -127,7 +127,7 @@ efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size,
{ {
efi_status_t ret; efi_status_t ret;
EFI_ENTRY("%p \"%ls\" %pUl", variable_name_size, variable_name, vendor); EFI_ENTRY("%p \"%ls\" %pUs", variable_name_size, variable_name, vendor);
ret = efi_get_next_variable_name_int(variable_name_size, variable_name, ret = efi_get_next_variable_name_int(variable_name_size, variable_name,
vendor); vendor);

25
lib/efi_selftest/efi_selftest_console.c
View file

@ -70,6 +70,28 @@ static void printx(u64 p, int prec, u16 **buf)
*buf = pos; *buf = pos;
} }
/**
* print_guid() - print GUID to an u16 string
*
* @p: GUID to print
* @buf: pointer to buffer address,
* on return position of terminating zero word
*/
static void print_uuid(u8 *p, u16 **buf)
{
int i;
const u8 seq[] = {
3, 2, 1, 0, '-', 5, 4, '-', 7, 6, '-',
8, 9, 10, 11, 12, 13, 14, 15 };
for (i = 0; i < sizeof(seq); ++i) {
if (seq[i] == '-')
*(*buf)++ = u'-';
else
printx(p[seq[i]], 2, buf);
}
}
/* /*
* Print an unsigned 32bit value as decimal number to an u16 string * Print an unsigned 32bit value as decimal number to an u16 string
* *
@ -212,6 +234,9 @@ void efi_st_printc(int color, const char *fmt, ...)
con_out->output_string(con_out, u); con_out->output_string(con_out, u);
pos = buf; pos = buf;
break; break;
case 'U':
print_uuid(va_arg(args, void*), &pos);
break;
default: default:
--c; --c;
printx((uintptr_t)va_arg(args, void *), printx((uintptr_t)va_arg(args, void *),

8
lib/efi_selftest/efi_selftest_esrt.c
View file

@ -121,28 +121,28 @@ static bool lib_test_check_uuid_entry(struct efi_system_resource_table *esrt,
for (u32 idx = 0; idx < filled_entries; idx++) { for (u32 idx = 0; idx < filled_entries; idx++) {
if (!guidcmp(&entry[idx].fw_class, &img_info->image_type_id)) { if (!guidcmp(&entry[idx].fw_class, &img_info->image_type_id)) {
if (entry[idx].fw_version != img_info->version) { if (entry[idx].fw_version != img_info->version) {
efi_st_error("ESRT field mismatch for entry with fw_class=%pUl\n", efi_st_error("ESRT field mismatch for entry with fw_class=%pU\n",
&img_info->image_type_id); &img_info->image_type_id);
return false; return false;
} }
if (entry[idx].lowest_supported_fw_version != if (entry[idx].lowest_supported_fw_version !=
img_info->lowest_supported_image_version) { img_info->lowest_supported_image_version) {
efi_st_error("ESRT field mismatch for entry with fw_class=%pUl\n", efi_st_error("ESRT field mismatch for entry with fw_class=%pU\n",
&img_info->image_type_id); &img_info->image_type_id);
return false; return false;
} }
if (entry[idx].last_attempt_version != if (entry[idx].last_attempt_version !=
img_info->last_attempt_version) { img_info->last_attempt_version) {
efi_st_error("ESRT field mismatch for entry with fw_class=%pUl\n", efi_st_error("ESRT field mismatch for entry with fw_class=%pU\n",
&img_info->image_type_id); &img_info->image_type_id);
return false; return false;
} }
if (entry[idx].last_attempt_status != if (entry[idx].last_attempt_status !=
img_info->last_attempt_status) { img_info->last_attempt_status) {
efi_st_error("ESRT field mismatch for entry with fw_class=%pUl\n", efi_st_error("ESRT field mismatch for entry with fw_class=%pU\n",
&img_info->image_type_id); &img_info->image_type_id);
return false; return false;
} }

148
lib/uuid.c
View file

@ -5,6 +5,7 @@
#include <common.h> #include <common.h>
#include <command.h> #include <command.h>
#include <efi_api.h>
#include <env.h> #include <env.h>
#include <rand.h> #include <rand.h>
#include <time.h> #include <time.h>
@ -86,11 +87,11 @@ int uuid_str_valid(const char *uuid)
return 1; return 1;
} }
#ifdef CONFIG_PARTITION_TYPE_GUID
static const struct { static const struct {
const char *string; const char *string;
efi_guid_t guid; efi_guid_t guid;
} list_guid[] = { } list_guid[] = {
#ifdef CONFIG_PARTITION_TYPE_GUID
{"system", PARTITION_SYSTEM_GUID}, {"system", PARTITION_SYSTEM_GUID},
{"mbr", LEGACY_MBR_PARTITION_GUID}, {"mbr", LEGACY_MBR_PARTITION_GUID},
{"msft", PARTITION_MSFT_RESERVED_GUID}, {"msft", PARTITION_MSFT_RESERVED_GUID},
@ -100,6 +101,150 @@ static const struct {
{"swap", PARTITION_LINUX_SWAP_GUID}, {"swap", PARTITION_LINUX_SWAP_GUID},
{"lvm", PARTITION_LINUX_LVM_GUID}, {"lvm", PARTITION_LINUX_LVM_GUID},
{"u-boot-env", PARTITION_U_BOOT_ENVIRONMENT}, {"u-boot-env", PARTITION_U_BOOT_ENVIRONMENT},
#endif
#ifdef CONFIG_CMD_EFIDEBUG
{
"Device Path",
EFI_DEVICE_PATH_PROTOCOL_GUID,
},
{
"Device Path To Text",
EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID,
},
{
"Device Path Utilities",
EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID,
},
{
"Unicode Collation 2",
EFI_UNICODE_COLLATION_PROTOCOL2_GUID,
},
{
"Driver Binding",
EFI_DRIVER_BINDING_PROTOCOL_GUID,
},
{
"Simple Text Input",
EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID,
},
{
"Simple Text Input Ex",
EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID,
},
{
"Simple Text Output",
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID,
},
{
"Block IO",
EFI_BLOCK_IO_PROTOCOL_GUID,
},
{
"Simple File System",
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID,
},
{
"Loaded Image",
EFI_LOADED_IMAGE_PROTOCOL_GUID,
},
{
"Graphics Output",
EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID,
},
{
"HII String",
EFI_HII_STRING_PROTOCOL_GUID,
},
{
"HII Database",
EFI_HII_DATABASE_PROTOCOL_GUID,
},
{
"HII Config Routing",
EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID,
},
{
"Load File2",
EFI_LOAD_FILE2_PROTOCOL_GUID,
},
{
"Random Number Generator",
EFI_RNG_PROTOCOL_GUID,
},
{
"Simple Network",
EFI_SIMPLE_NETWORK_PROTOCOL_GUID,
},
{
"PXE Base Code",
EFI_PXE_BASE_CODE_PROTOCOL_GUID,
},
{
"Device-Tree Fixup",
EFI_DT_FIXUP_PROTOCOL_GUID,
},
{
"TCG2",
EFI_TCG2_PROTOCOL_GUID,
},
{
"System Partition",
PARTITION_SYSTEM_GUID
},
{
"Firmware Management",
EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GUID
},
/* Configuration table GUIDs */
{
"ACPI table",
EFI_ACPI_TABLE_GUID,
},
{
"EFI System Resource Table",
EFI_SYSTEM_RESOURCE_TABLE_GUID,
},
{
"device tree",
EFI_FDT_GUID,
},
{
"SMBIOS table",
SMBIOS_TABLE_GUID,
},
{
"Runtime properties",
EFI_RT_PROPERTIES_TABLE_GUID,
},
{
"TCG2 Final Events Table",
EFI_TCG2_FINAL_EVENTS_TABLE_GUID,
},
#endif
#ifdef CONFIG_CMD_NVEDIT_EFI
/* signature database */
{
"EFI_GLOBAL_VARIABLE_GUID",
EFI_GLOBAL_VARIABLE_GUID,
},
{
"EFI_IMAGE_SECURITY_DATABASE_GUID",
EFI_IMAGE_SECURITY_DATABASE_GUID,
},
/* certificate types */
{
"EFI_CERT_SHA256_GUID",
EFI_CERT_SHA256_GUID,
},
{
"EFI_CERT_X509_GUID",
EFI_CERT_X509_GUID,
},
{
"EFI_CERT_TYPE_PKCS7_GUID",
EFI_CERT_TYPE_PKCS7_GUID,
},
#endif
}; };
/* /*
@ -139,7 +284,6 @@ const char *uuid_guid_get_str(const unsigned char *guid_bin)
} }
return NULL; return NULL;
} }
#endif
/* /*
* uuid_str_to_bin() - convert string UUID or GUID to big endian binary data. * uuid_str_to_bin() - convert string UUID or GUID to big endian binary data.

11
lib/vsprintf.c
View file

@ -255,7 +255,7 @@ static char *number(char *buf, char *end, u64 num,
return buf; return buf;
} }
static char *string(char *buf, char *end, char *s, int field_width, static char *string(char *buf, char *end, const char *s, int field_width,
int precision, int flags) int precision, int flags)
{ {
int len, i; int len, i;
@ -387,12 +387,14 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
* %pUB: 01020304-0506-0708-090A-0B0C0D0E0F10 * %pUB: 01020304-0506-0708-090A-0B0C0D0E0F10
* %pUl: 04030201-0605-0807-090a-0b0c0d0e0f10 * %pUl: 04030201-0605-0807-090a-0b0c0d0e0f10
* %pUL: 04030201-0605-0807-090A-0B0C0D0E0F10 * %pUL: 04030201-0605-0807-090A-0B0C0D0E0F10
* %pUs: GUID text representation if known or fallback to %pUl
*/ */
static char *uuid_string(char *buf, char *end, u8 *addr, int field_width, static char *uuid_string(char *buf, char *end, u8 *addr, int field_width,
int precision, int flags, const char *fmt) int precision, int flags, const char *fmt)
{ {
char uuid[UUID_STR_LEN + 1]; char uuid[UUID_STR_LEN + 1];
int str_format; int str_format;
const char *str;
switch (*(++fmt)) { switch (*(++fmt)) {
case 'L': case 'L':
@ -404,6 +406,13 @@ static char *uuid_string(char *buf, char *end, u8 *addr, int field_width,
case 'B': case 'B':
str_format = UUID_STR_FORMAT_STD | UUID_STR_UPPER_CASE; str_format = UUID_STR_FORMAT_STD | UUID_STR_UPPER_CASE;
break; break;
case 's':
str = uuid_guid_get_str(addr);
if (str)
return string(buf, end, str,
field_width, precision, flags);
str_format = UUID_STR_FORMAT_GUID;
break;
default: default:
str_format = UUID_STR_FORMAT_STD; str_format = UUID_STR_FORMAT_STD;
break; break;

20
test/print_ut.c
View file

@ -30,17 +30,29 @@ static int print_guid(struct unit_test_state *uts)
unsigned char guid[16] = { unsigned char guid[16] = {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
}; };
unsigned char guid_esp[16] = {
0x28, 0x73, 0x2a, 0xc1, 0x1f, 0xf8, 0xd2, 0x11,
0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B
};
char str[40]; char str[40];
int ret; int ret;
sprintf(str, "%pUb", guid); sprintf(str, "%pUb", guid);
ut_assertok(strcmp("01020304-0506-0708-090a-0b0c0d0e0f10", str)); ut_asserteq_str("01020304-0506-0708-090a-0b0c0d0e0f10", str);
sprintf(str, "%pUB", guid); sprintf(str, "%pUB", guid);
ut_assertok(strcmp("01020304-0506-0708-090A-0B0C0D0E0F10", str)); ut_asserteq_str("01020304-0506-0708-090A-0B0C0D0E0F10", str);
sprintf(str, "%pUl", guid); sprintf(str, "%pUl", guid);
ut_assertok(strcmp("04030201-0605-0807-090a-0b0c0d0e0f10", str)); ut_asserteq_str("04030201-0605-0807-090a-0b0c0d0e0f10", str);
sprintf(str, "%pUs", guid);
ut_asserteq_str("04030201-0605-0807-090a-0b0c0d0e0f10", str);
sprintf(str, "%pUL", guid); sprintf(str, "%pUL", guid);
ut_assertok(strcmp("04030201-0605-0807-090A-0B0C0D0E0F10", str)); ut_asserteq_str("04030201-0605-0807-090A-0B0C0D0E0F10", str);
sprintf(str, "%pUs", guid_esp);
if (IS_ENABLED(CONFIG_PARTITION_TYPE_GUID)) { /* brace needed */
ut_asserteq_str("system", str);
} else {
ut_asserteq_str("c12a7328-f81f-11d2-ba4b-00a0c93ec93b", str);
}
ret = snprintf(str, 4, "%pUL", guid); ret = snprintf(str, 4, "%pUL", guid);
ut_asserteq(0, str[3]); ut_asserteq(0, str[3]);
ut_asserteq(36, ret); ut_asserteq(36, ret);