initial commit

GRUB2/grub-2.04/grub-core/kern/file.c

@@ -0,0 +1,256 @@
+/* file.c - file I/O functions */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2006,2007,2009  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/misc.h>
+#include <grub/err.h>
+#include <grub/file.h>
+#include <grub/net.h>
+#include <grub/mm.h>
+#include <grub/fs.h>
+#include <grub/device.h>
+#include <grub/i18n.h>
+
+void (*EXPORT_VAR (grub_grubnet_fini)) (void);
+
+grub_file_filter_t grub_file_filters[GRUB_FILE_FILTER_MAX];
+
+/* Get the device part of the filename NAME. It is enclosed by parentheses.  */
+char *
+grub_file_get_device_name (const char *name)
+{
+  if (name[0] == '(')
+    {
+      char *p = grub_strchr (name, ')');
+      char *ret;
+
+      if (! p)
+	{
+	  grub_error (GRUB_ERR_BAD_FILENAME, N_("missing `%c' symbol"), ')');
+	  return 0;
+	}
+
+      ret = (char *) grub_malloc (p - name);
+      if (! ret)
+	return 0;
+
+      grub_memcpy (ret, name + 1, p - name - 1);
+      ret[p - name - 1] = '\0';
+      return ret;
+    }
+
+  return 0;
+}
+
+/* Support mem:xxx:size:xxx format in chainloader */
+grub_file_t grub_memfile_open(const char *name);
+#define GRUB_MEMFILE_MEM     "mem:"
+#define GRUB_MEMFILE_SIZE    "size:"
+
+grub_file_t grub_memfile_open(const char *name)
+{
+    char *size = NULL;
+    grub_file_t file = 0;
+    
+    file = (grub_file_t)grub_zalloc(sizeof(*file));
+    if (NULL == file)
+    {
+        return 0;
+    }
+
+    file->name = grub_strdup(name);
+    file->data = (void *)grub_strtoul(name + grub_strlen(GRUB_MEMFILE_MEM), NULL, 0);
+
+    size = grub_strstr(name, GRUB_MEMFILE_SIZE);
+    file->size = (grub_off_t)grub_strtoul(size + grub_strlen(GRUB_MEMFILE_SIZE), NULL, 0);
+
+    grub_errno = GRUB_ERR_NONE;
+    return file;
+}
+
+grub_file_t
+grub_file_open (const char *name, enum grub_file_type type)
+{
+  grub_device_t device = 0;
+  grub_file_t file = 0, last_file = 0;
+  char *device_name;
+  const char *file_name;
+  grub_file_filter_id_t filter;
+
+  /* <DESC> : mem:xxx:size:xxx format in chainloader */
+  if (grub_strncmp(name, GRUB_MEMFILE_MEM, grub_strlen(GRUB_MEMFILE_MEM)) == 0) {
+      return grub_memfile_open(name);
+  }  
+
+  device_name = grub_file_get_device_name (name);
+  if (grub_errno)
+    goto fail;
+
+  /* Get the file part of NAME.  */
+  file_name = (name[0] == '(') ? grub_strchr (name, ')') : NULL;
+  if (file_name)
+    file_name++;
+  else
+    file_name = name;
+
+  device = grub_device_open (device_name);
+  grub_free (device_name);
+  if (! device)
+    goto fail;
+
+  file = (grub_file_t) grub_zalloc (sizeof (*file));
+  if (! file)
+    goto fail;
+
+  file->device = device;
+
+  /* In case of relative pathnames and non-Unix systems (like Windows)
+   * name of host files may not start with `/'. Blocklists for host files
+   * are meaningless as well (for a start, host disk does not allow any direct
+   * access - it is just a marker). So skip host disk in this case.
+   */
+  if (device->disk && file_name[0] != '/'
+#if defined(GRUB_UTIL) || defined(GRUB_MACHINE_EMU)
+      && grub_strcmp (device->disk->name, "host")
+#endif
+     )
+    /* This is a block list.  */
+    file->fs = &grub_fs_blocklist;
+  else
+    {
+      file->fs = grub_fs_probe (device);
+      if (! file->fs)
+	goto fail;
+    }
+
+  if ((file->fs->fs_open) (file, file_name) != GRUB_ERR_NONE)
+    goto fail;
+
+  file->name = grub_strdup (name);
+  grub_errno = GRUB_ERR_NONE;
+
+  for (filter = 0; file && filter < ARRAY_SIZE (grub_file_filters);
+       filter++)
+    if (grub_file_filters[filter])
+      {
+	last_file = file;
+	file = grub_file_filters[filter] (file, type);
+	if (file && file != last_file)
+	  {
+	    file->name = grub_strdup (name);
+	    grub_errno = GRUB_ERR_NONE;
+	  }
+      }
+  if (!file)
+    grub_file_close (last_file);
+
+  return file;
+
+ fail:
+  if (device)
+    grub_device_close (device);
+
+  /* if (net) grub_net_close (net);  */
+
+  grub_free (file);
+
+  return 0;
+}
+
+grub_disk_read_hook_t grub_file_progress_hook;
+
+grub_ssize_t
+grub_file_read (grub_file_t file, void *buf, grub_size_t len)
+{
+  grub_ssize_t res;
+  grub_disk_read_hook_t read_hook;
+  void *read_hook_data;
+
+  if (file->offset > file->size)
+    {
+      grub_error (GRUB_ERR_OUT_OF_RANGE,
+		  N_("attempt to read past the end of file"));
+      return -1;
+    }
+
+  if (len == 0)
+    return 0;
+
+  if (len > file->size - file->offset)
+    len = file->size - file->offset;
+
+  /* Prevent an overflow.  */
+  if ((grub_ssize_t) len < 0)
+    len >>= 1;
+
+  if (len == 0)
+    return 0;
+
+  if (grub_strncmp(file->name, GRUB_MEMFILE_MEM, grub_strlen(GRUB_MEMFILE_MEM)) == 0) {
+      grub_memcpy(buf, (grub_uint8_t *)(file->data) + file->offset, len);
+      file->offset += len;
+      return len;
+  }
+  
+  read_hook = file->read_hook;
+  read_hook_data = file->read_hook_data;
+  if (!file->read_hook)
+    {
+      file->read_hook = grub_file_progress_hook;
+      file->read_hook_data = file;
+      file->progress_offset = file->offset;
+    }
+  res = (file->fs->fs_read) (file, buf, len);
+  file->read_hook = read_hook;
+  file->read_hook_data = read_hook_data;
+  if (res > 0)
+    file->offset += res;
+
+  return res;
+}
+
+grub_err_t
+grub_file_close (grub_file_t file)
+{
+  if (file->fs && file->fs->fs_close)
+    (file->fs->fs_close) (file);
+
+  if (file->device)
+    grub_device_close (file->device);
+  grub_free (file->name);
+  grub_free (file);
+  return grub_errno;
+}
+
+grub_off_t
+grub_file_seek (grub_file_t file, grub_off_t offset)
+{
+  grub_off_t old;
+
+  if (offset > file->size)
+    {
+      grub_error (GRUB_ERR_OUT_OF_RANGE,
+		  N_("attempt to seek outside of the file"));
+      return -1;
+    }
+  
+  old = file->offset;
+  file->offset = offset;
+    
+  return old;
+}

