Grub get and set efi variables

Grub get and set efi variables

[Mat Troi]

[-- Attachment #1: Type: text/plain, Size: 506 bytes --]

Hi,

Searching through google, I see there was an email thread to add a patch
for getting and setting efi variable in GRUB2.
https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html

However, looking at the tree, it doesn't look like this patch was added, am
I missing something?  Does anyone know if we have command to get/set efi
variables in GRUB2?
http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD

Thanks,
Mat

[-- Attachment #2: Type: text/html, Size: 834 bytes --]

Re: Grub get and set efi variables

[SevenBits]

[-- Attachment #1: Type: text/plain, Size: 771 bytes --]

On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:

> Hi,
>
> Searching through google, I see there was an email thread to add a patch
> for getting and setting efi variable in GRUB2.
> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>
> However, looking at the tree, it doesn't look like this patch was added,
> am I missing something?  Does anyone know if we have command to get/set efi
> variables in GRUB2?
>
>
> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>
>
I'm the author of that patch. No, it was never merged into the tree. As far
as I know, there is no equivalent functionality; GRUB does not support this
feature.


> Thanks,
> Mat
>

[-- Attachment #2: Type: text/html, Size: 1466 bytes --]

Re: Grub get and set efi variables

[Mat Troi]

[-- Attachment #1: Type: text/plain, Size: 1198 bytes --]

Hi SevenBits,

Thanks for letting me know.  Out of curiosity, any particular reason why
this patch did not get merged?  It looks to be a useful feature.

Thanks,
Mat

On Tue, Nov 3, 2015 at 12:12 PM, SevenBits <sevenbitstech@gmail.com> wrote:

> On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:
>
>> Hi,
>>
>> Searching through google, I see there was an email thread to add a patch
>> for getting and setting efi variable in GRUB2.
>> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>>
>> However, looking at the tree, it doesn't look like this patch was added,
>> am I missing something?  Does anyone know if we have command to get/set efi
>> variables in GRUB2?
>>
>>
>> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>>
>>
> I'm the author of that patch. No, it was never merged into the tree. As
> far as I know, there is no equivalent functionality; GRUB does not support
> this feature.
>
>
>> Thanks,
>> Mat
>>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>
>

[-- Attachment #2: Type: text/html, Size: 2406 bytes --]

Re: Grub get and set efi variables

[Andrei Borzenkov]

04.11.2015 02:05, Mat Troi пишет:
> Hi SevenBits,
>
> Thanks for letting me know.  Out of curiosity, any particular reason why
> this patch did not get merged?  It looks to be a useful feature.
>

First, this patch was reverse patch :)

I am not convinced making it easy to set EFI variable from within GRUB 
is good thing, because there are known reports about systems rendered 
unbootable by writing too much into EFI flash. What is your use case 
that absolutely requires setting EFI variables? How are you going to 
implement it on other platforms?

Reading does not harm and may be useful, but then it should provide 
generic interface to access arbitrary vendor namespace, not only EFI 
global variables, and handle arbitrary binary data, even if initial 
implementation handles only subset of them. Once someone starts to use 
it changing it will be much more difficult.

May be it should take hints how to interpret variable values, or have 
format option akin to printf.

> Thanks,
> Mat
>
> On Tue, Nov 3, 2015 at 12:12 PM, SevenBits <sevenbitstech@gmail.com> wrote:
>
>> On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:
>>
>>> Hi,
>>>
>>> Searching through google, I see there was an email thread to add a patch
>>> for getting and setting efi variable in GRUB2.
>>> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>>>
>>> However, looking at the tree, it doesn't look like this patch was added,
>>> am I missing something?  Does anyone know if we have command to get/set efi
>>> variables in GRUB2?
>>>
>>>
>>> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>>>
>>>
>> I'm the author of that patch. No, it was never merged into the tree. As
>> far as I know, there is no equivalent functionality; GRUB does not support
>> this feature.
>>
>>
>>> Thanks,
>>> Mat
>>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
>>
>
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>

Re: Grub get and set efi variables

[SevenBits]

[-- Attachment #1: Type: text/plain, Size: 3630 bytes --]

On Wednesday, November 4, 2015, Andrei Borzenkov <arvidjaar@gmail.com>
wrote:

> 04.11.2015 02:05, Mat Troi пишет:
>
>> Hi SevenBits,
>>
>> Thanks for letting me know.  Out of curiosity, any particular reason why
>> this patch did not get merged?  It looks to be a useful feature.
>>
>>
> First, this patch was reverse patch :)


Yeah, I think I had accidentally passed the arguments to the diff command
in the wrong order.


>
> I am not convinced making it easy to set EFI variable from within GRUB is
> good thing, because there are known reports about systems rendered
> unbootable by writing too much into EFI flash. What is your use case that
> absolutely requires setting EFI variables? How are you going to implement
> it on other platforms?


I should probably note that I wrote this patch for a specific project of
mine which required the ability to read UEFI variables. I added in write
functionality for good measure because I could. But I agree, this would
only encourage tinkering and users messing with their systems and
potentially bricking it, which would of course be blamed on GRUB.


>
> Reading does not harm and may be useful, but then it should provide
> generic interface to access arbitrary vendor namespace, not only EFI global
> variables, and handle arbitrary binary data, even if initial implementation
> handles only subset of them. Once someone starts to use it changing it will
> be much more difficult.
>
> Maybe it should take hints how to interpret variable values, or have
> format option akin to printf.


I would be happy to resume work on this, and debase it on the current code,
if GRUB has a clear need for such functionality. I would prefer to have it
be clear what the patch should consist of, though.

A key question would be how to e.g. handle arbitrary data stored in
variables if it is not something easily represent able like a string. Right
now, the patch stores it's value into an environment variable specified by
the user. Unless the powers that be think otherwise, I think this is the
best way to go.


>
> Thanks,
>> Mat
>>
>> On Tue, Nov 3, 2015 at 12:12 PM, SevenBits <sevenbitstech@gmail.com>
>> wrote:
>>
>> On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:
>>>
>>> Hi,
>>>>
>>>> Searching through google, I see there was an email thread to add a patch
>>>> for getting and setting efi variable in GRUB2.
>>>> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>>>>
>>>> However, looking at the tree, it doesn't look like this patch was added,
>>>> am I missing something?  Does anyone know if we have command to get/set
>>>> efi
>>>> variables in GRUB2?
>>>>
>>>>
>>>>
>>>> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>>>>
>>>>
>>>> I'm the author of that patch. No, it was never merged into the tree. As
>>> far as I know, there is no equivalent functionality; GRUB does not
>>> support
>>> this feature.
>>>
>>>
>>> Thanks,
>>>> Mat
>>>>
>>>>
>>> _______________________________________________
>>> Grub-devel mailing list
>>> Grub-devel@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>
>>>
>>>
>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
>>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>

[-- Attachment #2: Type: text/html, Size: 5385 bytes --]

Re: Grub get and set efi variables

[Ignat Korchagin]

Actually, I submitted similar patch recently as well. It provides read
function for variables and accepts a hint on how to process them. The
original patch is here:
https://lists.gnu.org/archive/html/grub-devel/2015-09/msg00043.html.

Probably, I forgot to enable plain-text mode, so it got there as a
binary attachment. I will repeat it here for convenience.

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 9764cd2..49fa3ec 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -728,6 +728,12 @@ module = {
 };

 module = {
+  name = efivar;
+  efi = commands/efi/efivar.c;
+  enable = efi;
+};
+
+module = {
   name = blocklist;
   common = commands/blocklist.c;
 };
diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
new file mode 100644
index 0000000..ca206eb
--- /dev/null
+++ b/grub-core/commands/efi/efivar.c
@@ -0,0 +1,146 @@
+/* efivar.c - Read EFI global variables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 Free Software Foundation, Inc.
+ *  Copyright (C) 2015 CloudFlare, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"type", 't', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR as
specific type (hex, uint8, string). Default: hex."), N_("TYPE"),
ARG_TYPE_STRING},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum efi_var_type
+  {
+    EFI_VAR_STRING = 0,
+    EFI_VAR_UINT8,
+    EFI_VAR_HEX,
+    EFI_VAR_INVALID = -1
+  };
+
+static enum efi_var_type
+parse_efi_var_type (const char *type)
+{
+  if (!grub_strncmp (type, "string", sizeof("string")))
+    return EFI_VAR_STRING;
+
+  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
+    return EFI_VAR_UINT8;
+
+  if (!grub_strncmp (type, "hex", sizeof("hex")))
+    return EFI_VAR_HEX;
+
+  return EFI_VAR_INVALID;
+}
+
+static grub_err_t
+grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
+  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  grub_err_t status;
+  void *efi_var = NULL;
+  grub_size_t efi_var_size = 0;
+  enum efi_var_type efi_type = EFI_VAR_HEX;
+  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
+  char *env_var = NULL;
+  grub_size_t i;
+
+  if (2 != argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments expected"));
+
+  if (state[0].set)
+    efi_type = parse_efi_var_type (state[0].arg);
+
+  if (EFI_VAR_INVALID == efi_type)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid EFI variable type"));
+
+  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
+  if (!efi_var || !efi_var_size)
+    status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
+
+  switch (efi_type)
+  {
+    case EFI_VAR_STRING:
+      env_var = grub_malloc (efi_var_size + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_memcpy(env_var, efi_var, efi_var_size);
+      env_var[efi_var_size] = '\0';
+      break;
+
+    case EFI_VAR_UINT8:
+      env_var = grub_malloc (4);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
+      break;
+
+    case EFI_VAR_HEX:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      for (i = 0; i < efi_var_size; i++)
+        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
*)efi_var)[i]);
+      break;
+
+    default:
+      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
in module?)"));
+  }
+
+  status = grub_env_set (args[1], env_var);
+
+  if (env_var)
+    grub_free (env_var);
+
+  if (efi_var)
+    grub_free (efi_var);
+
+  return status;
+}
+
+static grub_extcmd_t cmd = NULL;
+
+GRUB_MOD_INIT (efivar)
+{
+  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
N_("[-t TYPE] EFI_VAR ENV_VAR"),
+ N_("Read EFI variable and put its contents in environment
variable."), options);
+}
+
+GRUB_MOD_FINI (efivar)
+{
+  if (cmd)
+    grub_unregister_extcmd (cmd);
+}


On Thu, Nov 5, 2015 at 10:25 AM, SevenBits <sevenbitstech@gmail.com> wrote:
> On Wednesday, November 4, 2015, Andrei Borzenkov <arvidjaar@gmail.com>
> wrote:
>>
>> 04.11.2015 02:05, Mat Troi пишет:
>>>
>>> Hi SevenBits,
>>>
>>> Thanks for letting me know.  Out of curiosity, any particular reason why
>>> this patch did not get merged?  It looks to be a useful feature.
>>>
>>
>> First, this patch was reverse patch :)
>
>
> Yeah, I think I had accidentally passed the arguments to the diff command in
> the wrong order.
>
>>
>>
>> I am not convinced making it easy to set EFI variable from within GRUB is
>> good thing, because there are known reports about systems rendered
>> unbootable by writing too much into EFI flash. What is your use case that
>> absolutely requires setting EFI variables? How are you going to implement it
>> on other platforms?
>
>
> I should probably note that I wrote this patch for a specific project of
> mine which required the ability to read UEFI variables. I added in write
> functionality for good measure because I could. But I agree, this would only
> encourage tinkering and users messing with their systems and potentially
> bricking it, which would of course be blamed on GRUB.
>
>>
>>
>> Reading does not harm and may be useful, but then it should provide
>> generic interface to access arbitrary vendor namespace, not only EFI global
>> variables, and handle arbitrary binary data, even if initial implementation
>> handles only subset of them. Once someone starts to use it changing it will
>> be much more difficult.
>>
>> Maybe it should take hints how to interpret variable values, or have
>> format option akin to printf.
>
>
> I would be happy to resume work on this, and debase it on the current code,
> if GRUB has a clear need for such functionality. I would prefer to have it
> be clear what the patch should consist of, though.
>
> A key question would be how to e.g. handle arbitrary data stored in
> variables if it is not something easily represent able like a string. Right
> now, the patch stores it's value into an environment variable specified by
> the user. Unless the powers that be think otherwise, I think this is the
> best way to go.
>
>>
>>
>>> Thanks,
>>> Mat
>>>
>>> On Tue, Nov 3, 2015 at 12:12 PM, SevenBits <sevenbitstech@gmail.com>
>>> wrote:
>>>
>>>> On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:
>>>>
>>>>> Hi,
>>>>>
>>>>> Searching through google, I see there was an email thread to add a
>>>>> patch
>>>>> for getting and setting efi variable in GRUB2.
>>>>> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>>>>>
>>>>> However, looking at the tree, it doesn't look like this patch was
>>>>> added,
>>>>> am I missing something?  Does anyone know if we have command to get/set
>>>>> efi
>>>>> variables in GRUB2?
>>>>>
>>>>>
>>>>>
>>>>> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>>>>>
>>>>>
>>>> I'm the author of that patch. No, it was never merged into the tree. As
>>>> far as I know, there is no equivalent functionality; GRUB does not
>>>> support
>>>> this feature.
>>>>
>>>>
>>>>> Thanks,
>>>>> Mat
>>>>>
>>>>
>>>> _______________________________________________
>>>> Grub-devel mailing list
>>>> Grub-devel@gnu.org
>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>
>>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Grub-devel mailing list
>>> Grub-devel@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>
>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>

Re: Grub get and set efi variables

[Andrei Borzenkov]

06.11.2015 05:00, Ignat Korchagin пишет:
> Actually, I submitted similar patch recently as well. It provides read
> function for variables and accepts a hint on how to process them. The
> original patch is here:
> https://lists.gnu.org/archive/html/grub-devel/2015-09/msg00043.html.
>

Yes, I was intending to comment on it, sorry.

I am still unsure whether printf-like format specifier could be more 
flexible, but otherwise I like it in that it provides for future 
extensions. see comments below.

> Probably, I forgot to enable plain-text mode, so it got there as a
> binary attachment. I will repeat it here for convenience.
>
> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> index 9764cd2..49fa3ec 100644
> --- a/grub-core/Makefile.core.def
> +++ b/grub-core/Makefile.core.def
> @@ -728,6 +728,12 @@ module = {
>   };
>
>   module = {
> +  name = efivar;
> +  efi = commands/efi/efivar.c;
> +  enable = efi;
> +};
> +
> +module = {
>     name = blocklist;
>     common = commands/blocklist.c;
>   };
> diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
> new file mode 100644
> index 0000000..ca206eb
> --- /dev/null
> +++ b/grub-core/commands/efi/efivar.c
> @@ -0,0 +1,146 @@
> +/* efivar.c - Read EFI global variables. */
> +/*
> + *  GRUB  --  GRand Unified Bootloader
> + *  Copyright (C) 2015 Free Software Foundation, Inc.
> + *  Copyright (C) 2015 CloudFlare, Inc.
> + *
> + *  GRUB is free software: you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation, either version 3 of the License, or
> + *  (at your option) any later version.
> + *
> + *  GRUB is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <grub/types.h>
> +#include <grub/mm.h>
> +#include <grub/misc.h>
> +#include <grub/efi/api.h>
> +#include <grub/efi/efi.h>
> +#include <grub/extcmd.h>
> +#include <grub/env.h>
> +
> +GRUB_MOD_LICENSE ("GPLv3+");
> +
> +static const struct grub_arg_option options[] = {
> +  {"type", 't', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR as
> specific type (hex, uint8, string). Default: hex."), N_("TYPE"),
> ARG_TYPE_STRING},
> +  {0, 0, 0, 0, 0, 0}
> +};
> +
> +enum efi_var_type
> +  {
> +    EFI_VAR_STRING = 0,
> +    EFI_VAR_UINT8,
> +    EFI_VAR_HEX,
> +    EFI_VAR_INVALID = -1
> +  };
> +
> +static enum efi_var_type
> +parse_efi_var_type (const char *type)
> +{
> +  if (!grub_strncmp (type, "string", sizeof("string")))
> +    return EFI_VAR_STRING;
> +

I think this should be "ascii" or "utf8". "string" is too ambiguous in 
UEFI environment, it can also mean sequence of UCS-2 characters.

> +  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
> +    return EFI_VAR_UINT8;
> +
> +  if (!grub_strncmp (type, "hex", sizeof("hex")))
> +    return EFI_VAR_HEX;
> +
> +  return EFI_VAR_INVALID;
> +}
> +
> +static grub_err_t
> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
> +  int argc, char **args)
> +{
> +  struct grub_arg_list *state = ctxt->state;
> +  grub_err_t status;
> +  void *efi_var = NULL;
> +  grub_size_t efi_var_size = 0;
> +  enum efi_var_type efi_type = EFI_VAR_HEX;
> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
> +  char *env_var = NULL;
> +  grub_size_t i;
> +
> +  if (2 != argc)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments expected"));
> +

May be follow the suite and use "--set var". It could be useful to 
simply display variable on screen, like

efivar OsIndicators

or even

efivar --all

> +  if (state[0].set)
> +    efi_type = parse_efi_var_type (state[0].arg);
> +
> +  if (EFI_VAR_INVALID == efi_type)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid EFI variable type"));
> +
> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
> +  if (!efi_var || !efi_var_size)
> +    status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
> +

Should it distinguish between non-existent variable and failure to read 
variable? Is non-existent variable an error?

> +  switch (efi_type)
> +  {
> +    case EFI_VAR_STRING:
> +      env_var = grub_malloc (efi_var_size + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      grub_memcpy(env_var, efi_var, efi_var_size);
> +      env_var[efi_var_size] = '\0';
> +      break;
> +
> +    case EFI_VAR_UINT8:
> +      env_var = grub_malloc (4);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
> +      break;
> +
> +    case EFI_VAR_HEX:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      for (i = 0; i < efi_var_size; i++)
> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
> *)efi_var)[i]);
> +      break;
> +
> +    default:
> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
> in module?)"));
> +  }
> +
> +  status = grub_env_set (args[1], env_var);
> +
> +  if (env_var)
> +    grub_free (env_var);
> +
> +  if (efi_var)
> +    grub_free (efi_var);
> +
> +  return status;
> +}
> +
> +static grub_extcmd_t cmd = NULL;
> +
> +GRUB_MOD_INIT (efivar)
> +{
> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> N_("[-t TYPE] EFI_VAR ENV_VAR"),
> + N_("Read EFI variable and put its contents in environment
> variable."), options);
> +}
> +
> +GRUB_MOD_FINI (efivar)
> +{
> +  if (cmd)
> +    grub_unregister_extcmd (cmd);
> +}
>
>
> On Thu, Nov 5, 2015 at 10:25 AM, SevenBits <sevenbitstech@gmail.com> wrote:
>> On Wednesday, November 4, 2015, Andrei Borzenkov <arvidjaar@gmail.com>
>> wrote:
>>>
>>> 04.11.2015 02:05, Mat Troi пишет:
>>>>
>>>> Hi SevenBits,
>>>>
>>>> Thanks for letting me know.  Out of curiosity, any particular reason why
>>>> this patch did not get merged?  It looks to be a useful feature.
>>>>
>>>
>>> First, this patch was reverse patch :)
>>
>>
>> Yeah, I think I had accidentally passed the arguments to the diff command in
>> the wrong order.
>>
>>>
>>>
>>> I am not convinced making it easy to set EFI variable from within GRUB is
>>> good thing, because there are known reports about systems rendered
>>> unbootable by writing too much into EFI flash. What is your use case that
>>> absolutely requires setting EFI variables? How are you going to implement it
>>> on other platforms?
>>
>>
>> I should probably note that I wrote this patch for a specific project of
>> mine which required the ability to read UEFI variables. I added in write
>> functionality for good measure because I could. But I agree, this would only
>> encourage tinkering and users messing with their systems and potentially
>> bricking it, which would of course be blamed on GRUB.
>>
>>>
>>>
>>> Reading does not harm and may be useful, but then it should provide
>>> generic interface to access arbitrary vendor namespace, not only EFI global
>>> variables, and handle arbitrary binary data, even if initial implementation
>>> handles only subset of them. Once someone starts to use it changing it will
>>> be much more difficult.
>>>
>>> Maybe it should take hints how to interpret variable values, or have
>>> format option akin to printf.
>>
>>
>> I would be happy to resume work on this, and debase it on the current code,
>> if GRUB has a clear need for such functionality. I would prefer to have it
>> be clear what the patch should consist of, though.
>>
>> A key question would be how to e.g. handle arbitrary data stored in
>> variables if it is not something easily represent able like a string. Right
>> now, the patch stores it's value into an environment variable specified by
>> the user. Unless the powers that be think otherwise, I think this is the
>> best way to go.
>>
>>>
>>>
>>>> Thanks,
>>>> Mat
>>>>
>>>> On Tue, Nov 3, 2015 at 12:12 PM, SevenBits <sevenbitstech@gmail.com>
>>>> wrote:
>>>>
>>>>> On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:
>>>>>
>>>>>> Hi,
>>>>>>
>>>>>> Searching through google, I see there was an email thread to add a
>>>>>> patch
>>>>>> for getting and setting efi variable in GRUB2.
>>>>>> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>>>>>>
>>>>>> However, looking at the tree, it doesn't look like this patch was
>>>>>> added,
>>>>>> am I missing something?  Does anyone know if we have command to get/set
>>>>>> efi
>>>>>> variables in GRUB2?
>>>>>>
>>>>>>
>>>>>>
>>>>>> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>>>>>>
>>>>>>
>>>>> I'm the author of that patch. No, it was never merged into the tree. As
>>>>> far as I know, there is no equivalent functionality; GRUB does not
>>>>> support
>>>>> this feature.
>>>>>
>>>>>
>>>>>> Thanks,
>>>>>> Mat
>>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Grub-devel mailing list
>>>>> Grub-devel@gnu.org
>>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>>
>>>>>
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> Grub-devel mailing list
>>>> Grub-devel@gnu.org
>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>
>>>
>>>
>>> _______________________________________________
>>> Grub-devel mailing list
>>> Grub-devel@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>

Re: Grub get and set efi variables

[Ignat Korchagin]

On Wed, Nov 11, 2015 at 10:09 AM, Andrei Borzenkov <arvidjaar@gmail.com> wrote:
> 06.11.2015 05:00, Ignat Korchagin пишет:
>>
>> Actually, I submitted similar patch recently as well. It provides read
>> function for variables and accepts a hint on how to process them. The
>> original patch is here:
>> https://lists.gnu.org/archive/html/grub-devel/2015-09/msg00043.html.
>>
>
> Yes, I was intending to comment on it, sorry.
>
> I am still unsure whether printf-like format specifier could be more
> flexible, but otherwise I like it in that it provides for future extensions.
> see comments below.
>
>
>> Probably, I forgot to enable plain-text mode, so it got there as a
>> binary attachment. I will repeat it here for convenience.
>>
>> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
>> index 9764cd2..49fa3ec 100644
>> --- a/grub-core/Makefile.core.def
>> +++ b/grub-core/Makefile.core.def
>> @@ -728,6 +728,12 @@ module = {
>>   };
>>
>>   module = {
>> +  name = efivar;
>> +  efi = commands/efi/efivar.c;
>> +  enable = efi;
>> +};
>> +
>> +module = {
>>     name = blocklist;
>>     common = commands/blocklist.c;
>>   };
>> diff --git a/grub-core/commands/efi/efivar.c
>> b/grub-core/commands/efi/efivar.c
>> new file mode 100644
>> index 0000000..ca206eb
>> --- /dev/null
>> +++ b/grub-core/commands/efi/efivar.c
>> @@ -0,0 +1,146 @@
>> +/* efivar.c - Read EFI global variables. */
>> +/*
>> + *  GRUB  --  GRand Unified Bootloader
>> + *  Copyright (C) 2015 Free Software Foundation, Inc.
>> + *  Copyright (C) 2015 CloudFlare, Inc.
>> + *
>> + *  GRUB is free software: you can redistribute it and/or modify
>> + *  it under the terms of the GNU General Public License as published by
>> + *  the Free Software Foundation, either version 3 of the License, or
>> + *  (at your option) any later version.
>> + *
>> + *  GRUB is distributed in the hope that it will be useful,
>> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + *  GNU General Public License for more details.
>> + *
>> + *  You should have received a copy of the GNU General Public License
>> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
>> + */
>> +
>> +#include <grub/types.h>
>> +#include <grub/mm.h>
>> +#include <grub/misc.h>
>> +#include <grub/efi/api.h>
>> +#include <grub/efi/efi.h>
>> +#include <grub/extcmd.h>
>> +#include <grub/env.h>
>> +
>> +GRUB_MOD_LICENSE ("GPLv3+");
>> +
>> +static const struct grub_arg_option options[] = {
>> +  {"type", 't', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR as
>> specific type (hex, uint8, string). Default: hex."), N_("TYPE"),
>> ARG_TYPE_STRING},
>> +  {0, 0, 0, 0, 0, 0}
>> +};
>> +
>> +enum efi_var_type
>> +  {
>> +    EFI_VAR_STRING = 0,
>> +    EFI_VAR_UINT8,
>> +    EFI_VAR_HEX,
>> +    EFI_VAR_INVALID = -1
>> +  };
>> +
>> +static enum efi_var_type
>> +parse_efi_var_type (const char *type)
>> +{
>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>> +    return EFI_VAR_STRING;
>> +
>
>
> I think this should be "ascii" or "utf8". "string" is too ambiguous in UEFI
> environment, it can also mean sequence of UCS-2 characters.
I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
when printing. Maybe, to avoid confusion, it might be better to
completely remove this option. Basically, you do not want to interpret
raw buffers as strings. For best compatibility "hex" mode should be
promoted, I guess. What do you think?
>
>> +  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
>> +    return EFI_VAR_UINT8;
>> +
>> +  if (!grub_strncmp (type, "hex", sizeof("hex")))
>> +    return EFI_VAR_HEX;
>> +
>> +  return EFI_VAR_INVALID;
>> +}
>> +
>> +static grub_err_t
>> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
>> +  int argc, char **args)
>> +{
>> +  struct grub_arg_list *state = ctxt->state;
>> +  grub_err_t status;
>> +  void *efi_var = NULL;
>> +  grub_size_t efi_var_size = 0;
>> +  enum efi_var_type efi_type = EFI_VAR_HEX;
>> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
>> +  char *env_var = NULL;
>> +  grub_size_t i;
>> +
>> +  if (2 != argc)
>> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments
>> expected"));
>> +
>
>
> May be follow the suite and use "--set var". It could be useful to simply
> display variable on screen, like
>
> efivar OsIndicators
>
> or even
>
> efivar --all
>
Yes. Agree.
>> +  if (state[0].set)
>> +    efi_type = parse_efi_var_type (state[0].arg);
>> +
>> +  if (EFI_VAR_INVALID == efi_type)
>> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid EFI variable
>> type"));
>> +
>> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
>> +  if (!efi_var || !efi_var_size)
>> +    status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read
>> variable"));
>> +
>
>
> Should it distinguish between non-existent variable and failure to read
> variable? Is non-existent variable an error?
>
>
grub_efi_get_variable itself does not report the difference. It should
be modified to do that. From possible use-cases does it really matter
why you did not get the variable?
>> +  switch (efi_type)
>> +  {
>> +    case EFI_VAR_STRING:
>> +      env_var = grub_malloc (efi_var_size + 1);
>> +      if (!env_var)
>> +        {
>> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
>> memory"));
>> +          break;
>> +        }
>> +      grub_memcpy(env_var, efi_var, efi_var_size);
>> +      env_var[efi_var_size] = '\0';
>> +      break;
>> +
>> +    case EFI_VAR_UINT8:
>> +      env_var = grub_malloc (4);
>> +      if (!env_var)
>> +        {
>> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
>> memory"));
>> +          break;
>> +        }
>> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
>> +      break;
>> +
>> +    case EFI_VAR_HEX:
>> +      env_var = grub_malloc (efi_var_size * 2 + 1);
>> +      if (!env_var)
>> +        {
>> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
>> memory"));
>> +          break;
>> +        }
>> +      for (i = 0; i < efi_var_size; i++)
>> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
>> *)efi_var)[i]);
>> +      break;
>> +
>> +    default:
>> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
>> in module?)"));
>> +  }
>> +
>> +  status = grub_env_set (args[1], env_var);
>> +
>> +  if (env_var)
>> +    grub_free (env_var);
>> +
>> +  if (efi_var)
>> +    grub_free (efi_var);
>> +
>> +  return status;
>> +}
>> +
>> +static grub_extcmd_t cmd = NULL;
>> +
>> +GRUB_MOD_INIT (efivar)
>> +{
>> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
>> N_("[-t TYPE] EFI_VAR ENV_VAR"),
>> + N_("Read EFI variable and put its contents in environment
>> variable."), options);
>> +}
>> +
>> +GRUB_MOD_FINI (efivar)
>> +{
>> +  if (cmd)
>> +    grub_unregister_extcmd (cmd);
>> +}
>>
>>
>> On Thu, Nov 5, 2015 at 10:25 AM, SevenBits <sevenbitstech@gmail.com>
>> wrote:
>>>
>>> On Wednesday, November 4, 2015, Andrei Borzenkov <arvidjaar@gmail.com>
>>> wrote:
>>>>
>>>>
>>>> 04.11.2015 02:05, Mat Troi пишет:
>>>>>
>>>>>
>>>>> Hi SevenBits,
>>>>>
>>>>> Thanks for letting me know.  Out of curiosity, any particular reason
>>>>> why
>>>>> this patch did not get merged?  It looks to be a useful feature.
>>>>>
>>>>
>>>> First, this patch was reverse patch :)
>>>
>>>
>>>
>>> Yeah, I think I had accidentally passed the arguments to the diff command
>>> in
>>> the wrong order.
>>>
>>>>
>>>>
>>>> I am not convinced making it easy to set EFI variable from within GRUB
>>>> is
>>>> good thing, because there are known reports about systems rendered
>>>> unbootable by writing too much into EFI flash. What is your use case
>>>> that
>>>> absolutely requires setting EFI variables? How are you going to
>>>> implement it
>>>> on other platforms?
>>>
>>>
>>>
>>> I should probably note that I wrote this patch for a specific project of
>>> mine which required the ability to read UEFI variables. I added in write
>>> functionality for good measure because I could. But I agree, this would
>>> only
>>> encourage tinkering and users messing with their systems and potentially
>>> bricking it, which would of course be blamed on GRUB.
>>>
>>>>
>>>>
>>>> Reading does not harm and may be useful, but then it should provide
>>>> generic interface to access arbitrary vendor namespace, not only EFI
>>>> global
>>>> variables, and handle arbitrary binary data, even if initial
>>>> implementation
>>>> handles only subset of them. Once someone starts to use it changing it
>>>> will
>>>> be much more difficult.
>>>>
>>>> Maybe it should take hints how to interpret variable values, or have
>>>> format option akin to printf.
>>>
>>>
>>>
>>> I would be happy to resume work on this, and debase it on the current
>>> code,
>>> if GRUB has a clear need for such functionality. I would prefer to have
>>> it
>>> be clear what the patch should consist of, though.
>>>
>>> A key question would be how to e.g. handle arbitrary data stored in
>>> variables if it is not something easily represent able like a string.
>>> Right
>>> now, the patch stores it's value into an environment variable specified
>>> by
>>> the user. Unless the powers that be think otherwise, I think this is the
>>> best way to go.
>>>
>>>>
>>>>
>>>>> Thanks,
>>>>> Mat
>>>>>
>>>>> On Tue, Nov 3, 2015 at 12:12 PM, SevenBits <sevenbitstech@gmail.com>
>>>>> wrote:
>>>>>
>>>>>> On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:
>>>>>>
>>>>>>> Hi,
>>>>>>>
>>>>>>> Searching through google, I see there was an email thread to add a
>>>>>>> patch
>>>>>>> for getting and setting efi variable in GRUB2.
>>>>>>> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>>>>>>>
>>>>>>> However, looking at the tree, it doesn't look like this patch was
>>>>>>> added,
>>>>>>> am I missing something?  Does anyone know if we have command to
>>>>>>> get/set
>>>>>>> efi
>>>>>>> variables in GRUB2?
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>>>>>>>
>>>>>>>
>>>>>> I'm the author of that patch. No, it was never merged into the tree.
>>>>>> As
>>>>>> far as I know, there is no equivalent functionality; GRUB does not
>>>>>> support
>>>>>> this feature.
>>>>>>
>>>>>>
>>>>>>> Thanks,
>>>>>>> Mat
>>>>>>>
>>>>>>
>>>>>> _______________________________________________
>>>>>> Grub-devel mailing list
>>>>>> Grub-devel@gnu.org
>>>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Grub-devel mailing list
>>>>> Grub-devel@gnu.org
>>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> Grub-devel mailing list
>>>> Grub-devel@gnu.org
>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>
>>>
>>>
>>> _______________________________________________
>>> Grub-devel mailing list
>>> Grub-devel@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel

Re: Grub get and set efi variables

[Ignat Korchagin]

On Fri, Nov 13, 2015 at 11:34 AM, Ignat Korchagin <ignat@cloudflare.com> wrote:
> On Wed, Nov 11, 2015 at 10:09 AM, Andrei Borzenkov <arvidjaar@gmail.com> wrote:
>> 06.11.2015 05:00, Ignat Korchagin пишет:
>>>
>>> Actually, I submitted similar patch recently as well. It provides read
>>> function for variables and accepts a hint on how to process them. The
>>> original patch is here:
>>> https://lists.gnu.org/archive/html/grub-devel/2015-09/msg00043.html.
>>>
>>
>> Yes, I was intending to comment on it, sorry.
>>
>> I am still unsure whether printf-like format specifier could be more
>> flexible, but otherwise I like it in that it provides for future extensions.
>> see comments below.
>>
>>
>>> Probably, I forgot to enable plain-text mode, so it got there as a
>>> binary attachment. I will repeat it here for convenience.
>>>
>>> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
>>> index 9764cd2..49fa3ec 100644
>>> --- a/grub-core/Makefile.core.def
>>> +++ b/grub-core/Makefile.core.def
>>> @@ -728,6 +728,12 @@ module = {
>>>   };
>>>
>>>   module = {
>>> +  name = efivar;
>>> +  efi = commands/efi/efivar.c;
>>> +  enable = efi;
>>> +};
>>> +
>>> +module = {
>>>     name = blocklist;
>>>     common = commands/blocklist.c;
>>>   };
>>> diff --git a/grub-core/commands/efi/efivar.c
>>> b/grub-core/commands/efi/efivar.c
>>> new file mode 100644
>>> index 0000000..ca206eb
>>> --- /dev/null
>>> +++ b/grub-core/commands/efi/efivar.c
>>> @@ -0,0 +1,146 @@
>>> +/* efivar.c - Read EFI global variables. */
>>> +/*
>>> + *  GRUB  --  GRand Unified Bootloader
>>> + *  Copyright (C) 2015 Free Software Foundation, Inc.
>>> + *  Copyright (C) 2015 CloudFlare, Inc.
>>> + *
>>> + *  GRUB is free software: you can redistribute it and/or modify
>>> + *  it under the terms of the GNU General Public License as published by
>>> + *  the Free Software Foundation, either version 3 of the License, or
>>> + *  (at your option) any later version.
>>> + *
>>> + *  GRUB is distributed in the hope that it will be useful,
>>> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
>>> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>>> + *  GNU General Public License for more details.
>>> + *
>>> + *  You should have received a copy of the GNU General Public License
>>> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
>>> + */
>>> +
>>> +#include <grub/types.h>
>>> +#include <grub/mm.h>
>>> +#include <grub/misc.h>
>>> +#include <grub/efi/api.h>
>>> +#include <grub/efi/efi.h>
>>> +#include <grub/extcmd.h>
>>> +#include <grub/env.h>
>>> +
>>> +GRUB_MOD_LICENSE ("GPLv3+");
>>> +
>>> +static const struct grub_arg_option options[] = {
>>> +  {"type", 't', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR as
>>> specific type (hex, uint8, string). Default: hex."), N_("TYPE"),
>>> ARG_TYPE_STRING},
>>> +  {0, 0, 0, 0, 0, 0}
>>> +};
>>> +
>>> +enum efi_var_type
>>> +  {
>>> +    EFI_VAR_STRING = 0,
>>> +    EFI_VAR_UINT8,
>>> +    EFI_VAR_HEX,
>>> +    EFI_VAR_INVALID = -1
>>> +  };
>>> +
>>> +static enum efi_var_type
>>> +parse_efi_var_type (const char *type)
>>> +{
>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>> +    return EFI_VAR_STRING;
>>> +
>>
>>
>> I think this should be "ascii" or "utf8". "string" is too ambiguous in UEFI
>> environment, it can also mean sequence of UCS-2 characters.
> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
> when printing. Maybe, to avoid confusion, it might be better to
> completely remove this option. Basically, you do not want to interpret
> raw buffers as strings. For best compatibility "hex" mode should be
> promoted, I guess. What do you think?
Checked again the UEFI spec. For globally defined variables which are
strings they specify ASCII. So if we leave this option, ascii is the
best name.

>>
>>> +  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
>>> +    return EFI_VAR_UINT8;
>>> +
>>> +  if (!grub_strncmp (type, "hex", sizeof("hex")))
>>> +    return EFI_VAR_HEX;
>>> +
>>> +  return EFI_VAR_INVALID;
>>> +}
>>> +
>>> +static grub_err_t
>>> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
>>> +  int argc, char **args)
>>> +{
>>> +  struct grub_arg_list *state = ctxt->state;
>>> +  grub_err_t status;
>>> +  void *efi_var = NULL;
>>> +  grub_size_t efi_var_size = 0;
>>> +  enum efi_var_type efi_type = EFI_VAR_HEX;
>>> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
>>> +  char *env_var = NULL;
>>> +  grub_size_t i;
>>> +
>>> +  if (2 != argc)
>>> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments
>>> expected"));
>>> +
>>
>>
>> May be follow the suite and use "--set var". It could be useful to simply
>> display variable on screen, like
>>
>> efivar OsIndicators
>>
>> or even
>>
>> efivar --all
>>
> Yes. Agree.
>>> +  if (state[0].set)
>>> +    efi_type = parse_efi_var_type (state[0].arg);
>>> +
>>> +  if (EFI_VAR_INVALID == efi_type)
>>> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid EFI variable
>>> type"));
>>> +
>>> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
>>> +  if (!efi_var || !efi_var_size)
>>> +    status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read
>>> variable"));
>>> +
>>
>>
>> Should it distinguish between non-existent variable and failure to read
>> variable? Is non-existent variable an error?
>>
>>
> grub_efi_get_variable itself does not report the difference. It should
> be modified to do that. From possible use-cases does it really matter
> why you did not get the variable?
>>> +  switch (efi_type)
>>> +  {
>>> +    case EFI_VAR_STRING:
>>> +      env_var = grub_malloc (efi_var_size + 1);
>>> +      if (!env_var)
>>> +        {
>>> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
>>> memory"));
>>> +          break;
>>> +        }
>>> +      grub_memcpy(env_var, efi_var, efi_var_size);
>>> +      env_var[efi_var_size] = '\0';
>>> +      break;
>>> +
>>> +    case EFI_VAR_UINT8:
>>> +      env_var = grub_malloc (4);
>>> +      if (!env_var)
>>> +        {
>>> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
>>> memory"));
>>> +          break;
>>> +        }
>>> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
>>> +      break;
>>> +
>>> +    case EFI_VAR_HEX:
>>> +      env_var = grub_malloc (efi_var_size * 2 + 1);
>>> +      if (!env_var)
>>> +        {
>>> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
>>> memory"));
>>> +          break;
>>> +        }
>>> +      for (i = 0; i < efi_var_size; i++)
>>> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
>>> *)efi_var)[i]);
>>> +      break;
>>> +
>>> +    default:
>>> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
>>> in module?)"));
>>> +  }
>>> +
>>> +  status = grub_env_set (args[1], env_var);
>>> +
>>> +  if (env_var)
>>> +    grub_free (env_var);
>>> +
>>> +  if (efi_var)
>>> +    grub_free (efi_var);
>>> +
>>> +  return status;
>>> +}
>>> +
>>> +static grub_extcmd_t cmd = NULL;
>>> +
>>> +GRUB_MOD_INIT (efivar)
>>> +{
>>> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
>>> N_("[-t TYPE] EFI_VAR ENV_VAR"),
>>> + N_("Read EFI variable and put its contents in environment
>>> variable."), options);
>>> +}
>>> +
>>> +GRUB_MOD_FINI (efivar)
>>> +{
>>> +  if (cmd)
>>> +    grub_unregister_extcmd (cmd);
>>> +}
>>>
>>>
>>> On Thu, Nov 5, 2015 at 10:25 AM, SevenBits <sevenbitstech@gmail.com>
>>> wrote:
>>>>
>>>> On Wednesday, November 4, 2015, Andrei Borzenkov <arvidjaar@gmail.com>
>>>> wrote:
>>>>>
>>>>>
>>>>> 04.11.2015 02:05, Mat Troi пишет:
>>>>>>
>>>>>>
>>>>>> Hi SevenBits,
>>>>>>
>>>>>> Thanks for letting me know.  Out of curiosity, any particular reason
>>>>>> why
>>>>>> this patch did not get merged?  It looks to be a useful feature.
>>>>>>
>>>>>
>>>>> First, this patch was reverse patch :)
>>>>
>>>>
>>>>
>>>> Yeah, I think I had accidentally passed the arguments to the diff command
>>>> in
>>>> the wrong order.
>>>>
>>>>>
>>>>>
>>>>> I am not convinced making it easy to set EFI variable from within GRUB
>>>>> is
>>>>> good thing, because there are known reports about systems rendered
>>>>> unbootable by writing too much into EFI flash. What is your use case
>>>>> that
>>>>> absolutely requires setting EFI variables? How are you going to
>>>>> implement it
>>>>> on other platforms?
>>>>
>>>>
>>>>
>>>> I should probably note that I wrote this patch for a specific project of
>>>> mine which required the ability to read UEFI variables. I added in write
>>>> functionality for good measure because I could. But I agree, this would
>>>> only
>>>> encourage tinkering and users messing with their systems and potentially
>>>> bricking it, which would of course be blamed on GRUB.
>>>>
>>>>>
>>>>>
>>>>> Reading does not harm and may be useful, but then it should provide
>>>>> generic interface to access arbitrary vendor namespace, not only EFI
>>>>> global
>>>>> variables, and handle arbitrary binary data, even if initial
>>>>> implementation
>>>>> handles only subset of them. Once someone starts to use it changing it
>>>>> will
>>>>> be much more difficult.
>>>>>
>>>>> Maybe it should take hints how to interpret variable values, or have
>>>>> format option akin to printf.
>>>>
>>>>
>>>>
>>>> I would be happy to resume work on this, and debase it on the current
>>>> code,
>>>> if GRUB has a clear need for such functionality. I would prefer to have
>>>> it
>>>> be clear what the patch should consist of, though.
>>>>
>>>> A key question would be how to e.g. handle arbitrary data stored in
>>>> variables if it is not something easily represent able like a string.
>>>> Right
>>>> now, the patch stores it's value into an environment variable specified
>>>> by
>>>> the user. Unless the powers that be think otherwise, I think this is the
>>>> best way to go.
>>>>
>>>>>
>>>>>
>>>>>> Thanks,
>>>>>> Mat
>>>>>>
>>>>>> On Tue, Nov 3, 2015 at 12:12 PM, SevenBits <sevenbitstech@gmail.com>
>>>>>> wrote:
>>>>>>
>>>>>>> On Tuesday, November 3, 2015, Mat Troi <mattroisang@gmail.com> wrote:
>>>>>>>
>>>>>>>> Hi,
>>>>>>>>
>>>>>>>> Searching through google, I see there was an email thread to add a
>>>>>>>> patch
>>>>>>>> for getting and setting efi variable in GRUB2.
>>>>>>>> https://lists.gnu.org/archive/html/grub-devel/2013-11/msg00328.html
>>>>>>>>
>>>>>>>> However, looking at the tree, it doesn't look like this patch was
>>>>>>>> added,
>>>>>>>> am I missing something?  Does anyone know if we have command to
>>>>>>>> get/set
>>>>>>>> efi
>>>>>>>> variables in GRUB2?
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> http://git.savannah.gnu.org/gitweb/?p=grub.git;a=tree;f=grub-core/commands/efi;h=005fd2efc9a2eede2a1eb1cab8081c360219107b;hb=HEAD
>>>>>>>>
>>>>>>>>
>>>>>>> I'm the author of that patch. No, it was never merged into the tree.
>>>>>>> As
>>>>>>> far as I know, there is no equivalent functionality; GRUB does not
>>>>>>> support
>>>>>>> this feature.
>>>>>>>
>>>>>>>
>>>>>>>> Thanks,
>>>>>>>> Mat
>>>>>>>>
>>>>>>>
>>>>>>> _______________________________________________
>>>>>>> Grub-devel mailing list
>>>>>>> Grub-devel@gnu.org
>>>>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> _______________________________________________
>>>>>> Grub-devel mailing list
>>>>>> Grub-devel@gnu.org
>>>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>>>
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Grub-devel mailing list
>>>>> Grub-devel@gnu.org
>>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> Grub-devel mailing list
>>>> Grub-devel@gnu.org
>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>>
>>>
>>> _______________________________________________
>>> Grub-devel mailing list
>>> Grub-devel@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>
>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel

