Hi Vladimir,

Good idea! I can see your patch for it in master branch.

Great thanks for your help, I will try this ASAP :-)

On 29 October 2015 at 20:03, Vladimir 'φ-coder/phcoder' Serbinenko phcoder@gmail.com wrote:

On 23.07.2015 07:16, fu.wei@linaro.org wrote:

...

From: Fu Wei fu.wei@linaro.org

Add accessor functions of "loaded" flag in grub-core/loader/arm64/linux.c.

Export accessor functions of "loaded" flag and grub_linux_get_fdt function in include/grub/arm64/linux.h.

Purpose: Reuse the existing code of devicetree in linux module.

Signed-off-by: Fu Wei fu.wei@linaro.org

grub-core/loader/arm64/linux.c | 13 +++++++++++++ include/grub/arm64/linux.h | 6 +++++- 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/grub-core/loader/arm64/linux.c b/grub-core/loader/arm64/linux.c index 987f5b9..cf6026e 100644 --- a/grub-core/loader/arm64/linux.c +++ b/grub-core/loader/arm64/linux.c @@ -48,6 +48,19 @@ static grub_addr_t initrd_end; static void *loaded_fdt; static void *fdt;

+/* The accessor functions for "loaded" flag */ +int +grub_linux_get_loaded (void) +{

• return loaded;

+}

+void +grub_linux_set_loaded (int loaded_flag) +{

• loaded = loaded_flag;

+}

Accessor functions are usually useless in GRUB. We have no public API to respect. So it only adds clutter. Also "loaded" flag is static for а good reason: it's specific to linux.c. I'm going to move fdt part to fdt.c and have uniform interface for both linux and xen.

...

static void * get_firmware_fdt (void) { diff --git a/include/grub/arm64/linux.h b/include/grub/arm64/linux.h index 65796d9..20058f3 100644 --- a/include/grub/arm64/linux.h +++ b/include/grub/arm64/linux.h @@ -43,10 +43,14 @@ struct grub_arm64_linux_kernel_header };

/* Declare the functions for getting dtb and checking/booting image */ -void *grub_linux_get_fdt (void); grub_err_t grub_arm64_uefi_check_image (struct grub_arm64_linux_kernel_header *lh); grub_err_t grub_arm64_uefi_boot_image (grub_addr_t addr, grub_size_t size, char *args);

+/* Export the accessor functions for gettin dtb and "loaded" flag */ +void EXPORT_FUNC (*grub_linux_get_fdt) (void); +int EXPORT_FUNC (grub_linux_get_loaded) (void); +void EXPORT_FUNC (grub_linux_set_loaded) (int loaded_flag);

EXPORT_* are necessary only for core. Not for modules.

...

#endif /* ! GRUB_LINUX_CPU_HEADER */

Committed without the xen_module command. Its argument parsing was non-trivial and I don't quite get what its intent is. Can you resubmit? On 23.07.2015 07:16, fu.wei@linaro.org wrote:

From: Fu Wei fu.wei@linaro.org

grub-core/loader/arm64/xen_boot.c

• This adds support for the Xen boot on ARM specification for arm64.
• Introduce xen_hypervisor, xen_linux, xen_initrd and xen_xsm to load different binaries for xen boot; Introduce xen_module to load common or custom module for xen boot.
• This Xen boot support is a separated module for aarch64, but reuse the existing code of devicetree in linux module.

Signed-off-by: Fu Wei fu.wei@linaro.org

grub-core/Makefile.core.def | 7 + grub-core/loader/arm64/xen_boot.c | 685 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 692 insertions(+)

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def index a6101de..796f7e9 100644 --- a/grub-core/Makefile.core.def +++ b/grub-core/Makefile.core.def @@ -1648,6 +1648,13 @@ module = { }; module = {

• name = xen_boot;
• common = lib/cmdline.c;
• arm64 = loader/arm64/xen_boot.c;
• enable = arm64;

+};