GRUB2/grub-2.04/grub-core/kern/fs.c

@@ -0,0 +1,304 @@
+/* fs.c - filesystem manager */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2005,2007  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/disk.h>
+#include <grub/net.h>
+#include <grub/fs.h>
+#include <grub/file.h>
+#include <grub/err.h>
+#include <grub/misc.h>
+#include <grub/types.h>
+#include <grub/mm.h>
+#include <grub/term.h>
+#include <grub/i18n.h>
+#include <grub/env.h>
+
+grub_fs_t grub_fs_list = 0;
+
+grub_fs_autoload_hook_t grub_fs_autoload_hook = 0;
+
+/* Helper for grub_fs_probe.  */
+static int
+probe_dummy_iter (const char *filename __attribute__ ((unused)),
+		  const struct grub_dirhook_info *info __attribute__ ((unused)),
+		  void *data __attribute__ ((unused)))
+{
+  return 1;
+}
+
+grub_fs_t
+grub_fs_probe (grub_device_t device)
+{
+  grub_fs_t p;
+  const char *first_probe;
+  grub_size_t len;
+
+  if (device->disk)
+    {
+      /* Make it sure not to have an infinite recursive calls.  */
+      static int count = 0;
+
+      first_probe = grub_env_get("ventoy_fs_probe");
+      if (!first_probe)
+      {
+          first_probe = "iso9660";
+      }
+      len = grub_strlen(first_probe);
+
+      /* use iso9660 first */
+      for (p = grub_fs_list; p; p = p->next)
+      {
+          if (grub_strncmp(p->name, first_probe, len) == 0)
+          {
+              break;
+          }
+      }
+
+      if (p)
+      {
+	  grub_dprintf ("fs", "Detecting %s...\n", p->name);
+
+	  /* This is evil: newly-created just mounted BtrFS after copying all
+	     GRUB files has a very peculiar unrecoverable corruption which
+	     will be fixed at sync but we'd rather not do a global sync and
+	     syncing just files doesn't seem to help. Relax the check for
+	     this time.  */
+#ifdef GRUB_UTIL
+	  if (grub_strcmp (p->name, "btrfs") == 0)
+	    {
+	      char *label = 0;
+	      p->fs_uuid (device, &label);
+	      if (label)
+		grub_free (label);
+	    }
+	  else
+#endif
+	    (p->fs_dir) (device, "/", probe_dummy_iter, NULL);
+	  if (grub_errno == GRUB_ERR_NONE)
+	    return p;
+
+	  grub_error_push ();
+	  grub_dprintf ("fs", "%s detection failed.\n", p->name);
+	  grub_error_pop ();
+
+	  if (grub_errno != GRUB_ERR_BAD_FS
+	      && grub_errno != GRUB_ERR_OUT_OF_RANGE)
+	    return 0;
+
+	  grub_errno = GRUB_ERR_NONE;
+	}
+
+      for (p = grub_fs_list; p; p = p->next)
+	{
+	  grub_dprintf ("fs", "Detecting %s...\n", p->name);
+
+	  /* This is evil: newly-created just mounted BtrFS after copying all
+	     GRUB files has a very peculiar unrecoverable corruption which
+	     will be fixed at sync but we'd rather not do a global sync and
+	     syncing just files doesn't seem to help. Relax the check for
+	     this time.  */
+#ifdef GRUB_UTIL
+	  if (grub_strcmp (p->name, "btrfs") == 0)
+	    {
+	      char *label = 0;
+	      p->fs_uuid (device, &label);
+	      if (label)
+		grub_free (label);
+	    }
+	  else
+#endif
+	    (p->fs_dir) (device, "/", probe_dummy_iter, NULL);
+	  if (grub_errno == GRUB_ERR_NONE)
+	    return p;
+
+	  grub_error_push ();
+	  grub_dprintf ("fs", "%s detection failed.\n", p->name);
+	  grub_error_pop ();
+
+	  if (grub_errno != GRUB_ERR_BAD_FS
+	      && grub_errno != GRUB_ERR_OUT_OF_RANGE)
+	    return 0;
+
+	  grub_errno = GRUB_ERR_NONE;
+	}
+
+      /* Let's load modules automatically.  */
+      if (grub_fs_autoload_hook && count == 0)
+	{
+	  count++;
+
+	  while (grub_fs_autoload_hook ())
+	    {
+	      p = grub_fs_list;
+
+	      (p->fs_dir) (device, "/", probe_dummy_iter, NULL);
+	      if (grub_errno == GRUB_ERR_NONE)
+		{
+		  count--;
+		  return p;
+		}
+
+	      if (grub_errno != GRUB_ERR_BAD_FS
+		  && grub_errno != GRUB_ERR_OUT_OF_RANGE)
+		{
+		  count--;
+		  return 0;
+		}
+
+	      grub_errno = GRUB_ERR_NONE;
+	    }
+
+	  count--;
+	}
+    }
+  else if (device->net && device->net->fs)
+    return device->net->fs;
+
+  grub_error (GRUB_ERR_UNKNOWN_FS, N_("unknown filesystem"));
+  return 0;
+}
+
+
+
+/* Block list support routines.  */
+
+struct grub_fs_block
+{
+  grub_disk_addr_t offset;
+  unsigned long length;
+};
+
+static grub_err_t
+grub_fs_blocklist_open (grub_file_t file, const char *name)
+{
+  char *p = (char *) name;
+  unsigned num = 0;
+  unsigned i;
+  grub_disk_t disk = file->device->disk;
+  struct grub_fs_block *blocks;
+
+  /* First, count the number of blocks.  */
+  do
+    {
+      num++;
+      p = grub_strchr (p, ',');
+      if (p)
+	p++;
+    }
+  while (p);
+
+  /* Allocate a block list.  */
+  blocks = grub_zalloc (sizeof (struct grub_fs_block) * (num + 1));
+  if (! blocks)
+    return 0;
+
+  file->size = 0;
+  p = (char *) name;
+  for (i = 0; i < num; i++)
+    {
+      if (*p != '+')
+	{
+	  blocks[i].offset = grub_strtoull (p, &p, 0);
+	  if (grub_errno != GRUB_ERR_NONE || *p != '+')
+	    {
+	      grub_error (GRUB_ERR_BAD_FILENAME,
+			  N_("invalid file name `%s'"), name);
+	      goto fail;
+	    }
+	}
+
+      p++;
+      blocks[i].length = grub_strtoul (p, &p, 0);
+      if (grub_errno != GRUB_ERR_NONE
+	  || blocks[i].length == 0
+	  || (*p && *p != ',' && ! grub_isspace (*p)))
+	{
+	  grub_error (GRUB_ERR_BAD_FILENAME,
+		      N_("invalid file name `%s'"), name);
+	  goto fail;
+	}
+
+      if (disk->total_sectors < blocks[i].offset + blocks[i].length)
+	{
+	  grub_error (GRUB_ERR_BAD_FILENAME, "beyond the total sectors");
+	  goto fail;
+	}
+
+      file->size += (blocks[i].length << GRUB_DISK_SECTOR_BITS);
+      p++;
+    }
+
+  file->data = blocks;
+
+  return GRUB_ERR_NONE;
+
+ fail:
+  grub_free (blocks);
+  return grub_errno;
+}
+
+static grub_ssize_t
+grub_fs_blocklist_read (grub_file_t file, char *buf, grub_size_t len)
+{
+  struct grub_fs_block *p;
+  grub_disk_addr_t sector;
+  grub_off_t offset;
+  grub_ssize_t ret = 0;
+
+  if (len > file->size - file->offset)
+    len = file->size - file->offset;
+
+  sector = (file->offset >> GRUB_DISK_SECTOR_BITS);
+  offset = (file->offset & (GRUB_DISK_SECTOR_SIZE - 1));
+  for (p = file->data; p->length && len > 0; p++)
+    {
+      if (sector < p->length)
+	{
+	  grub_size_t size;
+
+	  size = len;
+	  if (((size + offset + GRUB_DISK_SECTOR_SIZE - 1)
+	       >> GRUB_DISK_SECTOR_BITS) > p->length - sector)
+	    size = ((p->length - sector) << GRUB_DISK_SECTOR_BITS) - offset;
+
+	  if (grub_disk_read (file->device->disk, p->offset + sector, offset,
+			      size, buf) != GRUB_ERR_NONE)
+	    return -1;
+
+	  ret += size;
+	  len -= size;
+	  sector -= ((size + offset) >> GRUB_DISK_SECTOR_BITS);
+	  offset = ((size + offset) & (GRUB_DISK_SECTOR_SIZE - 1));
+	}
+      else
+	sector -= p->length;
+    }
+
+  return ret;
+}
+
+struct grub_fs grub_fs_blocklist =
+  {
+    .name = "blocklist",
+    .fs_dir = 0,
+    .fs_open = grub_fs_blocklist_open,
+    .fs_read = grub_fs_blocklist_read,
+    .fs_close = 0,
+    .next = 0
+  };