Re: Grub get and set efi variables

[Andrei Borzenkov]

13.11.2015 22:42, Ignat Korchagin пишет:
>>>> +static enum efi_var_type
>>>> +parse_efi_var_type (const char *type)
>>>> +{
>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>> +    return EFI_VAR_STRING;
>>>> +
>>>
>>>
>>> I think this should be "ascii" or "utf8". "string" is too ambiguous in UEFI
>>> environment, it can also mean sequence of UCS-2 characters.
>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>> when printing. Maybe, to avoid confusion, it might be better to
>> completely remove this option. Basically, you do not want to interpret
>> raw buffers as strings. For best compatibility "hex" mode should be
>> promoted, I guess. What do you think?
> Checked again the UEFI spec. For globally defined variables which are
> strings they specify ASCII. So if we leave this option, ascii is the
> best name.
>

What about

   - ascii - print ASCII characters verbatim, escape non-ASCII in usual 
way (similar to "od -c")

   - raw - simply put raw variable without any interpretation.

This is better aligned with argument describing output formatting rather 
than attempting to "type" variable.

Alternative (or in addition to) ascii - dump which prints usual pretty 
hex dump of content (hexdump -C). This is handy to interactively look at 
variable content.

Or, and change name from --type to --format :)

Re: Grub get and set efi variables