+module = { name = linux; x86 = loader/i386/linux.c; xen = loader/i386/xen.c; diff --git a/grub-core/loader/arm64/xen_boot.c b/grub-core/loader/arm64/xen_boot.c new file mode 100644 index 0000000..33a65dd --- /dev/null +++ b/grub-core/loader/arm64/xen_boot.c @@ -0,0 +1,685 @@ +/*

• • GRUB -- GRand Unified Bootloader
• • Copyright (C) 2014 Free Software Foundation, 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/cache.h> +#include <grub/charset.h> +#include <grub/command.h> +#include <grub/err.h> +#include <grub/file.h> +#include <grub/fdt.h> +#include <grub/linux.h> +#include <grub/list.h> +#include <grub/loader.h> +#include <grub/misc.h> +#include <grub/mm.h> +#include <grub/types.h> +#include <grub/cpu/linux.h> +#include <grub/efi/efi.h> +#include <grub/efi/pe32.h> /* required by struct xen_hypervisor_header */ +#include <grub/i18n.h> +#include <grub/lib/cmdline.h>

+GRUB_MOD_LICENSE ("GPLv3+");

+#define XEN_HYPERVISOR_NAME "xen_hypervisor"

+#define MODULE_DEFAULT_ALIGN (0x0) +#define MODULE_IMAGE_MIN_ALIGN MODULE_DEFAULT_ALIGN +#define MODULE_INITRD_MIN_ALIGN MODULE_DEFAULT_ALIGN +#define MODULE_XSM_MIN_ALIGN MODULE_DEFAULT_ALIGN +#define MODULE_CUSTOM_MIN_ALIGN MODULE_DEFAULT_ALIGN

+/* #define MODULE_IMAGE_COMPATIBLE "xen,linux-image\0xen,module" +#define MODULE_INITRD_COMPATIBLE "xen,linux-image\0xen,module" +#define MODULE_XSM_COMPATIBLE "xen,xsm-policy\0xen,module" +#define MODULE_CUSTOM_COMPATIBLE "xen,module" */ +#define MODULE_IMAGE_COMPATIBLE "multiboot,kernel\0multiboot,module" +#define MODULE_INITRD_COMPATIBLE "multiboot,ramdisk\0multiboot,module" +#define MODULE_XSM_COMPATIBLE "xen,xsm-policy\0multiboot,module" +#define MODULE_CUSTOM_COMPATIBLE "multiboot,module"

+/* This maximum size is defined in Power.org ePAPR V1.1

• • https://www.power.org/documentation/epapr-version-1-1/
• • 2.2.1.1 Node Name Requirements
• • node-name@unit-address
• • 31 + 1(@) + 16(64bit address in hex format) + 1(\0) = 49
• */

+#define FDT_NODE_NAME_MAX_SIZE (49)

+#define ARG_SHIFT(argc, argv) \

• do { \
• (argc)--; \
• (argv)++; \
• } while (0)

+struct compat_string_struct +{

• grub_size_t size;
• const char *compat_string;

+}; +typedef struct compat_string_struct compat_string_struct_t; +#define FDT_COMPATIBLE(x) {.size = sizeof(x), .compat_string = (x)}

+enum module_type +{

• MODULE_IMAGE,
• MODULE_INITRD,
• MODULE_XSM,
• MODULE_CUSTOM

+}; +typedef enum module_type module_type_t;

+struct fdt_node_info +{

• module_type_t type;
• const char *compat_string;
• grub_size_t compat_string_size;

+};

+struct xen_hypervisor_header +{

• struct grub_arm64_linux_kernel_header efi_head;
• /* This is always PE\0\0. */
• grub_uint8_t signature[GRUB_PE32_SIGNATURE_SIZE];
• /* The COFF file header. */
• struct grub_pe32_coff_header coff_header;
• /* The Optional header. */
• struct grub_pe64_optional_header optional_header;

+};

+struct xen_boot_binary +{

• struct xen_boot_binary *next;
• struct xen_boot_binary **prev;
• const char *name;
• grub_addr_t start;
• grub_size_t size;
• grub_size_t align;
• char *cmdline;
• int cmdline_size;
• struct fdt_node_info node_info;

+};

+static grub_dl_t my_mod;

+static struct xen_boot_binary *xen_hypervisor; +static struct xen_boot_binary *module_head; +static const grub_size_t module_default_align[] = {

• MODULE_IMAGE_MIN_ALIGN,
• MODULE_INITRD_MIN_ALIGN,
• MODULE_XSM_MIN_ALIGN,
• MODULE_CUSTOM_MIN_ALIGN

+};

+static void *xen_boot_fdt; +static const compat_string_struct_t default_compat_string[] = {

• FDT_COMPATIBLE (MODULE_IMAGE_COMPATIBLE),
• FDT_COMPATIBLE (MODULE_INITRD_COMPATIBLE),
• FDT_COMPATIBLE (MODULE_XSM_COMPATIBLE),
• FDT_COMPATIBLE (MODULE_CUSTOM_COMPATIBLE)

+};

+static __inline grub_addr_t +xen_boot_address_align (grub_addr_t start, grub_size_t align) +{

• return (align ? (ALIGN_UP (start, align)) : start);

+}

+/* Parse the option of xen_module command. For now, we support

• (1) --type <the compatible stream>
• We also set up the type of module in this function.
• If there are some "--type" options in the command line,
• we make a custom compatible stream in this function. */

+static grub_err_t +set_module_type (grub_command_t cmd, struct xen_boot_binary *module,

•  int argc, char *argv[], int *file_name_index)
  

+{

• char **compat_string_temp_array;
• grub_size_t total_size = 0;
• int num_types = 0, i;
• char *temp = NULL;
• *file_name_index = 0;
• if (!grub_strcmp (cmd->name, "xen_linux"))
• module->node_info.type = MODULE_IMAGE;
• else if (!grub_strcmp (cmd->name, "xen_initrd"))
• module->node_info.type = MODULE_INITRD;
• else if (!grub_strcmp (cmd->name, "xen_xsm"))
• module->node_info.type = MODULE_XSM;
• else if (!grub_strcmp (cmd->name, "xen_module"))
• module->node_info.type = MODULE_CUSTOM;
• /* if there are some options we need to process. */
• if (module->node_info.type == MODULE_CUSTOM)
• {

•  compat_string_temp_array =
  

• (char **) grub_zalloc (sizeof (char *) * argc);

•  if (!compat_string_temp_array)
  

• return grub_errno;

•  /* the module type is set by "--type"(MODULE_CUSTOM) */
  

•  while (argc > 2 && !grub_strcmp (argv[0], "--type"))
  

• {

•  module->node_info.type = MODULE_CUSTOM;
  

•  ARG_SHIFT (argc, argv);
  

•  total_size += grub_strlen (argv[0]) + 1;
  

•  compat_string_temp_array[num_types++] = argv[0];
  

•  ARG_SHIFT (argc, argv);
  

•  (*file_name_index) += 2;
  

• }

•  if (total_size)
  

• {

•  module->node_info.compat_string = temp =
  

•    (char *) grub_zalloc (total_size);
  

•  if (!temp)
  

•    {
  

•      grub_free (compat_string_temp_array);
  

•      return grub_errno;
  

•    }
  

•  module->node_info.compat_string_size = total_size;
  

•  for (i = 0; num_types > 0; num_types--, i++, temp++)
  

•    {
  

•      grub_strcpy (temp, compat_string_temp_array[i]);
  

•      temp += grub_strlen (compat_string_temp_array[i]);
  

•    }
  

• }

•  else
  

• {

•  module->node_info.compat_string =
  

•    default_compat_string[MODULE_CUSTOM].compat_string;
  

•  module->node_info.compat_string_size =
  

•    default_compat_string[MODULE_CUSTOM].size;
  

• }

•  grub_free (compat_string_temp_array);
  

• }
• return GRUB_ERR_NONE;

+}

+static grub_err_t +prepare_xen_hypervisor_params (void) +{

• int chosen_node = 0;
• int retval;
• xen_boot_fdt = grub_linux_get_fdt ();
• if (!xen_boot_fdt)
• return grub_error (GRUB_ERR_IO, "failed to get FDT");
• chosen_node = grub_fdt_find_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 0)
• chosen_node = grub_fdt_add_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 1)
• return grub_error (GRUB_ERR_IO, "failed to get chosen node in FDT");
• grub_dprintf ("xen_loader",

• "Xen Hypervisor cmdline : %s @ %p size:%d\n",
  

• xen_hypervisor->cmdline, xen_hypervisor->cmdline,
  

• xen_hypervisor->cmdline_size);
  

• retval = grub_fdt_set_prop (xen_boot_fdt, chosen_node, "bootargs",

• 	      xen_hypervisor->cmdline,
  

• 	      xen_hypervisor->cmdline_size);
  

• if (retval)
• return grub_error (GRUB_ERR_IO, "failed to install/update FDT");
• return GRUB_ERR_NONE;

+}

+static grub_err_t +prepare_xen_module_params (struct xen_boot_binary *module) +{

• int retval, chosen_node = 0, module_node = 0;
• char module_name[FDT_NODE_NAME_MAX_SIZE];
• retval = grub_snprintf (module_name, FDT_NODE_NAME_MAX_SIZE, "module@%lx",

• 	  xen_boot_address_align (module->start,
  

• 				  module->align));
  

• grub_dprintf ("xen_loader", "Module node name %s \n", module_name);
• if (retval < (int) sizeof ("module@"))
• return grub_error (GRUB_ERR_IO, N_("failed to get FDT"));
• chosen_node = grub_fdt_find_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 0)
• chosen_node = grub_fdt_add_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 1)
• return grub_error (GRUB_ERR_IO, "failed to get chosen node in FDT");
• module_node =
• grub_fdt_find_subnode (xen_boot_fdt, chosen_node, module_name);
• if (module_node < 0)
• module_node =

•  grub_fdt_add_subnode (xen_boot_fdt, chosen_node, module_name);
  

• retval = grub_fdt_set_prop (xen_boot_fdt, module_node, "compatible",

• 	      module->node_info.compat_string,
  

• 	      (grub_uint32_t) module->
  

• 	      node_info.compat_string_size);
  

