On Wed, Apr 24, 2019 at 06:24:44PM +0200, Heinrich Schuchardt wrote:

On 4/24/19 8:30 AM, AKASHI Takahiro wrote:

...

u16 version of strcmp()

AUTHER: Patrick Wildt patrick@blueri.se

%s/AUTHER/Author/

Okay

...

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

include/charset.h | 5 +++++ lib/charset.c | 10 ++++++++++ 2 files changed, 15 insertions(+)

diff --git a/include/charset.h b/include/charset.h index 65087f76d1fc..747a9b376c03 100644 --- a/include/charset.h +++ b/include/charset.h @@ -166,6 +166,11 @@ s32 utf_to_lower(const s32 code); */ s32 utf_to_upper(const s32 code);

+/*

• • u16_strcmp() - strcmp() for u16 strings
• */

+int u16_strcmp(const u16 *s1, const u16 *s2);

/**

• u16_strlen - count non-zero words

diff --git a/lib/charset.c b/lib/charset.c index 5e349ed5ee45..4a25ac0bdb9c 100644 --- a/lib/charset.c +++ b/lib/charset.c @@ -335,6 +335,16 @@ s32 utf_to_upper(const s32 code) return ret; }

+int u16_strcmp(const u16 *s1, const u16 *s2) +{

• while (*s1 == *s2++)

• if (*s1++ == 0)
  

• 	return (0);
  

• --s2;

for (;*s1 == *s2; ++s1, ++s2) if (!s1) return 0;

does the same job without superfluous increment/decrement.

Indeed :)

...

• return (*(uint16_t *)s1 - *(uint16_t *)s2);

Why would you use both u16 and uint16_t in the same function? You can do without any conversion here.

Will fix.

How about

#define u16_strcmp(s1, s2) u16_strncmp(s1, s2, SIZE_MAX)

like we do for the other string functions?

Sure

Thanks, -Takahiro Akashi

Best regards

Heinrich

...

+}

size_t u16_strlen(const u16 *in) { size_t i;

On 4/24/19 8:30 AM, AKASHI Takahiro wrote:

u16_strncmp() works like u16_strcmp() but only at most n characters (in u16) are compared. This function will be used in a later patch.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

include/charset.h | 5 +++++ lib/charset.c | 13 +++++++++++++ 2 files changed, 18 insertions(+)

diff --git a/include/charset.h b/include/charset.h index 747a9b376c03..49842a88bc8b 100644 --- a/include/charset.h +++ b/include/charset.h @@ -171,6 +171,11 @@ s32 utf_to_upper(const s32 code); */ int u16_strcmp(const u16 *s1, const u16 *s2);

+/*

• • u16_strncmp() - strncmp() for u16 strings

* u16_strncmp() - compare two u16 string * * @s1: first string to compare * @s2: second string to compare * @n1: maximum number of u16 to compare * Return: 0 if the first n u16 are the same in s1 and s2 * < 0 if the first different u16 in s1 is less than the * corresponding u16 in s2 * > 0 if the first different u16 in s1 is greater than the * corresponding u16 in s2

• */

+int u16_strncmp(const u16 *s1, const u16 *s2, size_t n);