[Ignat Korchagin]

Please, see updated patch below. I tried to reuse GRUB hexdump
function, so as a result dump will not work with setting vatiables -
just dumping to stdout. But it doesn't make sense to assign dump to a
variable anyway.

diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
new file mode 100644
index 0000000..3ffd5ca
--- /dev/null
+++ b/grub-core/commands/efi/efivar.c
@@ -0,0 +1,253 @@
+/* efivar.c - Read EFI global variables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 Free Software Foundation, Inc.
+ *  Copyright (C) 2015 CloudFlare, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/lib/hexdump.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
specific format (hex, uint8, ascii, raw, dump). Default: hex."),
N_("FORMAT"), ARG_TYPE_STRING},
+  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
environment variable (does not work with dump)."), N_("ENV_VAR"),
ARG_TYPE_STRING},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum efi_var_type
+  {
+    EFI_VAR_ASCII = 0,
+    EFI_VAR_RAW,
+    EFI_VAR_UINT8,
+    EFI_VAR_HEX,
+    EFI_VAR_DUMP,
+    EFI_VAR_INVALID = -1
+  };
+
+static enum efi_var_type
+parse_efi_var_type (const char *type)
+{
+  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strncmp (type, "raw", sizeof("raw")))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
+    return EFI_VAR_UINT8;
+
+  if (!grub_strncmp (type, "hex", sizeof("hex")))
+    return EFI_VAR_HEX;
+
+  if (!grub_strncmp (type, "dump", sizeof("dump")))
+    return EFI_VAR_DUMP;
+
+  return EFI_VAR_INVALID;
+}
+
+static int
+grub_print_ascii (char *str, char c)
+{
+  if (grub_iscntrl (c))
+  {
+    switch (c)
+      {
+        case '\0':
+          str[0] = '\\';
+          str[1] = '0';
+          return 2;
+
+        case '\a':
+          str[0] = '\\';
+          str[1] = 'a';
+          return 2;
+
+        case '\b':
+          str[0] = '\\';
+          str[1] = 'b';
+          return 2;
+
+        case '\f':
+          str[0] = '\\';
+          str[1] = 'f';
+          return 2;
+
+        case '\n':
+          str[0] = '\\';
+          str[1] = 'n';
+          return 2;
+
+        case '\r':
+          str[0] = '\\';
+          str[1] = 'r';
+          return 2;
+
+        case '\t':
+          str[0] = '\\';
+          str[1] = 't';
+          return 2;
+
+        case '\v':
+          str[0] = '\\';
+          str[1] = 'v';
+          return 2;
+
+        default:
+          str[0] = '.'; /* as in hexdump -C */
+          return 1;
+      }
+  }
+
+  str[0] = c;
+  return 1;
+}
+
+static grub_err_t
+grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
+  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  grub_err_t status;
+  void *efi_var = NULL;
+  grub_size_t efi_var_size = 0;
+  enum efi_var_type efi_type = EFI_VAR_HEX;
+  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
+  char *env_var = NULL;
+  grub_size_t i;
+  char *ptr;
+
+  if (1 != argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments expected"));
+
+  if (state[0].set)
+    efi_type = parse_efi_var_type (state[0].arg);
+
+  if (EFI_VAR_INVALID == efi_type)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
+
+  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
+  if (!efi_var || !efi_var_size)
+    {
+      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
+      goto err;
+    }
+
+  switch (efi_type)
+  {
+    case EFI_VAR_ASCII:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+
+      ptr = env_var;
+
+      for (i = 0; i < efi_var_size; i++)
+        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
+      *ptr = '\0';
+      break;
+
+    case EFI_VAR_RAW:
+      env_var = grub_malloc (efi_var_size + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_memcpy (env_var, efi_var, efi_var_size);
+      env_var[efi_var_size] = '\0';
+      break;
+
+    case EFI_VAR_UINT8:
+      env_var = grub_malloc (4);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
+      break;
+
+    case EFI_VAR_HEX:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      for (i = 0; i < efi_var_size; i++)
+        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
*)efi_var)[i]);
+      break;
+
+    case EFI_VAR_DUMP:
+      if (state[1].set)
+        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
variable with dump format specifier"));
+      else
+        {
+          hexdump (0, (char *)efi_var, efi_var_size);
+          status = GRUB_ERR_NONE;
+        }
+      break;
+
+    default:
+      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
in module?)"));
+  }
+
+  if (efi_type != EFI_VAR_DUMP)
+    {
+      if (state[1].set)
+        status = grub_env_set (state[1].arg, env_var);
+      else
+        {
+          grub_printf ("%s\n", (const char *)env_var);
+          status = GRUB_ERR_NONE;
+        }
+    }
+
+err:
+
+  if (env_var)
+    grub_free (env_var);
+
+  if (efi_var)
+    grub_free (efi_var);
+
+  return status;
+}
+
+static grub_extcmd_t cmd = NULL;
+
+GRUB_MOD_INIT (efivar)
+{
+  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
+ N_("Read EFI variable and print it or save its contents to
environment variable."), options);
+}
+
+GRUB_MOD_FINI (efivar)
+{
+  if (cmd)
+    grub_unregister_extcmd (cmd);
+}
diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index a6101de..2c8f023 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -728,6 +728,12 @@
 };

 module = {
+  name = efivar;
+  efi = commands/efi/efivar.c;
+  enable = efi;
+};
+
+module = {
   name = blocklist;
   common = commands/blocklist.c;
 };

On Sat, Nov 14, 2015 at 4:03 AM, Andrei Borzenkov <arvidjaar@gmail.com> wrote:
> 13.11.2015 22:42, Ignat Korchagin пишет:
>>>>>
>>>>> +static enum efi_var_type
>>>>> +parse_efi_var_type (const char *type)
>>>>> +{
>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>> +    return EFI_VAR_STRING;
>>>>> +
>>>>
>>>>
>>>>
>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous in
>>>> UEFI
>>>> environment, it can also mean sequence of UCS-2 characters.
>>>
>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>> when printing. Maybe, to avoid confusion, it might be better to
>>> completely remove this option. Basically, you do not want to interpret
>>> raw buffers as strings. For best compatibility "hex" mode should be
>>> promoted, I guess. What do you think?
>>
>> Checked again the UEFI spec. For globally defined variables which are
>> strings they specify ASCII. So if we leave this option, ascii is the
>> best name.
>>
>
> What about
>
>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual way
> (similar to "od -c")
>
>   - raw - simply put raw variable without any interpretation.
>
> This is better aligned with argument describing output formatting rather
> than attempting to "type" variable.
>
> Alternative (or in addition to) ascii - dump which prints usual pretty hex
> dump of content (hexdump -C). This is handy to interactively look at
> variable content.
>
> Or, and change name from --type to --format :)
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel

Re: Grub get and set efi variables

[Mat Troi]