• if (retval)
• return grub_error (GRUB_ERR_IO, N_("failed to update FDT"));
• grub_dprintf ("xen_loader", "Module %s compatible = %s size = 0x%lx\n",

• module->name, module->node_info.compat_string,
  

• module->node_info.compat_string_size);
  

• retval = grub_fdt_set_reg64 (xen_boot_fdt, module_node,

• 	       xen_boot_address_align (module->start,
  

• 				       module->align),
  

• 	       module->size);
  

• if (retval)
• return grub_error (GRUB_ERR_IO, N_("failed to update FDT"));
• if (module->cmdline && module->cmdline_size > 0)
• {

•  grub_dprintf ("xen_loader",
  

•     "Module %s cmdline : %s @ %p size:%d\n", module->name,
  

•     module->cmdline, module->cmdline, module->cmdline_size);
  

•  retval = grub_fdt_set_prop (xen_boot_fdt, module_node, "bootargs",
  

• 		  module->cmdline, module->cmdline_size + 1);
  

•  if (retval)
  

• return grub_error (GRUB_ERR_IO, "failed to update FDT");
• }
• else
• {

•  grub_dprintf ("xen_loader", "Module %s has not bootargs!\n",
  

•     module->name);
  

• }
• return GRUB_ERR_NONE;

+}

+static grub_err_t +install_all_params (void) +{

• grub_efi_guid_t fdt_guid = GRUB_EFI_DEVICE_TREE_GUID;
• grub_efi_boot_services_t *b;
• grub_efi_status_t status;
• b = grub_efi_system_table->boot_services;
• status = b->install_configuration_table (&fdt_guid, xen_boot_fdt);
• if (status != GRUB_EFI_SUCCESS)
• return grub_error (GRUB_ERR_IO, "failed to install FDT");
• grub_dprintf ("xen_loader",

• "Installed/updated FDT configuration table @ %p\n",
  

• xen_boot_fdt);
  

• return GRUB_ERR_NONE;

+}

+static grub_err_t +clean_all_params (void) +{

• if (xen_boot_fdt)
• {

•  grub_efi_free_pages ((grub_efi_physical_address_t) xen_boot_fdt,
  

• 	   BYTES_TO_PAGES (grub_fdt_get_totalsize
  

• 			   (xen_boot_fdt)));
  

•  xen_boot_fdt = NULL;
  

• }
• return GRUB_ERR_NONE;

+}

+static grub_err_t +finalize_params_xen_boot (void) +{

• struct xen_boot_binary *module;
• if (xen_hypervisor)
• {

•  if (prepare_xen_hypervisor_params () != GRUB_ERR_NONE)
  

• goto fail;
• }
• else
• {

•  grub_dprintf ("xen_loader", "Failed to get Xen Hypervisor info!\n");
  

•  goto fail;
  

• }
• /* Set module params info */
• FOR_LIST_ELEMENTS (module, module_head)
• {
• if (module->start && module->size > 0)

•  {
  

• grub_dprintf ("xen_loader", "Module %s @ 0x%lx size:0x%lx\n",

•       module->name,
  

•       xen_boot_address_align (module->start, module->align),
  

•       module->size);
  

• if (prepare_xen_module_params (module) != GRUB_ERR_NONE)

•  goto fail;
  

•  }
  

• else

•  {
  

• grub_dprintf ("xen_loader", "Module info error: %s!\n", module->name);
• goto fail;

•  }
  

• }
• if (install_all_params () == GRUB_ERR_NONE)
• return GRUB_ERR_NONE;

+fail:

• clean_all_params ();
• return grub_error (GRUB_ERR_IO, "failed to install/update FDT");

+}

+static grub_err_t +xen_boot (void) +{

• grub_err_t err = finalize_params_xen_boot ();
• if (err)
• return err;
• return grub_arm64_uefi_boot_image (xen_hypervisor->start,

• 		     xen_hypervisor->size,
  

• 		     xen_hypervisor->cmdline);
  

+}

+static void +single_binary_unload (struct xen_boot_binary *binary) +{

• if (!binary)
• return;
• if (binary->start && binary->size > 0)
• {

•  grub_efi_free_pages ((grub_efi_physical_address_t) binary->start,
  

• 	   BYTES_TO_PAGES (binary->size + binary->align));
  

• }
• if (binary->cmdline && binary->cmdline_size > 0)
• {

•  grub_free (binary->cmdline);
  

•  grub_dprintf ("xen_loader",
  

•     "Module %s cmdline memory free @ %p size: %d\n",
  

•     binary->name, binary->cmdline, binary->cmdline_size);
  

• }
• if (binary->node_info.type == MODULE_CUSTOM)
• grub_free ((void *) binary->node_info.compat_string);
• if (grub_strcmp (binary->name, XEN_HYPERVISOR_NAME))
• grub_list_remove (GRUB_AS_LIST (binary));
• grub_dprintf ("xen_loader",

• "Module %s struct memory free @ %p size: 0x%lx\n",
  

• binary->name, binary, sizeof (binary));
  

• grub_free (binary);
• return;

+}

+static void +all_binaries_unload (void) +{

• struct xen_boot_binary *binary;
• FOR_LIST_ELEMENTS (binary, module_head)
• {
• single_binary_unload (binary);
• }
• if (xen_hypervisor)
• single_binary_unload (xen_hypervisor);
• return;

+}

+static grub_err_t +xen_unload (void) +{

• grub_linux_set_loaded (0);
• all_binaries_unload ();
• clean_all_params ();
• grub_dl_unref (my_mod);
• return GRUB_ERR_NONE;

+}

+static void +xen_boot_binary_load (struct xen_boot_binary *binary, grub_file_t file,

•       int argc, char *argv[])
  

+{

• binary->size = grub_file_size (file);
• grub_dprintf ("xen_loader", "Xen_boot %s file size: 0x%lx\n",

• binary->name, binary->size);
  

• binary->start = (grub_addr_t) grub_efi_allocate_pages (0,

• 					 (BYTES_TO_PAGES
  

• 					  (binary->size +
  

• 					   binary->align)));
  

• if (!binary->start)
• {

•  grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
  

•  return;
  

• }
• grub_dprintf ("xen_loader", "Xen_boot %s numpages: 0x%lx\n",

• binary->name, BYTES_TO_PAGES (binary->size + binary->align));
  

• if (grub_file_read (file, (void *) xen_boot_address_align (binary->start,

• 					     binary->align),
  

•       binary->size) != (grub_ssize_t) binary->size)
  

• {

•  single_binary_unload (binary);
  

•  grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), argv[0]);
  

•  return;
  

• }
• if (argc > 1)
• {

•  binary->cmdline_size = grub_loader_cmdline_size (argc - 1, argv + 1);
  

•  binary->cmdline = grub_zalloc (binary->cmdline_size);
  

•  if (!binary->cmdline)
  

• {

•  single_binary_unload (binary);
  

•  grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
  

•  return;
  

• }

•  grub_create_loader_cmdline (argc - 1, argv + 1, binary->cmdline,
  

• 		  binary->cmdline_size);
  

•  grub_dprintf ("xen_loader",
  

•     "Xen_boot %s cmdline @ %p %s, size: %d\n", binary->name,
  

•     binary->cmdline, binary->cmdline, binary->cmdline_size);
  

• }
• else
• {

•  binary->cmdline_size = 0;
  

•  binary->cmdline = NULL;
  

• }
• grub_errno = GRUB_ERR_NONE;
• return;