• /**
  • u16_strlen - count non-zero words

diff --git a/lib/charset.c b/lib/charset.c index 4a25ac0bdb9c..85f08db68fe2 100644 --- a/lib/charset.c +++ b/lib/charset.c @@ -345,6 +345,19 @@ int u16_strcmp(const u16 *s1, const u16 *s2) return (*(uint16_t *)s1 - *(uint16_t *)s2); }

+int u16_strncmp(const u16 *s1, const u16 *s2, size_t n) +{

• while ((n-- > 0) && (*s1 == *s2++)) {

• if (*s1++ == 0)
  

• 	return 0;
  

• if (!n)
  

• 	return 0;
  

• }
• --s2;

For u16_strncmp() called with n = 0 I would prefer to see 0 as return value instead of the result of an illegal memory access.

• return (*(uint16_t *)s1 - *(uint16_t *)s2);

No need for a conversion here.

Let's avoid the superfluous increment/decrement, provide 0 for n = 0, and make sure that the compiler calculates the difference only once per loop:

int u16_strncmp(const u16 *s1, const u16 *s2, size_t n) {         int ret = 0;

for (; n; --n, ++s1, ++s2) {                 ret = *s1 - *s2;                 if (ret || !*s1)                         break;         }         return ret; }

I would like to see a unit test in test/unicode_ut.c. The test should include the n = 0 case.

Best regards

Heinrich

+}

• size_t u16_strlen(const u16 *in) { size_t i;

On 4/24/19 8:30 AM, AKASHI Takahiro wrote:

Efidebug command should be implemented using well-defined EFI interfaces, rather than using internal functions/data. This change will be needed in a later patch where UEFI variables are re-implemented.

I had trouble to get the point. In the next version I suggest to write:

Currently in do_efi_boot_dump() we directly read EFI variables from the related environment variables. To accomodate alternative storage backends we should switch to using the UEFI API instead.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

cmd/efidebug.c | 92 ++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 66 insertions(+), 26 deletions(-)

diff --git a/cmd/efidebug.c b/cmd/efidebug.c index a40c4f4be286..8890dd7268f1 100644 --- a/cmd/efidebug.c +++ b/cmd/efidebug.c @@ -509,7 +509,7 @@ static int do_efi_boot_add(cmd_tbl_t *cmdtp, int flag, if (argc < 6 || argc > 7) return CMD_RET_USAGE;

• id = (int)simple_strtoul(argv[1], &endp, 16);

• id = simple_strtoul(argv[1], &endp, 16);

This change is correct but unrelated. Please, put it into a separate patch. Or at least mention it in the commit message.

if (*endp != '\0' || id > 0xffff) return CMD_RET_USAGE;

@@ -595,7 +595,7 @@ static int do_efi_boot_rm(cmd_tbl_t *cmdtp, int flag,

guid = efi_global_variable_guid; for (i = 1; i < argc; i++, argv++) {

• id = (int)simple_strtoul(argv[1], &endp, 16);
  

• id = simple_strtoul(argv[1], &endp, 16);
  

Same here.

if (*endp != '\0' || id > 0xffff)
	return CMD_RET_FAILURE;

@@ -693,6 +693,27 @@ static void show_efi_boot_opt(int id) free(data); }

+static bool u16_isxdigit(u16 c) +{

• if (c & 0xff00)

• return false;
  

• return isxdigit((u8)c);

+}

+static int u16_tohex(u16 c) +{

• if (c >= '0' && c < '9')

• return c - '0';
  

• if (c >= 'A' && c < 'F')

• return c - 'A' + 10;
  

• if (c >= 'a' && c < 'f')

• return c - 'a' + 10;
  

Does the UEFI spec really allow lower case hexadecimal numbers here? I only found an example with capital numbers. Would this imply that I could have variables Boot00a0 and Boot00A0 side by side? Which one would be selected by boot option 00a0?

Or should SetVariable() make a case insensitive search for variable names?

In EDK2 function FindVariableEx() in MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c uses CompareMem() to compare variable names.

Function BmCharToUint() is used to check the digits of boot options and has this comment:

"It assumes the input Char is in the scope of L'0' ~ L'9' and L'A' ~ L'F'"

So let's us assume that variable names are case sensitive and Boot entries can only have capital hexadecimal digits.

So u16_isxdigit() is incorrect.

• /* dummy */
• return -1;

As we do not check bounds here the function could be reduced to:

return c > '9' ? c - ('A' - 0xa) : c - '9';

But I would prefer one library function instead of the two static functions which returns -1 for a non-digit and 0 - 15 for a digit. And a unit test in test/unicoode_ut.c

+}

• /**
  • show_efi_boot_dump() - dump all UEFI load options

@@ -709,38 +730,57 @@ static void show_efi_boot_opt(int id) static int do_efi_boot_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) {

• char regex[256];
• char * const regexlist[] = {regex};
• char *variables = NULL, *boot, *value;
• int len;
• int id;

• u16 *var_name16, *p;

• efi_uintn_t buf_size, size;

• efi_guid_t guid;

• int id, i;

• efi_status_t ret;

  if (argc > 1) return CMD_RET_USAGE;

• snprintf(regex, 256, "efi_.*-.*-.*-.*-.*_Boot[0-9A-F]+");
• /* TODO: use GetNextVariableName? */
• len = hexport_r(&env_htab, '\n', H_MATCH_REGEX | H_MATCH_KEY,

• 	&variables, 0, 1, regexlist);
  