[-- Attachment #1: Type: text/plain, Size: 2150 bytes --]

For a specific project implementation, I need to be able to write and read
one EFI variable during boot only.  So I have written a grub command to do
just that.  But the issue is with setting these attributes to the variable
(GRUB_EFI_VARIABLE_NON_VOLATILE, GRUB_EFI_VARIABLE_BOOTSERVICE_ACCESS), I
am not able to modify it during boot on some platform.  Since this is so
specific, I am wondering if anyone has seen similar issue?

On Fri, Nov 13, 2015 at 8:03 PM, Andrei Borzenkov <arvidjaar@gmail.com>
wrote:

> 13.11.2015 22:42, Ignat Korchagin пишет:
>
>> +static enum efi_var_type
>>>>> +parse_efi_var_type (const char *type)
>>>>> +{
>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>> +    return EFI_VAR_STRING;
>>>>> +
>>>>>
>>>>
>>>>
>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous in
>>>> UEFI
>>>> environment, it can also mean sequence of UCS-2 characters.
>>>>
>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>> when printing. Maybe, to avoid confusion, it might be better to
>>> completely remove this option. Basically, you do not want to interpret
>>> raw buffers as strings. For best compatibility "hex" mode should be
>>> promoted, I guess. What do you think?
>>>
>> Checked again the UEFI spec. For globally defined variables which are
>> strings they specify ASCII. So if we leave this option, ascii is the
>> best name.
>>
>>
> What about
>
>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual way
> (similar to "od -c")
>
>   - raw - simply put raw variable without any interpretation.
>
> This is better aligned with argument describing output formatting rather
> than attempting to "type" variable.
>
> Alternative (or in addition to) ascii - dump which prints usual pretty hex
> dump of content (hexdump -C). This is handy to interactively look at
> variable content.
>
> Or, and change name from --type to --format :)
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>

[-- Attachment #2: Type: text/html, Size: 3226 bytes --]

Re: Grub get and set efi variables

[Seth Goldberg]

[-- Attachment #1: Type: text/plain, Size: 2543 bytes --]

That sounds like a firmware implementation bug, unfortunately.  I've seen it be hit or miss setting boot service only variables on some platforms.  

   --S

> On Nov 24, 2015, at 11:23 AM, Mat Troi <mattroisang@gmail.com> wrote:
> 
> For a specific project implementation, I need to be able to write and read one EFI variable during boot only.  So I have written a grub command to do just that.  But the issue is with setting these attributes to the variable (GRUB_EFI_VARIABLE_NON_VOLATILE, GRUB_EFI_VARIABLE_BOOTSERVICE_ACCESS), I am not able to modify it during boot on some platform.  Since this is so specific, I am wondering if anyone has seen similar issue?
> 
>> On Fri, Nov 13, 2015 at 8:03 PM, Andrei Borzenkov <arvidjaar@gmail.com> wrote:
>> 13.11.2015 22:42, Ignat Korchagin пишет:
>>>>>> +static enum efi_var_type
>>>>>> +parse_efi_var_type (const char *type)
>>>>>> +{
>>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>>> +    return EFI_VAR_STRING;
>>>>>> +
>>>>> 
>>>>> 
>>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous in UEFI
>>>>> environment, it can also mean sequence of UCS-2 characters.
>>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>>> when printing. Maybe, to avoid confusion, it might be better to
>>>> completely remove this option. Basically, you do not want to interpret
>>>> raw buffers as strings. For best compatibility "hex" mode should be
>>>> promoted, I guess. What do you think?
>>> Checked again the UEFI spec. For globally defined variables which are
>>> strings they specify ASCII. So if we leave this option, ascii is the
>>> best name.
>> 
>> What about
>> 
>>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual way (similar to "od -c")
>> 
>>   - raw - simply put raw variable without any interpretation.
>> 
>> This is better aligned with argument describing output formatting rather than attempting to "type" variable.
>> 
>> Alternative (or in addition to) ascii - dump which prints usual pretty hex dump of content (hexdump -C). This is handy to interactively look at variable content.
>> 
>> Or, and change name from --type to --format :)
>> 
>> 
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
> 
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel

[-- Attachment #2: Type: text/html, Size: 4049 bytes --]

Re: Grub get and set efi variables

[Vladimir 'φ-coder/phcoder' Serbinenko]

[-- Attachment #1: Type: text/plain, Size: 1996 bytes --]

On 14.11.2015 05:03, Andrei Borzenkov wrote:
> 13.11.2015 22:42, Ignat Korchagin пишет:
>>>>> +static enum efi_var_type
>>>>> +parse_efi_var_type (const char *type)
>>>>> +{
>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>> +    return EFI_VAR_STRING;
>>>>> +
>>>>
>>>>
>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous
>>>> in UEFI
>>>> environment, it can also mean sequence of UCS-2 characters.
>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>> when printing. Maybe, to avoid confusion, it might be better to
>>> completely remove this option. Basically, you do not want to interpret
>>> raw buffers as strings. For best compatibility "hex" mode should be
>>> promoted, I guess. What do you think?
>> Checked again the UEFI spec. For globally defined variables which are
>> strings they specify ASCII. So if we leave this option, ascii is the
>> best name.
>>
> 
> What about
> 
>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual
> way (similar to "od -c")
> 
>   - raw - simply put raw variable without any interpretation.
> 
I would add:
* hex. To print and store in hex form
* utf16. Decode utf16 into utf8. utf16 is a common encoding in EFI land.
I would also skip on raw, at least until we have a real need for it as
we currently are not equiped to handle raw strings in variable contents,
including but not limited to \0 being considered a terminator
> This is better aligned with argument describing output formatting rather
> than attempting to "type" variable.
> 
> Alternative (or in addition to) ascii - dump which prints usual pretty
> hex dump of content (hexdump -C). This is handy to interactively look at
> variable content.
> 
> Or, and change name from --type to --format :)
> 
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel



[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 213 bytes --]

Re: Grub get and set efi variables

[Ignat Korchagin]

> I would add:
> * hex. To print and store in hex form
> * utf16. Decode utf16 into utf8. utf16 is a common encoding in EFI land.

hex is already part of the latest proposed patch:
>> +    case EFI_VAR_HEX:

I'm not sure whether utf16 will be useful, as all standard UEFI
variables now are using ASCII for string data.

On Fri, Nov 27, 2015 at 2:07 PM, Vladimir 'φ-coder/phcoder' Serbinenko
<phcoder@gmail.com> wrote:
> On 14.11.2015 05:03, Andrei Borzenkov wrote:
>> 13.11.2015 22:42, Ignat Korchagin пишет:
>>>>>> +static enum efi_var_type
>>>>>> +parse_efi_var_type (const char *type)
>>>>>> +{
>>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>>> +    return EFI_VAR_STRING;
>>>>>> +
>>>>>
>>>>>
>>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous
>>>>> in UEFI
>>>>> environment, it can also mean sequence of UCS-2 characters.
>>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>>> when printing. Maybe, to avoid confusion, it might be better to
>>>> completely remove this option. Basically, you do not want to interpret
>>>> raw buffers as strings. For best compatibility "hex" mode should be
>>>> promoted, I guess. What do you think?
>>> Checked again the UEFI spec. For globally defined variables which are
>>> strings they specify ASCII. So if we leave this option, ascii is the
>>> best name.
>>>
>>
>> What about
>>
>>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual
>> way (similar to "od -c")
>>
>>   - raw - simply put raw variable without any interpretation.
>>
> I would add:
> * hex. To print and store in hex form
> * utf16. Decode utf16 into utf8. utf16 is a common encoding in EFI land.
> I would also skip on raw, at least until we have a real need for it as
> we currently are not equiped to handle raw strings in variable contents,
> including but not limited to \0 being considered a terminator
>> This is better aligned with argument describing output formatting rather
>> than attempting to "type" variable.
>>
>> Alternative (or in addition to) ascii - dump which prints usual pretty
>> hex dump of content (hexdump -C). This is handy to interactively look at
>> variable content.
>>
>> Or, and change name from --type to --format :)
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>

Re: Grub get and set efi variables

[Andrei Borzenkov]

17.11.2015 14:48, Ignat Korchagin пишет:
> Please, see updated patch below. I tried to reuse GRUB hexdump
> function, so as a result dump will not work with setting vatiables -
> just dumping to stdout. But it doesn't make sense to assign dump to a
> variable anyway.
> 
> diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
> new file mode 100644
> index 0000000..3ffd5ca
> --- /dev/null
> +++ b/grub-core/commands/efi/efivar.c
> @@ -0,0 +1,253 @@
> +/* efivar.c - Read EFI global variables. */
> +/*
> + *  GRUB  --  GRand Unified Bootloader
> + *  Copyright (C) 2015 Free Software Foundation, Inc.
> + *  Copyright (C) 2015 CloudFlare, Inc.
> + *
> + *  GRUB is free software: you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation, either version 3 of the License, or
> + *  (at your option) any later version.
> + *
> + *  GRUB is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <grub/types.h>
> +#include <grub/mm.h>
> +#include <grub/misc.h>
> +#include <grub/efi/api.h>
> +#include <grub/efi/efi.h>
> +#include <grub/extcmd.h>
> +#include <grub/env.h>
> +#include <grub/lib/hexdump.h>
> +
> +GRUB_MOD_LICENSE ("GPLv3+");
> +
> +static const struct grub_arg_option options[] = {
> +  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
> specific format (hex, uint8, ascii, raw, dump). Default: hex."),
> N_("FORMAT"), ARG_TYPE_STRING},
> +  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
> environment variable (does not work with dump)."), N_("ENV_VAR"),
> ARG_TYPE_STRING},
> +  {0, 0, 0, 0, 0, 0}
> +};
> +
> +enum efi_var_type
> +  {
> +    EFI_VAR_ASCII = 0,
> +    EFI_VAR_RAW,
> +    EFI_VAR_UINT8,
> +    EFI_VAR_HEX,
> +    EFI_VAR_DUMP,
> +    EFI_VAR_INVALID = -1
> +  };
> +
> +static enum efi_var_type
> +parse_efi_var_type (const char *type)
> +{
> +  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strncmp (type, "raw", sizeof("raw")))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
> +    return EFI_VAR_UINT8;
> +
> +  if (!grub_strncmp (type, "hex", sizeof("hex")))
> +    return EFI_VAR_HEX;
> +
> +  if (!grub_strncmp (type, "dump", sizeof("dump")))
> +    return EFI_VAR_DUMP;
> +

Should not this be strcmp, not str*n*cmp?

> +  return EFI_VAR_INVALID;
> +}
> +
> +static int
> +grub_print_ascii (char *str, char c)
> +{
> +  if (grub_iscntrl (c))
> +  {
> +    switch (c)
> +      {
> +        case '\0':
> +          str[0] = '\\';
> +          str[1] = '0';
> +          return 2;
> +
> +        case '\a':
> +          str[0] = '\\';
> +          str[1] = 'a';
> +          return 2;
> +
> +        case '\b':
> +          str[0] = '\\';
> +          str[1] = 'b';
> +          return 2;
> +
> +        case '\f':
> +          str[0] = '\\';
> +          str[1] = 'f';
> +          return 2;
> +
> +        case '\n':
> +          str[0] = '\\';
> +          str[1] = 'n';
> +          return 2;
> +
> +        case '\r':
> +          str[0] = '\\';
> +          str[1] = 'r';
> +          return 2;
> +
> +        case '\t':
> +          str[0] = '\\';
> +          str[1] = 't';
> +          return 2;
> +
> +        case '\v':
> +          str[0] = '\\';
> +          str[1] = 'v';
> +          return 2;
> +
> +        default:
> +          str[0] = '.'; /* as in hexdump -C */
> +          return 1;
> +      }
> +  }
> +
> +  str[0] = c;
> +  return 1;
> +}
> +
> +static grub_err_t
> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
> +  int argc, char **args)
> +{
> +  struct grub_arg_list *state = ctxt->state;
> +  grub_err_t status;
> +  void *efi_var = NULL;
> +  grub_size_t efi_var_size = 0;
> +  enum efi_var_type efi_type = EFI_VAR_HEX;
> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
> +  char *env_var = NULL;
> +  grub_size_t i;
> +  char *ptr;
> +
> +  if (1 != argc)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments expected"));

One argument expected

> +
> +  if (state[0].set)
> +    efi_type = parse_efi_var_type (state[0].arg);
> +
> +  if (EFI_VAR_INVALID == efi_type)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
> +
> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
> +  if (!efi_var || !efi_var_size)
> +    {
> +      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
> +      goto err;
> +    }
> +
> +  switch (efi_type)
> +  {
> +    case EFI_VAR_ASCII:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +
> +      ptr = env_var;
> +
> +      for (i = 0; i < efi_var_size; i++)
> +        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
> +      *ptr = '\0';
> +      break;
> +
> +    case EFI_VAR_RAW:
> +      env_var = grub_malloc (efi_var_size + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      grub_memcpy (env_var, efi_var, efi_var_size);
> +      env_var[efi_var_size] = '\0';

That would be wrong ("raw" implies no modification) but I am not keen on
keeping "raw" as was discussed.

> +      break;
> +
> +    case EFI_VAR_UINT8:
> +      env_var = grub_malloc (4);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
> +      break;
> +
> +    case EFI_VAR_HEX:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      for (i = 0; i < efi_var_size; i++)
> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
> *)efi_var)[i]);
> +      break;
> +
> +    case EFI_VAR_DUMP:
> +      if (state[1].set)
> +        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
> variable with dump format specifier"));
> +      else
> +        {
> +          hexdump (0, (char *)efi_var, efi_var_size);
> +          status = GRUB_ERR_NONE;
> +        }
> +      break;
> +
> +    default:
> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
> in module?)"));
> +  }
> +
> +  if (efi_type != EFI_VAR_DUMP)
> +    {
> +      if (state[1].set)
> +        status = grub_env_set (state[1].arg, env_var);
> +      else
> +        {
> +          grub_printf ("%s\n", (const char *)env_var);
> +          status = GRUB_ERR_NONE;
> +        }
> +    }
> +
> +err:
> +
> +  if (env_var)
> +    grub_free (env_var);
> +
> +  if (efi_var)
> +    grub_free (efi_var);
> +
> +  return status;
> +}
> +
> +static grub_extcmd_t cmd = NULL;
> +
> +GRUB_MOD_INIT (efivar)
> +{
> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
> + N_("Read EFI variable and print it or save its contents to
> environment variable."), options);
> +}
> +
> +GRUB_MOD_FINI (efivar)
> +{
> +  if (cmd)
> +    grub_unregister_extcmd (cmd);
> +}
> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> index a6101de..2c8f023 100644
> --- a/grub-core/Makefile.core.def
> +++ b/grub-core/Makefile.core.def
> @@ -728,6 +728,12 @@
>  };
> 
>  module = {
> +  name = efivar;
> +  efi = commands/efi/efivar.c;
> +  enable = efi;
> +};
> +
> +module = {
>    name = blocklist;
>    common = commands/blocklist.c;
>  };
> 
> On Sat, Nov 14, 2015 at 4:03 AM, Andrei Borzenkov <arvidjaar@gmail.com> wrote:
>> 13.11.2015 22:42, Ignat Korchagin пишет:
>>>>>>
>>>>>> +static enum efi_var_type
>>>>>> +parse_efi_var_type (const char *type)
>>>>>> +{
>>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>>> +    return EFI_VAR_STRING;
>>>>>> +
>>>>>
>>>>>
>>>>>
>>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous in
>>>>> UEFI
>>>>> environment, it can also mean sequence of UCS-2 characters.
>>>>
>>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>>> when printing. Maybe, to avoid confusion, it might be better to
>>>> completely remove this option. Basically, you do not want to interpret
>>>> raw buffers as strings. For best compatibility "hex" mode should be
>>>> promoted, I guess. What do you think?
>>>
>>> Checked again the UEFI spec. For globally defined variables which are
>>> strings they specify ASCII. So if we leave this option, ascii is the
>>> best name.
>>>
>>
>> What about
>>
>>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual way
>> (similar to "od -c")
>>
>>   - raw - simply put raw variable without any interpretation.
>>
>> This is better aligned with argument describing output formatting rather
>> than attempting to "type" variable.
>>
>> Alternative (or in addition to) ascii - dump which prints usual pretty hex
>> dump of content (hexdump -C). This is handy to interactively look at
>> variable content.
>>
>> Or, and change name from --type to --format :)
>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
> 
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
> 

Re: Grub get and set efi variables

[Andrei Borzenkov]

27.11.2015 17:25, Ignat Korchagin пишет:
>> I would add:
>> * hex. To print and store in hex form
>> * utf16. Decode utf16 into utf8. utf16 is a common encoding in EFI land.
> 
> hex is already part of the latest proposed patch:
>>> +    case EFI_VAR_HEX:
> 
> I'm not sure whether utf16 will be useful, as all standard UEFI
> variables now are using ASCII for string data.
> 

I agree; it can be added later if use case emerges. So far all
"interesting" cases that use UTF-16 are not limited to strings, and need
much more elaborate parsing. That is why I mentioned generic format
specifier before. But this also can be added if needed, overall syntax
seems to be flexible enough.

> On Fri, Nov 27, 2015 at 2:07 PM, Vladimir 'φ-coder/phcoder' Serbinenko
> <phcoder@gmail.com> wrote:
>> On 14.11.2015 05:03, Andrei Borzenkov wrote:
>>> 13.11.2015 22:42, Ignat Korchagin пишет:
>>>>>>> +static enum efi_var_type
>>>>>>> +parse_efi_var_type (const char *type)
>>>>>>> +{
>>>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>>>> +    return EFI_VAR_STRING;
>>>>>>> +
>>>>>>
>>>>>>
>>>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous
>>>>>> in UEFI
>>>>>> environment, it can also mean sequence of UCS-2 characters.
>>>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>>>> when printing. Maybe, to avoid confusion, it might be better to
>>>>> completely remove this option. Basically, you do not want to interpret
>>>>> raw buffers as strings. For best compatibility "hex" mode should be
>>>>> promoted, I guess. What do you think?
>>>> Checked again the UEFI spec. For globally defined variables which are
>>>> strings they specify ASCII. So if we leave this option, ascii is the
>>>> best name.
>>>>
>>>
>>> What about
>>>
>>>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual
>>> way (similar to "od -c")
>>>
>>>   - raw - simply put raw variable without any interpretation.
>>>
>> I would add:
>> * hex. To print and store in hex form
>> * utf16. Decode utf16 into utf8. utf16 is a common encoding in EFI land.
>> I would also skip on raw, at least until we have a real need for it as
>> we currently are not equiped to handle raw strings in variable contents,
>> including but not limited to \0 being considered a terminator
>>> This is better aligned with argument describing output formatting rather
>>> than attempting to "type" variable.
>>>
>>> Alternative (or in addition to) ascii - dump which prints usual pretty
>>> hex dump of content (hexdump -C). This is handy to interactively look at
>>> variable content.
>>>
>>> Or, and change name from --type to --format :)
>>>
>>> _______________________________________________
>>> Grub-devel mailing list
>>> Grub-devel@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
> 
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
> 

Re: Grub get and set efi variables

[Ignat Korchagin]

Let's add utf16 later then (if needed). I also noticed a typo in one
error string in my above patch (it was checking that command receives
one argument, but prints that two arguments expected), so here is the
updated one.

So, finally, should I remove the "raw" parser (as per Vladimir's
request). Personally, I would keep it. It might be useful to modify
the hexdump command, that it can dump the contents of a variable. Then
those pieces will fit together: storing raw value in the variable and
examining it with hexdump cmd.

diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
new file mode 100644
index 0000000..3ffd5ca
--- /dev/null
+++ b/grub-core/commands/efi/efivar.c
@@ -0,0 +1,253 @@
+/* efivar.c - Read EFI global variables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 Free Software Foundation, Inc.
+ *  Copyright (C) 2015 CloudFlare, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/lib/hexdump.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
specific format (hex, uint8, ascii, raw, dump). Default: hex."),
N_("FORMAT"), ARG_TYPE_STRING},
+  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
environment variable (does not work with dump)."), N_("ENV_VAR"),
ARG_TYPE_STRING},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum efi_var_type
+  {
+    EFI_VAR_ASCII = 0,
+    EFI_VAR_RAW,
+    EFI_VAR_UINT8,
+    EFI_VAR_HEX,
+    EFI_VAR_DUMP,
+    EFI_VAR_INVALID = -1
+  };
+
+static enum efi_var_type
+parse_efi_var_type (const char *type)
+{
+  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strncmp (type, "raw", sizeof("raw")))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
+    return EFI_VAR_UINT8;
+
+  if (!grub_strncmp (type, "hex", sizeof("hex")))
+    return EFI_VAR_HEX;
+
+  if (!grub_strncmp (type, "dump", sizeof("dump")))
+    return EFI_VAR_DUMP;
+
+  return EFI_VAR_INVALID;
+}
+
+static int
+grub_print_ascii (char *str, char c)
+{
+  if (grub_iscntrl (c))
+  {
+    switch (c)
+      {
+        case '\0':
+          str[0] = '\\';
+          str[1] = '0';
+          return 2;
+
+        case '\a':
+          str[0] = '\\';
+          str[1] = 'a';
+          return 2;
+
+        case '\b':
+          str[0] = '\\';
+          str[1] = 'b';
+          return 2;
+
+        case '\f':
+          str[0] = '\\';
+          str[1] = 'f';
+          return 2;
+
+        case '\n':
+          str[0] = '\\';
+          str[1] = 'n';
+          return 2;
+
+        case '\r':
+          str[0] = '\\';
+          str[1] = 'r';
+          return 2;
+
+        case '\t':
+          str[0] = '\\';
+          str[1] = 't';
+          return 2;
+
+        case '\v':
+          str[0] = '\\';
+          str[1] = 'v';
+          return 2;
+
+        default:
+          str[0] = '.'; /* as in hexdump -C */
+          return 1;
+      }
+  }
+
+  str[0] = c;
+  return 1;
+}
+
+static grub_err_t
+grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
+  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  grub_err_t status;
+  void *efi_var = NULL;
+  grub_size_t efi_var_size = 0;
+  enum efi_var_type efi_type = EFI_VAR_HEX;
+  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
+  char *env_var = NULL;
+  grub_size_t i;
+  char *ptr;
+
+  if (1 != argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
+
+  if (state[0].set)
+    efi_type = parse_efi_var_type (state[0].arg);
+
+  if (EFI_VAR_INVALID == efi_type)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
+
+  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
+  if (!efi_var || !efi_var_size)
+    {
+      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
+      goto err;
+    }
+
+  switch (efi_type)
+  {
+    case EFI_VAR_ASCII:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+
+      ptr = env_var;
+
+      for (i = 0; i < efi_var_size; i++)
+        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
+      *ptr = '\0';
+      break;
+
+    case EFI_VAR_RAW:
+      env_var = grub_malloc (efi_var_size + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_memcpy (env_var, efi_var, efi_var_size);
+      env_var[efi_var_size] = '\0';
+      break;
+
+    case EFI_VAR_UINT8:
+      env_var = grub_malloc (4);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
+      break;
+
+    case EFI_VAR_HEX:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      for (i = 0; i < efi_var_size; i++)
+        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
*)efi_var)[i]);
+      break;
+
+    case EFI_VAR_DUMP:
+      if (state[1].set)
+        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
variable with dump format specifier"));
+      else
+        {
+          hexdump (0, (char *)efi_var, efi_var_size);
+          status = GRUB_ERR_NONE;
+        }
+      break;
+
+    default:
+      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
in module?)"));
+  }
+
+  if (efi_type != EFI_VAR_DUMP)
+    {
+      if (state[1].set)
+        status = grub_env_set (state[1].arg, env_var);
+      else
+        {
+          grub_printf ("%s\n", (const char *)env_var);
+          status = GRUB_ERR_NONE;
+        }
+    }
+
+err:
+
+  if (env_var)
+    grub_free (env_var);
+
+  if (efi_var)
+    grub_free (efi_var);
+
+  return status;
+}
+
+static grub_extcmd_t cmd = NULL;
+
+GRUB_MOD_INIT (efivar)
+{
+  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
+ N_("Read EFI variable and print it or save its contents to
environment variable."), options);
+}
+
+GRUB_MOD_FINI (efivar)
+{
+  if (cmd)
+    grub_unregister_extcmd (cmd);
+}
diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index a6101de..2c8f023 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -728,6 +728,12 @@
 };

 module = {
+  name = efivar;
+  efi = commands/efi/efivar.c;
+  enable = efi;
+};
+
+module = {
   name = blocklist;
   common = commands/blocklist.c;
 };



On Sun, Nov 29, 2015 at 9:00 AM, Andrei Borzenkov <arvidjaar@gmail.com> wrote:
> 27.11.2015 17:25, Ignat Korchagin пишет:
>>> I would add:
>>> * hex. To print and store in hex form
>>> * utf16. Decode utf16 into utf8. utf16 is a common encoding in EFI land.
>>
>> hex is already part of the latest proposed patch:
>>>> +    case EFI_VAR_HEX:
>>
>> I'm not sure whether utf16 will be useful, as all standard UEFI
>> variables now are using ASCII for string data.
>>
>
> I agree; it can be added later if use case emerges. So far all
> "interesting" cases that use UTF-16 are not limited to strings, and need
> much more elaborate parsing. That is why I mentioned generic format
> specifier before. But this also can be added if needed, overall syntax
> seems to be flexible enough.
>
>> On Fri, Nov 27, 2015 at 2:07 PM, Vladimir 'φ-coder/phcoder' Serbinenko
>> <phcoder@gmail.com> wrote:
>>> On 14.11.2015 05:03, Andrei Borzenkov wrote:
>>>> 13.11.2015 22:42, Ignat Korchagin пишет:
>>>>>>>> +static enum efi_var_type
>>>>>>>> +parse_efi_var_type (const char *type)
>>>>>>>> +{
>>>>>>>> +  if (!grub_strncmp (type, "string", sizeof("string")))
>>>>>>>> +    return EFI_VAR_STRING;
>>>>>>>> +
>>>>>>>
>>>>>>>
>>>>>>> I think this should be "ascii" or "utf8". "string" is too ambiguous
>>>>>>> in UEFI
>>>>>>> environment, it can also mean sequence of UCS-2 characters.
>>>>>> I'm still not sure how exactly GRUB + UEFI interprets "raw buffers"
>>>>>> when printing. Maybe, to avoid confusion, it might be better to
>>>>>> completely remove this option. Basically, you do not want to interpret
>>>>>> raw buffers as strings. For best compatibility "hex" mode should be
>>>>>> promoted, I guess. What do you think?
>>>>> Checked again the UEFI spec. For globally defined variables which are
>>>>> strings they specify ASCII. So if we leave this option, ascii is the
>>>>> best name.
>>>>>
>>>>
>>>> What about
>>>>
>>>>   - ascii - print ASCII characters verbatim, escape non-ASCII in usual
>>>> way (similar to "od -c")
>>>>
>>>>   - raw - simply put raw variable without any interpretation.
>>>>
>>> I would add:
>>> * hex. To print and store in hex form
>>> * utf16. Decode utf16 into utf8. utf16 is a common encoding in EFI land.
>>> I would also skip on raw, at least until we have a real need for it as
>>> we currently are not equiped to handle raw strings in variable contents,
>>> including but not limited to \0 being considered a terminator
>>>> This is better aligned with argument describing output formatting rather
>>>> than attempting to "type" variable.
>>>>
>>>> Alternative (or in addition to) ascii - dump which prints usual pretty
>>>> hex dump of content (hexdump -C). This is handy to interactively look at
>>>> variable content.
>>>>
>>>> Or, and change name from --type to --format :)
>>>>
>>>> _______________________________________________
>>>> Grub-devel mailing list
>>>> Grub-devel@gnu.org
>>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>
>>>
>>>
>>> _______________________________________________
>>> Grub-devel mailing list
>>> Grub-devel@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>>
>>
>> _______________________________________________
>> Grub-devel mailing list
>> Grub-devel@gnu.org
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>>
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel

Re: Grub get and set efi variables

[Andrei Borzenkov]

On Wed, Dec 2, 2015 at 3:53 PM, Ignat Korchagin <ignat@cloudflare.com> wrote:
> Let's add utf16 later then (if needed). I also noticed a typo in one
> error string in my above patch (it was checking that command receives
> one argument, but prints that two arguments expected), so here is the
> updated one.
>

It is much more difficult to remove anything than to add it later.
Unless we have use case right now, I'd skip it.

> So, finally, should I remove the "raw" parser (as per Vladimir's
> request). Personally, I would keep it. It might be useful to modify
> the hexdump command, that it can dump the contents of a variable. Then
> those pieces will fit together: storing raw value in the variable and
> examining it with hexdump cmd.
>

hexdump does not support showing variable if that is what you mean. By
the same logic, unless we have current use case we probably should not
add it initially.

Re: Grub get and set efi variables

[Vladimir 'phcoder' Serbinenko]