+}

+static grub_err_t +grub_cmd_xen_module (grub_command_t cmd, int argc, char *argv[]) +{

• struct xen_boot_binary *module = NULL;
• int file_name_index = 0;
• grub_file_t file = 0;
• if (!argc)
• {

•  grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
  

•  goto fail;
  

• }
• if (!grub_linux_get_loaded ())
• {

•  grub_error (GRUB_ERR_BAD_ARGUMENT,
  

•   N_("you need to load the Xen Hypervisor first"));
  

•  goto fail;
  

• }
• module =
• (struct xen_boot_binary *) grub_zalloc (sizeof (struct xen_boot_binary));
• if (!module)
• return grub_errno;
• /* process all the options and get module type */
• if (set_module_type (cmd, module, argc, argv, &file_name_index) !=

•  GRUB_ERR_NONE)
  

• goto fail;
• switch (module->node_info.type)
• {
• case MODULE_IMAGE:
• case MODULE_INITRD:
• case MODULE_XSM:

•  module->node_info.compat_string =
  

• default_compat_string[module->node_info.type].compat_string;

•  module->node_info.compat_string_size =
  

• default_compat_string[module->node_info.type].size;

•  break;
  

• case MODULE_CUSTOM:

•  /* we have set the node_info in set_module_type */
  

•  break;
  

• default:

•  return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid argument"));
  

• }
• module->name = module->node_info.compat_string;
• module->align = module_default_align[module->node_info.type];
• grub_dprintf ("xen_loader", "Init %s module and node info:\n"

• "compatible %s\ncompat_string_size 0x%lx\n",
  

• module->name, module->node_info.compat_string,
  

• module->node_info.compat_string_size);
  

• file = grub_file_open (argv[file_name_index]);
• if (!file)
• goto fail;
• xen_boot_binary_load (module, file, argc - file_name_index,

• 	argv + file_name_index);
  

• if (grub_errno == GRUB_ERR_NONE)
• grub_list_push (GRUB_AS_LIST_P (&module_head), GRUB_AS_LIST (module));

+fail:

• if (file)
• grub_file_close (file);
• if (grub_errno != GRUB_ERR_NONE)
• single_binary_unload (module);
• return grub_errno;

+}

+static grub_err_t +grub_cmd_xen_hypervisor (grub_command_t cmd __attribute__ ((unused)),

• 	 int argc, char *argv[])
  

+{

• struct xen_hypervisor_header sh;
• grub_file_t file = NULL;
• grub_dl_ref (my_mod);
• if (!argc)
• {

•  grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
  

•  goto fail;
  

• }
• file = grub_file_open (argv[0]);
• if (!file)
• goto fail;
• if (grub_file_read (file, &sh, sizeof (sh)) != (long) sizeof (sh))
• goto fail;
• if (grub_arm64_uefi_check_image

•  ((struct grub_arm64_linux_kernel_header *) &sh) != GRUB_ERR_NONE)
  

• goto fail;
• grub_file_seek (file, 0);
• /* if another module has called grub_loader_set,

• we need to make sure that another module is unloaded properly */
  

• grub_loader_unset ();
• xen_hypervisor =
• (struct xen_boot_binary *) grub_zalloc (sizeof (struct xen_boot_binary));
• if (!xen_hypervisor)
• return grub_errno;
• xen_hypervisor->name = XEN_HYPERVISOR_NAME;
• xen_hypervisor->align = (grub_size_t) sh.optional_header.section_alignment;
• xen_boot_binary_load (xen_hypervisor, file, argc, argv);
• if (grub_errno == GRUB_ERR_NONE)
• {

•  grub_loader_set (xen_boot, xen_unload, 0);
  

•  grub_linux_set_loaded (1);
  

• }

+fail:

• if (file)
• grub_file_close (file);
• if (grub_errno != GRUB_ERR_NONE)
• {

•  grub_linux_set_loaded (0);
  

•  all_binaries_unload ();
  

•  grub_dl_unref (my_mod);
  

• }
• return grub_errno;

+}

+static grub_command_t cmd_xen_hypervisor, cmd_xen_module; +static grub_command_t cmd_xen_linux, cmd_xen_initrd, cmd_xen_xsm;

+GRUB_MOD_INIT (xen_boot) +{

• cmd_xen_hypervisor =
• grub_register_command ("xen_hypervisor", grub_cmd_xen_hypervisor, 0,

• 	   N_("Load a xen hypervisor."));
  

• cmd_xen_linux =
• grub_register_command ("xen_linux", grub_cmd_xen_module, 0,

• 	   N_("Load a xen linux kernel for dom0."));
  

• cmd_xen_initrd =
• grub_register_command ("xen_initrd", grub_cmd_xen_module, 0,

• 	   N_("Load a xen initrd for dom0."));
  

• cmd_xen_xsm =
• grub_register_command ("xen_xsm", grub_cmd_xen_module, 0,

• 	   N_("Load a xen security module."));
  

• cmd_xen_module =
• grub_register_command ("xen_module", grub_cmd_xen_module, 0,

• 	   N_("Load a xen module."));
  

• my_mod = mod;

+}

+GRUB_MOD_FINI (xen_boot) +{

• grub_unregister_command (cmd_xen_hypervisor);
• grub_unregister_command (cmd_xen_linux);
• grub_unregister_command (cmd_xen_initrd);
• grub_unregister_command (cmd_xen_xsm);
• grub_unregister_command (cmd_xen_module);

+}

Hi Vladimir,

After discussing with Ian Campbell, Since we already can load all the necessary binaries for Xen boot on arm64 for now, we don't really need "xen_module" command now. But maybe someday , xen need a new type of binary in boot time, then we still need this support.

So I will submit a "xen_module" command patch soon, in case we need it.

Great thanks ! :-)

On 30 October 2015 at 16:08, Fu Wei fu.wei@linaro.org wrote:

Hi Vladimir,

yes, Thanks for your modification :-)

I just follow the xen boot protocol : http://wiki.xen.org/wiki/Xen_ARM_with_Virtualization_Extensions/Multiboot

xen_module is just for "--type" option, I will discuss this with Xen developer for this. If we need this option, I will resubmit it :-)

Great thanks!

On 29 October 2015 at 22:27, Vladimir 'φ-coder/phcoder' Serbinenko phcoder@gmail.com wrote:

...

Committed without the xen_module command. Its argument parsing was non-trivial and I don't quite get what its intent is. Can you resubmit? On 23.07.2015 07:16, fu.wei@linaro.org wrote:

...

From: Fu Wei fu.wei@linaro.org

grub-core/loader/arm64/xen_boot.c