• buf_size = 128;
• var_name16 = malloc(buf_size);
• if (!var_name16)

• return CMD_RET_FAILURE;
  
  

• if (!len)

• return CMD_RET_SUCCESS;
  

• var_name16[0] = 0;
• for (;;) {

• size = buf_size;
  

• ret = EFI_CALL(efi_get_next_variable_name(&size, var_name16,
  

• 					  &guid));
  

• if (ret == EFI_NOT_FOUND)
  

• 	break;
  

• if (ret == EFI_BUFFER_TOO_SMALL) {
  

• 	buf_size = size;
  

• 	p = realloc(var_name16, buf_size);
  

• 	if (!p) {
  

• 		free(var_name16);
  

• 		return CMD_RET_FAILURE;
  

• 	}
  

• 	var_name16 = p;
  

• 	ret = EFI_CALL(efi_get_next_variable_name(&size,
  

• 						  var_name16,
  

• 						  &guid));
  

• }
  

• if (ret != EFI_SUCCESS) {
  

• 	free(var_name16);
  

• 	return CMD_RET_FAILURE;
  

• }
  
  

• if (len < 0)

• return CMD_RET_FAILURE;
  

• if (u16_strncmp(var_name16, L"Boot", 4) || var_name16[8] ||
  

We can use memcmp() here. This avoids introducing u16_strncmp().

•     !u16_isxdigit(var_name16[4]) ||
  

•     !u16_isxdigit(var_name16[5]) ||
  

•     !u16_isxdigit(var_name16[6]) ||
  

•     !u16_isxdigit(var_name16[7]))
  

• 	continue;
  
  

• boot = variables;
• while (*boot) {

• value = strstr(boot, "Boot") + 4;
  

• id = (int)simple_strtoul(value, NULL, 16);
  

• for (id = 0, i = 0; i < 4; i++)
  

• 	id = (id << 4) + u16_tohex(var_name16[4 + i]);
  

This all can be simplified if we unify u16_isxdigit() and u16_tohex(). Just one function returning -1 if not a hexadecimal and 0 - 15 otherwise.

show_efi_boot_opt(id);

• boot = strchr(boot, '\n');
  

• if (!*boot)
  

• 	break;
  

• boot++;
  

  }
• free(variables);

• free(var_name16);

  return CMD_RET_SUCCESS; }