[-- Attachment #1: Type: text/plain, Size: 1327 bytes --]

Le 2 déc. 2015 2:01 PM, "Andrei Borzenkov" <arvidjaar@gmail.com> a écrit :

>

> On Wed, Dec 2, 2015 at 3:53 PM, Ignat Korchagin <ignat@cloudflare.com>
wrote:

> > Let's add utf16 later then (if needed). I also noticed a typo in one

> > error string in my above patch (it was checking that command receives

> > one argument, but prints that two arguments expected), so here is the

> > updated one.

> >

>

> It is much more difficult to remove anything than to add it later.

> Unless we have use case right now, I'd skip it.

>

> > So, finally, should I remove the "raw" parser (as per Vladimir's

> > request). Personally, I would keep it. It might be useful to modify

> > the hexdump command, that it can dump the contents of a variable. Then

> > those pieces will fit together: storing raw value in the variable and

> > examining it with hexdump cmd.

> >

>

> hexdump does not support showing variable if that is what you mean. By

> the same logic, unless we have current use case we probably should not

> add it initially.

>

We don't even support storing non-utf8 in a variable. So please skip it

> _______________________________________________

> Grub-devel mailing list

> Grub-devel@gnu.org

> https://lists.gnu.org/mailman/listinfo/grub-devel

[-- Attachment #2: Type: text/html, Size: 1769 bytes --]

Re: Grub get and set efi variables

[Ignat Korchagin]

OK. Updated patch below:

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 0cc40bb..aa7b927 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -735,6 +735,12 @@ module = {
 };

 module = {
+  name = efivar;
+  efi = commands/efi/efivar.c;
+  enable = efi;
+};
+
+module = {
   name = blocklist;
   common = commands/blocklist.c;
 };
diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
new file mode 100644
index 0000000..8acd0c2
--- /dev/null
+++ b/grub-core/commands/efi/efivar.c
@@ -0,0 +1,238 @@
+/* efivar.c - Read EFI global variables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 Free Software Foundation, Inc.
+ *  Copyright (C) 2015 CloudFlare, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/lib/hexdump.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
specific format (hex, uint8, ascii, dump). Default: hex."),
N_("FORMAT"), ARG_TYPE_STRING},
+  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
environment variable (does not work with dump)."), N_("ENV_VAR"),
ARG_TYPE_STRING},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum efi_var_type
+  {
+    EFI_VAR_ASCII = 0,
+    EFI_VAR_UINT8,
+    EFI_VAR_HEX,
+    EFI_VAR_DUMP,
+    EFI_VAR_INVALID = -1
+  };
+
+static enum efi_var_type
+parse_efi_var_type (const char *type)
+{
+  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
+    return EFI_VAR_UINT8;
+
+  if (!grub_strncmp (type, "hex", sizeof("hex")))
+    return EFI_VAR_HEX;
+
+  if (!grub_strncmp (type, "dump", sizeof("dump")))
+    return EFI_VAR_DUMP;
+
+  return EFI_VAR_INVALID;
+}
+
+static int
+grub_print_ascii (char *str, char c)
+{
+  if (grub_iscntrl (c))
+  {
+    switch (c)
+      {
+        case '\0':
+          str[0] = '\\';
+          str[1] = '0';
+          return 2;
+
+        case '\a':
+          str[0] = '\\';
+          str[1] = 'a';
+          return 2;
+
+        case '\b':
+          str[0] = '\\';
+          str[1] = 'b';
+          return 2;
+
+        case '\f':
+          str[0] = '\\';
+          str[1] = 'f';
+          return 2;
+
+        case '\n':
+          str[0] = '\\';
+          str[1] = 'n';
+          return 2;
+
+        case '\r':
+          str[0] = '\\';
+          str[1] = 'r';
+          return 2;
+
+        case '\t':
+          str[0] = '\\';
+          str[1] = 't';
+          return 2;
+
+        case '\v':
+          str[0] = '\\';
+          str[1] = 'v';
+          return 2;
+
+        default:
+          str[0] = '.'; /* as in hexdump -C */
+          return 1;
+      }
+  }
+
+  str[0] = c;
+  return 1;
+}
+
+static grub_err_t
+grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
+  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  grub_err_t status;
+  void *efi_var = NULL;
+  grub_size_t efi_var_size = 0;
+  enum efi_var_type efi_type = EFI_VAR_HEX;
+  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
+  char *env_var = NULL;
+  grub_size_t i;
+  char *ptr;
+
+  if (1 != argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
+
+  if (state[0].set)
+    efi_type = parse_efi_var_type (state[0].arg);
+
+  if (EFI_VAR_INVALID == efi_type)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
+
+  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
+  if (!efi_var || !efi_var_size)
+    {
+      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
+      goto err;
+    }
+
+  switch (efi_type)
+  {
+    case EFI_VAR_ASCII:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+
+      ptr = env_var;
+
+      for (i = 0; i < efi_var_size; i++)
+        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
+      *ptr = '\0';
+      break;
+
+    case EFI_VAR_UINT8:
+      env_var = grub_malloc (4);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
+      break;
+
+    case EFI_VAR_HEX:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      for (i = 0; i < efi_var_size; i++)
+        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
*)efi_var)[i]);
+      break;
+
+    case EFI_VAR_DUMP:
+      if (state[1].set)
+        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
variable with dump format specifier"));
+      else
+        {
+          hexdump (0, (char *)efi_var, efi_var_size);
+          status = GRUB_ERR_NONE;
+        }
+      break;
+
+    default:
+      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
in module?)"));
+  }
+
+  if (efi_type != EFI_VAR_DUMP)
+    {
+      if (state[1].set)
+        status = grub_env_set (state[1].arg, env_var);
+      else
+        {
+          grub_printf ("%s\n", (const char *)env_var);
+          status = GRUB_ERR_NONE;
+        }
+    }
+
+err:
+
+  if (env_var)
+    grub_free (env_var);
+
+  if (efi_var)
+    grub_free (efi_var);
+
+  return status;
+}
+
+static grub_extcmd_t cmd = NULL;
+
+GRUB_MOD_INIT (efivar)
+{
+  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
+ N_("Read EFI variable and print it or save its contents to
environment variable."), options);
+}
+
+GRUB_MOD_FINI (efivar)
+{
+  if (cmd)
+    grub_unregister_extcmd (cmd);
+}

On Wed, Dec 2, 2015 at 1:05 PM, Vladimir 'phcoder' Serbinenko
<phcoder@gmail.com> wrote:
> Le 2 déc. 2015 2:01 PM, "Andrei Borzenkov" <arvidjaar@gmail.com> a écrit :
>
>>
>
>> On Wed, Dec 2, 2015 at 3:53 PM, Ignat Korchagin <ignat@cloudflare.com>
>> wrote:
>
>> > Let's add utf16 later then (if needed). I also noticed a typo in one
>
>> > error string in my above patch (it was checking that command receives
>
>> > one argument, but prints that two arguments expected), so here is the
>
>> > updated one.
>
>> >
>
>>
>
>> It is much more difficult to remove anything than to add it later.
>
>> Unless we have use case right now, I'd skip it.
>
>>
>
>> > So, finally, should I remove the "raw" parser (as per Vladimir's
>
>> > request). Personally, I would keep it. It might be useful to modify
>
>> > the hexdump command, that it can dump the contents of a variable. Then
>
>> > those pieces will fit together: storing raw value in the variable and
>
>> > examining it with hexdump cmd.
>
>> >
>
>>
>
>> hexdump does not support showing variable if that is what you mean. By
>
>> the same logic, unless we have current use case we probably should not
>
>> add it initially.
>
>>
>
> We don't even support storing non-utf8 in a variable. So please skip it
>
>> _______________________________________________
>
>> Grub-devel mailing list
>
>> Grub-devel@gnu.org
>
>> https://lists.gnu.org/mailman/listinfo/grub-devel
>
>
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
>

Re: Grub get and set efi variables

[Andrei Borzenkov]

02.12.2015 17:52, Ignat Korchagin пишет:
> OK. Updated patch below:
> 
> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> index 0cc40bb..aa7b927 100644
> --- a/grub-core/Makefile.core.def
> +++ b/grub-core/Makefile.core.def
> @@ -735,6 +735,12 @@ module = {
>  };
> 
>  module = {
> +  name = efivar;
> +  efi = commands/efi/efivar.c;
> +  enable = efi;
> +};
> +
> +module = {
>    name = blocklist;
>    common = commands/blocklist.c;
>  };
> diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
> new file mode 100644
> index 0000000..8acd0c2
> --- /dev/null
> +++ b/grub-core/commands/efi/efivar.c
> @@ -0,0 +1,238 @@
> +/* efivar.c - Read EFI global variables. */
> +/*
> + *  GRUB  --  GRand Unified Bootloader
> + *  Copyright (C) 2015 Free Software Foundation, Inc.
> + *  Copyright (C) 2015 CloudFlare, Inc.
> + *
> + *  GRUB is free software: you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation, either version 3 of the License, or
> + *  (at your option) any later version.
> + *
> + *  GRUB is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <grub/types.h>
> +#include <grub/mm.h>
> +#include <grub/misc.h>
> +#include <grub/efi/api.h>
> +#include <grub/efi/efi.h>
> +#include <grub/extcmd.h>
> +#include <grub/env.h>
> +#include <grub/lib/hexdump.h>
> +
> +GRUB_MOD_LICENSE ("GPLv3+");
> +
> +static const struct grub_arg_option options[] = {
> +  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
> specific format (hex, uint8, ascii, dump). Default: hex."),
> N_("FORMAT"), ARG_TYPE_STRING},
> +  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
> environment variable (does not work with dump)."), N_("ENV_VAR"),
> ARG_TYPE_STRING},
> +  {0, 0, 0, 0, 0, 0}
> +};
> +
> +enum efi_var_type
> +  {
> +    EFI_VAR_ASCII = 0,
> +    EFI_VAR_UINT8,
> +    EFI_VAR_HEX,
> +    EFI_VAR_DUMP,
> +    EFI_VAR_INVALID = -1
> +  };
> +
> +static enum efi_var_type
> +parse_efi_var_type (const char *type)
> +{
> +  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
> +    return EFI_VAR_UINT8;
> +
> +  if (!grub_strncmp (type, "hex", sizeof("hex")))
> +    return EFI_VAR_HEX;
> +
> +  if (!grub_strncmp (type, "dump", sizeof("dump")))
> +    return EFI_VAR_DUMP;
> +
> +  return EFI_VAR_INVALID;
> +}
> +

This should be grub_strcmp everywhere, there is no reason to use
grub_strncmp.
> +
> +GRUB_MOD_INIT (efivar)
> +{
> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
> + N_("Read EFI variable and print it or save its contents to

I believe it should be "content" (without final `s') but English is not
native.

Otherwise OK from my side.

Could you also add documentation part for it?

Re: Grub get and set efi variables

[Ignat Korchagin]

> This should be grub_strcmp everywhere, there is no reason to use grub_strncmp.
Yes, you are right. Please, find updated patch below

> I believe it should be "content" (without final `s') but English is not native
Mine not as well, but asked my native colleagues and they confirmed
"contents". Also this aligns with Google search.

> Could you also add documentation part for it?
Yes, sure. Could you give me a hint how the project handles
documentation? I didn't find the overall module descriptions, but,
maybe, I didn't look very well :)

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 0cc40bb..aa7b927 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -735,6 +735,12 @@ module = {
 };

 module = {
+  name = efivar;
+  efi = commands/efi/efivar.c;
+  enable = efi;
+};
+
+module = {
   name = blocklist;
   common = commands/blocklist.c;
 };
diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
new file mode 100644
index 0000000..8acd0c2
--- /dev/null
+++ b/grub-core/commands/efi/efivar.c
@@ -0,0 +1,238 @@
+/* efivar.c - Read EFI global variables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 Free Software Foundation, Inc.
+ *  Copyright (C) 2015 CloudFlare, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/lib/hexdump.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
specific format (hex, uint8, ascii, dump). Default: hex."),
N_("FORMAT"), ARG_TYPE_STRING},
+  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
environment variable (does not work with dump)."), N_("ENV_VAR"),
ARG_TYPE_STRING},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum efi_var_type
+  {
+    EFI_VAR_ASCII = 0,
+    EFI_VAR_UINT8,
+    EFI_VAR_HEX,
+    EFI_VAR_DUMP,
+    EFI_VAR_INVALID = -1
+  };
+
+static enum efi_var_type
+parse_efi_var_type (const char *type)
+{
+  if (!grub_strcmp (type, "ascii"))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strcmp (type, "uint8"))
+    return EFI_VAR_UINT8;
+
+  if (!grub_strcmp (type, "hex"))
+    return EFI_VAR_HEX;
+
+  if (!grub_strcmp (type, "dump"))
+    return EFI_VAR_DUMP;
+
+  return EFI_VAR_INVALID;
+}
+
+static int
+grub_print_ascii (char *str, char c)
+{
+  if (grub_iscntrl (c))
+  {
+    switch (c)
+      {
+        case '\0':
+          str[0] = '\\';
+          str[1] = '0';
+          return 2;
+
+        case '\a':
+          str[0] = '\\';
+          str[1] = 'a';
+          return 2;
+
+        case '\b':
+          str[0] = '\\';
+          str[1] = 'b';
+          return 2;
+
+        case '\f':
+          str[0] = '\\';
+          str[1] = 'f';
+          return 2;
+
+        case '\n':
+          str[0] = '\\';
+          str[1] = 'n';
+          return 2;
+
+        case '\r':
+          str[0] = '\\';
+          str[1] = 'r';
+          return 2;
+
+        case '\t':
+          str[0] = '\\';
+          str[1] = 't';
+          return 2;
+
+        case '\v':
+          str[0] = '\\';
+          str[1] = 'v';
+          return 2;
+
+        default:
+          str[0] = '.'; /* as in hexdump -C */
+          return 1;
+      }
+  }
+
+  str[0] = c;
+  return 1;
+}
+
+static grub_err_t
+grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
+  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  grub_err_t status;
+  void *efi_var = NULL;
+  grub_size_t efi_var_size = 0;
+  enum efi_var_type efi_type = EFI_VAR_HEX;
+  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
+  char *env_var = NULL;
+  grub_size_t i;
+  char *ptr;
+
+  if (1 != argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
+
+  if (state[0].set)
+    efi_type = parse_efi_var_type (state[0].arg);
+
+  if (EFI_VAR_INVALID == efi_type)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
+
+  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
+  if (!efi_var || !efi_var_size)
+    {
+      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
+      goto err;
+    }
+
+  switch (efi_type)
+  {
+    case EFI_VAR_ASCII:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+
+      ptr = env_var;
+
+      for (i = 0; i < efi_var_size; i++)
+        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
+      *ptr = '\0';
+      break;
+
+    case EFI_VAR_UINT8:
+      env_var = grub_malloc (4);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
+      break;
+
+    case EFI_VAR_HEX:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          break;
+        }
+      for (i = 0; i < efi_var_size; i++)
+        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
*)efi_var)[i]);
+      break;
+
+    case EFI_VAR_DUMP:
+      if (state[1].set)
+        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
variable with dump format specifier"));
+      else
+        {
+          hexdump (0, (char *)efi_var, efi_var_size);
+          status = GRUB_ERR_NONE;
+        }
+      break;
+
+    default:
+      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
in module?)"));
+  }
+
+  if (efi_type != EFI_VAR_DUMP)
+    {
+      if (state[1].set)
+        status = grub_env_set (state[1].arg, env_var);
+      else
+        {
+          grub_printf ("%s\n", (const char *)env_var);
+          status = GRUB_ERR_NONE;
+        }
+    }
+
+err:
+
+  if (env_var)
+    grub_free (env_var);
+
+  if (efi_var)
+    grub_free (efi_var);
+
+  return status;
+}
+
+static grub_extcmd_t cmd = NULL;
+
+GRUB_MOD_INIT (efivar)
+{
+  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
+ N_("Read EFI variable and print it or save its contents to
environment variable."), options);
+}
+
+GRUB_MOD_FINI (efivar)
+{
+  if (cmd)
+    grub_unregister_extcmd (cmd);
+}

Re: Grub get and set efi variables

[Ignat Korchagin]

Is this still considered?

On Thu, Dec 3, 2015 at 5:19 PM, Ignat Korchagin <ignat@cloudflare.com> wrote:
>> This should be grub_strcmp everywhere, there is no reason to use grub_strncmp.
> Yes, you are right. Please, find updated patch below
>
>> I believe it should be "content" (without final `s') but English is not native
> Mine not as well, but asked my native colleagues and they confirmed
> "contents". Also this aligns with Google search.
>
>> Could you also add documentation part for it?
> Yes, sure. Could you give me a hint how the project handles
> documentation? I didn't find the overall module descriptions, but,
> maybe, I didn't look very well :)
>
> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> index 0cc40bb..aa7b927 100644
> --- a/grub-core/Makefile.core.def
> +++ b/grub-core/Makefile.core.def
> @@ -735,6 +735,12 @@ module = {
>  };
>
>  module = {
> +  name = efivar;
> +  efi = commands/efi/efivar.c;
> +  enable = efi;
> +};
> +
> +module = {
>    name = blocklist;
>    common = commands/blocklist.c;
>  };
> diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
> new file mode 100644
> index 0000000..8acd0c2
> --- /dev/null
> +++ b/grub-core/commands/efi/efivar.c
> @@ -0,0 +1,238 @@
> +/* efivar.c - Read EFI global variables. */
> +/*
> + *  GRUB  --  GRand Unified Bootloader
> + *  Copyright (C) 2015 Free Software Foundation, Inc.
> + *  Copyright (C) 2015 CloudFlare, Inc.
> + *
> + *  GRUB is free software: you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation, either version 3 of the License, or
> + *  (at your option) any later version.
> + *
> + *  GRUB is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <grub/types.h>
> +#include <grub/mm.h>
> +#include <grub/misc.h>
> +#include <grub/efi/api.h>
> +#include <grub/efi/efi.h>
> +#include <grub/extcmd.h>
> +#include <grub/env.h>
> +#include <grub/lib/hexdump.h>
> +
> +GRUB_MOD_LICENSE ("GPLv3+");
> +
> +static const struct grub_arg_option options[] = {
> +  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
> specific format (hex, uint8, ascii, dump). Default: hex."),
> N_("FORMAT"), ARG_TYPE_STRING},
> +  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
> environment variable (does not work with dump)."), N_("ENV_VAR"),
> ARG_TYPE_STRING},
> +  {0, 0, 0, 0, 0, 0}
> +};
> +
> +enum efi_var_type
> +  {
> +    EFI_VAR_ASCII = 0,
> +    EFI_VAR_UINT8,
> +    EFI_VAR_HEX,
> +    EFI_VAR_DUMP,
> +    EFI_VAR_INVALID = -1
> +  };
> +
> +static enum efi_var_type
> +parse_efi_var_type (const char *type)
> +{
> +  if (!grub_strcmp (type, "ascii"))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strcmp (type, "uint8"))
> +    return EFI_VAR_UINT8;
> +
> +  if (!grub_strcmp (type, "hex"))
> +    return EFI_VAR_HEX;
> +
> +  if (!grub_strcmp (type, "dump"))
> +    return EFI_VAR_DUMP;
> +
> +  return EFI_VAR_INVALID;
> +}
> +
> +static int
> +grub_print_ascii (char *str, char c)
> +{
> +  if (grub_iscntrl (c))
> +  {
> +    switch (c)
> +      {
> +        case '\0':
> +          str[0] = '\\';
> +          str[1] = '0';
> +          return 2;
> +
> +        case '\a':
> +          str[0] = '\\';
> +          str[1] = 'a';
> +          return 2;
> +
> +        case '\b':
> +          str[0] = '\\';
> +          str[1] = 'b';
> +          return 2;
> +
> +        case '\f':
> +          str[0] = '\\';
> +          str[1] = 'f';
> +          return 2;
> +
> +        case '\n':
> +          str[0] = '\\';
> +          str[1] = 'n';
> +          return 2;
> +
> +        case '\r':
> +          str[0] = '\\';
> +          str[1] = 'r';
> +          return 2;
> +
> +        case '\t':
> +          str[0] = '\\';
> +          str[1] = 't';
> +          return 2;
> +
> +        case '\v':
> +          str[0] = '\\';
> +          str[1] = 'v';
> +          return 2;
> +
> +        default:
> +          str[0] = '.'; /* as in hexdump -C */
> +          return 1;
> +      }
> +  }
> +
> +  str[0] = c;
> +  return 1;
> +}
> +
> +static grub_err_t
> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
> +  int argc, char **args)
> +{
> +  struct grub_arg_list *state = ctxt->state;
> +  grub_err_t status;
> +  void *efi_var = NULL;
> +  grub_size_t efi_var_size = 0;
> +  enum efi_var_type efi_type = EFI_VAR_HEX;
> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
> +  char *env_var = NULL;
> +  grub_size_t i;
> +  char *ptr;
> +
> +  if (1 != argc)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
> +
> +  if (state[0].set)
> +    efi_type = parse_efi_var_type (state[0].arg);
> +
> +  if (EFI_VAR_INVALID == efi_type)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
> +
> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
> +  if (!efi_var || !efi_var_size)
> +    {
> +      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
> +      goto err;
> +    }
> +
> +  switch (efi_type)
> +  {
> +    case EFI_VAR_ASCII:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +
> +      ptr = env_var;
> +
> +      for (i = 0; i < efi_var_size; i++)
> +        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
> +      *ptr = '\0';
> +      break;
> +
> +    case EFI_VAR_UINT8:
> +      env_var = grub_malloc (4);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
> +      break;
> +
> +    case EFI_VAR_HEX:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      for (i = 0; i < efi_var_size; i++)
> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
> *)efi_var)[i]);
> +      break;
> +
> +    case EFI_VAR_DUMP:
> +      if (state[1].set)
> +        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
> variable with dump format specifier"));
> +      else
> +        {
> +          hexdump (0, (char *)efi_var, efi_var_size);
> +          status = GRUB_ERR_NONE;
> +        }
> +      break;
> +
> +    default:
> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
> in module?)"));
> +  }
> +
> +  if (efi_type != EFI_VAR_DUMP)
> +    {
> +      if (state[1].set)
> +        status = grub_env_set (state[1].arg, env_var);
> +      else
> +        {
> +          grub_printf ("%s\n", (const char *)env_var);
> +          status = GRUB_ERR_NONE;
> +        }
> +    }
> +
> +err:
> +
> +  if (env_var)
> +    grub_free (env_var);
> +
> +  if (efi_var)
> +    grub_free (efi_var);
> +
> +  return status;
> +}
> +
> +static grub_extcmd_t cmd = NULL;
> +
> +GRUB_MOD_INIT (efivar)
> +{
> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
> + N_("Read EFI variable and print it or save its contents to
> environment variable."), options);
> +}
> +
> +GRUB_MOD_FINI (efivar)
> +{
> +  if (cmd)
> +    grub_unregister_extcmd (cmd);
> +}

Re: Grub get and set efi variables

[Andrei Borzenkov]

03.12.2015 20:19, Ignat Korchagin пишет:
>> This should be grub_strcmp everywhere, there is no reason to use grub_strncmp.
> Yes, you are right. Please, find updated patch below
> 
>> I believe it should be "content" (without final `s') but English is not native
> Mine not as well, but asked my native colleagues and they confirmed
> "contents". Also this aligns with Google search.
> 
>> Could you also add documentation part for it?
> Yes, sure. Could you give me a hint how the project handles
> documentation? I didn't find the overall module descriptions, but,
> maybe, I didn't look very well :)
> 

Documentation is maintained in texinfo format in doc/grub.texi. It is
lacking, but there is list of available commands with index, so just
adding it would be good. It should ideally be a bit more verbose
(examples are welcome) than usage printed at run time.

> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> index 0cc40bb..aa7b927 100644
> --- a/grub-core/Makefile.core.def
> +++ b/grub-core/Makefile.core.def
> @@ -735,6 +735,12 @@ module = {
>  };
> 
>  module = {
> +  name = efivar;
> +  efi = commands/efi/efivar.c;
> +  enable = efi;
> +};
> +
> +module = {
>    name = blocklist;
>    common = commands/blocklist.c;
>  };
> diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
> new file mode 100644
> index 0000000..8acd0c2
> --- /dev/null
> +++ b/grub-core/commands/efi/efivar.c
> @@ -0,0 +1,238 @@
> +/* efivar.c - Read EFI global variables. */
> +/*
> + *  GRUB  --  GRand Unified Bootloader
> + *  Copyright (C) 2015 Free Software Foundation, Inc.
> + *  Copyright (C) 2015 CloudFlare, Inc.
> + *
> + *  GRUB is free software: you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation, either version 3 of the License, or
> + *  (at your option) any later version.
> + *
> + *  GRUB is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <grub/types.h>
> +#include <grub/mm.h>
> +#include <grub/misc.h>
> +#include <grub/efi/api.h>
> +#include <grub/efi/efi.h>
> +#include <grub/extcmd.h>
> +#include <grub/env.h>
> +#include <grub/lib/hexdump.h>
> +
> +GRUB_MOD_LICENSE ("GPLv3+");
> +
> +static const struct grub_arg_option options[] = {
> +  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
> specific format (hex, uint8, ascii, dump). Default: hex."),

Do we really need unit8 at all? "hex" already provides exactly the same
functionality, not? Do you think there are cases when uint8 is really
required?

If we remove unit8, this becomes really "Display EFI_VAR" not "Parse
EFI_VAR", as no parsing really happens.

> N_("FORMAT"), ARG_TYPE_STRING},
> +  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
> environment variable (does not work with dump)."), N_("ENV_VAR"),
> ARG_TYPE_STRING},
> +  {0, 0, 0, 0, 0, 0}
> +};
> +
> +enum efi_var_type
> +  {
> +    EFI_VAR_ASCII = 0,
> +    EFI_VAR_UINT8,
> +    EFI_VAR_HEX,
> +    EFI_VAR_DUMP,
> +    EFI_VAR_INVALID = -1
> +  };
> +
> +static enum efi_var_type
> +parse_efi_var_type (const char *type)
> +{
> +  if (!grub_strcmp (type, "ascii"))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strcmp (type, "uint8"))
> +    return EFI_VAR_UINT8;
> +
> +  if (!grub_strcmp (type, "hex"))
> +    return EFI_VAR_HEX;
> +
> +  if (!grub_strcmp (type, "dump"))
> +    return EFI_VAR_DUMP;
> +
> +  return EFI_VAR_INVALID;
> +}
> +
> +static int
> +grub_print_ascii (char *str, char c)
> +{
> +  if (grub_iscntrl (c))
> +  {
> +    switch (c)
> +      {
> +        case '\0':
> +          str[0] = '\\';
> +          str[1] = '0';
> +          return 2;
> +
> +        case '\a':
> +          str[0] = '\\';
> +          str[1] = 'a';
> +          return 2;
> +
> +        case '\b':
> +          str[0] = '\\';
> +          str[1] = 'b';
> +          return 2;
> +
> +        case '\f':
> +          str[0] = '\\';
> +          str[1] = 'f';
> +          return 2;
> +
> +        case '\n':
> +          str[0] = '\\';
> +          str[1] = 'n';
> +          return 2;
> +
> +        case '\r':
> +          str[0] = '\\';
> +          str[1] = 'r';
> +          return 2;
> +
> +        case '\t':
> +          str[0] = '\\';
> +          str[1] = 't';
> +          return 2;
> +
> +        case '\v':
> +          str[0] = '\\';
> +          str[1] = 'v';
> +          return 2;
> +
> +        default:
> +          str[0] = '.'; /* as in hexdump -C */
> +          return 1;
> +      }
> +  }
> +
> +  str[0] = c;
> +  return 1;
> +}
> +
> +static grub_err_t
> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
> +  int argc, char **args)
> +{
> +  struct grub_arg_list *state = ctxt->state;
> +  grub_err_t status;
> +  void *efi_var = NULL;
> +  grub_size_t efi_var_size = 0;
> +  enum efi_var_type efi_type = EFI_VAR_HEX;
> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
> +  char *env_var = NULL;
> +  grub_size_t i;
> +  char *ptr;
> +
> +  if (1 != argc)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
> +
> +  if (state[0].set)
> +    efi_type = parse_efi_var_type (state[0].arg);
> +
> +  if (EFI_VAR_INVALID == efi_type)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
> +
> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
> +  if (!efi_var || !efi_var_size)
> +    {
> +      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
> +      goto err;
> +    }
> +
> +  switch (efi_type)
> +  {
> +    case EFI_VAR_ASCII:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;

goto err; see below

> +        }
> +
> +      ptr = env_var;
> +
> +      for (i = 0; i < efi_var_size; i++)
> +        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
> +      *ptr = '\0';
> +      break;
> +
> +    case EFI_VAR_UINT8:
> +      env_var = grub_malloc (4);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;
> +        }
> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));

Assuming uint8 remains - should not you check that variable size is
exactly 1 byte in this case?

> +      break;
> +
> +    case EFI_VAR_HEX:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          break;

goto err

> +        }
> +      for (i = 0; i < efi_var_size; i++)
> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
> *)efi_var)[i]);
> +      break;
> +
> +    case EFI_VAR_DUMP:
> +      if (state[1].set)
> +        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
> variable with dump format specifier"));
> +      else
> +        {
> +          hexdump (0, (char *)efi_var, efi_var_size);
> +          status = GRUB_ERR_NONE;
> +        }
> +      break;
> +
> +    default:
> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
> in module?)"));

goto err

> +  }
> +
> +  if (efi_type != EFI_VAR_DUMP)
> +    {
> +      if (state[1].set)
> +        status = grub_env_set (state[1].arg, env_var);
> +      else
> +        {
> +          grub_printf ("%s\n", (const char *)env_var);
> +          status = GRUB_ERR_NONE;
> +        }
> +    }
> +

In OOM case you access NULL pointer here.

> +err:
> +
> +  if (env_var)
> +    grub_free (env_var);
> +
> +  if (efi_var)
> +    grub_free (efi_var);
> +