• This adds support for the Xen boot on ARM specification for arm64.
• Introduce xen_hypervisor, xen_linux, xen_initrd and xen_xsm to load different binaries for xen boot; Introduce xen_module to load common or custom module for xen boot.
• This Xen boot support is a separated module for aarch64, but reuse the existing code of devicetree in linux module.

Signed-off-by: Fu Wei fu.wei@linaro.org

grub-core/Makefile.core.def | 7 + grub-core/loader/arm64/xen_boot.c | 685 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 692 insertions(+)

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def index a6101de..796f7e9 100644 --- a/grub-core/Makefile.core.def +++ b/grub-core/Makefile.core.def @@ -1648,6 +1648,13 @@ module = { };

module = {

• name = xen_boot;
• common = lib/cmdline.c;
• arm64 = loader/arm64/xen_boot.c;
• enable = arm64;

+};

+module = { name = linux; x86 = loader/i386/linux.c; xen = loader/i386/xen.c; diff --git a/grub-core/loader/arm64/xen_boot.c b/grub-core/loader/arm64/xen_boot.c new file mode 100644 index 0000000..33a65dd --- /dev/null +++ b/grub-core/loader/arm64/xen_boot.c @@ -0,0 +1,685 @@ +/*

• • GRUB -- GRand Unified Bootloader
• • Copyright (C) 2014 Free Software Foundation, 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/cache.h> +#include <grub/charset.h> +#include <grub/command.h> +#include <grub/err.h> +#include <grub/file.h> +#include <grub/fdt.h> +#include <grub/linux.h> +#include <grub/list.h> +#include <grub/loader.h> +#include <grub/misc.h> +#include <grub/mm.h> +#include <grub/types.h> +#include <grub/cpu/linux.h> +#include <grub/efi/efi.h> +#include <grub/efi/pe32.h> /* required by struct xen_hypervisor_header */ +#include <grub/i18n.h> +#include <grub/lib/cmdline.h>

+GRUB_MOD_LICENSE ("GPLv3+");

+#define XEN_HYPERVISOR_NAME "xen_hypervisor"

+#define MODULE_DEFAULT_ALIGN (0x0) +#define MODULE_IMAGE_MIN_ALIGN MODULE_DEFAULT_ALIGN +#define MODULE_INITRD_MIN_ALIGN MODULE_DEFAULT_ALIGN +#define MODULE_XSM_MIN_ALIGN MODULE_DEFAULT_ALIGN +#define MODULE_CUSTOM_MIN_ALIGN MODULE_DEFAULT_ALIGN

+/* #define MODULE_IMAGE_COMPATIBLE "xen,linux-image\0xen,module" +#define MODULE_INITRD_COMPATIBLE "xen,linux-image\0xen,module" +#define MODULE_XSM_COMPATIBLE "xen,xsm-policy\0xen,module" +#define MODULE_CUSTOM_COMPATIBLE "xen,module" */ +#define MODULE_IMAGE_COMPATIBLE "multiboot,kernel\0multiboot,module" +#define MODULE_INITRD_COMPATIBLE "multiboot,ramdisk\0multiboot,module" +#define MODULE_XSM_COMPATIBLE "xen,xsm-policy\0multiboot,module" +#define MODULE_CUSTOM_COMPATIBLE "multiboot,module"

+/* This maximum size is defined in Power.org ePAPR V1.1

• • https://www.power.org/documentation/epapr-version-1-1/
• • 2.2.1.1 Node Name Requirements
• • node-name@unit-address
• • 31 + 1(@) + 16(64bit address in hex format) + 1(\0) = 49
• */

+#define FDT_NODE_NAME_MAX_SIZE (49)

+#define ARG_SHIFT(argc, argv) \

• do { \
• (argc)--; \
• (argv)++; \
• } while (0)

+struct compat_string_struct +{

• grub_size_t size;
• const char *compat_string;

+}; +typedef struct compat_string_struct compat_string_struct_t; +#define FDT_COMPATIBLE(x) {.size = sizeof(x), .compat_string = (x)}

+enum module_type +{

• MODULE_IMAGE,
• MODULE_INITRD,
• MODULE_XSM,
• MODULE_CUSTOM

+}; +typedef enum module_type module_type_t;

+struct fdt_node_info +{

• module_type_t type;
• const char *compat_string;
• grub_size_t compat_string_size;

+};

+struct xen_hypervisor_header +{

• struct grub_arm64_linux_kernel_header efi_head;
• /* This is always PE\0\0. */
• grub_uint8_t signature[GRUB_PE32_SIGNATURE_SIZE];
• /* The COFF file header. */
• struct grub_pe32_coff_header coff_header;
• /* The Optional header. */
• struct grub_pe64_optional_header optional_header;

+};

+struct xen_boot_binary +{

• struct xen_boot_binary *next;
• struct xen_boot_binary **prev;
• const char *name;
• grub_addr_t start;
• grub_size_t size;
• grub_size_t align;
• char *cmdline;
• int cmdline_size;
• struct fdt_node_info node_info;

+};

+static grub_dl_t my_mod;

+static struct xen_boot_binary *xen_hypervisor; +static struct xen_boot_binary *module_head; +static const grub_size_t module_default_align[] = {

• MODULE_IMAGE_MIN_ALIGN,
• MODULE_INITRD_MIN_ALIGN,
• MODULE_XSM_MIN_ALIGN,
• MODULE_CUSTOM_MIN_ALIGN

+};

+static void *xen_boot_fdt; +static const compat_string_struct_t default_compat_string[] = {

• FDT_COMPATIBLE (MODULE_IMAGE_COMPATIBLE),
• FDT_COMPATIBLE (MODULE_INITRD_COMPATIBLE),
• FDT_COMPATIBLE (MODULE_XSM_COMPATIBLE),
• FDT_COMPATIBLE (MODULE_CUSTOM_COMPATIBLE)

+};

+static __inline grub_addr_t +xen_boot_address_align (grub_addr_t start, grub_size_t align) +{

• return (align ? (ALIGN_UP (start, align)) : start);

+}

+/* Parse the option of xen_module command. For now, we support

• (1) --type <the compatible stream>
• We also set up the type of module in this function.
• If there are some "--type" options in the command line,
• we make a custom compatible stream in this function. */

+static grub_err_t +set_module_type (grub_command_t cmd, struct xen_boot_binary *module,

•          int argc, char *argv[], int *file_name_index)
  

+{

• char **compat_string_temp_array;
• grub_size_t total_size = 0;
• int num_types = 0, i;
• char *temp = NULL;
• *file_name_index = 0;
• if (!grub_strcmp (cmd->name, "xen_linux"))
• module->node_info.type = MODULE_IMAGE;
• else if (!grub_strcmp (cmd->name, "xen_initrd"))
• module->node_info.type = MODULE_INITRD;
• else if (!grub_strcmp (cmd->name, "xen_xsm"))
• module->node_info.type = MODULE_XSM;
• else if (!grub_strcmp (cmd->name, "xen_module"))
• module->node_info.type = MODULE_CUSTOM;
• /* if there are some options we need to process. */
• if (module->node_info.type == MODULE_CUSTOM)
• {

•  compat_string_temp_array =
  

• (char **) grub_zalloc (sizeof (char *) * argc);
  

•  if (!compat_string_temp_array)
  

• return grub_errno;
  

•  /* the module type is set by "--type"(MODULE_CUSTOM) */
  

•  while (argc > 2 && !grub_strcmp (argv[0], "--type"))
  

• {
  

•   module->node_info.type = MODULE_CUSTOM;
  

•   ARG_SHIFT (argc, argv);
  

•   total_size += grub_strlen (argv[0]) + 1;
  

•   compat_string_temp_array[num_types++] = argv[0];
  

•   ARG_SHIFT (argc, argv);
  

•   (*file_name_index) += 2;
  

• }
  

•  if (total_size)
  

• {
  

•   module->node_info.compat_string = temp =
  

•     (char *) grub_zalloc (total_size);
  

•   if (!temp)
  

•     {
  

•       grub_free (compat_string_temp_array);
  

•       return grub_errno;
  

•     }
  

•   module->node_info.compat_string_size = total_size;
  

•   for (i = 0; num_types > 0; num_types--, i++, temp++)
  

•     {
  

•       grub_strcpy (temp, compat_string_temp_array[i]);
  

•       temp += grub_strlen (compat_string_temp_array[i]);
  

•     }
  

• }
  

•  else
  

• {
  

•   module->node_info.compat_string =
  

•     default_compat_string[MODULE_CUSTOM].compat_string;
  

•   module->node_info.compat_string_size =
  

•     default_compat_string[MODULE_CUSTOM].size;
  

• }
  

•  grub_free (compat_string_temp_array);
  

• }
• return GRUB_ERR_NONE;

+}

+static grub_err_t +prepare_xen_hypervisor_params (void) +{

• int chosen_node = 0;
• int retval;
• xen_boot_fdt = grub_linux_get_fdt ();
• if (!xen_boot_fdt)
• return grub_error (GRUB_ERR_IO, "failed to get FDT");
• chosen_node = grub_fdt_find_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 0)
• chosen_node = grub_fdt_add_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 1)
• return grub_error (GRUB_ERR_IO, "failed to get chosen node in FDT");
• grub_dprintf ("xen_loader",

•         "Xen Hypervisor cmdline : %s @ %p size:%d\n",
  

•         xen_hypervisor->cmdline, xen_hypervisor->cmdline,
  

•         xen_hypervisor->cmdline_size);
  