@@ -914,7 +954,7 @@ static int do_efi_boot_order(cmd_tbl_t *cmdtp, int flag, return CMD_RET_FAILURE;

for (i = 0; i < argc; i++) {

• id = (int)simple_strtoul(argv[i], &endp, 16);
  

• id = simple_strtoul(argv[i], &endp, 16);
  

This change is correct but unrelated. Please, put it into a separate patch. Or at least mention it in the commit message.

Best regards

Heinrich

if (*endp != '\0' || id > 0xffff) {
	printf("invalid value: %s\n", argv[i]);
	ret = CMD_RET_FAILURE;

On 4/24/19 8:30 AM, AKASHI Takahiro wrote:

We need a variant of env_save()/env_load() to handle dedicated storage for UEFI variables. It is assumed that env_efi_load() will be called only ince at init

%s/ince/once/

and that env_efi_save() will be called at every SetVariable.

In this patch, new parameters will be expected to be configured: CONFIG_ENV_EFI_FAT_DEVICE_AND_PART CONFIG_ENV_EFI_FAT_FILE in case of CONFIG_ENV_IS_IN_FAT.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

env/Kconfig | 34 ++++++++++ env/env.c | 98 ++++++++++++++++++++++++++- env/fat.c | 109 ++++++++++++++++++++++++++++++ include/asm-generic/global_data.h | 1 + include/environment.h | 24 +++++++ 5 files changed, 265 insertions(+), 1 deletion(-)

diff --git a/env/Kconfig b/env/Kconfig index 78300660c720..8f59e9347d4b 100644 --- a/env/Kconfig +++ b/env/Kconfig @@ -438,6 +438,34 @@ config ENV_FAT_FILE It's a string of the FAT file name. This file use to store the environment.

+config ENV_EFI_FAT_DEVICE_AND_PART

API wise there is no reason why we should prefer FAT over other file-systemes.

• string "Device and partition for where to store the UEFI non-volatile variables in FAT"
• depends on ENV_IS_IN_FAT

It should be possible to store the U-Boot variable on a different medium than the EFI variable.

• depends on EFI_LOADER
• help

•  Define this to a string to specify the partition of the device. It can
  

•  be as following:
  

•    "D:P", "D:0", "D", "D:" or "D:auto" (D, P are integers. And P >= 1)
  

•       - "D:P": device D partition P. Error occurs if device D has no
  

•                partition table.
  

•       - "D:0": device D.
  

•       - "D" or "D:": device D partition 1 if device D has partition
  

•                      table, or the whole device D if has no partition
  

•                      table.
  

•       - "D:auto": first partition in device D with bootable flag set.
  

•                   If none, first valid partition in device D. If no
  

•                   partition table then means device D.
  

+config ENV_EFI_FAT_FILE

• string "Name of the FAT file to use for the UEFI non-volatile variables"
• depends on ENV_IS_IN_FAT
• depends on EFI_LOADER
• default "uboot_efi.env"
• help

•  It's a string of the FAT file name. This file use to store the
  

•  UEFI non-volatile variables.
  

• config ENV_EXT4_INTERFACE string "Name of the block device for the environment" depends on ENV_IS_IN_EXT4

@@ -470,6 +498,12 @@ config ENV_EXT4_FILE It's a string of the EXT4 file name. This file use to store the environment (explicit path to the file)

+config ENV_EFI_SIZE

• hex "UEFI Variables Environment Size"

• default 0x20000

• help

•  Size of the UEFI variables storage area
  

• if ARCH_ROCKCHIP || ARCH_SUNXI || ARCH_ZYNQ || ARCH_ZYNQMP || ARCH_VERSAL || ARC

  config ENV_OFFSET

diff --git a/env/env.c b/env/env.c index 4b417b90a291..d5af761ba57e 100644 --- a/env/env.c +++ b/env/env.c @@ -24,6 +24,10 @@ void env_fix_drivers(void) entry->load += gd->reloc_off; if (entry->save) entry->save += gd->reloc_off;

• if (entry->efi_load)
  

• 	entry->efi_load += gd->reloc_off;
  

• if (entry->efi_save)
  

• 	entry->efi_save += gd->reloc_off;
  

  if (entry->init) entry->init += gd->reloc_off; }

@@ -125,7 +129,8 @@ __weak enum env_location env_get_location(enum env_operation op, int prio) if (prio >= ARRAY_SIZE(env_locations)) return ENVL_UNKNOWN;

• gd->env_load_prio = prio;

• if (op != ENVOP_EFI)

• gd->env_load_prio = prio;
  
  

  return env_locations[prio]; }

@@ -280,3 +285,94 @@ int env_init(void)

return ret; }

+#ifdef CONFIG_EFI_LOADER +extern struct hsearch_data efi_var_htab; +extern struct hsearch_data efi_nv_var_htab;

+/* TODO: experimental */ +int env_efi_save(void)

This function should be __efi_runtime.

+{

• struct env_driver *drv = NULL;
• int ret;
• if (!efi_nv_var_htab.table)

• return 0;
  

• if (gd->env_efi_prio == -1) {

• printf("Cannot save UEFI non-volatile variable\n");
  

• return -1;
  

• }
• drv = _env_driver_lookup(env_get_location(ENVOP_EFI, gd->env_efi_prio));

Some drivers will support writing at runtime some will not.

I think at initialization you should decide on the one and only environment driver. And the link to it should be shored in an __efi_runtime variable.

• if (!drv) {

• printf("Cannot save UEFI non-volatile variable\n");
  

• return -1;
  

• }
• ret = drv->efi_save();
• if (ret)

• printf("Saving UEFI non-volatile variable failed\n");
  

• return ret;

+}

+/* TODO: experimental */ +/* This function should be called only once at init */ +int env_efi_load(void)

This function needs to be __efi_runtime.