grub_free already checks for NULL, no need to do it extra.

> +  return status;
> +}
> +
> +static grub_extcmd_t cmd = NULL;
> +
> +GRUB_MOD_INIT (efivar)
> +{
> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
> + N_("Read EFI variable and print it or save its contents to
> environment variable."), options);
> +}
> +
> +GRUB_MOD_FINI (efivar)
> +{
> +  if (cmd)
> +    grub_unregister_extcmd (cmd);
> +}
> 
> _______________________________________________
> Grub-devel mailing list
> Grub-devel@gnu.org
> https://lists.gnu.org/mailman/listinfo/grub-devel
> 

Re: Grub get and set efi variables

[Ignat Korchagin]

> Assuming uint8 remains - should not you check that variable size is exactly 1 byte in this case?
There are reports of a buggy firmware returning 4 bytes size for uint8
variables, however did not encounter them myself.

> Do we really need unit8 at all? "hex" already provides exactly the same functionality, not? Do you think there are cases when uint8 is really required?
Well, when checking for SecureBoot variable in grub configuration file
hex mode makes it look weird and creates a point of confusion. For
example to check if SecureBoot (suppose the result of the our command
is stored in secure_boot env variable in hex mode) is enabled one
should write:
if [ secure_boot = "01" ]
...
uint8 just allows to do a more straightforward config
if [ secure_boot = 1] - this case would be false for hex mode -
possible security breach
...

Added goto err in the module as pointed, see patch below. I will do a
follow-up patch for documentation once we get this confirmed.

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 0cc40bb..aa7b927 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -735,6 +735,12 @@ module = {
 };

 module = {
+  name = efivar;
+  efi = commands/efi/efivar.c;
+  enable = efi;
+};
+
+module = {
   name = blocklist;
   common = commands/blocklist.c;
 };
diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
new file mode 100644
index 0000000..7f5a957
--- /dev/null
+++ b/grub-core/commands/efi/efivar.c
@@ -0,0 +1,251 @@
+/* efivar.c - Read EFI global variables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 Free Software Foundation, Inc.
+ *  Copyright (C) 2015 CloudFlare, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/lib/hexdump.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
specific format (hex, uint8, ascii, raw, dump). Default: hex."),
N_("FORMAT"), ARG_TYPE_STRING},
+  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
environment variable (does not work with dump)."), N_("ENV_VAR"),
ARG_TYPE_STRING},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum efi_var_type
+  {
+    EFI_VAR_ASCII = 0,
+    EFI_VAR_RAW,
+    EFI_VAR_UINT8,
+    EFI_VAR_HEX,
+    EFI_VAR_DUMP,
+    EFI_VAR_INVALID = -1
+  };
+
+static enum efi_var_type
+parse_efi_var_type (const char *type)
+{
+  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strncmp (type, "raw", sizeof("raw")))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
+    return EFI_VAR_UINT8;
+
+  if (!grub_strncmp (type, "hex", sizeof("hex")))
+    return EFI_VAR_HEX;
+
+  if (!grub_strncmp (type, "dump", sizeof("dump")))
+    return EFI_VAR_DUMP;
+
+  return EFI_VAR_INVALID;
+}
+
+static int
+grub_print_ascii (char *str, char c)
+{
+  if (grub_iscntrl (c))
+  {
+    switch (c)
+      {
+        case '\0':
+          str[0] = '\\';
+          str[1] = '0';
+          return 2;
+
+        case '\a':
+          str[0] = '\\';
+          str[1] = 'a';
+          return 2;
+
+        case '\b':
+          str[0] = '\\';
+          str[1] = 'b';
+          return 2;
+
+        case '\f':
+          str[0] = '\\';
+          str[1] = 'f';
+          return 2;
+
+        case '\n':
+          str[0] = '\\';
+          str[1] = 'n';
+          return 2;
+
+        case '\r':
+          str[0] = '\\';
+          str[1] = 'r';
+          return 2;
+
+        case '\t':
+          str[0] = '\\';
+          str[1] = 't';
+          return 2;
+
+        case '\v':
+          str[0] = '\\';
+          str[1] = 'v';
+          return 2;
+
+        default:
+          str[0] = '.'; /* as in hexdump -C */
+          return 1;
+      }
+  }
+
+  str[0] = c;
+  return 1;
+}
+
+static grub_err_t
+grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
+  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  grub_err_t status;
+  void *efi_var = NULL;
+  grub_size_t efi_var_size = 0;
+  enum efi_var_type efi_type = EFI_VAR_HEX;
+  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
+  char *env_var = NULL;
+  grub_size_t i;
+  char *ptr;
+
+  if (1 != argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
+
+  if (state[0].set)
+    efi_type = parse_efi_var_type (state[0].arg);
+
+  if (EFI_VAR_INVALID == efi_type)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
+
+  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
+  if (!efi_var || !efi_var_size)
+    {
+      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
+      goto err;
+    }
+
+  switch (efi_type)
+  {
+    case EFI_VAR_ASCII:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          goto err;
+        }
+
+      ptr = env_var;
+
+      for (i = 0; i < efi_var_size; i++)
+        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
+      *ptr = '\0';
+      break;
+
+    case EFI_VAR_RAW:
+      env_var = grub_malloc (efi_var_size + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          goto err;
+        }
+      grub_memcpy (env_var, efi_var, efi_var_size);
+      env_var[efi_var_size] = '\0';
+      break;
+
+    case EFI_VAR_UINT8:
+      env_var = grub_malloc (4);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          goto err;
+        }
+      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
+      break;
+
+    case EFI_VAR_HEX:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          goto err;
+        }
+      for (i = 0; i < efi_var_size; i++)
+        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
*)efi_var)[i]);
+      break;
+
+    case EFI_VAR_DUMP:
+      if (state[1].set)
+        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
variable with dump format specifier"));
+      else
+        {
+          hexdump (0, (char *)efi_var, efi_var_size);
+          status = GRUB_ERR_NONE;
+        }
+      break;
+
+    default:
+      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
in module?)"));
+      goto err;
+  }
+
+  if (efi_type != EFI_VAR_DUMP)
+    {
+      if (state[1].set)
+        status = grub_env_set (state[1].arg, env_var);
+      else
+        {
+          grub_printf ("%s\n", (const char *)env_var);
+          status = GRUB_ERR_NONE;
+        }
+    }
+
+err:
+
+  grub_free (env_var);
+  grub_free (efi_var);
+
+  return status;
+}
+
+static grub_extcmd_t cmd = NULL;
+
+GRUB_MOD_INIT (efivar)
+{
+  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
+ N_("Read EFI variable and print it or save its contents to
environment variable."), options);
+}
+
+GRUB_MOD_FINI (efivar)
+{
+  if (cmd)
+    grub_unregister_extcmd (cmd);
+}

Re: Grub get and set efi variables

[Ignat Korchagin]

Sorry, pasted wrong file. Here is the correct one:

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 0cc40bb..aa7b927 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -735,6 +735,12 @@ module = {
 };

 module = {
+  name = efivar;
+  efi = commands/efi/efivar.c;
+  enable = efi;
+};
+
+module = {
   name = blocklist;
   common = commands/blocklist.c;
 };
diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
new file mode 100644
index 0000000..7fe7bda
--- /dev/null
+++ b/grub-core/commands/efi/efivar.c
@@ -0,0 +1,236 @@
+/* efivar.c - Read EFI global variables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 Free Software Foundation, Inc.
+ *  Copyright (C) 2015 CloudFlare, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/lib/hexdump.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static const struct grub_arg_option options[] = {
+  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
specific format (hex, uint8, ascii, dump). Default: hex."),
N_("FORMAT"), ARG_TYPE_STRING},
+  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
environment variable (does not work with dump)."), N_("ENV_VAR"),
ARG_TYPE_STRING},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum efi_var_type
+  {
+    EFI_VAR_ASCII = 0,
+    EFI_VAR_UINT8,
+    EFI_VAR_HEX,
+    EFI_VAR_DUMP,
+    EFI_VAR_INVALID = -1
+  };
+
+static enum efi_var_type
+parse_efi_var_type (const char *type)
+{
+  if (!grub_strcmp (type, "ascii"))
+    return EFI_VAR_ASCII;
+
+  if (!grub_strcmp (type, "uint8"))
+    return EFI_VAR_UINT8;
+
+  if (!grub_strcmp (type, "hex"))
+    return EFI_VAR_HEX;
+
+  if (!grub_strcmp (type, "dump"))
+    return EFI_VAR_DUMP;
+
+  return EFI_VAR_INVALID;
+}
+
+static int
+grub_print_ascii (char *str, char c)
+{
+  if (grub_iscntrl (c))
+  {
+    switch (c)
+      {
+        case '\0':
+          str[0] = '\\';
+          str[1] = '0';
+          return 2;
+
+        case '\a':
+          str[0] = '\\';
+          str[1] = 'a';
+          return 2;
+
+        case '\b':
+          str[0] = '\\';
+          str[1] = 'b';
+          return 2;
+
+        case '\f':
+          str[0] = '\\';
+          str[1] = 'f';
+          return 2;
+
+        case '\n':
+          str[0] = '\\';
+          str[1] = 'n';
+          return 2;
+
+        case '\r':
+          str[0] = '\\';
+          str[1] = 'r';
+          return 2;
+
+        case '\t':
+          str[0] = '\\';
+          str[1] = 't';
+          return 2;
+
+        case '\v':
+          str[0] = '\\';
+          str[1] = 'v';
+          return 2;
+
+        default:
+          str[0] = '.'; /* as in hexdump -C */
+          return 1;
+      }
+  }
+
+  str[0] = c;
+  return 1;
+}
+
+static grub_err_t
+grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
+  int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  grub_err_t status;
+  void *efi_var = NULL;
+  grub_size_t efi_var_size = 0;
+  enum efi_var_type efi_type = EFI_VAR_HEX;
+  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
+  char *env_var = NULL;
+  grub_size_t i;
+  char *ptr;
+
+  if (1 != argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
+
+  if (state[0].set)
+    efi_type = parse_efi_var_type (state[0].arg);
+
+  if (EFI_VAR_INVALID == efi_type)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
+
+  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
+  if (!efi_var || !efi_var_size)
+    {
+      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
+      goto err;
+    }
+
+  switch (efi_type)
+  {
+    case EFI_VAR_ASCII:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          goto err;
+        }
+
+      ptr = env_var;
+
+      for (i = 0; i < efi_var_size; i++)
+        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
+      *ptr = '\0';
+      break;
+
+    case EFI_VAR_UINT8:
+      env_var = grub_malloc (4);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          goto err;
+        }
+      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
+      break;
+
+    case EFI_VAR_HEX:
+      env_var = grub_malloc (efi_var_size * 2 + 1);
+      if (!env_var)
+        {
+          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+          goto err;
+        }
+      for (i = 0; i < efi_var_size; i++)
+        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
*)efi_var)[i]);
+      break;
+
+    case EFI_VAR_DUMP:
+      if (state[1].set)
+        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
variable with dump format specifier"));
+      else
+        {
+          hexdump (0, (char *)efi_var, efi_var_size);
+          status = GRUB_ERR_NONE;
+        }
+      break;
+
+    default:
+      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
in module?)"));
+      goto err;
+  }
+
+  if (efi_type != EFI_VAR_DUMP)
+    {
+      if (state[1].set)
+        status = grub_env_set (state[1].arg, env_var);
+      else
+        {
+          grub_printf ("%s\n", (const char *)env_var);
+          status = GRUB_ERR_NONE;
+        }
+    }
+
+err:
+
+  grub_free (env_var);
+  grub_free (efi_var);
+
+  return status;
+}
+
+static grub_extcmd_t cmd = NULL;
+
+GRUB_MOD_INIT (efivar)
+{
+  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
+ N_("Read EFI variable and print it or save its contents to
environment variable."), options);
+}
+
+GRUB_MOD_FINI (efivar)
+{
+  if (cmd)
+    grub_unregister_extcmd (cmd);
+}


On Mon, Dec 14, 2015 at 11:08 AM, Ignat Korchagin <ignat@cloudflare.com> wrote:
>> Assuming uint8 remains - should not you check that variable size is exactly 1 byte in this case?
> There are reports of a buggy firmware returning 4 bytes size for uint8
> variables, however did not encounter them myself.
>
>> Do we really need unit8 at all? "hex" already provides exactly the same functionality, not? Do you think there are cases when uint8 is really required?
> Well, when checking for SecureBoot variable in grub configuration file
> hex mode makes it look weird and creates a point of confusion. For
> example to check if SecureBoot (suppose the result of the our command
> is stored in secure_boot env variable in hex mode) is enabled one
> should write:
> if [ secure_boot = "01" ]
> ...
> uint8 just allows to do a more straightforward config
> if [ secure_boot = 1] - this case would be false for hex mode -
> possible security breach
> ...
>
> Added goto err in the module as pointed, see patch below. I will do a
> follow-up patch for documentation once we get this confirmed.
>
> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> index 0cc40bb..aa7b927 100644
> --- a/grub-core/Makefile.core.def
> +++ b/grub-core/Makefile.core.def
> @@ -735,6 +735,12 @@ module = {
>  };
>
>  module = {
> +  name = efivar;
> +  efi = commands/efi/efivar.c;
> +  enable = efi;
> +};
> +
> +module = {
>    name = blocklist;
>    common = commands/blocklist.c;
>  };
> diff --git a/grub-core/commands/efi/efivar.c b/grub-core/commands/efi/efivar.c
> new file mode 100644
> index 0000000..7f5a957
> --- /dev/null
> +++ b/grub-core/commands/efi/efivar.c
> @@ -0,0 +1,251 @@
> +/* efivar.c - Read EFI global variables. */
> +/*
> + *  GRUB  --  GRand Unified Bootloader
> + *  Copyright (C) 2015 Free Software Foundation, Inc.
> + *  Copyright (C) 2015 CloudFlare, Inc.
> + *
> + *  GRUB is free software: you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation, either version 3 of the License, or
> + *  (at your option) any later version.
> + *
> + *  GRUB is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <grub/types.h>
> +#include <grub/mm.h>
> +#include <grub/misc.h>
> +#include <grub/efi/api.h>
> +#include <grub/efi/efi.h>
> +#include <grub/extcmd.h>
> +#include <grub/env.h>
> +#include <grub/lib/hexdump.h>
> +
> +GRUB_MOD_LICENSE ("GPLv3+");
> +
> +static const struct grub_arg_option options[] = {
> +  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
> specific format (hex, uint8, ascii, raw, dump). Default: hex."),
> N_("FORMAT"), ARG_TYPE_STRING},
> +  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
> environment variable (does not work with dump)."), N_("ENV_VAR"),
> ARG_TYPE_STRING},
> +  {0, 0, 0, 0, 0, 0}
> +};
> +
> +enum efi_var_type
> +  {
> +    EFI_VAR_ASCII = 0,
> +    EFI_VAR_RAW,
> +    EFI_VAR_UINT8,
> +    EFI_VAR_HEX,
> +    EFI_VAR_DUMP,
> +    EFI_VAR_INVALID = -1
> +  };
> +
> +static enum efi_var_type
> +parse_efi_var_type (const char *type)
> +{
> +  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strncmp (type, "raw", sizeof("raw")))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
> +    return EFI_VAR_UINT8;
> +
> +  if (!grub_strncmp (type, "hex", sizeof("hex")))
> +    return EFI_VAR_HEX;
> +
> +  if (!grub_strncmp (type, "dump", sizeof("dump")))
> +    return EFI_VAR_DUMP;
> +
> +  return EFI_VAR_INVALID;
> +}
> +
> +static int
> +grub_print_ascii (char *str, char c)
> +{
> +  if (grub_iscntrl (c))
> +  {
> +    switch (c)
> +      {
> +        case '\0':
> +          str[0] = '\\';
> +          str[1] = '0';
> +          return 2;
> +
> +        case '\a':
> +          str[0] = '\\';
> +          str[1] = 'a';
> +          return 2;
> +
> +        case '\b':
> +          str[0] = '\\';
> +          str[1] = 'b';
> +          return 2;
> +
> +        case '\f':
> +          str[0] = '\\';
> +          str[1] = 'f';
> +          return 2;
> +
> +        case '\n':
> +          str[0] = '\\';
> +          str[1] = 'n';
> +          return 2;
> +
> +        case '\r':
> +          str[0] = '\\';
> +          str[1] = 'r';
> +          return 2;
> +
> +        case '\t':
> +          str[0] = '\\';
> +          str[1] = 't';
> +          return 2;
> +
> +        case '\v':
> +          str[0] = '\\';
> +          str[1] = 'v';
> +          return 2;
> +
> +        default:
> +          str[0] = '.'; /* as in hexdump -C */
> +          return 1;
> +      }
> +  }
> +
> +  str[0] = c;
> +  return 1;
> +}
> +
> +static grub_err_t
> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
> +  int argc, char **args)
> +{
> +  struct grub_arg_list *state = ctxt->state;
> +  grub_err_t status;
> +  void *efi_var = NULL;
> +  grub_size_t efi_var_size = 0;
> +  enum efi_var_type efi_type = EFI_VAR_HEX;
> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
> +  char *env_var = NULL;
> +  grub_size_t i;
> +  char *ptr;
> +
> +  if (1 != argc)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
> +
> +  if (state[0].set)
> +    efi_type = parse_efi_var_type (state[0].arg);
> +
> +  if (EFI_VAR_INVALID == efi_type)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format specifier"));
> +
> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
> +  if (!efi_var || !efi_var_size)
> +    {
> +      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read variable"));
> +      goto err;
> +    }
> +
> +  switch (efi_type)
> +  {
> +    case EFI_VAR_ASCII:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          goto err;
> +        }
> +
> +      ptr = env_var;
> +
> +      for (i = 0; i < efi_var_size; i++)
> +        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
> +      *ptr = '\0';
> +      break;
> +
> +    case EFI_VAR_RAW:
> +      env_var = grub_malloc (efi_var_size + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          goto err;
> +        }
> +      grub_memcpy (env_var, efi_var, efi_var_size);
> +      env_var[efi_var_size] = '\0';
> +      break;
> +
> +    case EFI_VAR_UINT8:
> +      env_var = grub_malloc (4);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          goto err;
> +        }
> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
> +      break;
> +
> +    case EFI_VAR_HEX:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
> +          goto err;
> +        }
> +      for (i = 0; i < efi_var_size; i++)
> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
> *)efi_var)[i]);
> +      break;
> +
> +    case EFI_VAR_DUMP:
> +      if (state[1].set)
> +        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
> variable with dump format specifier"));
> +      else
> +        {
> +          hexdump (0, (char *)efi_var, efi_var_size);
> +          status = GRUB_ERR_NONE;
> +        }
> +      break;
> +
> +    default:
> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
> in module?)"));
> +      goto err;
> +  }
> +
> +  if (efi_type != EFI_VAR_DUMP)
> +    {
> +      if (state[1].set)
> +        status = grub_env_set (state[1].arg, env_var);
> +      else
> +        {
> +          grub_printf ("%s\n", (const char *)env_var);
> +          status = GRUB_ERR_NONE;
> +        }
> +    }
> +
> +err:
> +
> +  grub_free (env_var);
> +  grub_free (efi_var);
> +
> +  return status;
> +}
> +
> +static grub_extcmd_t cmd = NULL;
> +
> +GRUB_MOD_INIT (efivar)
> +{
> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
> + N_("Read EFI variable and print it or save its contents to
> environment variable."), options);
> +}
> +
> +GRUB_MOD_FINI (efivar)
> +{
> +  if (cmd)
> +    grub_unregister_extcmd (cmd);
> +}

Re: Grub get and set efi variables

[Ignat Korchagin]

[-- Attachment #1: Type: text/plain, Size: 16677 bytes --]

Hi. Are we still considering this?

On Mon, Dec 14, 2015 at 11:17 AM, Ignat Korchagin <ignat@cloudflare.com>
wrote:

> Sorry, pasted wrong file. Here is the correct one:
>
> diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> index 0cc40bb..aa7b927 100644
> --- a/grub-core/Makefile.core.def
> +++ b/grub-core/Makefile.core.def
> @@ -735,6 +735,12 @@ module = {
>  };
>
>  module = {
> +  name = efivar;
> +  efi = commands/efi/efivar.c;
> +  enable = efi;
> +};
> +
> +module = {
>    name = blocklist;
>    common = commands/blocklist.c;
>  };
> diff --git a/grub-core/commands/efi/efivar.c
> b/grub-core/commands/efi/efivar.c
> new file mode 100644
> index 0000000..7fe7bda
> --- /dev/null
> +++ b/grub-core/commands/efi/efivar.c
> @@ -0,0 +1,236 @@
> +/* efivar.c - Read EFI global variables. */
> +/*
> + *  GRUB  --  GRand Unified Bootloader
> + *  Copyright (C) 2015 Free Software Foundation, Inc.
> + *  Copyright (C) 2015 CloudFlare, Inc.
> + *
> + *  GRUB is free software: you can redistribute it and/or modify
> + *  it under the terms of the GNU General Public License as published by
> + *  the Free Software Foundation, either version 3 of the License, or
> + *  (at your option) any later version.
> + *
> + *  GRUB is distributed in the hope that it will be useful,
> + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *  GNU General Public License for more details.
> + *
> + *  You should have received a copy of the GNU General Public License
> + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <grub/types.h>
> +#include <grub/mm.h>
> +#include <grub/misc.h>
> +#include <grub/efi/api.h>
> +#include <grub/efi/efi.h>
> +#include <grub/extcmd.h>
> +#include <grub/env.h>
> +#include <grub/lib/hexdump.h>
> +
> +GRUB_MOD_LICENSE ("GPLv3+");
> +
> +static const struct grub_arg_option options[] = {
> +  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
> specific format (hex, uint8, ascii, dump). Default: hex."),
> N_("FORMAT"), ARG_TYPE_STRING},
> +  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
> environment variable (does not work with dump)."), N_("ENV_VAR"),
> ARG_TYPE_STRING},
> +  {0, 0, 0, 0, 0, 0}
> +};
> +
> +enum efi_var_type
> +  {
> +    EFI_VAR_ASCII = 0,
> +    EFI_VAR_UINT8,
> +    EFI_VAR_HEX,
> +    EFI_VAR_DUMP,
> +    EFI_VAR_INVALID = -1
> +  };
> +
> +static enum efi_var_type
> +parse_efi_var_type (const char *type)
> +{
> +  if (!grub_strcmp (type, "ascii"))
> +    return EFI_VAR_ASCII;
> +
> +  if (!grub_strcmp (type, "uint8"))
> +    return EFI_VAR_UINT8;
> +
> +  if (!grub_strcmp (type, "hex"))
> +    return EFI_VAR_HEX;
> +
> +  if (!grub_strcmp (type, "dump"))
> +    return EFI_VAR_DUMP;
> +
> +  return EFI_VAR_INVALID;
> +}
> +
> +static int
> +grub_print_ascii (char *str, char c)
> +{
> +  if (grub_iscntrl (c))
> +  {
> +    switch (c)
> +      {
> +        case '\0':
> +          str[0] = '\\';
> +          str[1] = '0';
> +          return 2;
> +
> +        case '\a':
> +          str[0] = '\\';
> +          str[1] = 'a';
> +          return 2;
> +
> +        case '\b':
> +          str[0] = '\\';
> +          str[1] = 'b';
> +          return 2;
> +
> +        case '\f':
> +          str[0] = '\\';
> +          str[1] = 'f';
> +          return 2;
> +
> +        case '\n':
> +          str[0] = '\\';
> +          str[1] = 'n';
> +          return 2;
> +
> +        case '\r':
> +          str[0] = '\\';
> +          str[1] = 'r';
> +          return 2;
> +
> +        case '\t':
> +          str[0] = '\\';
> +          str[1] = 't';
> +          return 2;
> +
> +        case '\v':
> +          str[0] = '\\';
> +          str[1] = 'v';
> +          return 2;
> +
> +        default:
> +          str[0] = '.'; /* as in hexdump -C */
> +          return 1;
> +      }
> +  }
> +
> +  str[0] = c;
> +  return 1;
> +}
> +
> +static grub_err_t
> +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
> +  int argc, char **args)
> +{
> +  struct grub_arg_list *state = ctxt->state;
> +  grub_err_t status;
> +  void *efi_var = NULL;
> +  grub_size_t efi_var_size = 0;
> +  enum efi_var_type efi_type = EFI_VAR_HEX;
> +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
> +  char *env_var = NULL;
> +  grub_size_t i;
> +  char *ptr;
> +
> +  if (1 != argc)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument
> expected"));
> +
> +  if (state[0].set)
> +    efi_type = parse_efi_var_type (state[0].arg);
> +
> +  if (EFI_VAR_INVALID == efi_type)
> +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format
> specifier"));
> +
> +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
> +  if (!efi_var || !efi_var_size)
> +    {
> +      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read
> variable"));
> +      goto err;
> +    }
> +
> +  switch (efi_type)
> +  {
> +    case EFI_VAR_ASCII:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
> memory"));
> +          goto err;
> +        }
> +
> +      ptr = env_var;
> +
> +      for (i = 0; i < efi_var_size; i++)
> +        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
> +      *ptr = '\0';
> +      break;
> +
> +    case EFI_VAR_UINT8:
> +      env_var = grub_malloc (4);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
> memory"));
> +          goto err;
> +        }
> +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
> +      break;
> +
> +    case EFI_VAR_HEX:
> +      env_var = grub_malloc (efi_var_size * 2 + 1);
> +      if (!env_var)
> +        {
> +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
> memory"));
> +          goto err;
> +        }
> +      for (i = 0; i < efi_var_size; i++)
> +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
> *)efi_var)[i]);
> +      break;
> +
> +    case EFI_VAR_DUMP:
> +      if (state[1].set)
> +        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
> variable with dump format specifier"));
> +      else
> +        {
> +          hexdump (0, (char *)efi_var, efi_var_size);
> +          status = GRUB_ERR_NONE;
> +        }
> +      break;
> +
> +    default:
> +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
> in module?)"));
> +      goto err;
> +  }
> +
> +  if (efi_type != EFI_VAR_DUMP)
> +    {
> +      if (state[1].set)
> +        status = grub_env_set (state[1].arg, env_var);
> +      else
> +        {
> +          grub_printf ("%s\n", (const char *)env_var);
> +          status = GRUB_ERR_NONE;
> +        }
> +    }
> +
> +err:
> +
> +  grub_free (env_var);
> +  grub_free (efi_var);
> +
> +  return status;
> +}
> +
> +static grub_extcmd_t cmd = NULL;
> +
> +GRUB_MOD_INIT (efivar)
> +{
> +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
> + N_("Read EFI variable and print it or save its contents to
> environment variable."), options);
> +}
> +
> +GRUB_MOD_FINI (efivar)
> +{
> +  if (cmd)
> +    grub_unregister_extcmd (cmd);
> +}
>
>
> On Mon, Dec 14, 2015 at 11:08 AM, Ignat Korchagin <ignat@cloudflare.com>
> wrote:
> >> Assuming uint8 remains - should not you check that variable size is
> exactly 1 byte in this case?
> > There are reports of a buggy firmware returning 4 bytes size for uint8
> > variables, however did not encounter them myself.
> >
> >> Do we really need unit8 at all? "hex" already provides exactly the same
> functionality, not? Do you think there are cases when uint8 is really
> required?
> > Well, when checking for SecureBoot variable in grub configuration file
> > hex mode makes it look weird and creates a point of confusion. For
> > example to check if SecureBoot (suppose the result of the our command
> > is stored in secure_boot env variable in hex mode) is enabled one
> > should write:
> > if [ secure_boot = "01" ]
> > ...
> > uint8 just allows to do a more straightforward config
> > if [ secure_boot = 1] - this case would be false for hex mode -
> > possible security breach
> > ...
> >
> > Added goto err in the module as pointed, see patch below. I will do a
> > follow-up patch for documentation once we get this confirmed.
> >
> > diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
> > index 0cc40bb..aa7b927 100644
> > --- a/grub-core/Makefile.core.def
> > +++ b/grub-core/Makefile.core.def
> > @@ -735,6 +735,12 @@ module = {
> >  };
> >
> >  module = {
> > +  name = efivar;
> > +  efi = commands/efi/efivar.c;
> > +  enable = efi;
> > +};
> > +
> > +module = {
> >    name = blocklist;
> >    common = commands/blocklist.c;
> >  };
> > diff --git a/grub-core/commands/efi/efivar.c
> b/grub-core/commands/efi/efivar.c
> > new file mode 100644
> > index 0000000..7f5a957
> > --- /dev/null
> > +++ b/grub-core/commands/efi/efivar.c
> > @@ -0,0 +1,251 @@
> > +/* efivar.c - Read EFI global variables. */
> > +/*
> > + *  GRUB  --  GRand Unified Bootloader
> > + *  Copyright (C) 2015 Free Software Foundation, Inc.
> > + *  Copyright (C) 2015 CloudFlare, Inc.
> > + *
> > + *  GRUB is free software: you can redistribute it and/or modify
> > + *  it under the terms of the GNU General Public License as published by
> > + *  the Free Software Foundation, either version 3 of the License, or
> > + *  (at your option) any later version.
> > + *
> > + *  GRUB is distributed in the hope that it will be useful,
> > + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> > + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> > + *  GNU General Public License for more details.
> > + *
> > + *  You should have received a copy of the GNU General Public License
> > + *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
> > + */
> > +
> > +#include <grub/types.h>
> > +#include <grub/mm.h>
> > +#include <grub/misc.h>
> > +#include <grub/efi/api.h>
> > +#include <grub/efi/efi.h>
> > +#include <grub/extcmd.h>
> > +#include <grub/env.h>
> > +#include <grub/lib/hexdump.h>
> > +
> > +GRUB_MOD_LICENSE ("GPLv3+");
> > +
> > +static const struct grub_arg_option options[] = {
> > +  {"format", 'f', GRUB_ARG_OPTION_OPTIONAL, N_("Parse EFI_VAR in
> > specific format (hex, uint8, ascii, raw, dump). Default: hex."),
> > N_("FORMAT"), ARG_TYPE_STRING},
> > +  {"set", 's', GRUB_ARG_OPTION_OPTIONAL, N_("Save parsed result to
> > environment variable (does not work with dump)."), N_("ENV_VAR"),
> > ARG_TYPE_STRING},
> > +  {0, 0, 0, 0, 0, 0}
> > +};
> > +
> > +enum efi_var_type
> > +  {
> > +    EFI_VAR_ASCII = 0,
> > +    EFI_VAR_RAW,
> > +    EFI_VAR_UINT8,
> > +    EFI_VAR_HEX,
> > +    EFI_VAR_DUMP,
> > +    EFI_VAR_INVALID = -1
> > +  };
> > +
> > +static enum efi_var_type
> > +parse_efi_var_type (const char *type)
> > +{
> > +  if (!grub_strncmp (type, "ascii", sizeof("ascii")))
> > +    return EFI_VAR_ASCII;
> > +
> > +  if (!grub_strncmp (type, "raw", sizeof("raw")))
> > +    return EFI_VAR_ASCII;
> > +
> > +  if (!grub_strncmp (type, "uint8", sizeof("uint8")))
> > +    return EFI_VAR_UINT8;
> > +
> > +  if (!grub_strncmp (type, "hex", sizeof("hex")))
> > +    return EFI_VAR_HEX;
> > +
> > +  if (!grub_strncmp (type, "dump", sizeof("dump")))
> > +    return EFI_VAR_DUMP;
> > +
> > +  return EFI_VAR_INVALID;
> > +}
> > +
> > +static int
> > +grub_print_ascii (char *str, char c)
> > +{
> > +  if (grub_iscntrl (c))
> > +  {
> > +    switch (c)
> > +      {
> > +        case '\0':
> > +          str[0] = '\\';
> > +          str[1] = '0';
> > +          return 2;
> > +
> > +        case '\a':
> > +          str[0] = '\\';
> > +          str[1] = 'a';
> > +          return 2;
> > +
> > +        case '\b':
> > +          str[0] = '\\';
> > +          str[1] = 'b';
> > +          return 2;
> > +
> > +        case '\f':
> > +          str[0] = '\\';
> > +          str[1] = 'f';
> > +          return 2;
> > +
> > +        case '\n':
> > +          str[0] = '\\';
> > +          str[1] = 'n';
> > +          return 2;
> > +
> > +        case '\r':
> > +          str[0] = '\\';
> > +          str[1] = 'r';
> > +          return 2;
> > +
> > +        case '\t':
> > +          str[0] = '\\';
> > +          str[1] = 't';
> > +          return 2;
> > +
> > +        case '\v':
> > +          str[0] = '\\';
> > +          str[1] = 'v';
> > +          return 2;
> > +
> > +        default:
> > +          str[0] = '.'; /* as in hexdump -C */
> > +          return 1;
> > +      }
> > +  }
> > +
> > +  str[0] = c;
> > +  return 1;
> > +}
> > +
> > +static grub_err_t
> > +grub_cmd_get_efi_var (struct grub_extcmd_context *ctxt,
> > +  int argc, char **args)
> > +{
> > +  struct grub_arg_list *state = ctxt->state;
> > +  grub_err_t status;
> > +  void *efi_var = NULL;
> > +  grub_size_t efi_var_size = 0;
> > +  enum efi_var_type efi_type = EFI_VAR_HEX;
> > +  grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
> > +  char *env_var = NULL;
> > +  grub_size_t i;
> > +  char *ptr;
> > +
> > +  if (1 != argc)
> > +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument
> expected"));
> > +
> > +  if (state[0].set)
> > +    efi_type = parse_efi_var_type (state[0].arg);
> > +
> > +  if (EFI_VAR_INVALID == efi_type)
> > +    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid format
> specifier"));
> > +
> > +  efi_var = grub_efi_get_variable (args[0], &global, &efi_var_size);
> > +  if (!efi_var || !efi_var_size)
> > +    {
> > +      status = grub_error (GRUB_ERR_READ_ERROR, N_("cannot read
> variable"));
> > +      goto err;
> > +    }
> > +
> > +  switch (efi_type)
> > +  {
> > +    case EFI_VAR_ASCII:
> > +      env_var = grub_malloc (efi_var_size * 2 + 1);
> > +      if (!env_var)
> > +        {
> > +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
> memory"));
> > +          goto err;
> > +        }
> > +
> > +      ptr = env_var;
> > +
> > +      for (i = 0; i < efi_var_size; i++)
> > +        ptr += grub_print_ascii (ptr, ((const char *)efi_var)[i]);
> > +      *ptr = '\0';
> > +      break;
> > +
> > +    case EFI_VAR_RAW:
> > +      env_var = grub_malloc (efi_var_size + 1);
> > +      if (!env_var)
> > +        {
> > +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
> memory"));
> > +          goto err;
> > +        }
> > +      grub_memcpy (env_var, efi_var, efi_var_size);
> > +      env_var[efi_var_size] = '\0';
> > +      break;
> > +
> > +    case EFI_VAR_UINT8:
> > +      env_var = grub_malloc (4);
> > +      if (!env_var)
> > +        {
> > +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
> memory"));
> > +          goto err;
> > +        }
> > +      grub_snprintf (env_var, 4, "%u", *((grub_uint8_t *)efi_var));
> > +      break;
> > +
> > +    case EFI_VAR_HEX:
> > +      env_var = grub_malloc (efi_var_size * 2 + 1);
> > +      if (!env_var)
> > +        {
> > +          status = grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of
> memory"));
> > +          goto err;
> > +        }
> > +      for (i = 0; i < efi_var_size; i++)
> > +        grub_snprintf (env_var + (i * 2), 3, "%02x", ((grub_uint8_t
> > *)efi_var)[i]);
> > +      break;
> > +
> > +    case EFI_VAR_DUMP:
> > +      if (state[1].set)
> > +        status = grub_error (GRUB_ERR_BAD_ARGUMENT, N_("cannot set
> > variable with dump format specifier"));
> > +      else
> > +        {
> > +          hexdump (0, (char *)efi_var, efi_var_size);
> > +          status = GRUB_ERR_NONE;
> > +        }
> > +      break;
> > +
> > +    default:
> > +      status = grub_error (GRUB_ERR_BUG, N_("should not happen (bug
> > in module?)"));
> > +      goto err;
> > +  }
> > +
> > +  if (efi_type != EFI_VAR_DUMP)
> > +    {
> > +      if (state[1].set)
> > +        status = grub_env_set (state[1].arg, env_var);
> > +      else
> > +        {
> > +          grub_printf ("%s\n", (const char *)env_var);
> > +          status = GRUB_ERR_NONE;
> > +        }
> > +    }
> > +
> > +err:
> > +
> > +  grub_free (env_var);
> > +  grub_free (efi_var);
> > +
> > +  return status;
> > +}
> > +
> > +static grub_extcmd_t cmd = NULL;
> > +
> > +GRUB_MOD_INIT (efivar)
> > +{
> > +  cmd = grub_register_extcmd ("get_efivar", grub_cmd_get_efi_var, 0,
> > N_("[-f FORMAT] [-s ENV_VAR] EFI_VAR"),
> > + N_("Read EFI variable and print it or save its contents to
> > environment variable."), options);
> > +}
> > +
> > +GRUB_MOD_FINI (efivar)
> > +{
> > +  if (cmd)
> > +    grub_unregister_extcmd (cmd);
> > +}
>

[-- Attachment #2: Type: text/html, Size: 22168 bytes --]