• retval = grub_fdt_set_prop (xen_boot_fdt, chosen_node, "bootargs",

•                       xen_hypervisor->cmdline,
  

•                       xen_hypervisor->cmdline_size);
  

• if (retval)
• return grub_error (GRUB_ERR_IO, "failed to install/update FDT");
• return GRUB_ERR_NONE;

+}

+static grub_err_t +prepare_xen_module_params (struct xen_boot_binary *module) +{

• int retval, chosen_node = 0, module_node = 0;
• char module_name[FDT_NODE_NAME_MAX_SIZE];
• retval = grub_snprintf (module_name, FDT_NODE_NAME_MAX_SIZE, "module@%lx",

•                   xen_boot_address_align (module->start,
  

•                                           module->align));
  

• grub_dprintf ("xen_loader", "Module node name %s \n", module_name);
• if (retval < (int) sizeof ("module@"))
• return grub_error (GRUB_ERR_IO, N_("failed to get FDT"));
• chosen_node = grub_fdt_find_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 0)
• chosen_node = grub_fdt_add_subnode (xen_boot_fdt, 0, "chosen");
• if (chosen_node < 1)
• return grub_error (GRUB_ERR_IO, "failed to get chosen node in FDT");
• module_node =
• grub_fdt_find_subnode (xen_boot_fdt, chosen_node, module_name);
• if (module_node < 0)
• module_node =

•  grub_fdt_add_subnode (xen_boot_fdt, chosen_node, module_name);
  

• retval = grub_fdt_set_prop (xen_boot_fdt, module_node, "compatible",

•                       module->node_info.compat_string,
  

•                       (grub_uint32_t) module->
  

•                       node_info.compat_string_size);
  

• if (retval)
• return grub_error (GRUB_ERR_IO, N_("failed to update FDT"));
• grub_dprintf ("xen_loader", "Module %s compatible = %s size = 0x%lx\n",

•         module->name, module->node_info.compat_string,
  

•         module->node_info.compat_string_size);
  

• retval = grub_fdt_set_reg64 (xen_boot_fdt, module_node,

•                        xen_boot_address_align (module->start,
  

•                                                module->align),
  

•                        module->size);
  

• if (retval)
• return grub_error (GRUB_ERR_IO, N_("failed to update FDT"));
• if (module->cmdline && module->cmdline_size > 0)
• {

•  grub_dprintf ("xen_loader",
  

•             "Module %s cmdline : %s @ %p size:%d\n", module->name,
  

•             module->cmdline, module->cmdline, module->cmdline_size);
  

•  retval = grub_fdt_set_prop (xen_boot_fdt, module_node, "bootargs",
  

•                           module->cmdline, module->cmdline_size + 1);
  

•  if (retval)
  

• return grub_error (GRUB_ERR_IO, "failed to update FDT");
  

• }
• else
• {

•  grub_dprintf ("xen_loader", "Module %s has not bootargs!\n",
  

•             module->name);
  

• }
• return GRUB_ERR_NONE;

+}

+static grub_err_t +install_all_params (void) +{

• grub_efi_guid_t fdt_guid = GRUB_EFI_DEVICE_TREE_GUID;
• grub_efi_boot_services_t *b;
• grub_efi_status_t status;
• b = grub_efi_system_table->boot_services;
• status = b->install_configuration_table (&fdt_guid, xen_boot_fdt);
• if (status != GRUB_EFI_SUCCESS)
• return grub_error (GRUB_ERR_IO, "failed to install FDT");
• grub_dprintf ("xen_loader",

•         "Installed/updated FDT configuration table @ %p\n",
  

•         xen_boot_fdt);
  

• return GRUB_ERR_NONE;

+}

+static grub_err_t +clean_all_params (void) +{

• if (xen_boot_fdt)
• {

•  grub_efi_free_pages ((grub_efi_physical_address_t) xen_boot_fdt,
  

•                    BYTES_TO_PAGES (grub_fdt_get_totalsize
  

•                                    (xen_boot_fdt)));
  

•  xen_boot_fdt = NULL;
  

• }
• return GRUB_ERR_NONE;

+}