+{

• struct env_driver *drv = NULL;
• int prio, ret;
• enum env_location loc;
• gd->env_efi_prio = -1;
• /* volatile variables */
• if (!efi_var_htab.table) {

• ret = himport_r(&efi_var_htab, NULL, 0, '\0', 0, 0, 0, NULL);
  

• if (!ret) {
  

• 	printf("Creating default UEFI variables failed\n");
  

• 	return -1;
  

• }
  

• }
• /* non-loratile variables */
• if (efi_nv_var_htab.table)

• return 0;
  

• for (prio = 0; prio < ARRAY_SIZE(env_locations); prio++) {

• loc = env_get_location(ENVOP_EFI, prio);
  

• drv = _env_driver_lookup(loc);
  

• if (!drv)
  

• 	continue;
  

• if (drv->efi_load && drv->efi_save)
  

• 	break;
  

• }
• if (!drv || prio == ARRAY_SIZE(env_locations)) {

• printf("No driver for UEFI storage is available\n");
  

• return -1;
  

• }
• gd->env_efi_prio = prio;
• ret = drv->efi_load();
• if (ret) {

• printf("Loading UEFI non-volatile variables failed\n");
  

• return -1;
  

• }
• /* FIXME: init needed here? */
• if (!efi_nv_var_htab.table) {

• ret = himport_r(&efi_nv_var_htab, NULL, 0, '\0', 0, 0, 0, NULL);
  

• if (!ret) {
  

• 	printf("Creating default UEFI non-volatile variables failed\n");
  

• 	return -1;
  

• }
  

• return 0;
  

• }
• return 0;

+} +#endif /* CONFIG_EFI_LOADER */ diff --git a/env/fat.c b/env/fat.c index 7f74c64dfe7e..e2b050d4553d 100644 --- a/env/fat.c +++ b/env/fat.c @@ -14,6 +14,7 @@ #include <malloc.h> #include <memalign.h> #include <search.h> +#include <efi_loader.h> #include <errno.h> #include <fat.h> #include <mmc.h> @@ -128,6 +129,110 @@ err_env_relocate: } #endif /* LOADENV */

+#ifdef CONFIG_EFI_LOADER +#if 1 +extern int efi_variable_import(const char *buf, int check); +extern int efi_variable_export(env_t *env_out); +#endif +static int env_fat_efi_save(void)

Please, define a u-class for the different EFI variable stores. Currently there should be two of them:

- u-boot variables - EFI env file (on any block device supporting file writes)

The driver should provide an indication if it is supporting runtime access.

+{

• env_t __aligned(ARCH_DMA_MINALIGN) env_new;
• struct blk_desc *dev_desc = NULL;
• disk_partition_t info;
• int dev, part;
• int err;
• loff_t size;
• err = efi_variable_export(&env_new);
• if (err)

• return err;
  

• part = blk_get_device_part_str(CONFIG_ENV_FAT_INTERFACE,

• 		       CONFIG_ENV_EFI_FAT_DEVICE_AND_PART,
  

• 		       &dev_desc, &info, 1);
  

• if (part < 0)

• return 1;
  

• dev = dev_desc->devnum;
• if (fat_set_blk_dev(dev_desc, &info) != 0) {

• /*
  

•  * This printf is embedded in the messages from env_save that
  

•  * will calling it. The missing \n is intentional.
  

•  */
  

• printf("Unable to use %s %d:%d... ",
  

•        CONFIG_ENV_FAT_INTERFACE, dev, part);
  

• return 1;
  

• }
• err = file_fat_write(CONFIG_ENV_EFI_FAT_FILE,

• 	     (void *)&env_new, 0, sizeof(env_t), &size);
  

• if (err < 0) {

• /*
  

•  * This printf is embedded in the messages from env_save that
  

•  * will calling it. The missing \n is intentional.
  

•  */
  

• printf("Unable to write \"%s\" from %s%d:%d... ",
  

•        CONFIG_ENV_EFI_FAT_FILE, CONFIG_ENV_FAT_INTERFACE,
  

•        dev, part);
  

• return 1;
  

• }
• return 0;

+}

+static int env_fat_efi_load(void) +{

• ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_EFI_SIZE);
• struct blk_desc *dev_desc = NULL;
• disk_partition_t info;
• int dev, part;
• int err;

+#ifdef CONFIG_MMC

• if (!strcmp(CONFIG_ENV_FAT_INTERFACE, "mmc"))

• mmc_initialize(NULL);
  

+#endif

• part = blk_get_device_part_str(CONFIG_ENV_FAT_INTERFACE,

• 		       CONFIG_ENV_EFI_FAT_DEVICE_AND_PART,
  

• 		       &dev_desc, &info, 1);
  