GRUB2/grub-2.04/grub-core/kern/main.c

@@ -0,0 +1,312 @@
+/* main.c - the kernel main routine */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2003,2005,2006,2008,2009  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/kernel.h>
+#include <grub/misc.h>
+#include <grub/symbol.h>
+#include <grub/dl.h>
+#include <grub/term.h>
+#include <grub/file.h>
+#include <grub/device.h>
+#include <grub/env.h>
+#include <grub/mm.h>
+#include <grub/command.h>
+#include <grub/reader.h>
+#include <grub/parser.h>
+
+#ifdef GRUB_MACHINE_PCBIOS
+#include <grub/machine/memory.h>
+#endif
+
+grub_addr_t
+grub_modules_get_end (void)
+{
+  struct grub_module_info *modinfo;
+
+  modinfo = (struct grub_module_info *) grub_modbase;
+
+  /* Check if there are any modules.  */
+  if ((modinfo == 0) || modinfo->magic != GRUB_MODULE_MAGIC)
+    return grub_modbase;
+
+  return grub_modbase + modinfo->size;
+}
+
+/* Load all modules in core.  */
+static void
+grub_load_modules (void)
+{
+  struct grub_module_header *header;
+  FOR_MODULES (header)
+  {
+    /* Not an ELF module, skip.  */
+    if (header->type != OBJ_TYPE_ELF)
+      continue;
+
+    if (! grub_dl_load_core ((char *) header + sizeof (struct grub_module_header),
+			     (header->size - sizeof (struct grub_module_header))))
+      grub_fatal ("%s", grub_errmsg);
+
+    if (grub_errno)
+      grub_print_error ();
+  }
+}
+
+static char *load_config;
+
+static void
+grub_load_config (void)
+{
+  struct grub_module_header *header;
+  FOR_MODULES (header)
+  {
+    /* Not an embedded config, skip.  */
+    if (header->type != OBJ_TYPE_CONFIG)
+      continue;
+
+    load_config = grub_malloc (header->size - sizeof (struct grub_module_header) + 1);
+    if (!load_config)
+      {
+	grub_print_error ();
+	break;
+      }
+    grub_memcpy (load_config, (char *) header +
+		 sizeof (struct grub_module_header),
+		 header->size - sizeof (struct grub_module_header));
+    load_config[header->size - sizeof (struct grub_module_header)] = 0;
+    break;
+  }
+}
+
+/* Write hook for the environment variables of root. Remove surrounding
+   parentheses, if any.  */
+static char *
+grub_env_write_root (struct grub_env_var *var __attribute__ ((unused)),
+		     const char *val)
+{
+  /* XXX Is it better to check the existence of the device?  */
+  grub_size_t len = grub_strlen (val);
+
+  if (val[0] == '(' && val[len - 1] == ')')
+    return grub_strndup (val + 1, len - 2);
+
+  return grub_strdup (val);
+}
+
+static void
+grub_set_prefix_and_root (void)
+{
+  char *device = NULL;
+  char *path = NULL;
+  char *fwdevice = NULL;
+  char *fwpath = NULL;
+  char *prefix = NULL;
+  struct grub_module_header *header;
+
+  FOR_MODULES (header)
+    if (header->type == OBJ_TYPE_PREFIX)
+      prefix = (char *) header + sizeof (struct grub_module_header);
+
+  grub_register_variable_hook ("root", 0, grub_env_write_root);
+
+  grub_machine_get_bootlocation (&fwdevice, &fwpath);
+
+  if (fwdevice)
+    {
+      char *cmdpath;
+
+      cmdpath = grub_xasprintf ("(%s)%s", fwdevice, fwpath ? : "");
+      if (cmdpath)
+	{
+	  grub_env_set ("cmdpath", cmdpath);
+	  grub_env_export ("cmdpath");
+	  grub_free (cmdpath);
+	}
+    }
+
+  if (prefix)
+    {
+      char *pptr = NULL;
+      if (prefix[0] == '(')
+	{
+	  pptr = grub_strrchr (prefix, ')');
+	  if (pptr)
+	    {
+	      device = grub_strndup (prefix + 1, pptr - prefix - 1);
+	      pptr++;
+	    }
+	}
+      if (!pptr)
+	pptr = prefix;
+      if (pptr[0])
+	path = grub_strdup (pptr);
+    }
+
+  if (!device && fwdevice)
+    device = fwdevice;
+  else if (fwdevice && (device[0] == ',' || !device[0]))
+    {
+      /* We have a partition, but still need to fill in the drive.  */
+      char *comma, *new_device;
+
+      for (comma = fwdevice; *comma; )
+	{
+	  if (comma[0] == '\\' && comma[1] == ',')
+	    {
+	      comma += 2;
+	      continue;
+	    }
+	  if (*comma == ',')
+	    break;
+	  comma++;
+	}
+      if (*comma)
+	{
+	  char *drive = grub_strndup (fwdevice, comma - fwdevice);
+	  new_device = grub_xasprintf ("%s%s", drive, device);
+	  grub_free (drive);
+	}
+      else
+	new_device = grub_xasprintf ("%s%s", fwdevice, device);
+
+      grub_free (fwdevice);
+      grub_free (device);
+      device = new_device;
+    }
+  else
+    grub_free (fwdevice);
+  if (fwpath && !path)
+    {
+      grub_size_t len = grub_strlen (fwpath);
+      while (len > 1 && fwpath[len - 1] == '/')
+	fwpath[--len] = 0;
+      if (len >= sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1
+	  && grub_memcmp (fwpath + len - (sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1), GRUB_TARGET_CPU "-" GRUB_PLATFORM,
+			  sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1) == 0)
+	fwpath[len - (sizeof (GRUB_TARGET_CPU "-" GRUB_PLATFORM) - 1)] = 0;
+      path = fwpath;
+    }
+  else
+    grub_free (fwpath);
+  if (device)
+    {
+      char *prefix_set;
+    
+      prefix_set = grub_xasprintf ("(%s)%s", device, path ? : "");
+      if (prefix_set)
+	{
+	  grub_env_set ("prefix", prefix_set);
+	  grub_free (prefix_set);
+	}
+      grub_env_set ("root", device);
+    }
+
+  grub_free (device);
+  grub_free (path);
+  grub_print_error ();
+}
+
+/* Load the normal mode module and execute the normal mode if possible.  */
+static void
+grub_load_normal_mode (void)
+{
+  /* Load the module.  */
+  grub_dl_load ("normal");
+
+  /* Print errors if any.  */
+  grub_print_error ();
+  grub_errno = 0;
+
+  grub_command_execute ("normal", 0, 0);
+}
+
+static void
+reclaim_module_space (void)
+{
+  grub_addr_t modstart, modend;
+
+  if (!grub_modbase)
+    return;
+
+#ifdef GRUB_MACHINE_PCBIOS
+  modstart = GRUB_MEMORY_MACHINE_DECOMPRESSION_ADDR;
+#else
+  modstart = grub_modbase;
+#endif
+  modend = grub_modules_get_end ();
+  grub_modbase = 0;
+
+#if GRUB_KERNEL_PRELOAD_SPACE_REUSABLE
+  grub_mm_init_region ((void *) modstart, modend - modstart);
+#else
+  (void) modstart;
+  (void) modend;
+#endif
+}
+
+/* The main routine.  */
+void __attribute__ ((noreturn))
+grub_main (void)
+{
+  /* First of all, initialize the machine.  */
+  grub_machine_init ();
+
+  grub_boot_time ("After machine init.");
+
+  /* Hello.  */
+  grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
+  //grub_printf ("Welcome to GRUB!\n\n");
+  grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
+
+  grub_load_config ();
+
+  grub_boot_time ("Before loading embedded modules.");
+
+  /* Load pre-loaded modules and free the space.  */
+  grub_register_exported_symbols ();
+#ifdef GRUB_LINKER_HAVE_INIT
+  grub_arch_dl_init_linker ();
+#endif  
+  grub_load_modules ();
+
+  grub_boot_time ("After loading embedded modules.");
+
+  /* It is better to set the root device as soon as possible,
+     for convenience.  */
+  grub_set_prefix_and_root ();
+  grub_env_export ("root");
+  grub_env_export ("prefix");
+
+  /* Reclaim space used for modules.  */
+  reclaim_module_space ();
+
+  grub_boot_time ("After reclaiming module space.");
+
+  grub_register_core_commands ();
+
+  grub_boot_time ("Before execution of embedded config.");
+
+  if (load_config)
+    grub_parser_execute (load_config);
+
+  grub_boot_time ("After execution of embedded config. Attempt to go to normal mode");
+
+  grub_load_normal_mode ();
+  grub_rescue_run ();
+}