+static grub_err_t +finalize_params_xen_boot (void) +{

• struct xen_boot_binary *module;
• if (xen_hypervisor)
• {

•  if (prepare_xen_hypervisor_params () != GRUB_ERR_NONE)
  

• goto fail;
  

• }
• else
• {

•  grub_dprintf ("xen_loader", "Failed to get Xen Hypervisor info!\n");
  

•  goto fail;
  

• }
• /* Set module params info */
• FOR_LIST_ELEMENTS (module, module_head)
• {
• if (module->start && module->size > 0)

•  {
  

• grub_dprintf ("xen_loader", "Module %s @ 0x%lx size:0x%lx\n",
  

•               module->name,
  

•               xen_boot_address_align (module->start, module->align),
  

•               module->size);
  

• if (prepare_xen_module_params (module) != GRUB_ERR_NONE)
  

•   goto fail;
  

•  }
  

• else

•  {
  

• grub_dprintf ("xen_loader", "Module info error: %s!\n", module->name);
  

• goto fail;
  

•  }
  

• }
• if (install_all_params () == GRUB_ERR_NONE)
• return GRUB_ERR_NONE;

+fail:

• clean_all_params ();
• return grub_error (GRUB_ERR_IO, "failed to install/update FDT");

+}

+static grub_err_t +xen_boot (void) +{

• grub_err_t err = finalize_params_xen_boot ();
• if (err)
• return err;
• return grub_arm64_uefi_boot_image (xen_hypervisor->start,

•                              xen_hypervisor->size,
  

•                              xen_hypervisor->cmdline);
  

+}

+static void +single_binary_unload (struct xen_boot_binary *binary) +{

• if (!binary)
• return;
• if (binary->start && binary->size > 0)
• {

•  grub_efi_free_pages ((grub_efi_physical_address_t) binary->start,
  

•                    BYTES_TO_PAGES (binary->size + binary->align));
  

• }
• if (binary->cmdline && binary->cmdline_size > 0)
• {

•  grub_free (binary->cmdline);
  

•  grub_dprintf ("xen_loader",
  

•             "Module %s cmdline memory free @ %p size: %d\n",
  

•             binary->name, binary->cmdline, binary->cmdline_size);
  

• }
• if (binary->node_info.type == MODULE_CUSTOM)
• grub_free ((void *) binary->node_info.compat_string);
• if (grub_strcmp (binary->name, XEN_HYPERVISOR_NAME))
• grub_list_remove (GRUB_AS_LIST (binary));
• grub_dprintf ("xen_loader",

•         "Module %s struct memory free @ %p size: 0x%lx\n",
  

•         binary->name, binary, sizeof (binary));
  

• grub_free (binary);
• return;

+}

+static void +all_binaries_unload (void) +{

• struct xen_boot_binary *binary;
• FOR_LIST_ELEMENTS (binary, module_head)
• {
• single_binary_unload (binary);
• }
• if (xen_hypervisor)
• single_binary_unload (xen_hypervisor);
• return;

+}

+static grub_err_t +xen_unload (void) +{

• grub_linux_set_loaded (0);
• all_binaries_unload ();
• clean_all_params ();
• grub_dl_unref (my_mod);
• return GRUB_ERR_NONE;

+}

+static void +xen_boot_binary_load (struct xen_boot_binary *binary, grub_file_t file,

•               int argc, char *argv[])
  

+{

• binary->size = grub_file_size (file);
• grub_dprintf ("xen_loader", "Xen_boot %s file size: 0x%lx\n",

•         binary->name, binary->size);
  

• binary->start = (grub_addr_t) grub_efi_allocate_pages (0,

•                                                  (BYTES_TO_PAGES
  

•                                                   (binary->size +
  

•                                                    binary->align)));
  

• if (!binary->start)
• {

•  grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
  

•  return;
  

• }
• grub_dprintf ("xen_loader", "Xen_boot %s numpages: 0x%lx\n",

•         binary->name, BYTES_TO_PAGES (binary->size + binary->align));
  

• if (grub_file_read (file, (void *) xen_boot_address_align (binary->start,

•                                                      binary->align),
  

•               binary->size) != (grub_ssize_t) binary->size)
  

• {

•  single_binary_unload (binary);
  

•  grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), argv[0]);
  

•  return;
  

• }
• if (argc > 1)
• {

•  binary->cmdline_size = grub_loader_cmdline_size (argc - 1, argv + 1);
  

•  binary->cmdline = grub_zalloc (binary->cmdline_size);
  

•  if (!binary->cmdline)
  

• {
  

•   single_binary_unload (binary);
  

•   grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
  

•   return;
  

• }
  

•  grub_create_loader_cmdline (argc - 1, argv + 1, binary->cmdline,
  

•                           binary->cmdline_size);
  

•  grub_dprintf ("xen_loader",
  

•             "Xen_boot %s cmdline @ %p %s, size: %d\n", binary->name,
  

•             binary->cmdline, binary->cmdline, binary->cmdline_size);
  

• }
• else
• {

•  binary->cmdline_size = 0;
  

•  binary->cmdline = NULL;
  

• }
• grub_errno = GRUB_ERR_NONE;
• return;

+}

+static grub_err_t +grub_cmd_xen_module (grub_command_t cmd, int argc, char *argv[]) +{

• struct xen_boot_binary *module = NULL;
• int file_name_index = 0;
• grub_file_t file = 0;
• if (!argc)
• {

•  grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
  

•  goto fail;
  

• }
• if (!grub_linux_get_loaded ())
• {

•  grub_error (GRUB_ERR_BAD_ARGUMENT,
  

•           N_("you need to load the Xen Hypervisor first"));
  

•  goto fail;
  

• }
• module =
• (struct xen_boot_binary *) grub_zalloc (sizeof (struct xen_boot_binary));
• if (!module)
• return grub_errno;
• /* process all the options and get module type */
• if (set_module_type (cmd, module, argc, argv, &file_name_index) !=

•  GRUB_ERR_NONE)
  

• goto fail;
• switch (module->node_info.type)
• {
• case MODULE_IMAGE:
• case MODULE_INITRD:
• case MODULE_XSM:

•  module->node_info.compat_string =
  

• default_compat_string[module->node_info.type].compat_string;
  

•  module->node_info.compat_string_size =
  

• default_compat_string[module->node_info.type].size;
  

•  break;
  

• case MODULE_CUSTOM:

•  /* we have set the node_info in set_module_type */
  

•  break;
  

• default:

•  return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("invalid argument"));
  

• }
• module->name = module->node_info.compat_string;
• module->align = module_default_align[module->node_info.type];
• grub_dprintf ("xen_loader", "Init %s module and node info:\n"

•         "compatible %s\ncompat_string_size 0x%lx\n",
  

•         module->name, module->node_info.compat_string,
  

•         module->node_info.compat_string_size);
  

• file = grub_file_open (argv[file_name_index]);
• if (!file)
• goto fail;
• xen_boot_binary_load (module, file, argc - file_name_index,

•                 argv + file_name_index);
  

• if (grub_errno == GRUB_ERR_NONE)
• grub_list_push (GRUB_AS_LIST_P (&module_head), GRUB_AS_LIST (module));

+fail:

• if (file)
• grub_file_close (file);
• if (grub_errno != GRUB_ERR_NONE)
• single_binary_unload (module);
• return grub_errno;

+}

+static grub_err_t +grub_cmd_xen_hypervisor (grub_command_t cmd __attribute__ ((unused)),

•                  int argc, char *argv[])
  