• if (part < 0)

• goto err_env_relocate;
  

• dev = dev_desc->devnum;
• if (fat_set_blk_dev(dev_desc, &info) != 0) {

• /*
  

•  * This printf is embedded in the messages from env_save that
  

•  * will calling it. The missing \n is intentional.
  

•  */
  

• printf("Unable to use %s %d:%d...\n",
  

•        CONFIG_ENV_FAT_INTERFACE, dev, part);
  

• goto err_env_relocate;
  

• }
• err = file_fat_read(CONFIG_ENV_EFI_FAT_FILE, buf, CONFIG_ENV_EFI_SIZE);
• if (err <= 0 && (err != -ENOENT)) {

• /*
  

•  * This printf is embedded in the messages from env_save that
  

•  * will calling it. The missing \n is intentional.
  

•  */
  

• printf("Unable to read \"%s\" from %s %d:%d...\n",
  

•        CONFIG_ENV_EFI_FAT_FILE, CONFIG_ENV_FAT_INTERFACE,
  

•        dev, part);
  

• goto err_env_relocate;
  

• }
• if (err > 0)

• return efi_variable_import(buf, 1);
  

• else

• return 0;
  

+err_env_relocate:

• return -EIO;

+} +#endif /* CONFIG_EFI_LOADER */

• U_BOOT_ENV_LOCATION(fat) = { .location = ENVL_FAT, ENV_NAME("FAT")

@@ -137,4 +242,8 @@ U_BOOT_ENV_LOCATION(fat) = { #ifdef CMD_SAVEENV .save = env_save_ptr(env_fat_save), #endif +#ifdef CONFIG_EFI_LOADER

• .efi_load = env_fat_efi_load,
• .efi_save = env_fat_efi_save,

+#endif }; diff --git a/include/asm-generic/global_data.h b/include/asm-generic/global_data.h index 78dcf40bff48..8c4d56c346f3 100644 --- a/include/asm-generic/global_data.h +++ b/include/asm-generic/global_data.h @@ -51,6 +51,7 @@ typedef struct global_data { unsigned long env_valid; /* Environment valid? enum env_valid */ unsigned long env_has_init; /* Bitmask of boolean of struct env_location offsets */ int env_load_prio; /* Priority of the loaded environment */

• int env_efi_prio; /* Priority of the UEFI variables */

  unsigned long ram_base; /* Base address of RAM used by U-Boot */ unsigned long ram_top; /* Top address of RAM used by U-Boot */

diff --git a/include/environment.h b/include/environment.h index cd966761416e..f62399863ef9 100644 --- a/include/environment.h +++ b/include/environment.h @@ -200,6 +200,7 @@ enum env_operation { ENVOP_INIT, /* we want to call the init function */ ENVOP_LOAD, /* we want to call the load function */ ENVOP_SAVE, /* we want to call the save function */

• ENVOP_EFI, /* we want to call the efi_load/save function */ };

  struct env_driver {

@@ -225,6 +226,24 @@ struct env_driver {

If you would want to reuse the env driver you could simply change load() and save() to accept a filename as parameter.

Buf why mess with env_driver?

I think the EFI variable driver can simply use the functions provided in include/fs.h: fs_set_blk_dev(), fs_write(), fs_read().

Best regards

Heinrich

*/

int (*save)(void);

• /**

• * efi_load() - Load UEFI non-volatile variables from storage
  

• *
  

• * This method is required for UEFI non-volatile variables
  

• *
  

• * @return 0 if OK, -ve on error
  

• */
  

• int (*efi_load)(void);
• /**

• * efi_save() - Save UEFI non-volatile variables to storage
  

• *
  

• * This method is required for UEFI non-volatile variables
  

• *
  

• * @return 0 if OK, -ve on error
  

• */
  

• int (*efi_save)(void);
• /**
  • init() - Set up the initial pre-relocation environment

@@ -312,6 +331,11 @@ void eth_parse_enetaddr(const char *addr, uint8_t *enetaddr); int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr); int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr);

+#ifdef CONFIG_EFI_LOADER +int env_efi_load(void); +int env_efi_save(void); +#endif

• #endif /* DO_DEPS_ONLY */

  #endif /* _ENVIRONMENT_H_ */