+{

• struct xen_hypervisor_header sh;
• grub_file_t file = NULL;
• grub_dl_ref (my_mod);
• if (!argc)
• {

•  grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
  

•  goto fail;
  

• }
• file = grub_file_open (argv[0]);
• if (!file)
• goto fail;
• if (grub_file_read (file, &sh, sizeof (sh)) != (long) sizeof (sh))
• goto fail;
• if (grub_arm64_uefi_check_image

•  ((struct grub_arm64_linux_kernel_header *) &sh) != GRUB_ERR_NONE)
  

• goto fail;
• grub_file_seek (file, 0);
• /* if another module has called grub_loader_set,

• we need to make sure that another module is unloaded properly */
  

• grub_loader_unset ();
• xen_hypervisor =
• (struct xen_boot_binary *) grub_zalloc (sizeof (struct xen_boot_binary));
• if (!xen_hypervisor)
• return grub_errno;
• xen_hypervisor->name = XEN_HYPERVISOR_NAME;
• xen_hypervisor->align = (grub_size_t) sh.optional_header.section_alignment;
• xen_boot_binary_load (xen_hypervisor, file, argc, argv);
• if (grub_errno == GRUB_ERR_NONE)
• {

•  grub_loader_set (xen_boot, xen_unload, 0);
  

•  grub_linux_set_loaded (1);
  

• }

+fail:

• if (file)
• grub_file_close (file);
• if (grub_errno != GRUB_ERR_NONE)
• {

•  grub_linux_set_loaded (0);
  

•  all_binaries_unload ();
  

•  grub_dl_unref (my_mod);
  

• }
• return grub_errno;

+}

+static grub_command_t cmd_xen_hypervisor, cmd_xen_module; +static grub_command_t cmd_xen_linux, cmd_xen_initrd, cmd_xen_xsm;

+GRUB_MOD_INIT (xen_boot) +{

• cmd_xen_hypervisor =
• grub_register_command ("xen_hypervisor", grub_cmd_xen_hypervisor, 0,

•                    N_("Load a xen hypervisor."));
  

• cmd_xen_linux =
• grub_register_command ("xen_linux", grub_cmd_xen_module, 0,

•                    N_("Load a xen linux kernel for dom0."));
  

• cmd_xen_initrd =
• grub_register_command ("xen_initrd", grub_cmd_xen_module, 0,

•                    N_("Load a xen initrd for dom0."));
  

• cmd_xen_xsm =
• grub_register_command ("xen_xsm", grub_cmd_xen_module, 0,

•                    N_("Load a xen security module."));
  

• cmd_xen_module =
• grub_register_command ("xen_module", grub_cmd_xen_module, 0,

•                    N_("Load a xen module."));
  

• my_mod = mod;

+}

+GRUB_MOD_FINI (xen_boot) +{

• grub_unregister_command (cmd_xen_hypervisor);
• grub_unregister_command (cmd_xen_linux);
• grub_unregister_command (cmd_xen_initrd);
• grub_unregister_command (cmd_xen_xsm);
• grub_unregister_command (cmd_xen_module);

+}

-- Best regards,

Fu Wei Software Engineer Red Hat Software (Beijing) Co.,Ltd.Shanghai Branch Ph: +86 21 61221326(direct) Ph: +86 186 2020 4684 (mobile) Room 1512, Regus One Corporate Avenue,Level 15, One Corporate Avenue,222 Hubin Road,Huangpu District, Shanghai,China 200021

Hi Vladimir,

Great thanks for your suggestion! :-)

On 29 October 2015 at 23:25, Vladimir 'φ-coder/phcoder' Serbinenko phcoder@gmail.com wrote:

...

+if [ "x$machine" != xaarch64 ]; then

• multiboot_cmd="multiboot"
  

• module_linux_cmd="module"
  

• module_initrd_cmd="module --nounzip"
  

+else

• multiboot_cmd="xen_hypervisor"
  

• module_linux_cmd="xen_linux"
  

• module_initrd_cmd="xen_initrd"
  

+fi

Please do not hardcode an assumption that grub-mkconfig is executed on the same machine as GRUB is booted. I know that we have instances of such assumption in some cases but we'd like to eliminate them. Alternatives:

• Check arch on boot time

• Check that new xen commands are supported (define a new feature)

Please add xen_* aliases on x86 as well

I would like to go this way, but could you provide some help or a little example for : (1) How to check the new xen commands(or xen_boot module) (2)add xen_* aliases on x86, is that like something below?

diff --git a/grub-core/loader/i386/xen.c b/grub-core/loader/i386/xen.c index c4d9689..b88d51b 100644 --- a/grub-core/loader/i386/xen.c +++ b/grub-core/loader/i386/xen.c @@ -696,10 +696,14 @@ GRUB_MOD_INIT (xen) 0, N_("Load Linux.")); cmd_multiboot = grub_register_command ("multiboot", grub_cmd_xen, 0, N_("Load Linux.")); + cmd_multiboot = grub_register_command ("xen_hypervisor", grub_cmd_xen, + 0, N_("Load Linux.")); cmd_initrd = grub_register_command ("initrd", grub_cmd_initrd, 0, N_("Load initrd.")); cmd_module = grub_register_command ("module", grub_cmd_module, 0, N_("Load module.")); + cmd_module = grub_register_command ("xen_linux", grub_cmd_module, + 0, N_("Load module.")); my_mod = mod; }

But how to deal with xen_initrd ? Could you help me ?

Great thanks !!

Hi Stefano,

Sorry for late response, I will try to test my latest patch ASAP. but I don't see this problem before. will let you know the result , thanks for your testing

On 2 October 2015 at 00:19, Stefano Stabellini stefano.stabellini@eu.citrix.com wrote:

On Wed, 30 Sep 2015, Stefano Stabellini wrote:

...

Hi Fu,

I backported your patches to the CentOS aarch64 grub2 rpm. I am testing it on X-Gene with EFI firmware. It works fine when booting Xen, but booting native kernels (no Xen) doesn't work anymore. Grub prints

error: out of memory.

Press any key to continue...

grub is still able to continue and load Linux, but then the kernel fails to boot with "Cannot open root device", even though the grub config is still same as before and the rootfs (which is xfs) hasn't changed. Reverting the patches solved the problem.

Do you have any ideas on what is causing the issue? Maybe the initramfs hasn't been properly loaded?

It looks like the following chunk of commit f8451af8251a3866cb8b7307b9917dd5d34fbd0a "arm64: Export useful functions from linux.c" causes troubles:

diff --git a/grub-core/loader/linux.c b/grub-core/loader/linux.c index 117232f..a63a11a 100644 --- a/grub-core/loader/linux.c +++ b/grub-core/loader/linux.c @@ -205,7 +205,8 @@ grub_initrd_init (int argc, char *argv[], initrd_ctx->nfiles++; initrd_ctx->components[i].size = grub_file_size (initrd_ctx->components[i].file);

•  initrd_ctx->size += ALIGN_UP (initrd_ctx->components[i].size, 4);
  

•  if (argc != 1)
  

•   initrd_ctx->size += ALIGN_UP (initrd_ctx->components[i].size, 4);
  

  }

  if (newc)

Simply removing this change seems to fix the issue and Xen still boots fine.