diff --git a/ChangeLog b/ChangeLog
index 9506d26ca..c041a685c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,391 @@
+2009-12-22  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	* commands/lspci.c (grub_pci_classes): Add "USB Controller".
+	(options): New variable.
+	(iospace): Likewise.
+	(grub_lspci_iter): List IO spaces if "-i" was given.
+	(grub_cmd_lspci): Parse options.
+	(GRUB_MOD_INIT(lspci)): Use extcmd.
+	(GRUB_MOD_FINI(lspci)): Likewise.
+
+2009-12-22 Felix Zielcke <fzielcke@z-51.de>
+
+	* util/grub.d/30_os-prober.in (osx_entry): Remove non POSIX compliant
+	`function' keyword.
+	Patch by Tony Mancill <tmancill@debian.org>.
+
+2009-12-22  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	* bus/usb/uhci.c (grub_uhci_transfer): Set a limit transaction time.
+	(grub_uhci_portstatus): Likewise.
+	(grub_uhci_portstatus): Add necessary delay.
+	* bus/usb/usbhub.c (grub_usb_hub_add_dev): Fix loop-break condition.
+
+2009-12-21  Carles Pina i Estany  <carles@pina.cat>
+
+	* commands/acpi.c (options): Fix capitalizations and/or full stops.
+	(GRUB_MOD_INIT): Likewise.
+	* commands/boot.c (GRUB_MOD_INIT): Likewise.
+	* commands/cmp.c (grub_cmd_cmp): Improve the help message.
+	* commands/echo.c (options): Fix capitalizations and/or full stops.
+	* commands/efi/loadbios.c (enable_rom_area): Likewise.
+	(enable_rom_area): Likewise.
+	(GRUB_MOD_INIT): Likewise.
+	* commands/gptsync.c (GRUB_MOD_INIT): Likewise.
+	* commands/halt.c (GRUB_MOD_INIT): Improve the help message.
+	* commands/handler.c (GRUB_MOD_INIT): Likewise.
+	* commands/hdparm.c (options): Fix capitalizations and/or full stops.
+	* commands/hexdump.c (options): Likewise.
+	* commands/i386/cpuid.c (options): Likewise.
+	(GRUB_MOD_INIT): Likewise.
+	* commands/i386/pc/drivemap.c (options): Likewise.
+	(GRUB_MOD_INIT): Likewise.
+	* commands/i386/pc/halt (options): Likewise.
+	(GRUB_MOD_INIT): Likewise.
+	* commands/i386/pc/play.c (GRUB_MOD_INIT): Likewise.
+	* commands/i386/pc/pxecmd.c (options): Likewise.
+	* commands/i386/pc/vbetest.c (GRUB_MOD_INIT): Likewise.
+	* commands/ieee1275/suspend.c (GRUB_MOD_INIT): Likewise.
+	* commands/keystatus.c (options): Likewise.
+	(GRUB_MOD_INIT): Likewise.
+	* commands/loadenv.c (options): Likewise.
+	* commands/ls.c (options): Likewise.
+	* commands/lspci.c (GRUB_MOD_INIT): Likewise.
+	* commands/memrw.c (GRUB_MOD_INIT): Likewise.
+	* commands/minicmd.c (GRUB_MOD_INIT): Likewise.
+	* commands/parttool.c (helpmsg): Likewise.
+	* commands/probe.c (options): Likewise.
+	* commands/read.c (GRUB_MOD_INIT): Likewise.
+	* commands/reboot.c (GRUB_MOD_INIT): Likewise.
+	* commands/search.c (options): Likewise.
+	* commands/sleep.c (options): Likewise.
+	* commands/test.c (GRUB_MOD_INIT): Likewise.
+	* commands/true.c (GRUB_MOD_INIT): Likewise.
+	* commands/usbtest.c (GRUB_MOD_INIT): Likewise.
+	* commands/videotest.c (GRUB_MOD_INIT): Likewise.
+	* lib/arg.c (help_options): Likewise.
+	* Makefile.in ($(srcdir)/po/$(PACKAGE).pot): Pass -ctranslate to
+	`$(XGETTEXT)'.
+	* po/POTFILES: Add `commands/loadenv.c'.
+
+2009-12-21 Felix Zielcke <fzielcke@z-51.de>
+
+	* util/grub-mkrescue.in (process_input_dir): Copy `*.lst' files
+	instead of specifying them explicit.
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* NEWS: Add grub-probe support for GNU/Hurd.
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* NEWS: gettext was added after 1.97.
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* util/mkisofs/msdos_partition.h: New file (based on
+	include/grub/msdos_partition.h).
+	* util/mkisofs/mkisofs.c (use_protective_msdos_label): New variable.
+	(OPTION_PROTECTIVE_MSDOS_LABEL): New macro.
+	(ld_options, main): Recognize --protective-msdos-label.
+	* util/mkisofs/mkisofs.h (use_protective_msdos_label): New declaration.
+	* util/mkisofs/write.c: Include `"msdos_partition.h"'.
+	(padblock_write): If `use_protective_msdos_label' is set, patch a
+	protective DOS-style label in the output image.
+
+	* util/grub-mkrescue.in: Use --protective-msdos-label.
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* util/grub-mkrescue.in: Do not zero-pad image for BIOS-based disk
+	boot.
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* util/mkisofs/mkisofs.c (use_embedded_boot, boot_image_embed): New
+	variables.
+	(ld_options, main): Recognize `--embedded-boot'.
+	* util/mkisofs/mkisofs.h (use_embedded_boot, boot_image_embed): New
+	declarations.
+	* util/mkisofs/write.c (PADBLOCK_SIZE): New variable.
+	(padblock_size): Use `PADBLOCK_SIZE' instead of hardcoding 16.
+	(padblock_write): Likewise.  Rewrite to support embedded boot image.
+
+	* util/grub-mkrescue.in: When building i386-pc images, embed core.img
+	for BIOS-based disk boot instead of only ElTorito.
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* util/grub-mkrescue.in: Remove `configfile' and `sh' from i386-pc
+	build (not needed for bootstrap).
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* util/grub-mkrescue.in: Remove `memdisk', `tar' and `search' modules
+	from i386-pc build (not needed for bootstrap).
+	Rewrite a pair of strings.
+
+2009-12-21  Robert Millan  <rmh.grub@aybabtu.com>
+
+	* normal/main.c (grub_normal_reader_init): Set left margin back to 3.
+
+2009-12-21  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	* video/i386/pc/vbe.c (grub_video_vbe_fini): Set 'last_set_mode'.
+
+2009-12-21 Andreas Born  <futur.andy@googlemail.com>
+
+	* kern/env.c (grub_env_context_open): Mark exported variable for
+	reexport.
+
+2009-12-21 Andreas Born  <futur.andy@googlemail.com>
+
+	* kern/env.c (grub_env_export): Create nonexistent variables before
+	exporting.
+
+2009-12-20 Carles Pina i Estany  <carles@pina.cat>
+
+	* include/grub/auth.h: Include `<grub/i18n.h>'.
+	(GRUB_GET_PASSWORD): Gettextizze string.
+	* include/grub/normal.h (STANDARD_MARGIN): New macro, moved from
+	menu_text.c.
+	(grub_utf8_to_ucs4_alloc): Fix indentation.
+	(grub_print_ucs4): Likewise.
+	(grub_getstringwidth): Likewise.
+	(print_message_indented): New declaration.
+	* normal/auth.c: Include `<grub/i18n.h>'.
+	(grub_auth_check_authentication): Gettexttize string.
+	* normal/cmdline.c: Include `<grub/i18n.h>'.
+	(grub_cmdline_get): Gettextizze.
+	* normal/color.c: Include `<grub/i18n.h>'.
+	(grub_parse_color_name_pair): Gettexttize strings.
+	* normal/main.c (grub_normal_reader_init): Cleanup gettexttized
+	string (use `print_message_indented').
+	* normal/menu_text.c (STANDARD_MARGIN): Moved from here to
+	`include/grub/normal.h'.
+	(print_message_indented): Renamed to ...
+	(grub_print_message_indented): ... this. Remove `static' qualifer (now
+	used in normal/main.c).
+	(print_message): Use `grub_print_message_indented' instead of
+	`print_message_indented'.
+	(print_timeout): Likewise.
+	* normal/misc.c: Include `<grub/term.h>' and `<grub/i18n.h>'.
+	(grub_normal_print_device_info): Gettexttize strings.
+	* po/POTFILES: Add `auth.c', `color.c' and `misc.c'.
+
+2009-12-20  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	* kern/parser.c (grub_parser_split_cmdline): Fix incorrect counting
+	of arguments. Return number of tokens and not arguments. All users
+	updated.
+
+2009-12-20  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	* util/i386/pc/grub-setup.c (setup): Don't install on non-GPT,
+	non-MSDOS paritions.
+
+2009-12-19  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	* include/grub/types.h (UNUSED): Removed since it conflicts with
+	NetBSD headers. All users changed to direct __attribute__ ((unused)).
+	Reported by Grégoire Sutre.
+
+2009-12-19  Carles Pina i Estany  <carles@pina.cat>
+
+	* include/grub/normal.h (grub_utf8_to_ucs4): New declaration.
+	(grub_print_ucs4_alloc): Likewise.
+	(grub_getstringwidth): Likewise.
+	* normal/main.c (grub_normal_init_page): Gettextize version string.
+	* normal/menu_text.c (grub_utf8_to_ucs4_alloc): New definition.
+	(getstringwidth): Renamed to ...
+	(grub_getstringwidth): ... this. Remove `static' qualifier (now used
+	in normal/main.c).  Use `grub_utf8_to_ucs4_alloc'.
+	(grub_print_ucs4): Remove `static' qualifer (now used in
+	normal/main.c).
+	* po/POTFILES: Add normal/main.c.
+
+2009-12-19  Carles Pina i Estany  <carles@pina.cat>
+
+	* normal/menu_text.c (STANDARD_MARGIN): New macro.
+	(print_message_indented): Add `margin_left' and `margin_right'
+	parameters.
+	(print_message): Update `print_message_indented' calls. Adds '\n' to the
+	strings.
+	(print_timeout): Use `print_message_indented' to print the message.
+	Deletes `second_stage' parameter.
+	(run_menu): Update `print_timeout' calls.
+
+2009-12-18  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	Fix console palette on OpenFirmware.
+
+	* term/ieee1275/ofconsole.c (MAX): Removed.
+	(colors): Redone based on VGA palette.
+	(grub_ofconsole_setcolor): Discard brightness bit since only 8
+	colors are supported.
+	(grub_ofconsole_init_output): Use ARRAY_SIZE instead of hardcoded size.
+
+2009-12-18  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	Fix potential EfiEmu double prepare.
+
+	* efiemu/main.c (prepared): New variable
+	(grub_efiemu_unload): Set prepare to '0'.
+	(grub_efiemu_prepare): Return if already prepared. Set prepared.
+
+	set_virtual_address_map support.
+
+	* include/grub/efi/efi.h (grub_efi_set_virtual_address_map): New
+	prototype.
+	* include/grub/efiemu/efiemu.h (grub_efiemu_write_sym_markers): New
+	prototype.
+	(grub_efiemu_crc32): Likewise.
+	(grub_efiemu_crc64): Likewise.
+	(grub_efiemu_set_virtual_address_map): Likewise.
+	* include/grub/autoefi.h (grub_autoefi_exit_boot_services):
+	New definition.
+	(grub_autoefi_set_virtual_address_map): Likewise.
+	* kern/efi/efi.c (grub_efi_set_virtual_address_map): New function.
+	* loader/i386/xnu.c (grub_xnu_boot): Call set_virtual_address_map.
+	Restructure flow to accomodate it.
+	* efiemu/prepare.c (grub_efiemu_prepare): Support set_virtual_address_map.
+	(grub_efiemu_crc): Recompute CRC32.
+	* efiemu/runtime/efiemu.c (ptv_relocated): Renamed to ...
+	(efiemu_ptv_relocated): ... this. Made global. All users updated.
+	* efiemu/symbols.c (relocated_handle): New variable.
+	(grub_efiemu_free_syms): Free relocated_handle.
+	(grub_efiemu_alloc_syms): Allocate relocated_handle.
+	(grub_efiemu_write_sym_markers): New function.
+	(grub_efiemu_set_virtual_address_map): Likewise.
+
+	Newer XNU parameters.
+
+	* include/grub/i386/xnu.h (GRUB_XNU_BOOTARGS_VERMINOR): Change to 5.
+	* include/grub/xnu.h (grub_xnu_extheader): Add nameaddr and namesize.
+	(grub_xnu_fill_devicetree): New prototype.
+	(grub_xnu_heap_real_start): New variable.
+	* loader/xnu.c (get_name_ptr): New function.
+	(grub_xnu_load_driver): Fill namelen and name.
+
+	64-bit xnu support.
+
+	* conf/i386-efi.rmk (xnu_mod_SOURCES): Add 'loader/macho32.c'
+	and 'loader/macho64.c'.
+	* conf/i386-pc.rmk: Likewise.
+	* conf/x86_64-efi.rmk: Likewise.
+	* include/grub/i386/macho.h (grub_macho_thread64): New structure.
+	* include/grub/xnu.h (grub_xnu_is_64bit): New variable.
+	* include/grub/macho.h (grub_macho_segment64): New structure.
+	* include/grub/machoload.h (grub_macho32_size): Renamed from ...
+	(grub_macho_size32): ... to this.
+	(grub_macho32_get_entry_point): Renamed from ...
+	(grub_macho_get_entry_point32): ... to this.
+	(grub_macho_contains_macho64): New prototype.
+	(grub_macho_size64): Likewise.
+	(grub_macho_get_entry_point64): Likewise.
+	(grub_macho32_load): Renamed from ...
+	(grub_macho_load32): ... to this.
+	(grub_macho32_filesize): Renamed from ...
+	(grub_macho_filesize32): ... to this.
+	(grub_macho32_readfile): Renamed from ...
+	(grub_macho_readfile32): ... to this.
+	(grub_macho_filesize64): New prototype.
+	(grub_macho_readfile64): Likewise.
+	(grub_macho_parse32): Likewise.
+	(grub_macho_parse64): Likewise.
+	* loader/macho.c: Split into ...
+	* loader/machoXX.c: ... and this. Replace 32 with XX.
+	* loader/macho32.c: New file.
+	* loader/macho64.c: Likewise.
+	* loader/xnu.c (grub_xnu_is_64bit): New variable.
+	(grub_cmd_xnu_kernel): Make 32-bit only.
+	(grub_cmd_xnu_kernel64): New function.
+	(grub_xnu_load_driver): Support Mach-O 64.
+	(grub_cmd_xnu_mkext): Likewise.
+	* util/grub.d/30_os-prober.in (osx_entry): New function.
+	Generate entries for 64-bit boot too.
+
+	Eliminate ad-hoc tree format in XNU and EfiEmu.
+
+	* efiemu/main.c (grub_efiemu_prepare): Update comment.
+	* efiemu/pnvram.c: Rewritten to use environment variables.
+	All users updated.
+
+	Inline utf16_to_utf8.
+
+	* kern/misc.c (grub_utf16_to_utf8): Move from here ...
+	* include/grub/charset.h (grub_utf16_to_utf8): ... to here. Inlined.
+	All users updated.
+	* include/grub/misc.h (grub_utf16_to_utf8): Removed.
+
+	* bus/usb/usb.c (grub_usb_get_string): Move from here ...
+	* commands/usbtest.c (grub_usb_get_string): ... move here.
+	(usb_print_str): Fix error handling.
+	* include/grub/usb.h (grub_usb_get_string): Remove.
+
+	UTF-8 to UTF-16 transformation.
+
+	* conf/common.rmk (pkglib_MODULES): Add charset.mod
+	(charset_mod_SOURCES): New variable.
+	(charset_mod_CFLAGS): Likewise.
+	(charset_mod_LDFLAGS): Likewise.
+	* include/grub/utf.h: New file.
+	* lib/utf.c: New file. (Based on grub_utf8_to_ucs4 from kern/misc.c)
+
+	Support for device properties.
+
+	* include/grub/i386/xnu.h (grub_xnu_devprop_header): New structure.
+	(grub_xnu_devprop_device_header): Likewise.
+	(grub_xnu_devprop_device_descriptor): Likewise.
+	(grub_xnu_devprop_add_device): New prototype.
+	(grub_xnu_devprop_remove_device): Likewise.
+	(grub_xnu_devprop_remove_property): Likewise.
+	(grub_xnu_devprop_add_property_utf8): Likewise.
+	(grub_xnu_devprop_add_property_utf16): Likewise.
+	(grub_cpu_xnu_init): Likewise.
+	(grub_cpu_xnu_fini): Likewise.
+	(grub_cpu_xnu_unload): Likewise.
+	* loader/i386/xnu.c (grub_xnu_devprop_device_descriptor): New structure.
+	(property_descriptor): Likewise.
+	(devices): New variable.
+	(grub_xnu_devprop_remove_property): New function.
+	(grub_xnu_devprop_add_device): Likewise.
+	(grub_xnu_devprop_remove_device): Likewise.
+	(grub_xnu_devprop_add_property): Likewise.
+	(grub_xnu_devprop_add_property_utf8): Likewise.
+	(grub_xnu_devprop_add_property_utf16): Likewise.
+	(hextoval): Likewise.
+	(grub_cpu_xnu_fill_devprop): Likewise.
+	(grub_cmd_devprop_load): Likewise.
+	(grub_xnu_boot): Call grub_cpu_xnu_fill_devprop,
+	grub_xnu_fill_devicetree, grub_xnu_fill_devicetree
+	(cmd_devprop_load): New variable.
+	(grub_cpu_xnu_init): New function.
+	(grub_cpu_xnu_fini): Likewise.
+	* loader/i386/xnu.c (grub_xnu_unload): Call grub_cpu_xnu_unload.
+	* loader/xnu.c (grub_xnu_parse_devtree): Remove.
+	(grub_cmd_xnu_devtree): Likewise.
+	(hextoval): New function.
+	(unescape): Likewise.
+	(grub_xnu_fill_devicetree): Likewise.
+
+	* util/grub.d/30_os-prober.in: Load devprop.bin. Don't load devtree.txt.
+	* util/i386/efi/grub-dumpdevtree: Generate devprop.bin.
+
+2009-12-18  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	Workaround for broken ATI VBE.
+
+	* video/i386/pc/vbe.c (last_set_mode): New variable.
+	(grub_vbe_set_video_mode): Set 'last_set_mode'.
+	(grub_vbe_get_video_mode): Use 'last_set_mode' if get_mode fails.
+	(grub_video_vbe_setup): Don't check for reserved flag.
+
+2009-12-17 Felix Zielcke <fzielcke@z-51.de>
+
+	* gendistlist.sh: Use POSIX compliant `!' instead of `-not' in
+	the `find' command.
+
 2009-12-16  Vladimir Serbinenko  <phcoder@gmail.com>
 
 	UUID support for HFS.
diff --git a/Makefile.in b/Makefile.in
index e1dd0876f..46b380cd5 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -484,8 +484,8 @@ genkernsyms.sh: genkernsyms.sh.in config.status
 	$(SHELL) ./config.status
 
 $(srcdir)/po/$(PACKAGE).pot: po/POTFILES po/POTFILES-shell
-	cd $(srcdir) && $(XGETTEXT) --from-code=utf-8 -o $@ -f $< --keyword=_ --keyword=N_
-	cd $(srcdir) && $(XGETTEXT) --from-code=utf-8 -o $@ -f po/POTFILES-shell -j --language=Shell
+	cd $(srcdir) && $(XGETTEXT) -ctranslate --from-code=utf-8 -o $@ -f $< --keyword=_ --keyword=N_
+	cd $(srcdir) && $(XGETTEXT) -ctranslate --from-code=utf-8 -o $@ -f po/POTFILES-shell -j --language=Shell
 
 $(foreach lang, $(LINGUAS), $(srcdir)/po/$(lang).po): po/$(PACKAGE).pot
 	$(MSGMERGE) -U $@ $^
diff --git a/NEWS b/NEWS
index bf7492c6d..cc725fd3b 100644
--- a/NEWS
+++ b/NEWS
@@ -1,7 +1,11 @@
-New in 1.97 - :
+New in 1.98:
+
+* Add grub-probe support for GNU/Hurd.
 
 * Add support for gettext.
 
+New in 1.97:
+
 * Add support for loading XNU (MacOS X kernel).
 
 * ACPI override support.
diff --git a/bus/usb/uhci.c b/bus/usb/uhci.c
index 0d3daa5f1..e83fccc1d 100644
--- a/bus/usb/uhci.c
+++ b/bus/usb/uhci.c
@@ -23,7 +23,6 @@
 #include <grub/usb.h>
 #include <grub/usbtrans.h>
 #include <grub/pci.h>
-#include <grub/cpu/pci.h>
 #include <grub/i386/io.h>
 #include <grub/time.h>
 
@@ -435,6 +434,7 @@ grub_uhci_transfer (grub_usb_controller_t dev,
   grub_uhci_td_t td_prev = NULL;
   grub_usb_err_t err = GRUB_USB_ERR_NONE;
   int i;
+  grub_uint64_t endtime;
 
   /* Allocate a queue head for the transfer queue.  */
   qh = grub_alloc_qh (u, GRUB_USB_TRANSACTION_TYPE_CONTROL);
@@ -483,6 +483,7 @@ grub_uhci_transfer (grub_usb_controller_t dev,
 
   /* Wait until either the transaction completed or an error
      occurred.  */
+  endtime = grub_get_time_ms () + 1000;
   for (;;)
     {
       grub_uhci_td_t errtd;
@@ -534,6 +535,13 @@ grub_uhci_transfer (grub_usb_controller_t dev,
 	     updated.  */
 	  grub_dprintf ("uhci", "transaction fallthrough\n");
 	}
+      if (grub_get_time_ms () > endtime)
+	{
+	  err = GRUB_USB_ERR_STALL;
+	  grub_dprintf ("uhci", "transaction timed out\n");
+	  goto fail;
+	}
+      grub_cpu_idle ();
     }
 
   grub_dprintf ("uhci", "transaction complete\n");
@@ -573,6 +581,7 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
   struct grub_uhci *u = (struct grub_uhci *) dev->data;
   int reg;
   unsigned int status;
+  grub_uint64_t endtime;
 
   grub_dprintf ("uhci", "enable=%d port=%d\n", enable, port);
 
@@ -595,6 +604,7 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
   status = grub_uhci_readreg16 (u, reg);
   grub_uhci_writereg16 (u, reg, status & ~(1 << 9));
   grub_dprintf ("uhci", "reset completed\n");
+  grub_millisleep (10);
 
   /* Enable the port.  */
   grub_uhci_writereg16 (u, reg, enable << 2);
@@ -602,7 +612,10 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
 
   grub_dprintf ("uhci", "waiting for the port to be enabled\n");
 
-  while (! (grub_uhci_readreg16 (u, reg) & (1 << 2)));
+  endtime = grub_get_time_ms () + 1000;
+  while (! (grub_uhci_readreg16 (u, reg) & (1 << 2)))
+    if (grub_get_time_ms () > endtime)
+      return grub_error (GRUB_ERR_IO, "UHCI Timed out");
 
   status = grub_uhci_readreg16 (u, reg);
   grub_dprintf ("uhci", ">3detect=0x%02x\n", status);
diff --git a/bus/usb/usb.c b/bus/usb/usb.c
index 310b8cc6a..8289185da 100644
--- a/bus/usb/usb.c
+++ b/bus/usb/usb.c
@@ -155,42 +155,6 @@ grub_usb_get_endpdescriptor (grub_usb_device_t usbdev, int addr)
   return NULL;
 }
 
-grub_usb_err_t
-grub_usb_get_string (grub_usb_device_t dev, grub_uint8_t index, int langid,
-		     char **string)
-{
-  struct grub_usb_desc_str descstr;
-  struct grub_usb_desc_str *descstrp;
-  grub_usb_err_t err;
-
-  /* Only get the length.  */
-  err = grub_usb_control_msg (dev, 1 << 7,
-			      0x06, (3 << 8) | index,
-			      langid, 1, (char *) &descstr);
-  if (err)
-    return err;
-
-  descstrp = grub_malloc (descstr.length);
-  if (! descstrp)
-    return GRUB_USB_ERR_INTERNAL;
-  err = grub_usb_control_msg (dev, 1 << 7,
-			      0x06, (3 << 8) | index,
-			      langid, descstr.length, (char *) descstrp);
-
-  *string = grub_malloc (descstr.length / 2);
-  if (! *string)
-    {
-      grub_free (descstrp);
-      return GRUB_USB_ERR_INTERNAL;
-    }
-
-  grub_utf16_to_utf8 ((grub_uint8_t *) *string, descstrp->str, descstrp->length / 2 - 1);
-  (*string)[descstr.length / 2 - 1] = '\0';
-  grub_free (descstrp);
-
-  return GRUB_USB_ERR_NONE;
-}
-
 grub_usb_err_t
 grub_usb_device_initialize (grub_usb_device_t dev)
 {
diff --git a/bus/usb/usbhub.c b/bus/usb/usbhub.c
index 6881ce000..a22ca60c2 100644
--- a/bus/usb/usbhub.c
+++ b/bus/usb/usbhub.c
@@ -48,7 +48,7 @@ grub_usb_hub_add_dev (grub_usb_controller_t controller, grub_usb_speed_t speed)
       if (! grub_usb_devs[i])
 	break;
     }
-  if (grub_usb_devs[i])
+  if (i == 128)
     {
       grub_error (GRUB_ERR_IO, "Can't assign address to USB device");
       return NULL;
@@ -60,6 +60,7 @@ grub_usb_hub_add_dev (grub_usb_controller_t controller, grub_usb_speed_t speed)
 			 | GRUB_USB_REQTYPE_TARGET_DEV),
 			GRUB_USB_REQ_SET_ADDRESS,
 			i, 0, 0, NULL);
+
   dev->addr = i;
   dev->initialized = 1;
   grub_usb_devs[i] = dev;
diff --git a/commands/acpi.c b/commands/acpi.c
index 1a7bf8018..c9acf5abe 100644
--- a/commands/acpi.c
+++ b/commands/acpi.c
@@ -36,23 +36,23 @@
 
 static const struct grub_arg_option options[] = {
   {"exclude", 'x', 0,
-   "Don't load host tables specified by comma-separated list",
+   "Don't load host tables specified by comma-separated list.",
    0, ARG_TYPE_STRING},
   {"load-only", 'n', 0,
-   "Load only tables specified by comma-separated list", 0, ARG_TYPE_STRING},
-  {"v1", '1', 0, "Expose v1 tables", 0, ARG_TYPE_NONE},
-  {"v2", '2', 0, "Expose v2 and v3 tables", 0, ARG_TYPE_NONE},
-  {"oemid", 'o', 0, "Set OEMID of RSDP, XSDT and RSDT", 0, ARG_TYPE_STRING},
+   "Load only tables specified by comma-separated list.", 0, ARG_TYPE_STRING},
+  {"v1", '1', 0, "Expose v1 tables.", 0, ARG_TYPE_NONE},
+  {"v2", '2', 0, "Expose v2 and v3 tables.", 0, ARG_TYPE_NONE},
+  {"oemid", 'o', 0, "Set OEMID of RSDP, XSDT and RSDT.", 0, ARG_TYPE_STRING},
   {"oemtable", 't', 0,
-   "Set OEMTABLE ID of RSDP, XSDT and RSDT", 0, ARG_TYPE_STRING},
+   "Set OEMTABLE ID of RSDP, XSDT and RSDT.", 0, ARG_TYPE_STRING},
   {"oemtablerev", 'r', 0,
-   "Set OEMTABLE revision of RSDP, XSDT and RSDT", 0, ARG_TYPE_INT},
+   "Set OEMTABLE revision of RSDP, XSDT and RSDT.", 0, ARG_TYPE_INT},
   {"oemtablecreator", 'c', 0,
-   "Set creator field of RSDP, XSDT and RSDT", 0, ARG_TYPE_STRING},
+   "Set creator field of RSDP, XSDT and RSDT.", 0, ARG_TYPE_STRING},
   {"oemtablecreatorrev", 'd', 0,
-   "Set creator revision of RSDP, XSDT and RSDT", 0, ARG_TYPE_INT},
-  {"no-ebda", 'e', 0, "Don't update EBDA. May fix failures or hangs on some"
-   " BIOSes but makes it ineffective with OS not receiving RSDP from GRUB",
+   "Set creator revision of RSDP, XSDT and RSDT.", 0, ARG_TYPE_INT},
+  {"no-ebda", 'e', 0, "Don't update EBDA. May fix failures or hangs on some."
+   " BIOSes but makes it ineffective with OS not receiving RSDP from GRUB.",
    0, ARG_TYPE_NONE},
   {0, 0, 0, 0, 0, 0}
 };
@@ -763,7 +763,7 @@ GRUB_MOD_INIT(acpi)
 			      "--load-only=table1,table2] filename1 "
 			      " [filename2] [...]",
 			      "Load host acpi tables and tables "
-			      "specified by arguments",
+			      "specified by arguments.",
 			      options);
 }
 
diff --git a/commands/boot.c b/commands/boot.c
index e77b5ceb8..fe0453b8a 100644
--- a/commands/boot.c
+++ b/commands/boot.c
@@ -186,7 +186,7 @@ GRUB_MOD_INIT(boot)
 {
   cmd_boot =
     grub_register_command ("boot", grub_cmd_boot,
-			   0, "boot an operating system");
+			   0, "Boot an operating system.");
 }
 
 GRUB_MOD_FINI(boot)
diff --git a/commands/cmp.c b/commands/cmp.c
index 1258b1d63..8a4b4158b 100644
--- a/commands/cmp.c
+++ b/commands/cmp.c
@@ -40,7 +40,7 @@ grub_cmd_cmp (grub_command_t cmd __attribute__ ((unused)),
   if (argc != 2)
     return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments required");
 
-  grub_printf ("Compare `%s' and `%s':\n", args[0],
+  grub_printf ("Compare file `%s' with `%s':\n", args[0],
 	       args[1]);
 
   file1 = grub_gzfile_open (args[0], 1);
@@ -49,7 +49,7 @@ grub_cmd_cmp (grub_command_t cmd __attribute__ ((unused)),
     goto cleanup;
 
   if (grub_file_size (file1) != grub_file_size (file2))
-    grub_printf ("Differ in size: %llu [%s], %llu [%s]\n",
+    grub_printf ("Files differ in size: %llu [%s], %llu [%s]\n",
 		 (unsigned long long) grub_file_size (file1), args[0],
 		 (unsigned long long) grub_file_size (file2), args[1]);
   else
@@ -76,7 +76,7 @@ grub_cmd_cmp (grub_command_t cmd __attribute__ ((unused)),
 	    {
 	      if (buf1[i] != buf2[i])
 		{
-		  grub_printf ("Differ at the offset %llu: 0x%x [%s], 0x%x [%s]\n",
+		  grub_printf ("Files differ at the offset %llu: 0x%x [%s], 0x%x [%s]\n",
 			       (unsigned long long) (i + pos), buf1[i], args[0],
 			       buf2[i], args[1]);
 		  goto cleanup;
diff --git a/commands/echo.c b/commands/echo.c
index 69aa3be3c..c9daf62f1 100644
--- a/commands/echo.c
+++ b/commands/echo.c
@@ -23,8 +23,8 @@
 
 static const struct grub_arg_option options[] =
   {
-    {0, 'n', 0, "do not output the trailing newline", 0, 0},
-    {0, 'e', 0, "enable interpretation of backslash escapes", 0, 0},
+    {0, 'n', 0, "Do not output the trailing newline.", 0, 0},
+    {0, 'e', 0, "Enable interpretation of backslash escapes.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
diff --git a/commands/efi/loadbios.c b/commands/efi/loadbios.c
index 23586b269..d7ad42690 100644
--- a/commands/efi/loadbios.c
+++ b/commands/efi/loadbios.c
@@ -46,7 +46,7 @@ enable_rom_area (void)
   rom_ptr = (grub_uint32_t *) VBIOS_ADDR;
   if (*rom_ptr != BLANK_MEM)
     {
-      grub_printf ("ROM image present.\n");
+      grub_printf ("ROM image is present.\n");
       return 0;
     }
 
@@ -63,7 +63,7 @@ enable_rom_area (void)
   *rom_ptr = 0;
   if (*rom_ptr != 0)
     {
-      grub_printf ("Can\'t enable rom area.\n");
+      grub_printf ("Can\'t enable ROM area.\n");
       return 0;
     }
 
@@ -201,7 +201,7 @@ static grub_command_t cmd_fakebios, cmd_loadbios;
 GRUB_MOD_INIT(loadbios)
 {
   cmd_fakebios = grub_register_command ("fakebios", grub_cmd_fakebios,
-					0, "fake bios.");
+					0, "Fake bios.");
 
   cmd_loadbios = grub_register_command ("loadbios", grub_cmd_loadbios,
 					"loadbios BIOS_DUMP [INT10_DUMP]",
diff --git a/commands/gptsync.c b/commands/gptsync.c
index a603746a2..8315faa53 100644
--- a/commands/gptsync.c
+++ b/commands/gptsync.c
@@ -246,7 +246,7 @@ GRUB_MOD_INIT(gptsync)
 			       "of hybrid mbr. Up to 3 partitions are "
 			       "allowed. TYPE is an MBR type. "
 			       "+ means that partition is active. "
-			       "Only one partition can be active");
+			       "Only one partition can be active.");
 }
 
 GRUB_MOD_FINI(gptsync)
diff --git a/commands/halt.c b/commands/halt.c
index 8fa8db5be..09431d3cb 100644
--- a/commands/halt.c
+++ b/commands/halt.c
@@ -35,8 +35,8 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(halt)
 {
   cmd = grub_register_command ("halt", grub_cmd_halt,
-			       0, "halts the computer.  This command does not"
-			       " work on all firmware.");
+			       0, "Halts the computer.  This command does not"
+			       " work on all firmware implementations.");
 }
 
 GRUB_MOD_FINI(halt)
diff --git a/commands/handler.c b/commands/handler.c
index 2070c391c..d65a703e4 100644
--- a/commands/handler.c
+++ b/commands/handler.c
@@ -96,15 +96,15 @@ GRUB_MOD_INIT(handler)
   cmd_handler =
     grub_register_command ("handler", grub_cmd_handler,
 			   "handler [class [handler]]",
-			   "List or select a handler");
+			   "List or select a handler.");
   cmd_terminal_input =
     grub_register_command ("terminal_input", grub_cmd_handler,
 			   "terminal_input [handler]",
-			   "List or select a handler");
+			   "List or select an input terminal.");
   cmd_terminal_output =
     grub_register_command ("terminal_output", grub_cmd_handler,
 			   "terminal_output [handler]",
-			   "List or select a handler");
+			   "List or select an output terminal.");
 }
 
 GRUB_MOD_FINI(handler)
diff --git a/commands/hdparm.c b/commands/hdparm.c
index 389954c45..458a447c7 100644
--- a/commands/hdparm.c
+++ b/commands/hdparm.c
@@ -26,27 +26,27 @@
 #include <grub/extcmd.h>
 
 static const struct grub_arg_option options[] = {
-  {"apm",             'B', 0, "set Advanced Power Management\n"
-			      "(1=low, ..., 254=high, 255=off)",
+  {"apm",             'B', 0, "Set Advanced Power Management\n"
+			      "(1=low, ..., 254=high, 255=off).",
 			      0, ARG_TYPE_INT},
-  {"power",           'C', 0, "check power mode", 0, ARG_TYPE_NONE},
-  {"security-freeze", 'F', 0, "freeze ATA security settings until reset",
+  {"power",           'C', 0, "Check power mode.", 0, ARG_TYPE_NONE},
+  {"security-freeze", 'F', 0, "Freeze ATA security settings until reset.",
 			      0, ARG_TYPE_NONE},
-  {"health",          'H', 0, "check SMART health status", 0, ARG_TYPE_NONE},
-  {"aam",             'M', 0, "set Automatic Acoustic Management\n"
-			      "(0=off, 128=quiet, ..., 254=fast)",
+  {"health",          'H', 0, "Check SMART health status.", 0, ARG_TYPE_NONE},
+  {"aam",             'M', 0, "Set Automatic Acoustic Management\n"
+			      "(0=off, 128=quiet, ..., 254=fast).",
 			      0, ARG_TYPE_INT},
-  {"standby-timeout", 'S', 0, "set standby timeout\n"
-			      "(0=off, 1=5s, 2=10s, ..., 240=20m, 241=30m, ...)",
+  {"standby-timeout", 'S', 0, "Set standby timeout\n"
+			      "(0=off, 1=5s, 2=10s, ..., 240=20m, 241=30m, ...).",
 			      0, ARG_TYPE_INT},
-  {"standby",         'y', 0, "set drive to standby mode", 0, ARG_TYPE_NONE},
-  {"sleep",           'Y', 0, "set drive to sleep mode", 0, ARG_TYPE_NONE},
-  {"identify",        'i', 0, "print drive identity and settings",
+  {"standby",         'y', 0, "Set drive to standby mode.", 0, ARG_TYPE_NONE},
+  {"sleep",           'Y', 0, "Set drive to sleep mode.", 0, ARG_TYPE_NONE},
+  {"identify",        'i', 0, "Print drive identity and settings.",
 			      0, ARG_TYPE_NONE},
-  {"dumpid",          'I', 0, "dump contents of ATA IDENTIFY sector",
+  {"dumpid",          'I', 0, "Dump contents of ATA IDENTIFY sector.",
 			       0, ARG_TYPE_NONE},
-  {"smart",            -1, 0, "disable/enable SMART (0/1)", 0, ARG_TYPE_INT},
-  {"quiet",           'q', 0, "do not print messages", 0, ARG_TYPE_NONE},
+  {"smart",            -1, 0, "Disable/enable SMART (0/1).", 0, ARG_TYPE_INT},
+  {"quiet",           'q', 0, "Do not print messages.", 0, ARG_TYPE_NONE},
   {0, 0, 0, 0, 0, 0}
 };
 
diff --git a/commands/hexdump.c b/commands/hexdump.c
index 4b3e3ef29..727deecbf 100644
--- a/commands/hexdump.c
+++ b/commands/hexdump.c
@@ -26,9 +26,9 @@
 #include <grub/extcmd.h>
 
 static const struct grub_arg_option options[] = {
-  {"skip", 's', 0, "skip offset bytes from the beginning of file.", 0,
+  {"skip", 's', 0, "Skip offset bytes from the beginning of file.", 0,
    ARG_TYPE_INT},
-  {"length", 'n', 0, "read only length bytes", 0, ARG_TYPE_INT},
+  {"length", 'n', 0, "Read only LENGTH bytes.", 0, ARG_TYPE_INT},
   {0, 0, 0, 0, 0, 0}
 };
 
diff --git a/commands/i386/cpuid.c b/commands/i386/cpuid.c
index a8bbfe69b..8097e7372 100644
--- a/commands/i386/cpuid.c
+++ b/commands/i386/cpuid.c
@@ -33,7 +33,7 @@
 
 static const struct grub_arg_option options[] =
   {
-    {"long-mode", 'l', 0, "check for long mode flag (default)", 0, 0},
+    {"long-mode", 'l', 0, "Check for long mode flag (default).", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
@@ -88,7 +88,7 @@ done:
 #endif
 
   cmd = grub_register_extcmd ("cpuid", grub_cmd_cpuid, GRUB_COMMAND_FLAG_BOTH,
-			      "cpuid [-l]", "Check for CPU features", options);
+			      "cpuid [-l]", "Check for CPU features.", options);
 }
 
 GRUB_MOD_FINI(cpuid)
diff --git a/commands/i386/pc/drivemap.c b/commands/i386/pc/drivemap.c
index 52424c3d1..991634df0 100644
--- a/commands/i386/pc/drivemap.c
+++ b/commands/i386/pc/drivemap.c
@@ -33,9 +33,9 @@ static grub_uint32_t *const int13slot = UINT_TO_PTR (4 * 0x13);
 
 /* Remember to update enum opt_idxs accordingly.  */
 static const struct grub_arg_option options[] = {
-  {"list", 'l', 0, "show the current mappings", 0, 0},
-  {"reset", 'r', 0, "reset all mappings to the default values", 0, 0},
-  {"swap", 's', 0, "perform both direct and reverse mappings", 0, 0},
+  {"list", 'l', 0, "Show the current mappings.", 0, 0},
+  {"reset", 'r', 0, "Reset all mappings to the default values.", 0, 0},
+  {"swap", 's', 0, "Perform both direct and reverse mappings.", 0, 0},
   {0, 0, 0, 0, 0, 0}
 };
 
@@ -404,7 +404,7 @@ GRUB_MOD_INIT (drivemap)
 					GRUB_COMMAND_FLAG_BOTH,
 					"drivemap"
 					" -l | -r | [-s] grubdev osdisk",
-					"Manage the BIOS drive mappings",
+					"Manage the BIOS drive mappings.",
 					options);
   drivemap_hook =
     grub_loader_register_preboot_hook (&install_int13_handler,
diff --git a/commands/i386/pc/halt.c b/commands/i386/pc/halt.c
index 344dcecd8..befd58804 100644
--- a/commands/i386/pc/halt.c
+++ b/commands/i386/pc/halt.c
@@ -23,7 +23,7 @@
 
 static const struct grub_arg_option options[] =
   {
-    {"no-apm", 'n', 0, "do not use APM to halt the computer", 0, 0},
+    {"no-apm", 'n', 0, "Do not use APM to halt the computer.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
@@ -47,7 +47,7 @@ GRUB_MOD_INIT(halt)
 {
   cmd = grub_register_extcmd ("halt", grub_cmd_halt, GRUB_COMMAND_FLAG_BOTH,
 			      "halt [-n]",
-			      "Halt the system, if possible using APM",
+			      "Halt the system, if possible using APM.",
 			      options);
 }
 
diff --git a/commands/i386/pc/play.c b/commands/i386/pc/play.c
index 23150ea1f..6020b825a 100644
--- a/commands/i386/pc/play.c
+++ b/commands/i386/pc/play.c
@@ -207,7 +207,7 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(play)
 {
   cmd = grub_register_command ("play", grub_cmd_play,
-			       "play FILE", "Play a tune");
+			       "play FILE", "Play a tune.");
 }
 
 GRUB_MOD_FINI(play)
diff --git a/commands/i386/pc/pxecmd.c b/commands/i386/pc/pxecmd.c
index df538704c..1817898c9 100644
--- a/commands/i386/pc/pxecmd.c
+++ b/commands/i386/pc/pxecmd.c
@@ -25,9 +25,9 @@
 
 static const struct grub_arg_option options[] =
 {
-    {"info", 'i', 0, "show PXE information.", 0, 0},
-    {"bsize", 'b', 0, "set PXE block size", 0, ARG_TYPE_INT},
-    {"unload", 'u', 0, "unload PXE stack.", 0, 0},
+    {"info", 'i', 0, "Show PXE information.", 0, 0},
+    {"bsize", 'b', 0, "Set PXE block size.", 0, ARG_TYPE_INT},
+    {"unload", 'u', 0, "Unload PXE stack.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
diff --git a/commands/i386/pc/vbetest.c b/commands/i386/pc/vbetest.c
index 314320d07..4050c869e 100644
--- a/commands/i386/pc/vbetest.c
+++ b/commands/i386/pc/vbetest.c
@@ -168,7 +168,7 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(vbetest)
 {
   cmd = grub_register_command ("vbetest", grub_cmd_vbetest,
-			       0, "Test VESA BIOS Extension 2.0+ support");
+			       0, "Test VESA BIOS Extension 2.0+ support.");
 }
 
 GRUB_MOD_FINI(vbetest)
diff --git a/commands/ieee1275/suspend.c b/commands/ieee1275/suspend.c
index 028dd3cd8..fd538f8ea 100644
--- a/commands/ieee1275/suspend.c
+++ b/commands/ieee1275/suspend.c
@@ -39,7 +39,7 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(ieee1275_suspend)
 {
   cmd = grub_register_command ("suspend", grub_cmd_suspend,
-			       0, "Return to Open Firmware prompt");
+			       0, "Return to Open Firmware prompt.");
 }
 
 GRUB_MOD_FINI(ieee1275_suspend)
diff --git a/commands/keystatus.c b/commands/keystatus.c
index 28ceb2d0b..0a4667645 100644
--- a/commands/keystatus.c
+++ b/commands/keystatus.c
@@ -24,9 +24,9 @@
 
 static const struct grub_arg_option options[] =
   {
-    {"shift", 's', 0, "check Shift key", 0, 0},
-    {"ctrl", 'c', 0, "check Control key", 0, 0},
-    {"alt", 'a', 0, "check Alt key", 0, 0},
+    {"shift", 's', 0, "Check Shift key.", 0, 0},
+    {"ctrl", 'c', 0, "Check Control key.", 0, 0},
+    {"alt", 'a', 0, "Check Alt key.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
@@ -71,7 +71,7 @@ GRUB_MOD_INIT(keystatus)
   cmd = grub_register_extcmd ("keystatus", grub_cmd_keystatus,
 			      GRUB_COMMAND_FLAG_BOTH,
 			      "keystatus [--shift] [--ctrl] [--alt]",
-			      "Check key modifier status",
+			      "Check key modifier status.",
 			      options);
 }
 
diff --git a/commands/loadenv.c b/commands/loadenv.c
index c60eb835c..c10dd0e27 100644
--- a/commands/loadenv.c
+++ b/commands/loadenv.c
@@ -29,7 +29,7 @@
 
 static const struct grub_arg_option options[] =
   {
-    {"file", 'f', 0, "specify filename", 0, ARG_TYPE_PATHNAME},
+    {"file", 'f', 0, "Specify filename.", 0, ARG_TYPE_PATHNAME},
     {0, 0, 0, 0, 0, 0}
   };
 
diff --git a/commands/ls.c b/commands/ls.c
index 15b4c6bab..6eaa1d59e 100644
--- a/commands/ls.c
+++ b/commands/ls.c
@@ -33,9 +33,9 @@
 
 static const struct grub_arg_option options[] =
   {
-    {"long", 'l', 0, "show a long list with more detailed information", 0, 0},
-    {"human-readable", 'h', 0, "print sizes in a human readable format", 0, 0},
-    {"all", 'a', 0, "list all files", 0, 0},
+    {"long", 'l', 0, "Show a long list with more detailed information.", 0, 0},
+    {"human-readable", 'h', 0, "Print sizes in a human readable format.", 0, 0},
+    {"all", 'a', 0, "List all files.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
diff --git a/commands/lspci.c b/commands/lspci.c
index bcaafa4f8..559bb8242 100644
--- a/commands/lspci.c
+++ b/commands/lspci.c
@@ -20,7 +20,7 @@
 #include <grub/pci.h>
 #include <grub/dl.h>
 #include <grub/misc.h>
-#include <grub/command.h>
+#include <grub/extcmd.h>
 
 struct grub_pci_classname
 {
@@ -84,6 +84,7 @@ static const struct grub_pci_classname grub_pci_classes[] =
     { 11, 0x30, "MIPS Processor" },
     { 11, 0x40, "Co-Processor" },
     { 11, 0x80, "Unknown Processor" },
+    { 12, 3, "USB Controller" },
     { 12, 0x80, "Serial Bus Controller" },
     { 13, 0x80, "Wireless Controller" },
     { 14, 0, "I2O" },
@@ -114,12 +115,21 @@ grub_pci_get_class (int class, int subclass)
   return 0;
 }
 
+static const struct grub_arg_option options[] =
+  {
+    {"iospace", 'i', 0, "show I/O spaces", 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static int iospace;
+
 static int NESTED_FUNC_ATTR
 grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 {
   grub_uint32_t class;
   const char *sclass;
   grub_pci_address_t addr;
+  int reg;
 
   grub_printf ("%02x:%02x.%x %04x:%04x", grub_pci_get_bus (dev),
 	       grub_pci_get_device (dev), grub_pci_get_function (dev),
@@ -143,27 +153,75 @@ grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 
   grub_printf ("\n");
 
+  if (iospace)
+    {
+      reg = 4;
+      while (reg < 10)
+	{
+	  grub_uint64_t space;
+	  addr = grub_pci_make_address (dev, reg);
+	  space = grub_pci_read (addr);
+
+	  reg++;
+	  
+	  if (space == 0)
+	    continue;
+	  
+	  switch (space & GRUB_PCI_ADDR_SPACE_MASK)
+	    {
+	    case GRUB_PCI_ADDR_SPACE_IO:
+	      grub_printf ("\tIO space %d at 0x%llx\n", (reg - 1) - 4,
+			   (unsigned long long)
+			   (space & GRUB_PCI_ADDR_IO_MASK));
+	      break;
+	    case GRUB_PCI_ADDR_SPACE_MEMORY:
+	      if ((space & GRUB_PCI_ADDR_MEM_TYPE_MASK) 
+		  == GRUB_PCI_ADDR_MEM_TYPE_64)
+		{
+		  addr = grub_pci_make_address (dev, reg);
+		  space |= ((grub_uint64_t) grub_pci_read (addr)) << 32;
+		  reg++;
+		  grub_printf ("\t64-bit memory space %d at 0x%016llx [%s]\n",
+			       (reg - 2) - 4, (unsigned long long)
+			       (space & GRUB_PCI_ADDR_MEM_MASK),
+			       space & GRUB_PCI_ADDR_MEM_PREFETCH
+			       ? "prefetchable" : "non-prefetchable");
+		  
+		}
+	      else
+		grub_printf ("\t32-bit memory space %d at 0x%016llx [%s]\n",
+			     (reg - 1) - 4, (unsigned long long) 
+			     (space & GRUB_PCI_ADDR_MEM_MASK),
+			     space & GRUB_PCI_ADDR_MEM_PREFETCH
+			     ? "prefetchable" : "non-prefetchable");
+	      break;
+	    }
+	}
+    }
+
+
   return 0;
 }
 
 static grub_err_t
-grub_cmd_lspci (grub_command_t cmd __attribute__ ((unused)),
+grub_cmd_lspci (grub_extcmd_t cmd,
 		int argc __attribute__ ((unused)),
 		char **args __attribute__ ((unused)))
 {
+  iospace = cmd->state[0].set;
   grub_pci_iterate (grub_lspci_iter);
   return GRUB_ERR_NONE;
 }
 
-static grub_command_t cmd;
+static grub_extcmd_t cmd;
 
 GRUB_MOD_INIT(lspci)
 {
-  cmd = grub_register_command ("lspci", grub_cmd_lspci,
-			       0, "List PCI devices");
+  cmd = grub_register_extcmd ("lspci", grub_cmd_lspci, GRUB_COMMAND_FLAG_BOTH,
+			      "lspci [-i]", "List PCI devices.", options);
 }
 
 GRUB_MOD_FINI(lspci)
 {
-  grub_unregister_command (cmd);
+  grub_unregister_extcmd (cmd);
 }
diff --git a/commands/memrw.c b/commands/memrw.c
index adffb7fc8..f43380f04 100644
--- a/commands/memrw.c
+++ b/commands/memrw.c
@@ -71,22 +71,22 @@ GRUB_MOD_INIT(memrw)
 {
   cmd_read_byte =
     grub_register_command ("read_byte", grub_cmd_read,
-			   "read_byte ADDR", "read byte.");
+			   "read_byte ADDR", "Read byte from ADDR.");
   cmd_read_word =
     grub_register_command ("read_word", grub_cmd_read,
-			   "read_word ADDR", "read word.");
+			   "read_word ADDR", "Read word from ADDR.");
   cmd_read_dword =
     grub_register_command ("read_dword", grub_cmd_read,
-			   "read_dword ADDR", "read dword.");
+			   "read_dword ADDR", "Read dword from ADDR.");
   cmd_write_byte =
     grub_register_command ("write_byte", grub_cmd_write,
-			   "write_byte ADDR VALUE", "write byte.");
+			   "write_byte ADDR VALUE", "Write byte VALUE to ADDR.");
   cmd_write_word =
     grub_register_command ("write_word", grub_cmd_write,
-			   "write_word ADDR VALUE", "write word.");
+			   "write_word ADDR VALUE", "Write word VALUE to ADDR.");
   cmd_write_dword =
     grub_register_command ("write_dword", grub_cmd_write,
-			   "write_dword ADDR VALUE", "write dword.");
+			   "write_dword ADDR VALUE", "Write dword VALUE to ADDR.");
 }
 
 GRUB_MOD_FINI(memrw)
diff --git a/commands/minicmd.c b/commands/minicmd.c
index 6c9c33a0e..9e06fa5de 100644
--- a/commands/minicmd.c
+++ b/commands/minicmd.c
@@ -354,28 +354,28 @@ GRUB_MOD_INIT(minicmd)
 {
   cmd_cat =
     grub_register_command ("cat", grub_mini_cmd_cat,
-			   "cat FILE", "show the contents of a file");
+			   "cat FILE", "Show the contents of a file.");
   cmd_help =
     grub_register_command ("help", grub_mini_cmd_help,
-			   0, "show this message");
+			   0, "Show this message.");
   cmd_root =
     grub_register_command ("root", grub_mini_cmd_root,
-			   "root [DEVICE]", "set the root device");
+			   "root [DEVICE]", "Set the root device.");
   cmd_dump =
     grub_register_command ("dump", grub_mini_cmd_dump,
-			   "dump ADDR", "dump memory");
+			   "dump ADDR", "Dump memory.");
   cmd_rmmod =
     grub_register_command ("rmmod", grub_mini_cmd_rmmod,
-			   "rmmod MODULE", "remove a module");
+			   "rmmod MODULE", "Remove a module.");
   cmd_lsmod =
     grub_register_command ("lsmod", grub_mini_cmd_lsmod,
-			   0, "show loaded modules");
+			   0, "Show loaded modules.");
   cmd_exit =
     grub_register_command ("exit", grub_mini_cmd_exit,
-			   0, "exit from GRUB");
+			   0, "Exit from GRUB.");
   cmd_clear =
     grub_register_command ("clear", grub_mini_cmd_clear,
-			   0, "clear the screen");
+			   0, "Clear the screen.");
 }
 
 GRUB_MOD_FINI(minicmd)
diff --git a/commands/parttool.c b/commands/parttool.c
index 8c985fc4b..473652cec 100644
--- a/commands/parttool.c
+++ b/commands/parttool.c
@@ -34,9 +34,9 @@ static struct grub_parttool *parts = 0;
 static int curhandle = 0;
 static grub_dl_t mymod;
 static char helpmsg[] =
-  "perform COMMANDS on partition.\n"
+  "Perform COMMANDS on partition.\n"
   "Use \"parttool PARTITION help\" for the list "
-  "of available commands";
+  "of available commands.";
 
 int
 grub_parttool_register(const char *part_name,
diff --git a/commands/probe.c b/commands/probe.c
index fabdb2a4a..0acbf30f4 100644
--- a/commands/probe.c
+++ b/commands/probe.c
@@ -34,12 +34,12 @@
 static const struct grub_arg_option options[] = 
   {
     {"set",             's', GRUB_ARG_OPTION_OPTIONAL,
-     "set a variable to return value", "VAR", ARG_TYPE_STRING},
-    {"driver",		'd', 0, "determine driver", 0, 0},
-    {"partmap",		'p', 0, "determine partition map type", 0, 0},
-    {"fs",		'f', 0, "determine filesystem type", 0, 0},
-    {"fs-uuid",		'u', 0, "determine filesystem UUID", 0, 0},
-    {"label",		'l', 0, "determine filesystem label", 0, 0},
+     "Set a variable to return value.", "VAR", ARG_TYPE_STRING},
+    {"driver",		'd', 0, "Determine driver.", 0, 0},
+    {"partmap",		'p', 0, "Determine partition map type.", 0, 0},
+    {"fs",		'f', 0, "Determine filesystem type.", 0, 0},
+    {"fs-uuid",		'u', 0, "Determine filesystem UUID.", 0, 0},
+    {"label",		'l', 0, "Determine filesystem label.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
diff --git a/commands/read.c b/commands/read.c
index 82b30b461..270b7bd77 100644
--- a/commands/read.c
+++ b/commands/read.c
@@ -62,7 +62,7 @@ grub_getline (void)
 }
 
 static grub_err_t
-grub_cmd_read (grub_command_t cmd UNUSED, int argc, char **args)
+grub_cmd_read (grub_command_t cmd __attribute__ ((unused)), int argc, char **args)
 {
   char *line = grub_getline ();
   if (! line)
@@ -80,7 +80,7 @@ GRUB_MOD_INIT(read)
 {
   cmd = grub_register_command ("read", grub_cmd_read,
 			       "read [ENVVAR]",
-			       "Set variable with user input");
+			       "Set variable with user input.");
 }
 
 GRUB_MOD_FINI(read)
diff --git a/commands/reboot.c b/commands/reboot.c
index 86c9e2dd9..2add295ef 100644
--- a/commands/reboot.c
+++ b/commands/reboot.c
@@ -35,7 +35,7 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(reboot)
 {
   cmd = grub_register_command ("reboot", grub_cmd_reboot,
-			       0, "Reboot the computer");
+			       0, "Reboot the computer.");
 }
 
 GRUB_MOD_FINI(reboot)
diff --git a/commands/search.c b/commands/search.c
index 0cfd0ebbc..2907daa9f 100644
--- a/commands/search.c
+++ b/commands/search.c
@@ -29,11 +29,11 @@
 
 static const struct grub_arg_option options[] =
   {
-    {"file",		'f', 0, "search devices by a file", 0, 0},
-    {"label",		'l', 0, "search devices by a filesystem label", 0, 0},
-    {"fs-uuid",		'u', 0, "search devices by a filesystem UUID", 0, 0},
-    {"set",		's', GRUB_ARG_OPTION_OPTIONAL, "set a variable to the first device found", "VAR", ARG_TYPE_STRING},
-    {"no-floppy",	'n', 0, "do not probe any floppy drive", 0, 0},
+    {"file",		'f', 0, "Search devices by a file.", 0, 0},
+    {"label",		'l', 0, "Search devices by a filesystem label.", 0, 0},
+    {"fs-uuid",		'u', 0, "Search devices by a filesystem UUID.", 0, 0},
+    {"set",		's', GRUB_ARG_OPTION_OPTIONAL, "Set a variable to the first device found.", "VAR", ARG_TYPE_STRING},
+    {"no-floppy",	'n', 0, "Do not probe any floppy drive.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
diff --git a/commands/sleep.c b/commands/sleep.c
index c9d533369..9207b60a7 100644
--- a/commands/sleep.c
+++ b/commands/sleep.c
@@ -27,8 +27,8 @@
 
 static const struct grub_arg_option options[] =
   {
-    {"verbose", 'v', 0, "verbose countdown", 0, 0},
-    {"interruptible", 'i', 0, "interruptible with ESC", 0, 0},
+    {"verbose", 'v', 0, "Verbose countdown.", 0, 0},
+    {"interruptible", 'i', 0, "Interruptible with ESC.", 0, 0},
     {0, 0, 0, 0, 0, 0}
   };
 
@@ -106,7 +106,7 @@ GRUB_MOD_INIT(sleep)
 {
   cmd = grub_register_extcmd ("sleep", grub_cmd_sleep, GRUB_COMMAND_FLAG_BOTH,
 			      "sleep NUMBER_OF_SECONDS",
-			      "Wait for a specified number of seconds",
+			      "Wait for a specified number of seconds.",
 			      options);
 }
 
diff --git a/commands/test.c b/commands/test.c
index 9c813c820..84b4279ea 100644
--- a/commands/test.c
+++ b/commands/test.c
@@ -420,9 +420,9 @@ static grub_command_t cmd_1, cmd_2;
 GRUB_MOD_INIT(test)
 {
   cmd_1 = grub_register_command ("[", grub_cmd_test,
-				 "[ EXPRESSION ]", "Evaluate an expression");
+				 "[ EXPRESSION ]", "Evaluate an expression.");
   cmd_2 = grub_register_command ("test", grub_cmd_test,
-				 "test EXPRESSION", "Evaluate an expression");
+				 "test EXPRESSION", "Evaluate an expression.");
 }
 
 GRUB_MOD_FINI(test)
diff --git a/commands/true.c b/commands/true.c
index 16ca31579..ef9f65889 100644
--- a/commands/true.c
+++ b/commands/true.c
@@ -43,10 +43,10 @@ GRUB_MOD_INIT(true)
 {
   cmd_true =
     grub_register_command ("true", grub_cmd_true,
-			   0, "do nothing, successfully");
+			   0, "Do nothing, successfully.");
   cmd_false =
     grub_register_command ("false", grub_cmd_false,
-			   0, "do nothing, unsuccessfully");
+			   0, "Do nothing, unsuccessfully.");
 }
 
 GRUB_MOD_FINI(true)
diff --git a/commands/usbtest.c b/commands/usbtest.c
index 018c1a25b..df124ca18 100644
--- a/commands/usbtest.c
+++ b/commands/usbtest.c
@@ -19,6 +19,7 @@
 
 #include <grub/types.h>
 #include <grub/misc.h>
+#include <grub/charset.h>
 #include <grub/mm.h>
 #include <grub/err.h>
 #include <grub/dl.h>
@@ -59,18 +60,60 @@ static const char *usb_devspeed[] =
     "High"
   };
 
+static grub_usb_err_t
+grub_usb_get_string (grub_usb_device_t dev, grub_uint8_t index, int langid,
+		     char **string)
+{
+  struct grub_usb_desc_str descstr;
+  struct grub_usb_desc_str *descstrp;
+  grub_usb_err_t err;
+
+  /* Only get the length.  */
+  err = grub_usb_control_msg (dev, 1 << 7,
+			      0x06, (3 << 8) | index,
+			      langid, 1, (char *) &descstr);
+  if (err)
+    return err;
+
+  descstrp = grub_malloc (descstr.length);
+  if (! descstrp)
+    return GRUB_USB_ERR_INTERNAL;
+  err = grub_usb_control_msg (dev, 1 << 7,
+			      0x06, (3 << 8) | index,
+			      langid, descstr.length, (char *) descstrp);
+
+  *string = grub_malloc (descstr.length / 2);
+  if (! *string)
+    {
+      grub_free (descstrp);
+      return GRUB_USB_ERR_INTERNAL;
+    }
+
+  grub_utf16_to_utf8 ((grub_uint8_t *) *string, descstrp->str, descstrp->length / 2 - 1);
+  (*string)[descstr.length / 2 - 1] = '\0';
+  grub_free (descstrp);
+
+  return GRUB_USB_ERR_NONE;
+}
+
 static void
 usb_print_str (const char *description, grub_usb_device_t dev, int idx)
 {
   char *name;
+  grub_usb_err_t err;
   /* XXX: LANGID  */
 
   if (! idx)
     return;
 
-  grub_usb_get_string (dev, idx, 0x0409, &name);
-  grub_printf ("%s: `%s'\n", description, name);
-  grub_free (name);
+  err = grub_usb_get_string (dev, idx, 0x0409, &name);
+  if (err)
+    grub_printf ("Error %d retrieving %s\n", err, description);
+  else
+    {
+      grub_printf ("%s: `%s'\n", description, name);
+      grub_free (name);
+    }
 }
 
 static int
@@ -152,7 +195,7 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(usbtest)
 {
   cmd = grub_register_command ("usb", grub_cmd_usbtest,
-			       0, "Test USB support");
+			       0, "Test USB support.");
 }
 
 GRUB_MOD_FINI(usbtest)
diff --git a/commands/videotest.c b/commands/videotest.c
index fe504ee7b..33b46e229 100644
--- a/commands/videotest.c
+++ b/commands/videotest.c
@@ -181,7 +181,7 @@ static grub_command_t cmd;
 GRUB_MOD_INIT(videotest)
 {
   cmd = grub_register_command ("videotest", grub_cmd_videotest,
-			       0, "Test video subsystem");
+			       0, "Test video subsystem.");
 }
 
 GRUB_MOD_FINI(videotest)
diff --git a/conf/common.rmk b/conf/common.rmk
index 56f17e4e7..1ed30a404 100644
--- a/conf/common.rmk
+++ b/conf/common.rmk
@@ -638,3 +638,8 @@ pkglib_MODULES += setjmp.mod
 setjmp_mod_SOURCES = lib/$(target_cpu)/setjmp.S
 setjmp_mod_ASFLAGS = $(COMMON_ASFLAGS)
 setjmp_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += charset.mod
+charset_mod_SOURCES = lib/charset.c
+charset_mod_CFLAGS = $(COMMON_CFLAGS)
+charset_mod_LDFLAGS = $(COMMON_LDFLAGS)
diff --git a/conf/i386-efi.rmk b/conf/i386-efi.rmk
index a037ed383..5869ca554 100644
--- a/conf/i386-efi.rmk
+++ b/conf/i386-efi.rmk
@@ -155,7 +155,7 @@ efi_gop_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 pkglib_MODULES += xnu.mod
 xnu_mod_SOURCES = loader/xnu_resume.c loader/i386/xnu.c \
-	 loader/macho.c loader/xnu.c
+	loader/macho32.c loader/macho64.c loader/macho.c loader/xnu.c
 xnu_mod_CFLAGS = $(COMMON_CFLAGS)
 xnu_mod_LDFLAGS = $(COMMON_LDFLAGS)
 xnu_mod_ASFLAGS = $(COMMON_ASFLAGS)
diff --git a/conf/i386-pc.rmk b/conf/i386-pc.rmk
index b71a7edc0..2aee9e678 100644
--- a/conf/i386-pc.rmk
+++ b/conf/i386-pc.rmk
@@ -184,7 +184,7 @@ linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 pkglib_MODULES += xnu.mod
 xnu_mod_SOURCES = loader/xnu_resume.c loader/i386/xnu.c \
-	 loader/macho.c loader/xnu.c
+	 loader/macho32.c loader/macho64.c loader/macho.c loader/xnu.c
 xnu_mod_CFLAGS = $(COMMON_CFLAGS)
 xnu_mod_LDFLAGS = $(COMMON_LDFLAGS)
 xnu_mod_ASFLAGS = $(COMMON_ASFLAGS)
diff --git a/conf/x86_64-efi.rmk b/conf/x86_64-efi.rmk
index 6db52f480..de45a9f86 100644
--- a/conf/x86_64-efi.rmk
+++ b/conf/x86_64-efi.rmk
@@ -161,7 +161,7 @@ efi_gop_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 pkglib_MODULES += xnu.mod
 xnu_mod_SOURCES = loader/xnu_resume.c loader/i386/xnu.c \
-	 loader/macho.c loader/xnu.c
+	loader/macho32.c loader/macho64.c loader/macho.c loader/xnu.c
 xnu_mod_CFLAGS = $(COMMON_CFLAGS)
 xnu_mod_LDFLAGS = $(COMMON_LDFLAGS)
 xnu_mod_ASFLAGS = $(COMMON_ASFLAGS)
diff --git a/efiemu/main.c b/efiemu/main.c
index b5608e666..05787284d 100644
--- a/efiemu/main.c
+++ b/efiemu/main.c
@@ -39,6 +39,7 @@ grub_efi_system_table64_t *grub_efiemu_system_table64 = 0;
 static struct grub_efiemu_prepare_hook *efiemu_prepare_hooks = 0;
 /* Linked list of configuration tables */
 static struct grub_efiemu_configuration_table *efiemu_config_tables = 0;
+static int prepared = 0;
 
 /* Free all allocated space */
 grub_err_t
@@ -70,6 +71,8 @@ grub_efiemu_unload (void)
     }
   efiemu_prepare_hooks = 0;
 
+  prepared = 0;
+
   return GRUB_ERR_NONE;
 }
 
@@ -277,14 +280,19 @@ grub_efiemu_prepare (void)
 {
   grub_err_t err;
 
+  if (prepared)
+    return GRUB_ERR_NONE;
+
   grub_dprintf ("efiemu", "Preparing %d-bit efiemu\n",
 		8 * grub_efiemu_sizeof_uintn_t ());
 
   err = grub_efiemu_autocore ();
 
-  /* Create NVRAM if not yet done. */
+  /* Create NVRAM. */
   grub_efiemu_pnvram ();
 
+  prepared = 1;
+
   if (grub_efiemu_sizeof_uintn_t () == 4)
     return grub_efiemu_prepare32 (efiemu_prepare_hooks, efiemu_config_tables);
   else
@@ -316,9 +324,6 @@ grub_cmd_efiemu_load (grub_command_t cmd __attribute__ ((unused)),
 
 static grub_command_t cmd_loadcore, cmd_prepare, cmd_unload;
 
-void
-grub_efiemu_pnvram_cmd_register (void);
-
 GRUB_MOD_INIT(efiemu)
 {
   cmd_loadcore = grub_register_command ("efiemu_loadcore",
@@ -332,7 +337,6 @@ GRUB_MOD_INIT(efiemu)
   cmd_unload = grub_register_command ("efiemu_unload", grub_cmd_efiemu_unload,
 				      "efiemu_unload",
 				      "Unload  EFI emulator");
-  grub_efiemu_pnvram_cmd_register ();
 }
 
 GRUB_MOD_FINI(efiemu)
@@ -340,5 +344,4 @@ GRUB_MOD_FINI(efiemu)
   grub_unregister_command (cmd_loadcore);
   grub_unregister_command (cmd_prepare);
   grub_unregister_command (cmd_unload);
-  grub_efiemu_pnvram_cmd_unregister ();
 }
diff --git a/efiemu/pnvram.c b/efiemu/pnvram.c
index 04ad6e284..7af01c055 100644
--- a/efiemu/pnvram.c
+++ b/efiemu/pnvram.c
@@ -22,6 +22,7 @@
 #include <grub/normal.h>
 #include <grub/mm.h>
 #include <grub/misc.h>
+#include <grub/charset.h>
 #include <grub/efiemu/efiemu.h>
 #include <grub/efiemu/runtime.h>
 #include <grub/extcmd.h>
@@ -34,62 +35,184 @@ static int timezone_handle = 0;
 static int accuracy_handle = 0;
 static int daylight_handle = 0;
 
-/* Temporary place */
-static grub_uint8_t *nvram;
 static grub_size_t nvramsize;
-static grub_uint32_t high_monotonic_count;
-static grub_int16_t timezone;
-static grub_uint8_t daylight;
-static grub_uint32_t accuracy;
-
-static const struct grub_arg_option options[] = {
-  {"size", 's', 0, "number of bytes to reserve for pseudo NVRAM", 0,
-   ARG_TYPE_INT},
-  {"high-monotonic-count", 'm', 0,
-   "Initial value of high monotonic count", 0, ARG_TYPE_INT},
-  {"timezone", 't', 0,
-   "Timezone, offset in minutes from GMT", 0, ARG_TYPE_INT},
-  {"accuracy", 'a', 0,
-   "Accuracy of clock, in 1e-12 units", 0, ARG_TYPE_INT},
-  {"daylight", 'd', 0,
-   "Daylight value, as per EFI specifications", 0, ARG_TYPE_INT},
-  {0, 0, 0, 0, 0, 0}
-};
 
 /* Parse signed value */
 static int
-grub_strtosl (char *arg, char **end, int base)
+grub_strtosl (const char *arg, char **end, int base)
 {
   if (arg[0] == '-')
     return -grub_strtoul (arg + 1, end, base);
   return grub_strtoul (arg, end, base);
 }
 
+static inline int
+hextoval (char c)
+{
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'a' && c <= 'z')
+    return c - 'a' + 10;
+  if (c >= 'A' && c <= 'Z')
+    return c - 'A' + 10;
+  return 0;
+}
+
+static inline grub_err_t
+unescape (char *in, char *out, char *outmax, int *len)
+{
+  char *ptr, *dptr;
+  dptr = out;
+  for (ptr = in; *ptr && dptr < outmax; )
+    if (*ptr == '%' && ptr[1] && ptr[2])
+      {
+	*dptr = (hextoval (ptr[1]) << 4) | (hextoval (ptr[2]));
+	ptr += 3;
+	dptr++;
+      }
+    else
+      {
+	*dptr = *ptr;
+	ptr++;
+	dptr++;
+      }
+  if (dptr == outmax)
+    return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+		       "Too many NVRAM variables for reserved variable space."
+		       " Try increasing EfiEmu.pnvram.size.");
+  *len = dptr - out;
+  return 0;
+}
+
 /* Export stuff for efiemu */
 static grub_err_t
 nvram_set (void * data __attribute__ ((unused)))
 {
+  const char *env;
   /* Take definitive pointers */
-  grub_uint8_t *nvram_def = grub_efiemu_mm_obtain_request (nvram_handle);
+  char *nvram = grub_efiemu_mm_obtain_request (nvram_handle);
   grub_uint32_t *nvramsize_def
     = grub_efiemu_mm_obtain_request (nvramsize_handle);
-  grub_uint32_t *high_monotonic_count_def
+  grub_uint32_t *high_monotonic_count
     = grub_efiemu_mm_obtain_request (high_monotonic_count_handle);
-  grub_int16_t *timezone_def
+  grub_int16_t *timezone
     = grub_efiemu_mm_obtain_request (timezone_handle);
-  grub_uint8_t *daylight_def
+  grub_uint8_t *daylight
     = grub_efiemu_mm_obtain_request (daylight_handle);
-  grub_uint32_t *accuracy_def
+  grub_uint32_t *accuracy
     = grub_efiemu_mm_obtain_request (accuracy_handle);
+  char *nvramptr;
+
+  auto int iterate_env (struct grub_env_var *var);
+  int iterate_env (struct grub_env_var *var)
+  {
+    char *guid, *attr, *name, *varname;
+    struct efi_variable *efivar;
+    int len = 0;
+    int i;
+    grub_uint64_t guidcomp;
+
+    if (grub_memcmp (var->name, "EfiEmu.pnvram.",
+		     sizeof ("EfiEmu.pnvram.") - 1) != 0)
+      return 0;
+
+    guid = var->name + sizeof ("EfiEmu.pnvram.") - 1;
+
+    attr = grub_strchr (guid, '.');
+    if (!attr)
+      return 0;
+    attr++;
+
+    name = grub_strchr (attr, '.');
+    if (!name)
+      return 0;
+    name++;
+
+    efivar = (struct efi_variable *) nvramptr;
+    if (nvramptr - nvram + sizeof (struct efi_variable) > nvramsize)
+      {
+	grub_error (GRUB_ERR_OUT_OF_MEMORY,
+		    "Too many NVRAM variables for reserved variable space."
+		    " Try increasing EfiEmu.pnvram.size.");
+	return 1;
+      }
+
+    nvramptr += sizeof (struct efi_variable);
+
+    efivar->guid.data1 = grub_cpu_to_le32 (grub_strtoul (guid, &guid, 16));
+    if (*guid != '-')
+      return 0;
+    guid++;
+
+    efivar->guid.data2 = grub_cpu_to_le16 (grub_strtoul (guid, &guid, 16));
+    if (*guid != '-')
+      return 0;
+    guid++;
+
+    efivar->guid.data3 = grub_cpu_to_le16 (grub_strtoul (guid, &guid, 16));
+    if (*guid != '-')
+      return 0;
+    guid++;
+
+    guidcomp = grub_strtoull (guid, 0, 16);
+    for (i = 0; i < 8; i++)
+      efivar->guid.data4[i] = (guidcomp >> (56 - 8 * i)) & 0xff;
+
+    efivar->attributes = grub_strtoull (attr, 0, 16);
+
+    varname = grub_malloc (grub_strlen (name) + 1);
+    if (! varname)
+      return 1;
+
+    if (unescape (name, varname, varname + grub_strlen (name) + 1, &len))
+      return 1;
+
+    len = grub_utf8_to_utf16 ((grub_uint16_t *) nvramptr,
+			      (nvramsize - (nvramptr - nvram)) / 2,
+			      (grub_uint8_t *) varname, len, NULL);
+
+    if (len < 0)
+      {
+	grub_error (GRUB_ERR_BAD_ARGUMENT, "Broken UTF-8 in variable name\n");
+	return 1;
+      }
+
+    nvramptr += 2 * len;
+    *((grub_uint16_t *) nvramptr) = 0;
+    nvramptr += 2;
+    efivar->namelen = 2 * len + 2;
+
+    if (unescape (var->value, nvramptr, nvram + nvramsize, &len))
+      {
+	efivar->namelen = 0;
+	return 1;
+      }
+
+    nvramptr += len;
+
+    efivar->size = len;
+
+    return 0;
+  }
 
   /* Copy to definitive loaction */
   grub_dprintf ("efiemu", "preparing pnvram\n");
-  grub_memcpy (nvram_def, nvram, nvramsize);
+
+  env = grub_env_get ("EfiEmu.pnvram.high_monotonic_count");
+  *high_monotonic_count = env ? grub_strtoul (env, 0, 0) : 1;
+  env = grub_env_get ("EfiEmu.pnvram.timezone");
+  *timezone = env ? grub_strtosl (env, 0, 0) : GRUB_EFI_UNSPECIFIED_TIMEZONE;
+  env = grub_env_get ("EfiEmu.pnvram.accuracy");
+  *accuracy = env ? grub_strtoul (env, 0, 0) : 50000000;
+  env = grub_env_get ("EfiEmu.pnvram.daylight");
+  *daylight = env ? grub_strtoul (env, 0, 0) : 0;
+
+  nvramptr = nvram;
+  grub_memset (nvram, 0, nvramsize);
+  grub_env_iterate (iterate_env);
+  if (grub_errno)
+    return grub_errno;
   *nvramsize_def = nvramsize;
-  *high_monotonic_count_def = high_monotonic_count;
-  *timezone_def = timezone;
-  *daylight_def = daylight;
-  *accuracy_def = accuracy;
 
   /* Register symbols */
   grub_efiemu_register_symbol ("efiemu_variables", nvram_handle, 0);
@@ -113,197 +236,27 @@ nvram_unload (void * data __attribute__ ((unused)))
   grub_efiemu_mm_return_request (timezone_handle);
   grub_efiemu_mm_return_request (accuracy_handle);
   grub_efiemu_mm_return_request (daylight_handle);
-
-  grub_free (nvram);
-  nvram = 0;
 }
 
-/* Load the variables file It's in format
-   guid1:attr1:name1:data1;
-   guid2:attr2:name2:data2;
-   ...
-   Where all fields are in hex
-*/
-static grub_err_t
-read_pnvram (char *filename)
-{
-  char *buf, *ptr, *ptr2;
-  grub_file_t file;
-  grub_size_t size;
-  grub_uint8_t *nvramptr = nvram;
-  struct efi_variable *efivar;
-  grub_size_t guidlen, datalen;
-  unsigned i, j;
-
-  file = grub_file_open (filename);
-  if (!file)
-    return grub_error (GRUB_ERR_BAD_OS, "couldn't read pnvram");
-  size = grub_file_size (file);
-  buf = grub_malloc (size + 1);
-  if (!buf)
-    return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't read pnvram");
-  if (grub_file_read (file, buf, size) != (grub_ssize_t) size)
-    return grub_error (GRUB_ERR_BAD_OS, "couldn't read pnvram");
-  buf[size] = 0;
-  grub_file_close (file);
-
-  for (ptr = buf; *ptr; )
-    {
-      if (grub_isspace (*ptr))
-	{
-	  ptr++;
-	  continue;
-	}
-
-      efivar = (struct efi_variable *) nvramptr;
-      if (nvramptr - nvram + sizeof (struct efi_variable) > nvramsize)
-	return grub_error (GRUB_ERR_OUT_OF_MEMORY,
-			   "file is too large for reserved variable space");
-
-      nvramptr += sizeof (struct efi_variable);
-
-      /* look ahow long guid field is*/
-      guidlen = 0;
-      for (ptr2 = ptr; (grub_isspace (*ptr2)
-			|| (*ptr2 >= '0' && *ptr2 <= '9')
-			|| (*ptr2 >= 'a' && *ptr2 <= 'f')
-			|| (*ptr2 >= 'A' && *ptr2 <= 'F'));
-	   ptr2++)
-	if (!grub_isspace (*ptr2))
-	  guidlen++;
-      guidlen /= 2;
-
-      /* Read guid */
-      if (guidlen != sizeof (efivar->guid))
-	{
-	  grub_free (buf);
-	  return grub_error (GRUB_ERR_BAD_OS, "can't parse %s", filename);
-	}
-      for (i = 0; i < 2 * sizeof (efivar->guid); i++)
-	{
-	  int hex = 0;
-	  while (grub_isspace (*ptr))
-	    ptr++;
-	  if (*ptr >= '0' && *ptr <= '9')
-	    hex = *ptr - '0';
-	  if (*ptr >= 'a' && *ptr <= 'f')
-	    hex = *ptr - 'a' + 10;
-	  if (*ptr >= 'A' && *ptr <= 'F')
-	    hex = *ptr - 'A' + 10;
-
-	  if (i%2 == 0)
-	    ((grub_uint8_t *)&(efivar->guid))[i/2] = hex << 4;
-	  else
-	    ((grub_uint8_t *)&(efivar->guid))[i/2] |= hex;
-	  ptr++;
-	}
-
-      while (grub_isspace (*ptr))
-	ptr++;
-      if (*ptr != ':')
-	{
-	  grub_dprintf ("efiemu", "Not colon\n");
-	  grub_free (buf);
-	  return grub_error (GRUB_ERR_BAD_OS, "can't parse %s", filename);
-	}
-      ptr++;
-      while (grub_isspace (*ptr))
-	ptr++;
-
-      /* Attributes can be just parsed by existing functions */
-      efivar->attributes = grub_strtoul (ptr, &ptr, 16);
-
-      while (grub_isspace (*ptr))
-	ptr++;
-      if (*ptr != ':')
-	{
-	  grub_dprintf ("efiemu", "Not colon\n");
-	  grub_free (buf);
-	  return grub_error (GRUB_ERR_BAD_OS, "can't parse %s", filename);
-	}
-      ptr++;
-      while (grub_isspace (*ptr))
-	ptr++;
-
-      /* Read name and value */
-      for (j = 0; j < 2; j++)
-	{
-	  /* Look the length */
-	  datalen = 0;
-	  for (ptr2 = ptr; *ptr2 && (grub_isspace (*ptr2)
-				     || (*ptr2 >= '0' && *ptr2 <= '9')
-				     || (*ptr2 >= 'a' && *ptr2 <= 'f')
-				     || (*ptr2 >= 'A' && *ptr2 <= 'F'));
-	       ptr2++)
-	    if (!grub_isspace (*ptr2))
-	      datalen++;
-	  datalen /= 2;
-
-	  if (nvramptr - nvram + datalen > nvramsize)
-	    {
-	      grub_free (buf);
-	      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
-				 "file is too large for reserved "
-				 " variable space");
-	    }
-
-	  for (i = 0; i < 2 * datalen; i++)
-	    {
-	      int hex = 0;
-	      while (grub_isspace (*ptr))
-		ptr++;
-	      if (*ptr >= '0' && *ptr <= '9')
-		hex = *ptr - '0';
-	      if (*ptr >= 'a' && *ptr <= 'f')
-		hex = *ptr - 'a' + 10;
-	      if (*ptr >= 'A' && *ptr <= 'F')
-		hex = *ptr - 'A' + 10;
-
-	      if (i%2 == 0)
-		nvramptr[i/2] = hex << 4;
-	      else
-		nvramptr[i/2] |= hex;
-	      ptr++;
-	    }
-	  nvramptr += datalen;
-	  while (grub_isspace (*ptr))
-	    ptr++;
-	  if (*ptr != (j ? ';' : ':'))
-	    {
-	      grub_free (buf);
-	      grub_dprintf ("efiemu", j?"Not semicolon\n":"Not colon\n");
-	      return grub_error (GRUB_ERR_BAD_OS, "can't parse %s", filename);
-	    }
-	  if (j)
-	    efivar->size = datalen;
-	  else
-	    efivar->namelen = datalen;
-
-	  ptr++;
-	}
-    }
-  grub_free (buf);
-  return GRUB_ERR_NONE;
-}
-
-static grub_err_t
-grub_efiemu_make_nvram (void)
+grub_err_t
+grub_efiemu_pnvram (void)
 {
+  const char *size;
   grub_err_t err;
 
-  err = grub_efiemu_autocore ();
-  if (err)
-    {
-      grub_free (nvram);
-      return err;
-    }
+  nvramsize = 0;
+
+  size = grub_env_get ("EfiEmu.pnvram.size");
+  if (size)
+    nvramsize = grub_strtoul (size, 0, 0);
+
+  if (!nvramsize)
+    nvramsize = 2048;
 
   err = grub_efiemu_register_prepare_hook (nvram_set, nvram_unload, 0);
   if (err)
-    {
-      grub_free (nvram);
-      return err;
-    }
+    return err;
+
   nvram_handle
     = grub_efiemu_request_memalign (1, nvramsize,
 				    GRUB_EFI_RUNTIME_SERVICES_DATA);
@@ -323,78 +276,5 @@ grub_efiemu_make_nvram (void)
     = grub_efiemu_request_memalign (1, sizeof (grub_uint32_t),
 				    GRUB_EFI_RUNTIME_SERVICES_DATA);
 
-  grub_efiemu_request_symbols (6);
   return GRUB_ERR_NONE;
 }
-
-grub_err_t
-grub_efiemu_pnvram (void)
-{
-  if (nvram)
-    return GRUB_ERR_NONE;
-
-  nvramsize = 2048;
-  high_monotonic_count = 1;
-  timezone = GRUB_EFI_UNSPECIFIED_TIMEZONE;
-  accuracy = 50000000;
-  daylight = 0;
-
-  nvram = grub_zalloc (nvramsize);
-  if (!nvram)
-    return grub_error (GRUB_ERR_OUT_OF_MEMORY,
-		       "Couldn't allocate space for temporary pnvram storage");
-
-  return grub_efiemu_make_nvram ();
-}
-
-static grub_err_t
-grub_cmd_efiemu_pnvram (struct grub_extcmd *cmd,
-			int argc, char **args)
-{
-  struct grub_arg_list *state = cmd->state;
-  grub_err_t err;
-
-  if (argc > 1)
-    return grub_error (GRUB_ERR_BAD_ARGUMENT, "only one argument expected");
-
-  nvramsize = state[0].set ? grub_strtoul (state[0].arg, 0, 0) : 2048;
-  high_monotonic_count = state[1].set ? grub_strtoul (state[1].arg, 0, 0) : 1;
-  timezone = state[2].set ? grub_strtosl (state[2].arg, 0, 0)
-    : GRUB_EFI_UNSPECIFIED_TIMEZONE;
-  accuracy = state[3].set ? grub_strtoul (state[3].arg, 0, 0) : 50000000;
-  daylight = state[4].set ? grub_strtoul (state[4].arg, 0, 0) : 0;
-
-  nvram = grub_zalloc (nvramsize);
-  if (!nvram)
-    return grub_error (GRUB_ERR_OUT_OF_MEMORY,
-		       "Couldn't allocate space for temporary pnvram storage");
-
-  if (argc == 1 && (err = read_pnvram (args[0])))
-    {
-      grub_free (nvram);
-      return err;
-    }
-  return grub_efiemu_make_nvram ();
-}
-
-static grub_extcmd_t cmd;
-
-void grub_efiemu_pnvram_cmd_register (void);
-void grub_efiemu_pnvram_cmd_unregister (void);
-
-void
-grub_efiemu_pnvram_cmd_register (void)
-{
-  cmd = grub_register_extcmd ("efiemu_pnvram", grub_cmd_efiemu_pnvram,
-			      GRUB_COMMAND_FLAG_BOTH,
-			      "efiemu_pnvram [FILENAME]",
-			      "Initialise pseudo-NVRAM and load variables "
-			      "from FILE",
-			      options);
-}
-
-void
-grub_efiemu_pnvram_cmd_unregister (void)
-{
-  grub_unregister_extcmd (cmd);
-}
diff --git a/efiemu/prepare.c b/efiemu/prepare.c
index 9e6d46fa1..620260049 100644
--- a/efiemu/prepare.c
+++ b/efiemu/prepare.c
@@ -36,7 +36,6 @@ SUFFIX (grub_efiemu_prepare) (struct grub_efiemu_prepare_hook *prepare_hooks,
 
   int cntconftables = 0;
   struct SUFFIX (grub_efiemu_configuration_table) *conftables = 0;
-  struct SUFFIX (grub_efiemu_runtime_services) *runtime_services;
   int i;
   int handle;
   grub_off_t off;
@@ -54,6 +53,7 @@ SUFFIX (grub_efiemu_prepare) (struct grub_efiemu_prepare_hook *prepare_hooks,
   /* Switch from phase 1 (counting) to phase 2 (real job) */
   grub_efiemu_alloc_syms ();
   grub_efiemu_mm_do_alloc ();
+  grub_efiemu_write_sym_markers ();
 
   grub_efiemu_system_table32 = 0;
   grub_efiemu_system_table64 = 0;
@@ -81,16 +81,6 @@ SUFFIX (grub_efiemu_prepare) (struct grub_efiemu_prepare_hook *prepare_hooks,
     = (struct SUFFIX (grub_efi_system_table) *)
     ((grub_uint8_t *) grub_efiemu_mm_obtain_request (handle) + off);
 
-  /* compute CRC32 of runtime_services */
-  if ((err = grub_efiemu_resolve_symbol ("efiemu_runtime_services",
-					 &handle, &off)))
-    return err;
-  runtime_services = (struct SUFFIX (grub_efiemu_runtime_services) *)
-	((grub_uint8_t *) grub_efiemu_mm_obtain_request (handle) + off);
-  runtime_services->hdr.crc32 = 0;
-  runtime_services->hdr.crc32 = grub_getcrc32
-    (0, runtime_services, runtime_services->hdr.header_size);
-
   /* Put pointer to the list of configuration tables in system table */
   grub_efiemu_write_value
     (&(SUFFIX (grub_efiemu_system_table)->configuration_table), 0,
@@ -113,16 +103,51 @@ SUFFIX (grub_efiemu_prepare) (struct grub_efiemu_prepare_hook *prepare_hooks,
 	conftables[i].vendor_table = PTR_TO_UINT64 (cur->data);
     }
 
+  err = SUFFIX (grub_efiemu_crc) ();
+  if (err)
+    {
+      grub_efiemu_unload ();
+      return err;
+    }
+
+  grub_dprintf ("efiemu","system_table = %p, conftables = %p (%d entries)\n",
+		SUFFIX (grub_efiemu_system_table), conftables, cntconftables);
+
+  return GRUB_ERR_NONE;
+}
+
+grub_err_t
+SUFFIX (grub_efiemu_crc) (void)
+{
+  grub_err_t err;
+  int handle;
+  grub_off_t off;
+  struct SUFFIX (grub_efiemu_runtime_services) *runtime_services;
+
+  /* compute CRC32 of runtime_services */
+  err = grub_efiemu_resolve_symbol ("efiemu_runtime_services",
+				    &handle, &off);
+  if (err)
+    return err;
+
+  runtime_services = (struct SUFFIX (grub_efiemu_runtime_services) *)
+	((grub_uint8_t *) grub_efiemu_mm_obtain_request (handle) + off);
+  runtime_services->hdr.crc32 = 0;
+  runtime_services->hdr.crc32 = grub_getcrc32
+    (0, runtime_services, runtime_services->hdr.header_size);
+
+  err = grub_efiemu_resolve_symbol ("efiemu_system_table", &handle, &off);
+  if (err)
+    return err;
+
   /* compute CRC32 of system table */
   SUFFIX (grub_efiemu_system_table)->hdr.crc32 = 0;
   SUFFIX (grub_efiemu_system_table)->hdr.crc32
     = grub_getcrc32 (0, SUFFIX (grub_efiemu_system_table),
 		     SUFFIX (grub_efiemu_system_table)->hdr.header_size);
 
-  grub_dprintf ("efiemu","system_table = %p, runtime_services = %p,"
-		" conftables = %p (%d entries)\n",
-		SUFFIX (grub_efiemu_system_table), runtime_services,
-		conftables, cntconftables);
+  grub_dprintf ("efiemu","system_table = %p, runtime_services = %p\n",
+		SUFFIX (grub_efiemu_system_table), runtime_services);
 
   return GRUB_ERR_NONE;
 }
diff --git a/efiemu/runtime/efiemu.c b/efiemu/runtime/efiemu.c
index 085e75d0c..73893414a 100644
--- a/efiemu/runtime/efiemu.c
+++ b/efiemu/runtime/efiemu.c
@@ -111,9 +111,8 @@ static grub_uint8_t loge[1000] = "EFIEMULOG";
 static int logn = 9;
 #define LOG(x)   { if (logn<900) loge[logn++]=x; }
 
-static int ptv_relocated = 0;
-
 /* Interface with grub */
+extern grub_uint8_t efiemu_ptv_relocated;
 struct grub_efi_runtime_services efiemu_runtime_services;
 struct grub_efi_system_table efiemu_system_table;
 extern struct grub_efiemu_ptv_rel efiemu_ptv_relloc[];
@@ -343,9 +342,9 @@ grub_efi_status_t EFI_FUNC
   LOG ('e');
 
   /* Ensure that we are called only once */
-  if (ptv_relocated)
+  if (efiemu_ptv_relocated)
     return GRUB_EFI_UNSUPPORTED;
-  ptv_relocated = 1;
+  efiemu_ptv_relocated = 1;
 
   /* Correct addresses using information supplied by grub */
   for (cur_relloc = efiemu_ptv_relloc; cur_relloc->size;cur_relloc++)
diff --git a/efiemu/symbols.c b/efiemu/symbols.c
index ec508d975..5b9b2aec7 100644
--- a/efiemu/symbols.c
+++ b/efiemu/symbols.c
@@ -26,6 +26,7 @@
 static int ptv_written = 0;
 static int ptv_alloc = 0;
 static int ptv_handle = 0;
+static int relocated_handle = 0;
 static int ptv_requested = 0;
 static struct grub_efiemu_sym *efiemu_syms = 0;
 
@@ -54,6 +55,8 @@ grub_efiemu_free_syms (void)
   ptv_requested = 0;
   grub_efiemu_mm_return_request (ptv_handle);
   ptv_handle = 0;
+  grub_efiemu_mm_return_request (relocated_handle);
+  relocated_handle = 0;
 }
 
 /* Announce that the module will need NUM allocators */
@@ -114,10 +117,26 @@ grub_efiemu_alloc_syms (void)
   ptv_handle = grub_efiemu_request_memalign
     (1, (ptv_requested + 1) * sizeof (struct grub_efiemu_ptv_rel),
      GRUB_EFI_RUNTIME_SERVICES_DATA);
+  relocated_handle = grub_efiemu_request_memalign
+    (1, sizeof (grub_uint8_t), GRUB_EFI_RUNTIME_SERVICES_DATA);
+
+  grub_efiemu_register_symbol ("efiemu_ptv_relocated", relocated_handle, 0);
   grub_efiemu_register_symbol ("efiemu_ptv_relloc", ptv_handle, 0);
   return grub_errno;
 }
 
+grub_err_t
+grub_efiemu_write_sym_markers (void)
+{
+  struct grub_efiemu_ptv_rel *ptv_rels
+    = grub_efiemu_mm_obtain_request (ptv_handle);
+  grub_uint8_t *relocated = grub_efiemu_mm_obtain_request (relocated_handle);
+  grub_memset (ptv_rels, 0, (ptv_requested + 1)
+	       * sizeof (struct grub_efiemu_ptv_rel));
+  *relocated = 0;
+  return GRUB_ERR_NONE;
+}
+
 /* Write value (pointer to memory PLUS_HANDLE)
    - (pointer to memory MINUS_HANDLE) + VALUE to ADDR assuming that the
    size SIZE bytes. If PTV_NEEDED is 1 then announce it to runtime that this
@@ -186,3 +205,67 @@ grub_efiemu_write_value (void *addr, grub_uint32_t value, int plus_handle,
 
   return GRUB_ERR_NONE;
 }
+
+grub_err_t
+grub_efiemu_set_virtual_address_map (grub_efi_uintn_t memory_map_size,
+				     grub_efi_uintn_t descriptor_size,
+				     grub_efi_uint32_t descriptor_version
+				     __attribute__ ((unused)),
+				     grub_efi_memory_descriptor_t *virtual_map)
+{
+  grub_uint8_t *ptv_relocated;
+  struct grub_efiemu_ptv_rel *cur_relloc;
+  struct grub_efiemu_ptv_rel *ptv_rels;
+
+  ptv_relocated = grub_efiemu_mm_obtain_request (relocated_handle);
+  ptv_rels = grub_efiemu_mm_obtain_request (ptv_handle);
+
+  /* Ensure that we are called only once */
+  if (*ptv_relocated)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "EfiEmu is already relocated.");
+  *ptv_relocated = 1;
+
+  /* Correct addresses using information supplied by grub */
+  for (cur_relloc = ptv_rels; cur_relloc->size; cur_relloc++)
+    {
+      grub_int64_t corr = 0;
+      grub_efi_memory_descriptor_t *descptr;
+
+      /* Compute correction */
+      for (descptr = virtual_map;
+	   (grub_size_t) ((grub_uint8_t *) descptr
+			  - (grub_uint8_t *) virtual_map) < memory_map_size;
+	   descptr = (grub_efi_memory_descriptor_t *)
+	     ((grub_uint8_t *) descptr + descriptor_size))
+	{
+	  if (descptr->type == cur_relloc->plustype)
+	    corr += descptr->virtual_start - descptr->physical_start;
+	  if (descptr->type == cur_relloc->minustype)
+	    corr -= descptr->virtual_start - descptr->physical_start;
+	}
+
+      /* Apply correction */
+      switch (cur_relloc->size)
+	{
+	case 8:
+	  *((grub_uint64_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
+	  break;
+	case 4:
+	  *((grub_uint32_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
+	  break;
+	case 2:
+	  *((grub_uint16_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
+	  break;
+	case 1:
+	  *((grub_uint8_t *) UINT_TO_PTR (cur_relloc->addr)) += corr;
+	  break;
+	}
+    }
+
+  /* Recompute crc32 of system table and runtime services */
+
+  if (grub_efiemu_sizeof_uintn_t () == 4)
+    return grub_efiemu_crc32 ();
+  else
+    return grub_efiemu_crc64 ();
+}
diff --git a/fs/fat.c b/fs/fat.c
index e7f01629e..ab84ee49a 100644
--- a/fs/fat.c
+++ b/fs/fat.c
@@ -25,6 +25,7 @@
 #include <grub/mm.h>
 #include <grub/err.h>
 #include <grub/dl.h>
+#include <grub/charset.h>
 
 #define GRUB_FAT_DIR_ENTRY_SIZE	32
 
diff --git a/fs/hfsplus.c b/fs/hfsplus.c
index b306e8d6a..71910330f 100644
--- a/fs/hfsplus.c
+++ b/fs/hfsplus.c
@@ -28,6 +28,7 @@
 #include <grub/types.h>
 #include <grub/fshelp.h>
 #include <grub/hfs.h>
+#include <grub/charset.h>
 
 #define GRUB_HFSPLUS_MAGIC 0x482B
 #define GRUB_HFSPLUSX_MAGIC 0x4858
diff --git a/fs/i386/pc/pxe.c b/fs/i386/pc/pxe.c
index 6c41d4298..dec3b91bf 100644
--- a/fs/i386/pc/pxe.c
+++ b/fs/i386/pc/pxe.c
@@ -107,9 +107,11 @@ static struct grub_disk_dev grub_pxe_dev =
   };
 
 static grub_err_t
-grub_pxefs_dir (grub_device_t device UNUSED, const char *path UNUSED,
+grub_pxefs_dir (grub_device_t device __attribute__ ((unused)),
+		const char *path  __attribute__ ((unused)),
 		int (*hook) (const char *filename,
-			     const struct grub_dirhook_info *info) UNUSED)
+			     const struct grub_dirhook_info *info) 
+		__attribute__ ((unused)))
 {
   return GRUB_ERR_NONE;
 }
diff --git a/fs/iso9660.c b/fs/iso9660.c
index 9b7ce765b..976222a45 100644
--- a/fs/iso9660.c
+++ b/fs/iso9660.c
@@ -26,6 +26,7 @@
 #include <grub/dl.h>
 #include <grub/types.h>
 #include <grub/fshelp.h>
+#include <grub/charset.h>
 
 #define GRUB_ISO9660_FSTYPE_DIR		0040000
 #define GRUB_ISO9660_FSTYPE_REG		0100000
diff --git a/fs/jfs.c b/fs/jfs.c
index b73f9bdd4..589b6ae5a 100644
--- a/fs/jfs.c
+++ b/fs/jfs.c
@@ -24,6 +24,7 @@
 #include <grub/disk.h>
 #include <grub/dl.h>
 #include <grub/types.h>
+#include <grub/charset.h>
 
 #define GRUB_JFS_MAX_SYMLNK_CNT	8
 #define GRUB_JFS_FILETYPE_MASK	0170000
diff --git a/fs/ntfs.c b/fs/ntfs.c
index c780887c6..f3097d60b 100644
--- a/fs/ntfs.c
+++ b/fs/ntfs.c
@@ -24,6 +24,7 @@
 #include <grub/dl.h>
 #include <grub/fshelp.h>
 #include <grub/ntfs.h>
+#include <grub/charset.h>
 
 static grub_dl_t my_mod;
 
diff --git a/gendistlist.sh b/gendistlist.sh
old mode 100644
new mode 100755
index 43366bd73..102c0c11c
--- a/gendistlist.sh
+++ b/gendistlist.sh
@@ -36,7 +36,7 @@ dir=`dirname $0`
 cd $dir
 
 for dir in $DISTDIRS; do
-  for d in `find $dir -type d -not -name .svn -not -name .bzr | sort`; do
+  for d in `find $dir -type d ! -name .svn ! -name .bzr | sort`; do
     find $d -maxdepth 1 -name '*.[chSy]' -o -name '*.mk' -o -name '*.rmk' \
       -o -name '*.rb' -o -name '*.in' -o -name '*.tex' -o -name '*.texi' \
       -o -name '*.info' -o -name 'grub.cfg' -o -name 'README' \
diff --git a/include/grub/auth.h b/include/grub/auth.h
index da930eeda..823442941 100644
--- a/include/grub/auth.h
+++ b/include/grub/auth.h
@@ -19,10 +19,11 @@
 #define GRUB_AUTH_HEADER	1
 
 #include <grub/err.h>
+#include <grub/i18n.h>
 
 /* Macros for indistinguishibility.  */
 #define GRUB_ACCESS_DENIED grub_error (GRUB_ERR_ACCESS_DENIED, "Access denied.")
-#define GRUB_GET_PASSWORD(string, len) grub_cmdline_get ("Enter password: ", \
+#define GRUB_GET_PASSWORD(string, len) grub_cmdline_get (N_("Enter password:"), \
 							 string, len,	\
 							 '*', 0, 0)
 
diff --git a/include/grub/autoefi.h b/include/grub/autoefi.h
index b151cfc37..5ae4b3a21 100644
--- a/include/grub/autoefi.h
+++ b/include/grub/autoefi.h
@@ -26,8 +26,10 @@
 # include <grub/efi/efi.h>
 # define grub_autoefi_get_memory_map grub_efi_get_memory_map
 # define grub_autoefi_finish_boot_services grub_efi_finish_boot_services
+# define grub_autoefi_exit_boot_services grub_efi_exit_boot_services
 # define grub_autoefi_system_table grub_efi_system_table
 # define grub_autoefi_mmap_iterate grub_machine_mmap_iterate
+# define grub_autoefi_set_virtual_address_map grub_efi_set_virtual_address_map
 static inline grub_err_t grub_autoefi_prepare (void)
 {
   return GRUB_ERR_NONE;
@@ -53,9 +55,11 @@ static inline grub_err_t grub_autoefi_prepare (void)
 # include <grub/efiemu/efiemu.h>
 # define grub_autoefi_get_memory_map grub_efiemu_get_memory_map
 # define grub_autoefi_finish_boot_services grub_efiemu_finish_boot_services
+# define grub_autoefi_exit_boot_services grub_efiemu_exit_boot_services
 # define grub_autoefi_system_table grub_efiemu_system_table
 # define grub_autoefi_mmap_iterate grub_efiemu_mmap_iterate
 # define grub_autoefi_prepare grub_efiemu_prepare
+# define grub_autoefi_set_virtual_address_map grub_efiemu_set_virtual_address_map
 # define GRUB_AUTOEFI_MEMORY_AVAILABLE GRUB_EFIEMU_MEMORY_AVAILABLE
 # define GRUB_AUTOEFI_MEMORY_RESERVED GRUB_EFIEMU_MEMORY_RESERVED
 # define GRUB_AUTOEFI_MEMORY_ACPI GRUB_EFIEMU_MEMORY_ACPI
diff --git a/include/grub/charset.h b/include/grub/charset.h
new file mode 100644
index 000000000..f85862f8b
--- /dev/null
+++ b/include/grub/charset.h
@@ -0,0 +1,112 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,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/>.
+ */
+
+#ifndef GRUB_CHARSET_HEADER
+#define GRUB_CHARSET_HEADER	1
+
+#include <grub/types.h>
+
+#define GRUB_UINT8_1_LEADINGBIT 0x80
+#define GRUB_UINT8_2_LEADINGBITS 0xc0
+#define GRUB_UINT8_3_LEADINGBITS 0xe0
+#define GRUB_UINT8_4_LEADINGBITS 0xf0
+#define GRUB_UINT8_5_LEADINGBITS 0xf8
+#define GRUB_UINT8_6_LEADINGBITS 0xfc
+#define GRUB_UINT8_7_LEADINGBITS 0xfe
+
+#define GRUB_UINT8_1_TRAILINGBIT 0x01
+#define GRUB_UINT8_2_TRAILINGBITS 0x03
+#define GRUB_UINT8_3_TRAILINGBITS 0x07
+#define GRUB_UINT8_4_TRAILINGBITS 0x0f
+#define GRUB_UINT8_5_TRAILINGBITS 0x1f
+#define GRUB_UINT8_6_TRAILINGBITS 0x3f
+
+#define GRUB_UCS2_LIMIT 0x10000
+#define GRUB_UTF16_UPPER_SURROGATE(code) \
+  (0xD800 + ((((code) - GRUB_UCS2_LIMIT) >> 12) & 0xfff))
+#define GRUB_UTF16_LOWER_SURROGATE(code) \
+  (0xDC00 + (((code) - GRUB_UCS2_LIMIT) & 0xfff))
+
+grub_ssize_t
+grub_utf8_to_utf16 (grub_uint16_t *dest, grub_size_t destsize,
+		    const grub_uint8_t *src, grub_size_t srcsize,
+		    const grub_uint8_t **srcend);
+
+/* Convert UTF-16 to UTF-8.  */
+static inline grub_uint8_t *
+grub_utf16_to_utf8 (grub_uint8_t *dest, grub_uint16_t *src,
+		    grub_size_t size)
+{
+  grub_uint32_t code_high = 0;
+
+  while (size--)
+    {
+      grub_uint32_t code = *src++;
+
+      if (code_high)
+	{
+	  if (code >= 0xDC00 && code <= 0xDFFF)
+	    {
+	      /* Surrogate pair.  */
+	      code = ((code_high - 0xD800) << 12) + (code - 0xDC00) + 0x10000;
+
+	      *dest++ = (code >> 18) | 0xF0;
+	      *dest++ = ((code >> 12) & 0x3F) | 0x80;
+	      *dest++ = ((code >> 6) & 0x3F) | 0x80;
+	      *dest++ = (code & 0x3F) | 0x80;
+	    }
+	  else
+	    {
+	      /* Error...  */
+	      *dest++ = '?';
+	    }
+
+	  code_high = 0;
+	}
+      else
+	{
+	  if (code <= 0x007F)
+	    *dest++ = code;
+	  else if (code <= 0x07FF)
+	    {
+	      *dest++ = (code >> 6) | 0xC0;
+	      *dest++ = (code & 0x3F) | 0x80;
+	    }
+	  else if (code >= 0xD800 && code <= 0xDBFF)
+	    {
+	      code_high = code;
+	      continue;
+	    }
+	  else if (code >= 0xDC00 && code <= 0xDFFF)
+	    {
+	      /* Error... */
+	      *dest++ = '?';
+	    }
+	  else
+	    {
+	      *dest++ = (code >> 12) | 0xE0;
+	      *dest++ = ((code >> 6) & 0x3F) | 0x80;
+	      *dest++ = (code & 0x3F) | 0x80;
+	    }
+	}
+    }
+
+  return dest;
+}
+
+#endif
diff --git a/include/grub/efi/api.h b/include/grub/efi/api.h
index e870eab41..32904150e 100644
--- a/include/grub/efi/api.h
+++ b/include/grub/efi/api.h
@@ -21,6 +21,7 @@
 #define GRUB_EFI_API_HEADER	1
 
 #include <grub/types.h>
+#include <grub/symbol.h>
 
 /* For consistency and safety, we name the EFI-defined types differently.
    All names are transformed into lower case, _t appended, and
diff --git a/include/grub/efi/efi.h b/include/grub/efi/efi.h
index 43f152981..b12205ad3 100644
--- a/include/grub/efi/efi.h
+++ b/include/grub/efi/efi.h
@@ -55,6 +55,10 @@ grub_efi_device_path_t *
 EXPORT_FUNC(grub_efi_get_device_path) (grub_efi_handle_t handle);
 int EXPORT_FUNC(grub_efi_exit_boot_services) (grub_efi_uintn_t map_key);
 int EXPORT_FUNC (grub_efi_finish_boot_services) (void);
+grub_err_t EXPORT_FUNC (grub_efi_set_virtual_address_map) (grub_efi_uintn_t memory_map_size,
+							   grub_efi_uintn_t descriptor_size,
+							   grub_efi_uint32_t descriptor_version,
+							   grub_efi_memory_descriptor_t *virtual_map);
 
 void grub_efi_mm_init (void);
 void grub_efi_mm_fini (void);
diff --git a/include/grub/efiemu/efiemu.h b/include/grub/efiemu/efiemu.h
index 20163dd61..3980d32cd 100644
--- a/include/grub/efiemu/efiemu.h
+++ b/include/grub/efiemu/efiemu.h
@@ -268,9 +268,19 @@ void grub_efiemu_free_syms (void);
 grub_err_t grub_efiemu_write_value (void * addr, grub_uint32_t value,
 				    int plus_handle,
 				    int minus_handle, int ptv_needed, int size);
+grub_err_t grub_efiemu_write_sym_markers (void);
 grub_err_t grub_efiemu_pnvram (void);
 grub_err_t grub_efiemu_prepare (void);
 char *grub_efiemu_get_default_core_name (void);
 void grub_efiemu_pnvram_cmd_unregister (void);
 grub_err_t grub_efiemu_autocore (void);
+grub_err_t grub_efiemu_crc32 (void);
+grub_err_t grub_efiemu_crc64 (void);
+grub_err_t
+grub_efiemu_set_virtual_address_map (grub_efi_uintn_t memory_map_size,
+				     grub_efi_uintn_t descriptor_size,
+				     grub_efi_uint32_t descriptor_version
+				     __attribute__ ((unused)),
+				     grub_efi_memory_descriptor_t *virtual_map);
+
 #endif /* ! GRUB_EFI_EMU_HEADER */
diff --git a/include/grub/i386/macho.h b/include/grub/i386/macho.h
index 61e72a71b..f22c21190 100644
--- a/include/grub/i386/macho.h
+++ b/include/grub/i386/macho.h
@@ -1,3 +1,26 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 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/>.
+ */
+
+#ifndef GRUB_CPU_MACHO_H
+#define GRUB_CPU_MACHO_H 1
+
+#include <grub/macho.h>
+
 #define GRUB_MACHO_CPUTYPE_IS_HOST32(x) ((x)==0x00000007)
 #define GRUB_MACHO_CPUTYPE_IS_HOST64(x) ((x)==0x01000007)
 
@@ -9,3 +32,15 @@ struct grub_macho_thread32
   grub_uint32_t entry_point;
   grub_uint8_t unknown2[20];
 } __attribute__ ((packed));
+
+
+struct grub_macho_thread64
+{
+  grub_uint32_t cmd;
+  grub_uint32_t cmdsize;
+  grub_uint8_t unknown1[0x88];
+  grub_uint64_t entry_point;
+  grub_uint8_t unknown2[0x20];
+} __attribute__ ((packed));
+
+#endif
diff --git a/include/grub/i386/xnu.h b/include/grub/i386/xnu.h
index ea2767a79..2fa2639c1 100644
--- a/include/grub/i386/xnu.h
+++ b/include/grub/i386/xnu.h
@@ -20,6 +20,7 @@
 #define GRUB_CPU_XNU_H 1
 
 #include <grub/err.h>
+#include <grub/efi/api.h>
 #include <grub/cpu/relocator.h>
 
 #define XNU_RELOCATOR(x) (grub_relocator32_ ## x)
@@ -67,9 +68,47 @@ struct grub_xnu_boot_params
   /* Size of grub_efi_uintn_t in bits. */
   grub_uint8_t efi_uintnbits;
 } __attribute__ ((packed));
-#define GRUB_XNU_BOOTARGS_VERMINOR 4
+#define GRUB_XNU_BOOTARGS_VERMINOR 5
 #define GRUB_XNU_BOOTARGS_VERMAJOR 1
 
+struct grub_xnu_devprop_header
+{
+  grub_uint32_t length;
+  /* Always set to 1. Version?  */
+  grub_uint32_t alwaysone;
+  grub_uint32_t num_devices;
+};
+
+struct grub_xnu_devprop_device_header
+{
+  grub_uint32_t length;
+  grub_uint32_t num_values;
+};
+
+void grub_cpu_xnu_unload (void);
+
+struct grub_xnu_devprop_device_descriptor;
+
+struct grub_xnu_devprop_device_descriptor *
+grub_xnu_devprop_add_device (struct grub_efi_device_path *path, int length);
+grub_err_t
+grub_xnu_devprop_remove_device (struct grub_xnu_devprop_device_descriptor *dev);
+grub_err_t
+grub_xnu_devprop_remove_property (struct grub_xnu_devprop_device_descriptor *dev,
+				  char *name);
+grub_err_t
+grub_xnu_devprop_add_property_utf8 (struct grub_xnu_devprop_device_descriptor *dev,
+				    char *name, void *data, int datalen);
+grub_err_t
+grub_xnu_devprop_add_property_utf16 (struct grub_xnu_devprop_device_descriptor *dev,
+				     grub_uint16_t *name, int namelen,
+				     void *data, int datalen);
+grub_err_t
+grub_xnu_devprop_remove_property_utf8 (struct grub_xnu_devprop_device_descriptor *dev,
+				       char *name);
+void grub_cpu_xnu_init (void);
+void grub_cpu_xnu_fini (void);
+
 extern grub_uint32_t grub_xnu_entry_point;
 extern grub_uint32_t grub_xnu_stack;
 extern grub_uint32_t grub_xnu_arg1;
diff --git a/include/grub/macho.h b/include/grub/macho.h
index 0604100e9..82145835f 100644
--- a/include/grub/macho.h
+++ b/include/grub/macho.h
@@ -102,6 +102,23 @@ struct grub_macho_segment32
   grub_uint32_t flags;
 } __attribute__ ((packed));
 
+/* 64-bit segment command. */
+struct grub_macho_segment64
+{
+#define GRUB_MACHO_CMD_SEGMENT64  0x19
+  grub_uint32_t cmd;
+  grub_uint32_t cmdsize;
+  grub_uint8_t segname[16];
+  grub_uint64_t vmaddr;
+  grub_uint64_t vmsize;
+  grub_uint64_t fileoff;
+  grub_uint64_t filesize;
+  grub_macho_vmprot_t maxprot;
+  grub_macho_vmprot_t initprot;
+  grub_uint32_t nsects;
+  grub_uint32_t flags;
+} __attribute__ ((packed));
+
 #define GRUB_MACHO_CMD_THREAD     5
 
 #endif
diff --git a/include/grub/machoload.h b/include/grub/machoload.h
index a80bac68c..8410162fb 100644
--- a/include/grub/machoload.h
+++ b/include/grub/machoload.h
@@ -46,17 +46,28 @@ grub_macho_t grub_macho_file (grub_file_t);
 grub_err_t grub_macho_close (grub_macho_t);
 
 int grub_macho_contains_macho32 (grub_macho_t);
-grub_err_t grub_macho32_size (grub_macho_t macho, grub_addr_t *segments_start,
-			      grub_addr_t *segments_end, int flags);
-grub_uint32_t grub_macho32_get_entry_point (grub_macho_t macho);
+grub_err_t grub_macho_size32 (grub_macho_t macho, grub_uint32_t *segments_start,
+			      grub_uint32_t *segments_end, int flags);
+grub_uint32_t grub_macho_get_entry_point32 (grub_macho_t macho);
+
+int grub_macho_contains_macho64 (grub_macho_t);
+grub_err_t grub_macho_size64 (grub_macho_t macho, grub_uint64_t *segments_start,
+			      grub_uint64_t *segments_end, int flags);
+grub_uint64_t grub_macho_get_entry_point64 (grub_macho_t macho);
 
 /* Ignore BSS segments when loading. */
 #define GRUB_MACHO_NOBSS 0x1
-grub_err_t grub_macho32_load (grub_macho_t macho, char *offset, int flags);
+grub_err_t grub_macho_load32 (grub_macho_t macho, char *offset, int flags);
+grub_err_t grub_macho_load64 (grub_macho_t macho, char *offset, int flags);
 
 /* Like filesize and file_read but take only 32-bit part
    for current architecture. */
-grub_size_t grub_macho32_filesize (grub_macho_t macho);
-grub_err_t grub_macho32_readfile (grub_macho_t macho, void *dest);
+grub_size_t grub_macho_filesize32 (grub_macho_t macho);
+grub_err_t grub_macho_readfile32 (grub_macho_t macho, void *dest);
+grub_size_t grub_macho_filesize64 (grub_macho_t macho);
+grub_err_t grub_macho_readfile64 (grub_macho_t macho, void *dest);
+
+void grub_macho_parse32 (grub_macho_t macho);
+void grub_macho_parse64 (grub_macho_t macho);
 
 #endif /* ! GRUB_MACHOLOAD_HEADER */
diff --git a/include/grub/misc.h b/include/grub/misc.h
index 926195d2c..92fb460cf 100644
--- a/include/grub/misc.h
+++ b/include/grub/misc.h
@@ -183,9 +183,6 @@ int EXPORT_FUNC(grub_sprintf) (char *str, const char *fmt, ...) __attribute__ ((
 int EXPORT_FUNC(grub_vsprintf) (char *str, const char *fmt, va_list args);
 void EXPORT_FUNC(grub_exit) (void) __attribute__ ((noreturn));
 void EXPORT_FUNC(grub_abort) (void) __attribute__ ((noreturn));
-grub_uint8_t *EXPORT_FUNC(grub_utf16_to_utf8) (grub_uint8_t *dest,
-					       grub_uint16_t *src,
-					       grub_size_t size);
 grub_ssize_t EXPORT_FUNC(grub_utf8_to_ucs4) (grub_uint32_t *dest,
 					     grub_size_t destsize,
 					     const grub_uint8_t *src,
diff --git a/include/grub/normal.h b/include/grub/normal.h
index feebc85b1..e55553de5 100644
--- a/include/grub/normal.h
+++ b/include/grub/normal.h
@@ -30,6 +30,9 @@
 /* The maximum size of a command-line.  */
 #define GRUB_MAX_CMDLINE	1600
 
+/* The standard left and right margin for some messages.  */
+#define STANDARD_MARGIN 6
+
 /* The type of a completion item.  */
 enum grub_completion_type
   {
@@ -73,6 +76,14 @@ void grub_parse_color_name_pair (grub_uint8_t *ret, const char *name);
 
 /* Defined in `menu_text.c'.  */
 void grub_wait_after_message (void);
+int grub_utf8_to_ucs4_alloc (const char *msg, grub_uint32_t **unicode_msg,
+			     grub_uint32_t **last_position);
+void grub_print_ucs4 (const grub_uint32_t * str,
+		      const grub_uint32_t * last_position);
+grub_ssize_t grub_getstringwidth (grub_uint32_t * str,
+				  const grub_uint32_t * last_position);
+void grub_print_message_indented (const char *msg, int margin_left,
+				  int margin_right);
 
 /* Defined in `handler.c'.  */
 void read_handler_list (void);
diff --git a/include/grub/types.h b/include/grub/types.h
index 8e2ad15ef..5f6b7ec62 100644
--- a/include/grub/types.h
+++ b/include/grub/types.h
@@ -22,8 +22,6 @@
 #include <config.h>
 #include <grub/cpu/types.h>
 
-#define UNUSED __attribute__ ((unused))
-
 #ifdef GRUB_UTIL
 # define GRUB_CPU_SIZEOF_VOID_P	SIZEOF_VOID_P
 # define GRUB_CPU_SIZEOF_LONG	SIZEOF_LONG
diff --git a/include/grub/usb.h b/include/grub/usb.h
index 8dd3b6e2e..dc90e7879 100644
--- a/include/grub/usb.h
+++ b/include/grub/usb.h
@@ -64,9 +64,6 @@ grub_usb_err_t grub_usb_clear_halt (grub_usb_device_t dev, int endpoint);
 grub_usb_err_t grub_usb_set_configuration (grub_usb_device_t dev,
 					   int configuration);
 
-grub_usb_err_t grub_usb_get_string (grub_usb_device_t dev, grub_uint8_t index,
-				    int langid, char **string);
-
 void grub_usb_controller_dev_register (grub_usb_controller_dev_t usb);
 
 void grub_usb_controller_dev_unregister (grub_usb_controller_dev_t usb);
diff --git a/include/grub/xnu.h b/include/grub/xnu.h
index cf778cf6b..6ce17c25e 100644
--- a/include/grub/xnu.h
+++ b/include/grub/xnu.h
@@ -76,6 +76,8 @@ struct grub_xnu_extheader
   grub_uint32_t infoplistsize;
   grub_uint32_t binaryaddr;
   grub_uint32_t binarysize;
+  grub_uint32_t nameaddr;
+  grub_uint32_t namesize;
 } __attribute__ ((packed));
 
 struct grub_xnu_devtree_key *grub_xnu_create_key (struct grub_xnu_devtree_key **parent,
@@ -101,7 +103,10 @@ grub_err_t grub_xnu_scan_dir_for_kexts (char *dirname, char *osbundlerequired,
 grub_err_t grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
 					int maxrecursion);
 void *grub_xnu_heap_malloc (int size);
+grub_err_t grub_xnu_fill_devicetree (void);
+extern grub_uint32_t grub_xnu_heap_real_start;
 extern grub_size_t grub_xnu_heap_size;
 extern void *grub_xnu_heap_start;
 extern struct grub_video_bitmap *grub_xnu_bitmap;
+extern int grub_xnu_is_64bit;
 #endif
diff --git a/kern/efi/efi.c b/kern/efi/efi.c
index 8e09a90c0..501ab4578 100644
--- a/kern/efi/efi.c
+++ b/kern/efi/efi.c
@@ -18,6 +18,7 @@
  */
 
 #include <grub/misc.h>
+#include <grub/charset.h>
 #include <grub/efi/api.h>
 #include <grub/efi/efi.h>
 #include <grub/efi/console_control.h>
@@ -188,6 +189,25 @@ grub_efi_exit_boot_services (grub_efi_uintn_t map_key)
   return status == GRUB_EFI_SUCCESS;
 }
 
+grub_err_t
+grub_efi_set_virtual_address_map (grub_efi_uintn_t memory_map_size,
+				  grub_efi_uintn_t descriptor_size,
+				  grub_efi_uint32_t descriptor_version,
+				  grub_efi_memory_descriptor_t *virtual_map)
+{
+  grub_efi_runtime_services_t *r;
+  grub_efi_status_t status;
+
+  r = grub_efi_system_table->runtime_services;
+  status = efi_call_4 (r->set_virtual_address_map, memory_map_size,
+		       descriptor_size, descriptor_version, virtual_map);
+
+  if (status == GRUB_EFI_SUCCESS)
+    return GRUB_ERR_NONE;
+
+  return grub_error (GRUB_ERR_IO, "set_virtual_address_map failed");
+}
+
 grub_uint32_t
 grub_get_rtc (void)
 {
diff --git a/kern/elf.c b/kern/elf.c
index f14161060..951049e73 100644
--- a/kern/elf.c
+++ b/kern/elf.c
@@ -181,7 +181,9 @@ grub_elf32_size (grub_elf_t elf)
   /* Run through the program headers to calculate the total memory size we
    * should claim.  */
   auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf32_Phdr *phdr, void *_arg);
-  int NESTED_FUNC_ATTR calcsize (grub_elf_t UNUSED _elf, Elf32_Phdr *phdr, void UNUSED *_arg)
+  int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf  __attribute__ ((unused)),
+				 Elf32_Phdr *phdr,
+				 void *_arg __attribute__ ((unused)))
     {
       /* Only consider loadable segments.  */
       if (phdr->p_type != PT_LOAD)
@@ -360,7 +362,9 @@ grub_elf64_size (grub_elf_t elf)
   /* Run through the program headers to calculate the total memory size we
    * should claim.  */
   auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf64_Phdr *phdr, void *_arg);
-  int NESTED_FUNC_ATTR calcsize (grub_elf_t UNUSED _elf, Elf64_Phdr *phdr, void UNUSED *_arg)
+  int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf __attribute__ ((unused)),
+				 Elf64_Phdr *phdr,
+				 void *_arg __attribute__ ((unused)))
     {
       /* Only consider loadable segments.  */
       if (phdr->p_type != PT_LOAD)
diff --git a/kern/env.c b/kern/env.c
index 750902af8..73a2b927a 100644
--- a/kern/env.c
+++ b/kern/env.c
@@ -101,6 +101,7 @@ grub_env_context_open (int export)
 		  grub_env_context_close ();
 		  return grub_errno;
 		}
+	      grub_env_export (var->name);
 	      grub_register_variable_hook (var->name, var->read_hook, var->write_hook);
 	    }
 	}
@@ -170,8 +171,16 @@ grub_env_export (const char *name)
   struct grub_env_var *var;
 
   var = grub_env_find (name);
-  if (var)
-    var->type = GRUB_ENV_VAR_GLOBAL;
+  if (! var)
+    {
+      grub_err_t err;
+      
+      err = grub_env_set (name, "");
+      if (err)
+	return err;
+      var = grub_env_find (name);
+    }    
+  var->type = GRUB_ENV_VAR_GLOBAL;
 
   return GRUB_ERR_NONE;
 }
diff --git a/kern/misc.c b/kern/misc.c
index d9988961c..f6d189e94 100644
--- a/kern/misc.c
+++ b/kern/misc.c
@@ -879,68 +879,6 @@ grub_sprintf (char *str, const char *fmt, ...)
   return ret;
 }
 
-/* Convert UTF-16 to UTF-8.  */
-grub_uint8_t *
-grub_utf16_to_utf8 (grub_uint8_t *dest, grub_uint16_t *src,
-		    grub_size_t size)
-{
-  grub_uint32_t code_high = 0;
-
-  while (size--)
-    {
-      grub_uint32_t code = *src++;
-
-      if (code_high)
-	{
-	  if (code >= 0xDC00 && code <= 0xDFFF)
-	    {
-	      /* Surrogate pair.  */
-	      code = ((code_high - 0xD800) << 12) + (code - 0xDC00) + 0x10000;
-
-	      *dest++ = (code >> 18) | 0xF0;
-	      *dest++ = ((code >> 12) & 0x3F) | 0x80;
-	      *dest++ = ((code >> 6) & 0x3F) | 0x80;
-	      *dest++ = (code & 0x3F) | 0x80;
-	    }
-	  else
-	    {
-	      /* Error...  */
-	      *dest++ = '?';
-	    }
-
-	  code_high = 0;
-	}
-      else
-	{
-	  if (code <= 0x007F)
-	    *dest++ = code;
-	  else if (code <= 0x07FF)
-	    {
-	      *dest++ = (code >> 6) | 0xC0;
-	      *dest++ = (code & 0x3F) | 0x80;
-	    }
-	  else if (code >= 0xD800 && code <= 0xDBFF)
-	    {
-	      code_high = code;
-	      continue;
-	    }
-	  else if (code >= 0xDC00 && code <= 0xDFFF)
-	    {
-	      /* Error... */
-	      *dest++ = '?';
-	    }
-	  else
-	    {
-	      *dest++ = (code >> 12) | 0xE0;
-	      *dest++ = ((code >> 6) & 0x3F) | 0x80;
-	      *dest++ = (code & 0x3F) | 0x80;
-	    }
-	}
-    }
-
-  return dest;
-}
-
 /* Convert a (possibly null-terminated) UTF-8 string of at most SRCSIZE
    bytes (if SRCSIZE is -1, it is ignored) in length to a UCS-4 string.
    Return the number of characters converted. DEST must be able to hold
diff --git a/kern/parser.c b/kern/parser.c
index db59af056..006d67da7 100644
--- a/kern/parser.c
+++ b/kern/parser.c
@@ -142,7 +142,7 @@ grub_parser_split_cmdline (const char *cmdline, grub_reader_getline_t getline,
 	*(bp++) = *val;
     }
 
-  *argc = 1;
+  *argc = 0;
   do
     {
       if (! *rd)
@@ -188,12 +188,16 @@ grub_parser_split_cmdline (const char *cmdline, grub_reader_getline_t getline,
 	  state = newstate;
 	}
     } while (state != GRUB_PARSER_STATE_TEXT && !check_varstate (state));
-  *(bp++) = '\0';
 
   /* A special case for when the last character was part of a
      variable.  */
   add_var (GRUB_PARSER_STATE_TEXT);
 
+  if (bp != buffer && *(bp - 1))
+    {
+      *(bp++) = '\0';
+      (*argc)++;
+    }
 
   /* Reserve memory for the return values.  */
   args = grub_malloc (bp - buffer);
@@ -219,8 +223,6 @@ grub_parser_split_cmdline (const char *cmdline, grub_reader_getline_t getline,
       bp++;
     }
 
-  (*argc)--;
-
   return 0;
 }
 
diff --git a/kern/rescue_parser.c b/kern/rescue_parser.c
index 1e0841e49..d3725e739 100644
--- a/kern/rescue_parser.c
+++ b/kern/rescue_parser.c
@@ -35,9 +35,12 @@ grub_rescue_parse_line (char *line, grub_reader_getline_t getline)
   if (grub_parser_split_cmdline (line, getline, &n, &args) || n < 0)
     return grub_errno;
 
+  if (n == 0)
+    return GRUB_ERR_NONE;
+
   /* In case of an assignment set the environment accordingly
      instead of calling a function.  */
-  if (n == 0 && grub_strchr (line, '='))
+  if (n == 1 && grub_strchr (line, '='))
     {
       char *val = grub_strchr (args[0], '=');
       val[0] = 0;
@@ -56,7 +59,7 @@ grub_rescue_parse_line (char *line, grub_reader_getline_t getline)
   cmd = grub_command_find (name);
   if (cmd)
     {
-      (cmd->func) (cmd, n, &args[1]);
+      (cmd->func) (cmd, n - 1, &args[1]);
     }
   else
     {
diff --git a/lib/arg.c b/lib/arg.c
index 24e9d5b15..6da9bb5dd 100644
--- a/lib/arg.c
+++ b/lib/arg.c
@@ -30,9 +30,9 @@
 static const struct grub_arg_option help_options[] =
   {
     {"help", SHORT_ARG_HELP, 0,
-     "display this help and exit", 0, ARG_TYPE_NONE},
+     "Display this help and exit.", 0, ARG_TYPE_NONE},
     {"usage", SHORT_ARG_USAGE, 0,
-     "display the usage of this command and exit", 0, ARG_TYPE_NONE},
+     "Display the usage of this command and exit.", 0, ARG_TYPE_NONE},
     {0, 0, 0, 0, 0, 0}
   };
 
diff --git a/lib/charset.c b/lib/charset.c
new file mode 100644
index 000000000..8bc5b9149
--- /dev/null
+++ b/lib/charset.c
@@ -0,0 +1,116 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,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/>.
+ */
+
+/* Convert a (possibly null-terminated) UTF-8 string of at most SRCSIZE
+   bytes (if SRCSIZE is -1, it is ignored) in length to a UTF-16 string.
+   Return the number of characters converted. DEST must be able to hold
+   at least DESTSIZE characters. If an invalid sequence is found, return -1.
+   If SRCEND is not NULL, then *SRCEND is set to the next byte after the
+   last byte used in SRC.  */
+
+#include <grub/charset.h>
+
+grub_ssize_t
+grub_utf8_to_utf16 (grub_uint16_t *dest, grub_size_t destsize,
+		    const grub_uint8_t *src, grub_size_t srcsize,
+		    const grub_uint8_t **srcend)
+{
+  grub_uint16_t *p = dest;
+  int count = 0;
+  grub_uint32_t code = 0;
+
+  if (srcend)
+    *srcend = src;
+
+  while (srcsize && destsize)
+    {
+      grub_uint32_t c = *src++;
+      if (srcsize != (grub_size_t)-1)
+	srcsize--;
+      if (count)
+	{
+	  if ((c & GRUB_UINT8_2_LEADINGBITS) != GRUB_UINT8_1_LEADINGBIT)
+	    {
+	      /* invalid */
+	      return -1;
+	    }
+	  else
+	    {
+	      code <<= 6;
+	      code |= (c & GRUB_UINT8_6_TRAILINGBITS);
+	      count--;
+	    }
+	}
+      else
+	{
+	  if (c == 0)
+	    break;
+
+	  if ((c & GRUB_UINT8_1_LEADINGBIT) == 0)
+	    code = c;
+	  else if ((c & GRUB_UINT8_3_LEADINGBITS) == GRUB_UINT8_2_LEADINGBITS)
+	    {
+	      count = 1;
+	      code = c & GRUB_UINT8_5_TRAILINGBITS;
+	    }
+	  else if ((c & GRUB_UINT8_4_LEADINGBITS) == GRUB_UINT8_3_LEADINGBITS)
+	    {
+	      count = 2;
+	      code = c & GRUB_UINT8_4_TRAILINGBITS;
+	    }
+	  else if ((c & GRUB_UINT8_5_LEADINGBITS) == GRUB_UINT8_4_LEADINGBITS)
+	    {
+	      count = 3;
+	      code = c & GRUB_UINT8_3_TRAILINGBITS;
+	    }
+	  else if ((c & GRUB_UINT8_6_LEADINGBITS) == GRUB_UINT8_5_LEADINGBITS)
+	    {
+	      count = 4;
+	      code = c & GRUB_UINT8_2_TRAILINGBITS;
+	    }
+	  else if ((c & GRUB_UINT8_7_LEADINGBITS) == GRUB_UINT8_6_LEADINGBITS)
+	    {
+	      count = 5;
+	      code = c & GRUB_UINT8_1_TRAILINGBIT;
+	    }
+	  else
+	    return -1;
+	}
+
+      if (count == 0)
+	{
+	  if (destsize < 2 && code >= GRUB_UCS2_LIMIT)
+	    break;
+	  if (code >= GRUB_UCS2_LIMIT)
+	    {
+	      *p++ = GRUB_UTF16_UPPER_SURROGATE (code);
+	      *p++ = GRUB_UTF16_LOWER_SURROGATE (code);
+	      destsize -= 2;
+	    }
+	  else
+	    {
+	      *p++ = code;
+	      destsize--;
+	    }
+	}
+    }
+
+  if (srcend)
+    *srcend = src;
+  return p - dest;
+}
diff --git a/loader/efi/chainloader.c b/loader/efi/chainloader.c
index 01acc4135..9c833e9b9 100644
--- a/loader/efi/chainloader.c
+++ b/loader/efi/chainloader.c
@@ -25,6 +25,7 @@
 #include <grub/device.h>
 #include <grub/disk.h>
 #include <grub/misc.h>
+#include <grub/charset.h>
 #include <grub/mm.h>
 #include <grub/types.h>
 #include <grub/dl.h>
diff --git a/loader/i386/pc/multiboot2.c b/loader/i386/pc/multiboot2.c
index e2d649613..6ef8c70ca 100644
--- a/loader/i386/pc/multiboot2.c
+++ b/loader/i386/pc/multiboot2.c
@@ -27,7 +27,8 @@
 #include <grub/cpu/multiboot.h>
 
 grub_err_t
-grub_mb2_arch_elf32_hook (Elf32_Phdr *phdr, UNUSED grub_addr_t *addr,
+grub_mb2_arch_elf32_hook (Elf32_Phdr *phdr,
+			  grub_addr_t *addr __attribute__ ((unused)),
 			  int *do_load)
 {
   Elf32_Addr paddr = phdr->p_paddr;
@@ -48,7 +49,8 @@ grub_mb2_arch_elf32_hook (Elf32_Phdr *phdr, UNUSED grub_addr_t *addr,
 }
 
 grub_err_t
-grub_mb2_arch_elf64_hook (Elf64_Phdr *phdr, UNUSED grub_addr_t *addr,
+grub_mb2_arch_elf64_hook (Elf64_Phdr *phdr,
+			  grub_addr_t *addr __attribute__ ((unused)),
 			  int *do_load)
 {
   Elf64_Addr paddr = phdr->p_paddr;
@@ -82,7 +84,8 @@ grub_mb2_arch_module_alloc (grub_size_t size, grub_addr_t *addr)
 }
 
 grub_err_t
-grub_mb2_arch_module_free (grub_addr_t addr, UNUSED grub_size_t size)
+grub_mb2_arch_module_free (grub_addr_t addr,
+			   grub_size_t size __attribute__ ((unused)))
 {
   grub_free((void *) addr);
   return GRUB_ERR_NONE;
diff --git a/loader/i386/xnu.c b/loader/i386/xnu.c
index 23fbbe7e0..0b307ae53 100644
--- a/loader/i386/xnu.c
+++ b/loader/i386/xnu.c
@@ -25,9 +25,13 @@
 #include <grub/loader.h>
 #include <grub/autoefi.h>
 #include <grub/i386/tsc.h>
+#include <grub/efi/api.h>
 #include <grub/i386/pit.h>
 #include <grub/misc.h>
+#include <grub/charset.h>
 #include <grub/term.h>
+#include <grub/command.h>
+#include <grub/gzio.h>
 
 #define min(a,b) (((a) < (b)) ? (a) : (b))
 #define max(a,b) (((a) > (b)) ? (a) : (b))
@@ -51,6 +55,14 @@ struct tbl_alias table_aliases[] =
     {GRUB_EFI_ACPI_TABLE_GUID, "ACPI"},
   };
 
+struct grub_xnu_devprop_device_descriptor
+{
+  struct grub_xnu_devprop_device_descriptor *next;
+  struct property_descriptor *properties;
+  struct grub_efi_device_path *path;
+  int pathlen;
+};
+
 static int
 utf16_strlen (grub_uint16_t *in)
 {
@@ -197,6 +209,417 @@ guessfsb (void)
 			((msrlow >> 7) & 0x3e) + ((msrlow >> 14) & 1), 0);
 }
 
+struct property_descriptor
+{
+  struct property_descriptor *next;
+  grub_uint8_t *name;
+  grub_uint16_t *name16;
+  int name16len;
+  int length;
+  void *data;
+};
+
+struct grub_xnu_devprop_device_descriptor *devices = 0;
+
+grub_err_t
+grub_xnu_devprop_remove_property (struct grub_xnu_devprop_device_descriptor *dev,
+				  char *name)
+{
+  struct property_descriptor *prop;
+  prop = grub_named_list_find (GRUB_AS_NAMED_LIST_P (&dev->properties), name);
+  if (!prop)
+    return GRUB_ERR_NONE;
+
+  grub_free (prop->name);
+  grub_free (prop->name16);
+  grub_free (prop->data);
+
+  grub_list_remove (GRUB_AS_LIST_P (&dev->properties), GRUB_AS_LIST (prop));
+
+  return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_xnu_devprop_remove_device (struct grub_xnu_devprop_device_descriptor *dev)
+{
+  void *t;
+  struct property_descriptor *prop;
+
+  grub_list_remove (GRUB_AS_LIST_P (&devices), GRUB_AS_LIST (dev));
+
+  for (prop = dev->properties; prop; )
+    {
+      grub_free (prop->name);
+      grub_free (prop->name16);
+      grub_free (prop->data);
+      t = prop;
+      prop = prop->next;
+      grub_free (t);
+    }
+
+  grub_free (dev->path);
+  grub_free (dev);
+
+  return GRUB_ERR_NONE;
+}
+
+struct grub_xnu_devprop_device_descriptor *
+grub_xnu_devprop_add_device (struct grub_efi_device_path *path, int length)
+{
+  struct grub_xnu_devprop_device_descriptor *ret;
+
+  ret = grub_zalloc (sizeof (*ret));
+  if (!ret)
+    return 0;
+
+  ret->path = grub_malloc (length);
+  if (!ret->path)
+    {
+      grub_free (ret);
+      return 0;
+    }
+  ret->pathlen = length;
+  grub_memcpy (ret->path, path, length);
+
+  grub_list_push (GRUB_AS_LIST_P (&devices), GRUB_AS_LIST (ret));
+
+  return ret;
+}
+
+static grub_err_t
+grub_xnu_devprop_add_property (struct grub_xnu_devprop_device_descriptor *dev,
+			       grub_uint8_t *utf8, grub_uint16_t *utf16,
+			       int utf16len, void *data, int datalen)
+{
+  struct property_descriptor *prop;
+
+  prop = grub_malloc (sizeof (*prop));
+  if (!prop)
+    return grub_errno;
+
+  prop->name = utf8;
+  prop->name16 = utf16;
+  prop->name16len = utf16len;
+
+  prop->length = datalen;
+  prop->data = grub_malloc (prop->length);
+  if (!prop->data)
+    {
+      grub_free (prop);
+      grub_free (prop->name);
+      grub_free (prop->name16);
+      return grub_errno;
+    }
+  grub_memcpy (prop->data, data, prop->length);
+  grub_list_push (GRUB_AS_LIST_P (&dev->properties),
+		  GRUB_AS_LIST (prop));
+  return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_xnu_devprop_add_property_utf8 (struct grub_xnu_devprop_device_descriptor *dev,
+				    char *name, void *data, int datalen)
+{
+  grub_uint8_t *utf8;
+  grub_uint16_t *utf16;
+  int len, utf16len;
+  grub_err_t err;
+
+  utf8 = (grub_uint8_t *) grub_strdup (name);
+  if (!utf8)
+    return grub_errno;
+
+  len = grub_strlen (name);
+  utf16 = grub_malloc (sizeof (grub_uint16_t) * len);
+  if (!utf16)
+    {
+      grub_free (utf8);
+      return grub_errno;
+    }
+
+  utf16len = grub_utf8_to_utf16 (utf16, len, utf8, len, NULL);
+  if (utf16len < 0)
+    {
+      grub_free (utf8);
+      grub_free (utf16);
+      return grub_errno;
+    }
+
+  err = grub_xnu_devprop_add_property (dev, utf8, utf16,
+				       utf16len, data, datalen);
+  if (err)
+    {
+      grub_free (utf8);
+      grub_free (utf16);
+      return err;
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_xnu_devprop_add_property_utf16 (struct grub_xnu_devprop_device_descriptor *dev,
+				     grub_uint16_t *name, int namelen,
+				     void *data, int datalen)
+{
+  grub_uint8_t *utf8;
+  grub_uint16_t *utf16;
+  grub_err_t err;
+
+  utf16 = grub_malloc (sizeof (grub_uint16_t) * namelen);
+  if (!utf16)
+    return grub_errno;
+  grub_memcpy (utf16, name, sizeof (grub_uint16_t) * namelen);
+
+  utf8 = grub_malloc (namelen * 4 + 1);
+  if (!utf8)
+    {
+      grub_free (utf8);
+      return grub_errno;
+    }
+
+  *grub_utf16_to_utf8 ((grub_uint8_t *) utf8, name, namelen) = '\0';
+
+  err = grub_xnu_devprop_add_property (dev, utf8, utf16,
+				       namelen, data, datalen);
+  if (err)
+    {
+      grub_free (utf8);
+      grub_free (utf16);
+      return err;
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+static inline int
+hextoval (char c)
+{
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'a' && c <= 'z')
+    return c - 'a' + 10;
+  if (c >= 'A' && c <= 'Z')
+    return c - 'A' + 10;
+  return 0;
+}
+
+void
+grub_cpu_xnu_unload (void)
+{
+  struct grub_xnu_devprop_device_descriptor *dev1, *dev2;
+
+  for (dev1 = devices; dev1; )
+    {
+      dev2 = dev1->next;
+      grub_xnu_devprop_remove_device (dev1);
+      dev1 = dev2;
+    }
+}
+
+static grub_err_t
+grub_cpu_xnu_fill_devprop (void)
+{
+  struct grub_xnu_devtree_key *efikey;
+  int total_length = sizeof (struct grub_xnu_devprop_header);
+  struct grub_xnu_devtree_key *devprop;
+  struct grub_xnu_devprop_device_descriptor *device;
+  void *ptr;
+  struct grub_xnu_devprop_header *head;
+  void *t;
+  int numdevs = 0;
+
+  /* The key "efi". */
+  efikey = grub_xnu_create_key (&grub_xnu_devtree_root, "efi");
+  if (! efikey)
+    return grub_errno;
+
+  for (device = devices; device; device = device->next)
+    {
+      struct property_descriptor *propdesc;
+      total_length += sizeof (struct grub_xnu_devprop_device_header);
+      total_length += device->pathlen;
+
+      for (propdesc = device->properties; propdesc; propdesc = propdesc->next)
+	{
+	  total_length += sizeof (grub_uint32_t);
+	  total_length += sizeof (grub_uint16_t)
+	    * (propdesc->name16len + 1);
+	  total_length += sizeof (grub_uint32_t);
+	  total_length += propdesc->length;
+	}
+      numdevs++;
+    }
+
+  devprop = grub_xnu_create_value (&(efikey->first_child), "device-properties");
+  if (devprop)
+    {
+      devprop->data = grub_malloc (total_length);
+      devprop->datasize = total_length;
+    }
+
+  ptr = devprop->data;
+  head = ptr;
+  ptr = head + 1;
+  head->length = total_length;
+  head->alwaysone = 1;
+  head->num_devices = numdevs;
+  for (device = devices; device; )
+    {
+      struct grub_xnu_devprop_device_header *devhead;
+      struct property_descriptor *propdesc;
+      devhead = ptr;
+      devhead->num_values = 0;
+      ptr = devhead + 1;
+
+      grub_memcpy (ptr, device->path, device->pathlen);
+      ptr = (char *) ptr + device->pathlen;
+
+      for (propdesc = device->properties; propdesc; )
+	{
+	  grub_uint32_t *len;
+	  grub_uint16_t *name;
+	  void *data;
+
+	  len = ptr;
+	  *len = 2 * propdesc->name16len + sizeof (grub_uint16_t)
+	    + sizeof (grub_uint32_t);
+	  ptr = len + 1;
+
+	  name = ptr;
+	  grub_memcpy (name, propdesc->name16, 2 * propdesc->name16len);
+	  name += propdesc->name16len;
+
+	  /* NUL terminator.  */
+	  *name = 0;
+	  ptr = name + 1;
+
+	  len = ptr;
+	  *len = propdesc->length + sizeof (grub_uint32_t);
+	  data = len + 1;
+	  ptr = data;
+	  grub_memcpy (ptr, propdesc->data, propdesc->length);
+	  ptr = (char *) ptr + propdesc->length;
+
+	  grub_free (propdesc->name);
+	  grub_free (propdesc->name16);
+	  grub_free (propdesc->data);
+	  t = propdesc;
+	  propdesc = propdesc->next;
+	  grub_free (t);
+	  devhead->num_values++;
+	}
+
+      devhead->length = (char *) ptr - (char *) devhead;
+      t = device;
+      device = device->next;
+      grub_free (t);
+    }
+
+  devices = 0;
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_cmd_devprop_load (grub_command_t cmd __attribute__ ((unused)),
+		       int argc, char *args[])
+{
+  grub_file_t file;
+  void *buf, *bufstart, *bufend;
+  struct grub_xnu_devprop_header *head;
+  grub_size_t size;
+  unsigned i, j;
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "File name required. ");
+
+  file = grub_gzfile_open (args[0], 1);
+  if (! file)
+    return grub_error (GRUB_ERR_FILE_NOT_FOUND,
+		       "Couldn't load device-propertie dump. ");
+  size = grub_file_size (file);
+  buf = grub_malloc (size);
+  if (!buf)
+    {
+      grub_file_close (file);
+      return grub_errno;
+    }
+  if (grub_file_read (file, buf, size) != (grub_ssize_t) size)
+    {
+      grub_file_close (file);
+      return grub_errno;
+    }
+  grub_file_close (file);
+
+  bufstart = buf;
+  bufend = (char *) buf + size;
+  head = buf;
+  buf = head + 1;
+  for (i = 0; i < grub_le_to_cpu32 (head->num_devices) && buf < bufend; i++)
+    {
+      struct grub_efi_device_path *dp, *dpstart;
+      struct grub_xnu_devprop_device_descriptor *dev;
+      struct grub_xnu_devprop_device_header *devhead;
+
+      devhead = buf;
+      buf = devhead + 1;
+      dpstart = buf;
+
+      do
+	{
+	  dp = buf;
+	  buf = (char *) buf + GRUB_EFI_DEVICE_PATH_LENGTH (dp);
+	}
+      while (!GRUB_EFI_END_ENTIRE_DEVICE_PATH (dp) && buf < bufend);
+
+      dev = grub_xnu_devprop_add_device (dpstart, (char *) buf
+					 - (char *) dpstart);
+
+      for (j = 0; j < grub_le_to_cpu32 (devhead->num_values) && buf < bufend;
+	   j++)
+	{
+	  grub_uint32_t *namelen;
+	  grub_uint32_t *datalen;
+	  grub_uint16_t *utf16;
+	  void *data;
+	  grub_err_t err;
+
+	  namelen = buf;
+	  buf = namelen + 1;
+	  if (buf >= bufend)
+	    break;
+
+	  utf16 = buf;
+	  buf = (char *) buf + *namelen - sizeof (grub_uint32_t);
+	  if (buf >= bufend)
+	    break;
+
+	  datalen = buf;
+	  buf = datalen + 1;
+	  if (buf >= bufend)
+	    break;
+
+	  data = buf;
+	  buf = (char *) buf + *datalen - sizeof (grub_uint32_t);
+	  if (buf >= bufend)
+	    break;
+	  err = grub_xnu_devprop_add_property_utf16
+	    (dev, utf16, (*namelen - sizeof (grub_uint32_t)
+			  - sizeof (grub_uint16_t)) / sizeof (grub_uint16_t),
+	     data, *datalen - sizeof (grub_uint32_t));
+	  if (err)
+	    {
+	      grub_free (bufstart);
+	      return err;
+	    }
+	}
+    }
+
+  grub_free (bufstart);
+  return GRUB_ERR_NONE;
+}
+
 /* Fill device tree. */
 /* FIXME: some entries may be platform-agnostic. Move them to loader/xnu.c. */
 grub_err_t
@@ -208,11 +631,6 @@ grub_cpu_xnu_fill_devicetree (void)
   struct grub_xnu_devtree_key *runtimesrvkey;
   struct grub_xnu_devtree_key *platformkey;
   unsigned i, j;
-  grub_err_t err;
-
-  err = grub_autoefi_prepare ();
-  if (err)
-    return err;
 
   /* The value "model". */
   /* FIXME: may this value be sometimes different? */
@@ -513,12 +931,29 @@ grub_xnu_boot (void)
   grub_efi_uintn_t map_key = 0;
   grub_efi_uintn_t descriptor_size = 0;
   grub_efi_uint32_t descriptor_version = 0;
-  grub_uint64_t firstruntimeaddr, lastruntimeaddr;
+  grub_uint64_t firstruntimepage, lastruntimepage;
+  grub_uint64_t curruntimepage;
   void *devtree;
   grub_size_t devtreelen;
   int i;
   struct grub_relocator32_state state;
 
+  err = grub_autoefi_prepare ();
+  if (err)
+    return err;
+
+  err = grub_cpu_xnu_fill_devprop ();
+  if (err)
+    return err;
+
+  err = grub_cpu_xnu_fill_devicetree ();
+  if (err)
+    return err;
+
+  err = grub_xnu_fill_devicetree ();
+  if (err)
+    return err;
+
   /* Page-align to avoid following parts to be inadvertently freed. */
   err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE);
   if (err)
@@ -531,89 +966,6 @@ grub_xnu_boot (void)
   descriptor_size = 0;
   descriptor_version = 0;
 
-  if (grub_autoefi_get_memory_map (&memory_map_size, memory_map,
-				   &map_key, &descriptor_size,
-				   &descriptor_version) < 0)
-    return grub_errno;
-
-  memory_map = grub_xnu_heap_malloc (memory_map_size);
-  if (! memory_map)
-    return grub_errno;
-
-  if (grub_autoefi_get_memory_map (&memory_map_size, memory_map,
-				   &map_key, &descriptor_size,
-				   &descriptor_version) <= 0)
-    return grub_errno;
-  mmap_relloc_off = (grub_uint8_t *) memory_map
-    - (grub_uint8_t *) grub_xnu_heap_start;
-
-  firstruntimeaddr = (grub_uint64_t) (-1);
-  lastruntimeaddr = 0;
-  for (i = 0; (unsigned) i < memory_map_size / descriptor_size; i++)
-    {
-      grub_efi_memory_descriptor_t *curdesc = (grub_efi_memory_descriptor_t *)
-	((char *) memory_map + descriptor_size * i);
-
-      /* Some EFI implementations set physical_start to 0 which
-	 causes XNU crash. */
-      curdesc->virtual_start = curdesc->physical_start;
-
-      if (curdesc->type == GRUB_EFI_RUNTIME_SERVICES_DATA
-	  || curdesc->type == GRUB_EFI_RUNTIME_SERVICES_CODE)
-	{
-	  if (firstruntimeaddr > curdesc->physical_start)
-	    firstruntimeaddr = curdesc->physical_start;
-	  if (lastruntimeaddr < curdesc->physical_start
-	      + curdesc->num_pages * 4096)
-	    lastruntimeaddr = curdesc->physical_start
-	      + curdesc->num_pages * 4096;
-	}
-    }
-
-  /* Relocate the boot parameters to heap. */
-  bootparams_relloc = grub_xnu_heap_malloc (sizeof (*bootparams_relloc));
-  if (! bootparams_relloc)
-    return grub_errno;
-  bootparams_relloc_off = (grub_uint8_t *) bootparams_relloc
-    - (grub_uint8_t *) grub_xnu_heap_start;
-  err = grub_xnu_writetree_toheap (&devtree, &devtreelen);
-  if (err)
-    return err;
-  bootparams_relloc = (struct grub_xnu_boot_params *)
-    (bootparams_relloc_off + (grub_uint8_t *) grub_xnu_heap_start);
-
-  grub_memcpy (bootparams_relloc->cmdline, grub_xnu_cmdline,
-	       sizeof (bootparams_relloc->cmdline));
-
-  bootparams_relloc->devtree
-    = ((grub_uint8_t *) devtree - (grub_uint8_t *) grub_xnu_heap_start)
-    + grub_xnu_heap_will_be_at;
-  bootparams_relloc->devtreelen = devtreelen;
-
-  bootparams_relloc->heap_start = grub_xnu_heap_will_be_at;
-  bootparams_relloc->heap_size = grub_xnu_heap_size;
-
-  bootparams_relloc->efi_mmap = grub_xnu_heap_will_be_at + mmap_relloc_off;
-  bootparams_relloc->efi_mmap_size = memory_map_size;
-  bootparams_relloc->efi_mem_desc_size = descriptor_size;
-  bootparams_relloc->efi_mem_desc_version = descriptor_version;
-
-  bootparams_relloc->efi_runtime_first_page = firstruntimeaddr
-    / GRUB_XNU_PAGESIZE;
-  bootparams_relloc->efi_runtime_npages
-    = ((lastruntimeaddr + GRUB_XNU_PAGESIZE - 1) / GRUB_XNU_PAGESIZE)
-    - (firstruntimeaddr / GRUB_XNU_PAGESIZE);
-  bootparams_relloc->efi_uintnbits = SIZEOF_OF_UINTN * 8;
-  bootparams_relloc->efi_system_table
-    = PTR_TO_UINT32 (grub_autoefi_system_table);
-
-  bootparams_relloc->verminor = GRUB_XNU_BOOTARGS_VERMINOR;
-  bootparams_relloc->vermajor = GRUB_XNU_BOOTARGS_VERMAJOR;
-
-  /* Parameters for asm helper. */
-  grub_xnu_stack = bootparams_relloc->heap_start
-    + bootparams_relloc->heap_size + GRUB_XNU_PAGESIZE;
-  grub_xnu_arg1 = bootparams_relloc_off + grub_xnu_heap_will_be_at;
   grub_dprintf ("xnu", "eip=%x\n", grub_xnu_entry_point);
 
   const char *debug = grub_env_get ("debug");
@@ -624,6 +976,13 @@ grub_xnu_boot (void)
       grub_getkey ();
     }
 
+  /* Relocate the boot parameters to heap. */
+  bootparams_relloc = grub_xnu_heap_malloc (sizeof (*bootparams_relloc));
+  if (! bootparams_relloc)
+    return grub_errno;
+  bootparams_relloc_off = (grub_uint8_t *) bootparams_relloc
+    - (grub_uint8_t *) grub_xnu_heap_start;
+
   /* Set video. */
   err = grub_xnu_set_video (bootparams_relloc);
   if (err != GRUB_ERR_NONE)
@@ -640,12 +999,121 @@ grub_xnu_boot (void)
       bootparams_relloc->lfb_base = 0;
     }
 
-  if (! grub_autoefi_finish_boot_services ())
+  if (grub_autoefi_get_memory_map (&memory_map_size, memory_map,
+				   &map_key, &descriptor_size,
+				   &descriptor_version) < 0)
+    return grub_errno;
+
+  /* We will do few allocations later. Reserve some space for possible
+     memory map growth.  */
+  memory_map_size += 20 * descriptor_size;
+  memory_map = grub_xnu_heap_malloc (memory_map_size);
+  if (! memory_map)
+    return grub_errno;
+  mmap_relloc_off = (grub_uint8_t *) memory_map
+    - (grub_uint8_t *) grub_xnu_heap_start;
+
+  err = grub_xnu_writetree_toheap (&devtree, &devtreelen);
+  if (err)
+    return err;
+  bootparams_relloc = (struct grub_xnu_boot_params *)
+    (bootparams_relloc_off + (grub_uint8_t *) grub_xnu_heap_start);
+
+  grub_memcpy (bootparams_relloc->cmdline, grub_xnu_cmdline,
+	       sizeof (bootparams_relloc->cmdline));
+
+  bootparams_relloc->devtree
+    = ((grub_uint8_t *) devtree - (grub_uint8_t *) grub_xnu_heap_start)
+    + grub_xnu_heap_will_be_at;
+  bootparams_relloc->devtreelen = devtreelen;
+
+  memory_map = (grub_efi_memory_descriptor_t *)
+    ((grub_uint8_t *) grub_xnu_heap_start + mmap_relloc_off);
+
+  if (grub_autoefi_get_memory_map (&memory_map_size, memory_map,
+				   &map_key, &descriptor_size,
+				   &descriptor_version) <= 0)
+    return grub_errno;
+
+  bootparams_relloc->efi_system_table
+    = PTR_TO_UINT32 (grub_autoefi_system_table);
+
+  firstruntimepage = (((grub_addr_t) grub_xnu_heap_will_be_at
+		       + grub_xnu_heap_size + GRUB_XNU_PAGESIZE - 1)
+		      / GRUB_XNU_PAGESIZE) + 20;
+  curruntimepage = firstruntimepage;
+
+  for (i = 0; (unsigned) i < memory_map_size / descriptor_size; i++)
+    {
+      grub_efi_memory_descriptor_t *curdesc = (grub_efi_memory_descriptor_t *)
+	((char *) memory_map + descriptor_size * i);
+
+      curdesc->virtual_start = curdesc->physical_start;
+
+      if (curdesc->type == GRUB_EFI_RUNTIME_SERVICES_DATA
+	  || curdesc->type == GRUB_EFI_RUNTIME_SERVICES_CODE)
+	{
+	  curdesc->virtual_start = curruntimepage << 12;
+	  curruntimepage += curdesc->num_pages;
+	  if (curdesc->physical_start
+	      <= PTR_TO_UINT64 (grub_autoefi_system_table)
+	      && curdesc->physical_start + (curdesc->num_pages << 12)
+	      > PTR_TO_UINT64 (grub_autoefi_system_table))
+	    bootparams_relloc->efi_system_table
+	      = PTR_TO_UINT64 (grub_autoefi_system_table)
+	      - curdesc->physical_start + curdesc->virtual_start;
+	  if (SIZEOF_OF_UINTN == 8 && grub_xnu_is_64bit)
+	    curdesc->virtual_start |= 0xffffff8000000000ULL;
+	}
+    }
+
+  lastruntimepage = curruntimepage;
+
+  bootparams_relloc->efi_mmap = grub_xnu_heap_will_be_at + mmap_relloc_off;
+  bootparams_relloc->efi_mmap_size = memory_map_size;
+  bootparams_relloc->efi_mem_desc_size = descriptor_size;
+  bootparams_relloc->efi_mem_desc_version = descriptor_version;
+
+  bootparams_relloc->heap_start = grub_xnu_heap_will_be_at;
+  bootparams_relloc->heap_size = grub_xnu_heap_size;
+  bootparams_relloc->efi_runtime_first_page = firstruntimepage;
+
+  bootparams_relloc->efi_runtime_npages = lastruntimepage - firstruntimepage;
+  bootparams_relloc->efi_uintnbits = SIZEOF_OF_UINTN * 8;
+
+  bootparams_relloc->verminor = GRUB_XNU_BOOTARGS_VERMINOR;
+  bootparams_relloc->vermajor = GRUB_XNU_BOOTARGS_VERMAJOR;
+
+  /* Parameters for asm helper. */
+  grub_xnu_stack = bootparams_relloc->heap_start
+    + bootparams_relloc->heap_size + GRUB_XNU_PAGESIZE;
+  grub_xnu_arg1 = bootparams_relloc_off + grub_xnu_heap_will_be_at;
+
+  if (! grub_autoefi_exit_boot_services (map_key))
     return grub_error (GRUB_ERR_IO, "can't exit boot services");
 
+  grub_autoefi_set_virtual_address_map (memory_map_size, descriptor_size,
+					descriptor_version,memory_map);
+
   state.eip = grub_xnu_entry_point;
   state.eax = grub_xnu_arg1;
   state.esp = grub_xnu_stack;
   return grub_relocator32_boot (grub_xnu_heap_start, grub_xnu_heap_will_be_at,
 				state);
 }
+
+static grub_command_t cmd_devprop_load;
+
+void
+grub_cpu_xnu_init (void)
+{
+  cmd_devprop_load = grub_register_command ("xnu_devprop_load",
+					    grub_cmd_devprop_load,
+					    0, "Load device-properties dump.");
+}
+
+void
+grub_cpu_xnu_fini (void)
+{
+  grub_unregister_command (cmd_devprop_load);
+}
diff --git a/loader/ieee1275/multiboot2.c b/loader/ieee1275/multiboot2.c
index 3646e8091..3b0ab758e 100644
--- a/loader/ieee1275/multiboot2.c
+++ b/loader/ieee1275/multiboot2.c
@@ -36,7 +36,8 @@ typedef void (*kernel_entry_t) (unsigned long, void *, int (void *),
 
 /* Claim the memory occupied by the multiboot kernel.  */
 grub_err_t
-grub_mb2_arch_elf32_hook (Elf32_Phdr *phdr, UNUSED grub_addr_t *addr,
+grub_mb2_arch_elf32_hook (Elf32_Phdr *phdr,
+			  grub_addr_t *addr __attribute__((unused)),
 			  int *do_load)
 {
   int rc;
@@ -61,7 +62,8 @@ grub_mb2_arch_elf32_hook (Elf32_Phdr *phdr, UNUSED grub_addr_t *addr,
 
 /* Claim the memory occupied by the multiboot kernel.  */
 grub_err_t
-grub_mb2_arch_elf64_hook (Elf64_Phdr *phdr, UNUSED grub_addr_t *addr,
+grub_mb2_arch_elf64_hook (Elf64_Phdr *phdr,
+			  grub_addr_t *addr __attribute__((unused)),
 			  int *do_load)
 {
   int rc;
diff --git a/loader/macho.c b/loader/macho.c
index bd460b810..a23f5b206 100644
--- a/loader/macho.c
+++ b/loader/macho.c
@@ -30,239 +30,6 @@
 #include <grub/misc.h>
 #include <grub/mm.h>
 
-#define min(a,b) (((a) < (b)) ? (a) : (b))
-
-/* 32-bit. */
-
-int
-grub_macho_contains_macho32 (grub_macho_t macho)
-{
-  return macho->offset32 != -1;
-}
-
-static void
-grub_macho_parse32 (grub_macho_t macho)
-{
-  struct grub_macho_header32 head;
-
-  /* Is there any candidate at all? */
-  if (macho->offset32 == -1)
-    return;
-
-  /* Read header and check magic*/
-  if (grub_file_seek (macho->file, macho->offset32) == (grub_off_t) -1
-      || grub_file_read (macho->file, &head, sizeof (head))
-      != sizeof(head))
-    {
-      grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
-      macho->offset32 = -1;
-      return;
-    }
-  if (head.magic != GRUB_MACHO_MAGIC32)
-    {
-      grub_error (GRUB_ERR_BAD_OS, "Invalid Mach-O 32-bit header.");
-      macho->offset32 = -1;
-      return;
-    }
-
-  /* Read commands. */
-  macho->ncmds32 = head.ncmds;
-  macho->cmdsize32 = head.sizeofcmds;
-  macho->cmds32 = grub_malloc(macho->cmdsize32);
-  if (! macho->cmds32)
-    {
-      grub_error (GRUB_ERR_OUT_OF_MEMORY, "not enough memory to read commands");
-      return;
-    }
-  if (grub_file_read (macho->file, macho->cmds32,
-		      (grub_size_t) macho->cmdsize32)
-      != (grub_ssize_t) macho->cmdsize32)
-    {
-      grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
-      macho->offset32 = -1;
-    }
-}
-
-typedef int NESTED_FUNC_ATTR (*grub_macho_iter_hook_t)
-(grub_macho_t , struct grub_macho_cmd *,
-	       void *);
-
-static grub_err_t
-grub_macho32_cmds_iterate (grub_macho_t macho,
-			   grub_macho_iter_hook_t hook,
-			   void *hook_arg)
-{
-  grub_uint8_t *hdrs = macho->cmds32;
-  int i;
-  if (! macho->cmds32)
-    return grub_error (GRUB_ERR_BAD_OS, "Couldn't find 32-bit Mach-O");
-  for (i = 0; i < macho->ncmds32; i++)
-    {
-      struct grub_macho_cmd *hdr = (struct grub_macho_cmd *) hdrs;
-      if (hook (macho, hdr, hook_arg))
-	break;
-      hdrs += hdr->cmdsize;
-    }
-
-  return grub_errno;
-}
-
-grub_size_t
-grub_macho32_filesize (grub_macho_t macho)
-{
-  if (grub_macho_contains_macho32 (macho))
-    return macho->end32 - macho->offset32;
-  return 0;
-}
-
-grub_err_t
-grub_macho32_readfile (grub_macho_t macho, void *dest)
-{
-  grub_ssize_t read;
-  if (! grub_macho_contains_macho32 (macho))
-    return grub_error (GRUB_ERR_BAD_OS,
-		       "Couldn't read architecture-specific part");
-
-  if (grub_file_seek (macho->file, macho->offset32) == (grub_off_t) -1)
-    {
-      grub_error_push ();
-      return grub_error (GRUB_ERR_BAD_OS,
-			 "Invalid offset in program header.");
-    }
-
-  read = grub_file_read (macho->file, dest,
-			 macho->end32 - macho->offset32);
-  if (read != (grub_ssize_t) (macho->end32 - macho->offset32))
-    {
-      grub_error_push ();
-      return grub_error (GRUB_ERR_BAD_OS,
-			 "Couldn't read architecture-specific part");
-    }
-  return GRUB_ERR_NONE;
-}
-
-/* Calculate the amount of memory spanned by the segments. */
-grub_err_t
-grub_macho32_size (grub_macho_t macho, grub_addr_t *segments_start,
-		   grub_addr_t *segments_end, int flags)
-{
-  int nr_phdrs = 0;
-
-  /* Run through the program headers to calculate the total memory size we
-     should claim.  */
-  auto int NESTED_FUNC_ATTR calcsize (grub_macho_t _macho,
-				      struct grub_macho_cmd *phdr, void *_arg);
-  int NESTED_FUNC_ATTR calcsize (grub_macho_t UNUSED _macho,
-				 struct grub_macho_cmd *hdr0, void UNUSED *_arg)
-    {
-      struct grub_macho_segment32 *hdr = (struct grub_macho_segment32 *) hdr0;
-      if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT32)
-	return 0;
-      if (! hdr->filesize && (flags & GRUB_MACHO_NOBSS))
-	return 0;
-
-      nr_phdrs++;
-      if (hdr->vmaddr < *segments_start)
-	*segments_start = hdr->vmaddr;
-      if (hdr->vmaddr + hdr->vmsize > *segments_end)
-	*segments_end = hdr->vmaddr + hdr->vmsize;
-      return 0;
-    }
-
-  *segments_start = (grub_uint32_t) -1;
-  *segments_end = 0;
-
-  grub_macho32_cmds_iterate (macho, calcsize, 0);
-
-  if (nr_phdrs == 0)
-    return grub_error (GRUB_ERR_BAD_OS, "No program headers present");
-
-  if (*segments_end < *segments_start)
-    /* Very bad addresses.  */
-    return grub_error (GRUB_ERR_BAD_OS, "Bad program header load addresses");
-
-  return GRUB_ERR_NONE;
-}
-
-/* Load every loadable segment into memory specified by `_load_hook'.  */
-grub_err_t
-grub_macho32_load (grub_macho_t macho, char *offset, int flags)
-{
-  grub_err_t err = 0;
-  auto int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
-			       struct grub_macho_cmd *hdr0,
-			       void UNUSED *_arg);
-  int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
-			       struct grub_macho_cmd *hdr0,
-			       void UNUSED *_arg)
-  {
-    struct grub_macho_segment32 *hdr = (struct grub_macho_segment32 *) hdr0;
-
-    if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT32)
-      return 0;
-
-    if (! hdr->filesize && (flags & GRUB_MACHO_NOBSS))
-      return 0;
-    if (! hdr->vmsize)
-      return 0;
-
-    if (grub_file_seek (_macho->file, hdr->fileoff
-			+ _macho->offset32) == (grub_off_t) -1)
-      {
-	grub_error_push ();
-	grub_error (GRUB_ERR_BAD_OS,
-		    "Invalid offset in program header.");
-	return 1;
-      }
-
-    if (hdr->filesize)
-      {
-	grub_ssize_t read;
-	read = grub_file_read (_macho->file, offset + hdr->vmaddr,
-				   min (hdr->filesize, hdr->vmsize));
-	if (read != (grub_ssize_t) min (hdr->filesize, hdr->vmsize))
-	  {
-	    /* XXX How can we free memory from `load_hook'? */
-	    grub_error_push ();
-	    err=grub_error (GRUB_ERR_BAD_OS,
-			    "Couldn't read segment from file: "
-			    "wanted 0x%lx bytes; read 0x%lx bytes.",
-			    hdr->filesize, read);
-	    return 1;
-	  }
-      }
-
-    if (hdr->filesize < hdr->vmsize)
-      grub_memset (offset + hdr->vmaddr + hdr->filesize,
-		   0, hdr->vmsize - hdr->filesize);
-    return 0;
-  }
-
-  grub_macho32_cmds_iterate (macho, do_load, 0);
-
-  return err;
-}
-
-grub_uint32_t
-grub_macho32_get_entry_point (grub_macho_t macho)
-{
-  grub_uint32_t entry_point = 0;
-  auto int NESTED_FUNC_ATTR hook(grub_macho_t _macho,
-			       struct grub_macho_cmd *hdr,
-			       void UNUSED *_arg);
-  int NESTED_FUNC_ATTR hook(grub_macho_t UNUSED _macho,
-			       struct grub_macho_cmd *hdr,
-			       void UNUSED *_arg)
-  {
-    if (hdr->cmd == GRUB_MACHO_CMD_THREAD)
-      entry_point = ((struct grub_macho_thread32 *) hdr)->entry_point;
-    return 0;
-  }
-  grub_macho32_cmds_iterate (macho, hook, 0);
-  return entry_point;
-}
-
-
 grub_err_t
 grub_macho_close (grub_macho_t macho)
 {
@@ -367,8 +134,7 @@ grub_macho_file (grub_file_t file)
     }
 
   grub_macho_parse32 (macho);
-  /* FIXME: implement 64-bit.*/
-  /*  grub_macho_parse64 (macho); */
+  grub_macho_parse64 (macho);
 
   return macho;
 
diff --git a/loader/macho32.c b/loader/macho32.c
new file mode 100644
index 000000000..0d740eda7
--- /dev/null
+++ b/loader/macho32.c
@@ -0,0 +1,18 @@
+#include <grub/cpu/macho.h>
+#include <grub/machoload.h>
+
+#define SUFFIX(x) x ## 32
+typedef struct grub_macho_header32 grub_macho_header_t;
+typedef struct grub_macho_segment32 grub_macho_segment_t;
+typedef grub_uint32_t grub_macho_addr_t;
+typedef struct grub_macho_thread32 grub_macho_thread_t;
+#define offsetXX offset32
+#define ncmdsXX ncmds32
+#define cmdsizeXX cmdsize32
+#define cmdsXX cmds32
+#define endXX end32
+#define XX "32"
+#define GRUB_MACHO_MAGIC GRUB_MACHO_MAGIC32
+#define GRUB_MACHO_CMD_SEGMENT GRUB_MACHO_CMD_SEGMENT32
+#include "machoXX.c"
+
diff --git a/loader/macho64.c b/loader/macho64.c
new file mode 100644
index 000000000..17a8021e0
--- /dev/null
+++ b/loader/macho64.c
@@ -0,0 +1,18 @@
+#include <grub/cpu/macho.h>
+#include <grub/machoload.h>
+
+#define SUFFIX(x) x ## 64
+typedef struct grub_macho_header64 grub_macho_header_t;
+typedef struct grub_macho_segment64 grub_macho_segment_t;
+typedef grub_uint64_t grub_macho_addr_t;
+typedef struct grub_macho_thread64 grub_macho_thread_t;
+#define offsetXX offset64
+#define ncmdsXX ncmds64
+#define cmdsizeXX cmdsize64
+#define cmdsXX cmds64
+#define endXX end64
+#define XX "64"
+#define GRUB_MACHO_MAGIC GRUB_MACHO_MAGIC64
+#define GRUB_MACHO_CMD_SEGMENT GRUB_MACHO_CMD_SEGMENT64
+#include "machoXX.c"
+
diff --git a/loader/machoXX.c b/loader/machoXX.c
new file mode 100644
index 000000000..8441e0128
--- /dev/null
+++ b/loader/machoXX.c
@@ -0,0 +1,239 @@
+
+#include <grub/file.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+
+int
+SUFFIX (grub_macho_contains_macho) (grub_macho_t macho)
+{
+  return macho->offsetXX != -1;
+}
+
+void
+SUFFIX (grub_macho_parse) (grub_macho_t macho)
+{
+  grub_macho_header_t head;
+
+  /* Is there any candidate at all? */
+  if (macho->offsetXX == -1)
+    return;
+
+  /* Read header and check magic*/
+  if (grub_file_seek (macho->file, macho->offsetXX) == (grub_off_t) -1
+      || grub_file_read (macho->file, &head, sizeof (head))
+      != sizeof(head))
+    {
+      grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
+      macho->offsetXX = -1;
+      return;
+    }
+  if (head.magic != GRUB_MACHO_MAGIC)
+    {
+      grub_error (GRUB_ERR_BAD_OS, "Invalid Mach-O " XX "-bit header.");
+      macho->offsetXX = -1;
+      return;
+    }
+
+  /* Read commands. */
+  macho->ncmdsXX = head.ncmds;
+  macho->cmdsizeXX = head.sizeofcmds;
+  macho->cmdsXX = grub_malloc(macho->cmdsizeXX);
+  if (! macho->cmdsXX)
+    {
+      grub_error (GRUB_ERR_OUT_OF_MEMORY, "not enough memory to read commands");
+      return;
+    }
+  if (grub_file_read (macho->file, macho->cmdsXX,
+		      (grub_size_t) macho->cmdsizeXX)
+      != (grub_ssize_t) macho->cmdsizeXX)
+    {
+      grub_error (GRUB_ERR_READ_ERROR, "Cannot read Mach-O header.");
+      macho->offsetXX = -1;
+    }
+}
+
+typedef int NESTED_FUNC_ATTR (*grub_macho_iter_hook_t)
+(grub_macho_t , struct grub_macho_cmd *,
+	       void *);
+
+static grub_err_t
+grub_macho_cmds_iterate (grub_macho_t macho,
+			 grub_macho_iter_hook_t hook,
+			 void *hook_arg)
+{
+  grub_uint8_t *hdrs = macho->cmdsXX;
+  int i;
+  if (! macho->cmdsXX)
+    return grub_error (GRUB_ERR_BAD_OS, "Couldn't find " XX "-bit Mach-O");
+  for (i = 0; i < macho->ncmdsXX; i++)
+    {
+      struct grub_macho_cmd *hdr = (struct grub_macho_cmd *) hdrs;
+      if (hook (macho, hdr, hook_arg))
+	break;
+      hdrs += hdr->cmdsize;
+    }
+
+  return grub_errno;
+}
+
+grub_size_t
+SUFFIX (grub_macho_filesize) (grub_macho_t macho)
+{
+  if (SUFFIX (grub_macho_contains_macho) (macho))
+    return macho->endXX - macho->offsetXX;
+  return 0;
+}
+
+grub_err_t
+SUFFIX (grub_macho_readfile) (grub_macho_t macho, void *dest)
+{
+  grub_ssize_t read;
+  if (! SUFFIX (grub_macho_contains_macho) (macho))
+    return grub_error (GRUB_ERR_BAD_OS,
+		       "Couldn't read architecture-specific part");
+
+  if (grub_file_seek (macho->file, macho->offsetXX) == (grub_off_t) -1)
+    {
+      grub_error_push ();
+      return grub_error (GRUB_ERR_BAD_OS,
+			 "Invalid offset in program header.");
+    }
+
+  read = grub_file_read (macho->file, dest,
+			 macho->endXX - macho->offsetXX);
+  if (read != (grub_ssize_t) (macho->endXX - macho->offsetXX))
+    {
+      grub_error_push ();
+      return grub_error (GRUB_ERR_BAD_OS,
+			 "Couldn't read architecture-specific part");
+    }
+  return GRUB_ERR_NONE;
+}
+
+/* Calculate the amount of memory spanned by the segments. */
+grub_err_t
+SUFFIX (grub_macho_size) (grub_macho_t macho, grub_macho_addr_t *segments_start,
+			  grub_macho_addr_t *segments_end, int flags)
+{
+  int nr_phdrs = 0;
+
+  /* Run through the program headers to calculate the total memory size we
+     should claim.  */
+  auto int NESTED_FUNC_ATTR calcsize (grub_macho_t _macho,
+				      struct grub_macho_cmd *phdr, void *_arg);
+  int NESTED_FUNC_ATTR calcsize (grub_macho_t _macho __attribute__ ((unused)),
+				 struct grub_macho_cmd *hdr0,
+				 void *_arg __attribute__ ((unused)))
+    {
+      grub_macho_segment_t *hdr = (grub_macho_segment_t *) hdr0;
+      if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT)
+	return 0;
+
+      if (! hdr->vmsize)
+	return 0;
+
+      if (! hdr->filesize && (flags & GRUB_MACHO_NOBSS))
+	return 0;
+
+      nr_phdrs++;
+      if (hdr->vmaddr < *segments_start)
+	*segments_start = hdr->vmaddr;
+      if (hdr->vmaddr + hdr->vmsize > *segments_end)
+	*segments_end = hdr->vmaddr + hdr->vmsize;
+      return 0;
+    }
+
+  *segments_start = (grub_macho_addr_t) -1;
+  *segments_end = 0;
+
+  grub_macho_cmds_iterate (macho, calcsize, 0);
+
+  if (nr_phdrs == 0)
+    return grub_error (GRUB_ERR_BAD_OS, "No program headers present");
+
+  if (*segments_end < *segments_start)
+    /* Very bad addresses.  */
+    return grub_error (GRUB_ERR_BAD_OS, "Bad program header load addresses");
+
+  return GRUB_ERR_NONE;
+}
+
+/* Load every loadable segment into memory specified by `_load_hook'.  */
+grub_err_t
+SUFFIX (grub_macho_load) (grub_macho_t macho, char *offset, int flags)
+{
+  grub_err_t err = 0;
+  auto int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
+			       struct grub_macho_cmd *hdr0,
+			       void *_arg __attribute__ ((unused)));
+  int NESTED_FUNC_ATTR do_load(grub_macho_t _macho,
+			       struct grub_macho_cmd *hdr0,
+			       void *_arg __attribute__ ((unused)))
+  {
+    grub_macho_segment_t *hdr = (grub_macho_segment_t *) hdr0;
+
+    if (hdr->cmd != GRUB_MACHO_CMD_SEGMENT)
+      return 0;
+
+    if (! hdr->filesize && (flags & GRUB_MACHO_NOBSS))
+      return 0;
+    if (! hdr->vmsize)
+      return 0;
+
+    if (grub_file_seek (_macho->file, hdr->fileoff
+			+ _macho->offsetXX) == (grub_off_t) -1)
+      {
+	grub_error_push ();
+	grub_error (GRUB_ERR_BAD_OS,
+		    "Invalid offset in program header.");
+	return 1;
+      }
+
+    if (hdr->filesize)
+      {
+	grub_ssize_t read;
+	read = grub_file_read (_macho->file, offset + hdr->vmaddr,
+				   min (hdr->filesize, hdr->vmsize));
+	if (read != (grub_ssize_t) min (hdr->filesize, hdr->vmsize))
+	  {
+	    /* XXX How can we free memory from `load_hook'? */
+	    grub_error_push ();
+	    err=grub_error (GRUB_ERR_BAD_OS,
+			    "Couldn't read segment from file: "
+			    "wanted 0x%lx bytes; read 0x%lx bytes.",
+			    hdr->filesize, read);
+	    return 1;
+	  }
+      }
+
+    if (hdr->filesize < hdr->vmsize)
+      grub_memset (offset + hdr->vmaddr + hdr->filesize,
+		   0, hdr->vmsize - hdr->filesize);
+    return 0;
+  }
+
+  grub_macho_cmds_iterate (macho, do_load, 0);
+
+  return err;
+}
+
+grub_macho_addr_t
+SUFFIX (grub_macho_get_entry_point) (grub_macho_t macho)
+{
+  grub_macho_addr_t entry_point = 0;
+  auto int NESTED_FUNC_ATTR hook(grub_macho_t _macho,
+				 struct grub_macho_cmd *hdr,
+				 void *_arg __attribute__ ((unused)));
+  int NESTED_FUNC_ATTR hook(grub_macho_t _macho __attribute__ ((unused)),
+			    struct grub_macho_cmd *hdr,
+			    void *_arg __attribute__ ((unused)))
+  {
+    if (hdr->cmd == GRUB_MACHO_CMD_THREAD)
+      entry_point = ((grub_macho_thread_t *) hdr)->entry_point;
+    return 0;
+  }
+  grub_macho_cmds_iterate (macho, hook, 0);
+  return entry_point;
+}
diff --git a/loader/multiboot2.c b/loader/multiboot2.c
index 976285b85..4c73a2f17 100644
--- a/loader/multiboot2.c
+++ b/loader/multiboot2.c
@@ -222,7 +222,8 @@ grub_mb2_unload (void)
 }
 
 static grub_err_t
-grub_mb2_load_other (UNUSED grub_file_t file, UNUSED void *buffer)
+grub_mb2_load_other (grub_file_t file __attribute__ ((unused)),
+		     void *buffer __attribute__ ((unused)))
 {
   /* XXX Create module tag here.  */
   return grub_error (GRUB_ERR_UNKNOWN_OS, "currently only ELF is supported");
diff --git a/loader/xnu.c b/loader/xnu.c
index cc6d55ae2..7d33f8ea4 100644
--- a/loader/xnu.c
+++ b/loader/xnu.c
@@ -31,10 +31,12 @@
 #include <grub/gzio.h>
 #include <grub/command.h>
 #include <grub/misc.h>
+#include <grub/env.h>
 
 struct grub_xnu_devtree_key *grub_xnu_devtree_root = 0;
 static int driverspackagenum = 0;
 static int driversnum = 0;
+int grub_xnu_is_64bit = 0;
 
 void *grub_xnu_heap_start = 0;
 grub_size_t grub_xnu_heap_size = 0;
@@ -326,6 +328,8 @@ grub_xnu_create_value (struct grub_xnu_devtree_key **parent, char *name)
 static grub_err_t
 grub_xnu_unload (void)
 {
+  grub_cpu_xnu_unload ();
+
   grub_xnu_free_devtree (grub_xnu_devtree_root);
   grub_xnu_devtree_root = 0;
 
@@ -345,7 +349,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
 {
   grub_err_t err;
   grub_macho_t macho;
-  grub_addr_t startcode, endcode;
+  grub_uint32_t startcode, endcode;
   int i;
   char *ptr, *loadaddr;
 
@@ -361,10 +365,10 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
     {
       grub_macho_close (macho);
       return grub_error (GRUB_ERR_BAD_OS,
-			 "Kernel doesn't contain suitable architecture");
+			 "Kernel doesn't contain suitable 32-bit architecture");
     }
 
-  err = grub_macho32_size (macho, &startcode, &endcode, GRUB_MACHO_NOBSS);
+  err = grub_macho_size32 (macho, &startcode, &endcode, GRUB_MACHO_NOBSS);
   if (err)
     {
       grub_macho_close (macho);
@@ -387,7 +391,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
     }
 
   /* Load kernel. */
-  err = grub_macho32_load (macho, loadaddr - startcode, GRUB_MACHO_NOBSS);
+  err = grub_macho_load32 (macho, loadaddr - startcode, GRUB_MACHO_NOBSS);
   if (err)
     {
       grub_macho_close (macho);
@@ -395,7 +399,7 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
       return err;
     }
 
-  grub_xnu_entry_point = grub_macho32_get_entry_point (macho);
+  grub_xnu_entry_point = grub_macho_get_entry_point32 (macho);
   if (! grub_xnu_entry_point)
     {
       grub_macho_close (macho);
@@ -429,13 +433,112 @@ grub_cmd_xnu_kernel (grub_command_t cmd __attribute__ ((unused)),
   if (ptr != grub_xnu_cmdline)
     *(ptr - 1) = 0;
 
-  err = grub_cpu_xnu_fill_devicetree ();
+  grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0);
+
+  grub_xnu_lock ();
+  grub_xnu_is_64bit = 0;
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_xnu_kernel64 (grub_command_t cmd __attribute__ ((unused)),
+		       int argc, char *args[])
+{
+  grub_err_t err;
+  grub_macho_t macho;
+  grub_uint64_t startcode, endcode;
+  int i;
+  char *ptr, *loadaddr;
+
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
+
+  grub_xnu_unload ();
+
+  macho = grub_macho_open (args[0]);
+  if (! macho)
+    return grub_errno;
+  if (! grub_macho_contains_macho64 (macho))
+    {
+      grub_macho_close (macho);
+      return grub_error (GRUB_ERR_BAD_OS,
+			 "Kernel doesn't contain suitable 64-bit architecture");
+    }
+
+  err = grub_macho_size64 (macho, &startcode, &endcode, GRUB_MACHO_NOBSS);
   if (err)
-    return err;
+    {
+      grub_macho_close (macho);
+      grub_xnu_unload ();
+      return err;
+    }
+
+  startcode &= 0x0fffffff;
+  endcode &= 0x0fffffff;
+
+  grub_dprintf ("xnu", "endcode = %lx, startcode = %lx\n",
+		(unsigned long) endcode, (unsigned long) startcode);
+
+  loadaddr = grub_xnu_heap_malloc (endcode - startcode);
+  grub_xnu_heap_will_be_at = startcode;
+
+  if (! loadaddr)
+    {
+      grub_macho_close (macho);
+      grub_xnu_unload ();
+      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+			 "not enough memory to load kernel");
+    }
+
+  /* Load kernel. */
+  err = grub_macho_load64 (macho, loadaddr - startcode, GRUB_MACHO_NOBSS);
+  if (err)
+    {
+      grub_macho_close (macho);
+      grub_xnu_unload ();
+      return err;
+    }
+
+  grub_xnu_entry_point = grub_macho_get_entry_point64 (macho) & 0x0fffffff;
+  if (! grub_xnu_entry_point)
+    {
+      grub_macho_close (macho);
+      grub_xnu_unload ();
+      return grub_error (GRUB_ERR_BAD_OS, "couldn't find entry point");
+    }
+
+  grub_macho_close (macho);
+
+  err = grub_xnu_align_heap (GRUB_XNU_PAGESIZE);
+  if (err)
+    {
+      grub_xnu_unload ();
+      return err;
+    }
+
+  /* Copy parameters to kernel command line. */
+  ptr = grub_xnu_cmdline;
+  for (i = 1; i < argc; i++)
+    {
+      if (ptr + grub_strlen (args[i]) + 1
+	  >= grub_xnu_cmdline + sizeof (grub_xnu_cmdline))
+	break;
+      grub_memcpy (ptr, args[i], grub_strlen (args[i]));
+      ptr += grub_strlen (args[i]);
+      *ptr = ' ';
+      ptr++;
+    }
+
+  /* Replace last space by '\0'. */
+  if (ptr != grub_xnu_cmdline)
+    *(ptr - 1) = 0;
 
   grub_loader_set (grub_xnu_boot, grub_xnu_unload, 0);
 
   grub_xnu_lock ();
+  grub_xnu_is_64bit = 1;
+
   return 0;
 }
 
@@ -487,6 +590,34 @@ grub_xnu_register_memory (char *prefix, int *suffix,
   return GRUB_ERR_NONE;
 }
 
+static inline char *
+get_name_ptr (char *name)
+{
+  char *p = name, *p2;
+  /* Skip Info.plist.  */
+  p2 = grub_strrchr (p, '/');
+  if (!p2)
+    return name;
+  if (p2 == name)
+    return name + 1;
+  p = p2 - 1;
+
+  p2 = grub_strrchr (p, '/');
+  if (!p2)
+    return name;
+  if (p2 == name)
+    return name + 1;
+  if (grub_memcmp (p2, "/Contents/", sizeof ("/Contents/") - 1) != 0)
+    return p2 + 1;
+
+  p = p2 - 1;
+
+  p2 = grub_strrchr (p, '/');
+  if (!p2)
+    return name;
+  return p2 + 1;
+}
+
 /* Load .kext. */
 static grub_err_t
 grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
@@ -498,6 +629,18 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
   int neededspace = sizeof (*exthead);
   grub_uint8_t *buf;
   grub_size_t infoplistsize = 0, machosize = 0;
+  char *name, *nameend;
+  int namelen;
+
+  name = get_name_ptr (infoplistname);
+  nameend = grub_strchr (name, '/');
+
+  if (nameend)
+    namelen = nameend - name;
+  else
+    namelen = grub_strlen (name);
+
+  neededspace += namelen + 1;
 
   if (! grub_xnu_heap_size)
     return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
@@ -513,7 +656,10 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
 	  return grub_error (GRUB_ERR_BAD_OS,
 			     "Extension doesn't contain suitable architecture");
 	}
-      machosize = grub_macho32_filesize (macho);
+      if (grub_xnu_is_64bit)
+	machosize = grub_macho_filesize64 (macho);
+      else
+	machosize = grub_macho_filesize32 (macho);
       neededspace += machosize;
     }
   else
@@ -548,7 +694,11 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
       exthead->binaryaddr = (buf - (grub_uint8_t *) grub_xnu_heap_start)
 	+ grub_xnu_heap_will_be_at;
       exthead->binarysize = machosize;
-      if ((err = grub_macho32_readfile (macho, buf)))
+      if (grub_xnu_is_64bit)
+	err = grub_macho_readfile64 (macho, buf);
+      else
+	err = grub_macho_readfile32 (macho, buf);
+      if (err)
 	{
 	  grub_macho_close (macho);
 	  return err;
@@ -574,9 +724,17 @@ grub_xnu_load_driver (char *infoplistname, grub_file_t binaryfile)
 	}
       grub_file_close (infoplist);
       buf[infoplistsize] = 0;
+      buf += infoplistsize + 1;
     }
   grub_errno = GRUB_ERR_NONE;
 
+  exthead->nameaddr = (buf - (grub_uint8_t *) grub_xnu_heap_start)
+    + grub_xnu_heap_will_be_at;
+  exthead->namesize = namelen + 1;
+  grub_memcpy (buf, name, namelen);
+  buf[namelen] = 0;
+  buf += namelen + 1;
+
   /* Announce to kernel */
   return grub_xnu_register_memory ("Driver-", &driversnum, exthead,
 				   neededspace);
@@ -641,7 +799,13 @@ grub_cmd_xnu_mkext (grub_command_t cmd __attribute__ ((unused)),
 	}
       for (i = 0; i < narchs; i++)
 	{
-	  if (GRUB_MACHO_CPUTYPE_IS_HOST32
+	  if (!grub_xnu_is_64bit && GRUB_MACHO_CPUTYPE_IS_HOST32
+	      (grub_be_to_cpu32 (archs[i].cputype)))
+	    {
+	      readoff = grub_be_to_cpu32 (archs[i].offset);
+	      readlen = grub_be_to_cpu32 (archs[i].size);
+	    }
+	  if (grub_xnu_is_64bit && GRUB_MACHO_CPUTYPE_IS_HOST64
 	      (grub_be_to_cpu32 (archs[i].cputype)))
 	    {
 	      readoff = grub_be_to_cpu32 (archs[i].offset);
@@ -732,135 +896,6 @@ grub_cmd_xnu_ramdisk (grub_command_t cmd __attribute__ ((unused)),
   return grub_xnu_register_memory ("RAMDisk", 0, loadto, size);
 }
 
-/* Parse a devtree file. It uses the following format:
-   valuename:valuedata;
-   keyname{
-     contents
-   }
-   keyname, valuename and valuedata are in hex.
- */
-static char *
-grub_xnu_parse_devtree (struct grub_xnu_devtree_key **parent,
-			char *start, char *end)
-{
-  char *ptr, *ptr2;
-  char *name, *data;
-  int namelen, datalen, i;
-  for (ptr = start; ptr && ptr < end; )
-    {
-      if (grub_isspace (*ptr))
-	{
-	  ptr++;
-	  continue;
-	}
-      if (*ptr == '}')
-	return ptr + 1;
-      namelen = 0;
-
-      /* Parse the name. */
-      for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
-				      || (*ptr2 >= '0' && *ptr2 <= '9')
-				      || (*ptr2 >= 'a' && *ptr2 <= 'f')
-				      || (*ptr2 >= 'A' && *ptr2 <= 'F'));
-	   ptr2++)
-	if (! grub_isspace (*ptr2))
-	  namelen++;
-      if (ptr2 == end)
-	return 0;
-      namelen /= 2;
-      name = grub_malloc (namelen + 1);
-      if (!name)
-	return 0;
-      for (i = 0; i < 2 * namelen; i++)
-	{
-	  int hex = 0;
-	  while (grub_isspace (*ptr))
-	    ptr++;
-	  if (*ptr >= '0' && *ptr <= '9')
-	    hex = *ptr - '0';
-	  if (*ptr >= 'a' && *ptr <= 'f')
-	    hex = *ptr - 'a' + 10;
-	  if (*ptr >= 'A' && *ptr <= 'F')
-	    hex = *ptr - 'A' + 10;
-
-	  if (i % 2 == 0)
-	    name[i / 2] = hex << 4;
-	  else
-	    name[i / 2] |= hex;
-	  ptr++;
-	}
-      name [namelen] = 0;
-      while (grub_isspace (*ptr))
-	ptr++;
-
-      /* If it describes a key recursively invoke the function. */
-      if (*ptr == '{')
-	{
-	  struct grub_xnu_devtree_key *newkey
-	    = grub_xnu_create_key (parent, name);
-	  grub_free (name);
-	  if (! newkey)
-	    return 0;
-	  ptr = grub_xnu_parse_devtree (&(newkey->first_child), ptr + 1, end);
-	  continue;
-	}
-
-      /* Parse the data. */
-      if (*ptr != ':')
-	return 0;
-      ptr++;
-      datalen = 0;
-      for (ptr2 = ptr; ptr2 < end && (grub_isspace (*ptr2)
-				      || (*ptr2 >= '0' && *ptr2 <= '9')
-				      || (*ptr2 >= 'a' && *ptr2 <= 'f')
-				      || (*ptr2 >= 'A' && *ptr2 <= 'F'));
-	   ptr2++)
-	if (! grub_isspace (*ptr2))
-	  datalen++;
-      if (ptr2 == end)
-	return 0;
-      datalen /= 2;
-      data = grub_malloc (datalen);
-      if (! data)
-	return 0;
-      for (i = 0; i < 2 * datalen; i++)
-	{
-	  int hex = 0;
-	  while (grub_isspace (*ptr))
-	    ptr++;
-	  if (*ptr >= '0' && *ptr <= '9')
-	    hex = *ptr - '0';
-	  if (*ptr >= 'a' && *ptr <= 'f')
-	    hex = *ptr - 'a' + 10;
-	  if (*ptr >= 'A' && *ptr <= 'F')
-	    hex = *ptr - 'A' + 10;
-
-	  if (i % 2 == 0)
-	    data[i / 2] = hex << 4;
-	  else
-	    data[i / 2] |= hex;
-	  ptr++;
-	}
-      while (ptr < end && grub_isspace (*ptr))
-	ptr++;
-      {
-	struct grub_xnu_devtree_key *newkey
-	  = grub_xnu_create_value (parent, name);
-	grub_free (name);
-	if (! newkey)
-	  return 0;
-	newkey->datasize = datalen;
-	newkey->data = data;
-      }
-      if (*ptr != ';')
-	return 0;
-      ptr++;
-    }
-  if (ptr >= end && *parent != grub_xnu_devtree_root)
-    return 0;
-  return ptr;
-}
-
 /* Returns true if the kext should be loaded according to plist
    and osbundlereq. Also fill BINNAME. */
 static int
@@ -1157,53 +1192,6 @@ grub_xnu_load_kext_from_dir (char *dirname, char *osbundlerequired,
   return GRUB_ERR_NONE;
 }
 
-/* Load devtree file. */
-static grub_err_t
-grub_cmd_xnu_devtree (grub_command_t cmd __attribute__ ((unused)),
-		      int argc, char *args[])
-{
-  grub_file_t file;
-  char *data, *endret;
-  grub_size_t datalen;
-
-  if (argc != 1)
-    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Filename required");
-
-  if (! grub_xnu_heap_size)
-    return grub_error (GRUB_ERR_BAD_OS, "no xnu kernel loaded");
-
-  /* Load the file. */
-  file = grub_gzfile_open (args[0], 1);
-  if (! file)
-    return grub_error (GRUB_ERR_FILE_NOT_FOUND, "Couldn't load device tree");
-  datalen = grub_file_size (file);
-  data = grub_malloc (datalen + 1);
-  if (! data)
-    {
-      grub_file_close (file);
-      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
-			 "Could load device tree into memory");
-    }
-  if (grub_file_read (file, data, datalen) != (grub_ssize_t) datalen)
-    {
-      grub_file_close (file);
-      grub_free (data);
-      grub_error_push ();
-      return grub_error (GRUB_ERR_BAD_OS, "Couldn't read file %s", args[0]);
-    }
-  grub_file_close (file);
-  data[datalen] = 0;
-
-  /* Parse the file. */
-  endret = grub_xnu_parse_devtree (&grub_xnu_devtree_root,
-				   data, data + datalen);
-  grub_free (data);
-
-  if (! endret)
-    return grub_error (GRUB_ERR_BAD_OS, "Couldn't parse devtree");
-
-  return GRUB_ERR_NONE;
-}
 
 static int locked=0;
 static grub_dl_t my_mod;
@@ -1264,6 +1252,107 @@ grub_cmd_xnu_kextdir (grub_command_t cmd __attribute__ ((unused)),
     }
 }
 
+static inline int
+hextoval (char c)
+{
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'a' && c <= 'z')
+    return c - 'a' + 10;
+  if (c >= 'A' && c <= 'Z')
+    return c - 'A' + 10;
+  return 0;
+}
+
+static inline void
+unescape (char *name, char *curdot, char *nextdot, int *len)
+{
+  char *ptr, *dptr;
+  dptr = name;
+  for (ptr = curdot; ptr < nextdot;)
+    if (ptr + 2 < nextdot && *ptr == '%')
+      {
+	*dptr = (hextoval (ptr[1]) << 4) | (hextoval (ptr[2]));
+	ptr += 3;
+	dptr++;
+      }
+    else
+      {
+	*dptr = *ptr;
+	ptr++;
+	dptr++;
+      }
+  *len = dptr - name;
+}
+
+grub_err_t
+grub_xnu_fill_devicetree (void)
+{
+  auto int iterate_env (struct grub_env_var *var);
+  int iterate_env (struct grub_env_var *var)
+  {
+    char *nextdot = 0, *curdot;
+    struct grub_xnu_devtree_key **curkey = &grub_xnu_devtree_root;
+    struct grub_xnu_devtree_key *curvalue;
+    char *name = 0, *data;
+    int len;
+
+    if (grub_memcmp (var->name, "XNU.DeviceTree.",
+		     sizeof ("XNU.DeviceTree.") - 1) != 0)
+      return 0;
+
+    curdot = var->name + sizeof ("XNU.DeviceTree.") - 1;
+    nextdot = grub_strchr (curdot, '.');
+    if (nextdot)
+      nextdot++;
+    while (nextdot)
+      {
+	name = grub_realloc (name, nextdot - curdot + 1);
+
+	if (!name)
+	  return 1;
+
+	unescape (name, curdot, nextdot, &len);
+	name[len - 1] = 0;
+
+	curkey = &(grub_xnu_create_key (curkey, name)->first_child);
+
+	curdot = nextdot;
+	nextdot = grub_strchr (nextdot, '.');
+	if (nextdot)
+	  nextdot++;
+      }
+
+    nextdot = curdot + grub_strlen (curdot) + 1;
+
+    name = grub_realloc (name, nextdot - curdot + 1);
+    
+    if (!name)
+      return 1;
+    
+    unescape (name, curdot, nextdot, &len);
+    name[len] = 0;
+
+    curvalue = grub_xnu_create_value (curkey, name);
+    grub_free (name);
+    
+    data = grub_malloc (grub_strlen (var->value) + 1);
+    if (!data)
+      return 1;
+    
+    unescape (data, var->value, var->value + grub_strlen (var->value),
+	      &len);
+    curvalue->datasize = len;
+    curvalue->data = data;
+
+    return 0;
+  }
+
+  grub_env_iterate (iterate_env);
+
+  return grub_errno;
+}
+
 struct grub_video_bitmap *grub_xnu_bitmap = 0;
 
 static grub_err_t
@@ -1309,13 +1398,15 @@ grub_xnu_unlock ()
   locked = 0;
 }
 
-static grub_command_t cmd_kernel, cmd_mkext, cmd_kext, cmd_kextdir,
-  cmd_ramdisk, cmd_devtree, cmd_resume, cmd_splash;
+static grub_command_t cmd_kernel64, cmd_kernel, cmd_mkext, cmd_kext;
+static grub_command_t cmd_kextdir, cmd_ramdisk, cmd_resume, cmd_splash;
 
 GRUB_MOD_INIT(xnu)
 {
   cmd_kernel = grub_register_command ("xnu_kernel", grub_cmd_xnu_kernel, 0,
 				      "load a xnu kernel");
+  cmd_kernel64 = grub_register_command ("xnu_kernel64", grub_cmd_xnu_kernel64,
+					0, "load a 64-bit xnu kernel");
   cmd_mkext = grub_register_command ("xnu_mkext", grub_cmd_xnu_mkext, 0,
 				     "Load XNU extension package.");
   cmd_kext = grub_register_command ("xnu_kext", grub_cmd_xnu_kext, 0,
@@ -1326,8 +1417,6 @@ GRUB_MOD_INIT(xnu)
   cmd_ramdisk = grub_register_command ("xnu_ramdisk", grub_cmd_xnu_ramdisk, 0,
 				       "Load XNU ramdisk. "
 				       "It will be seen as md0");
-  cmd_devtree = grub_register_command ("xnu_devtree", grub_cmd_xnu_devtree, 0,
-				       "Load XNU devtree");
   cmd_splash = grub_register_command ("xnu_splash", grub_cmd_xnu_splash, 0,
 				      "Load a splash image for XNU");
 
@@ -1335,7 +1424,10 @@ GRUB_MOD_INIT(xnu)
   cmd_resume = grub_register_command ("xnu_resume", grub_cmd_xnu_resume,
 				      0, "Load XNU hibernate image.");
 #endif
-  my_mod=mod;
+
+  grub_cpu_xnu_init ();
+
+  my_mod = mod;
 }
 
 GRUB_MOD_FINI(xnu)
@@ -1346,8 +1438,10 @@ GRUB_MOD_FINI(xnu)
   grub_unregister_command (cmd_mkext);
   grub_unregister_command (cmd_kext);
   grub_unregister_command (cmd_kextdir);
-  grub_unregister_command (cmd_devtree);
   grub_unregister_command (cmd_ramdisk);
   grub_unregister_command (cmd_kernel);
+  grub_unregister_command (cmd_kernel64);
   grub_unregister_command (cmd_splash);
+
+  grub_cpu_xnu_fini ();
 }
diff --git a/normal/auth.c b/normal/auth.c
index c71262584..54107fe01 100644
--- a/normal/auth.c
+++ b/normal/auth.c
@@ -23,6 +23,7 @@
 #include <grub/env.h>
 #include <grub/normal.h>
 #include <grub/time.h>
+#include <grub/i18n.h>
 
 struct grub_auth_user
 {
@@ -237,7 +238,7 @@ grub_auth_check_authentication (const char *userlist)
       return GRUB_ERR_NONE;
     }
 
-  if (!grub_cmdline_get ("Enter username: ", login, sizeof (login) - 1,
+  if (!grub_cmdline_get (N_("Enter username:"), login, sizeof (login) - 1,
 			 0, 0, 0))
     goto access_denied;
 
diff --git a/normal/cmdline.c b/normal/cmdline.c
index 7a5b6ec84..6d74e6e69 100644
--- a/normal/cmdline.c
+++ b/normal/cmdline.c
@@ -1,6 +1,6 @@
 /*
  *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2007  Free Software Foundation, Inc.
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,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
@@ -26,6 +26,7 @@
 #include <grub/disk.h>
 #include <grub/file.h>
 #include <grub/env.h>
+#include <grub/i18n.h>
 
 static char *kill_buf;
 
@@ -193,6 +194,7 @@ grub_cmdline_get (const char *prompt, char cmdline[], unsigned max_len,
   auto void cl_delete (unsigned len);
   auto void cl_print (int pos, int c);
   auto void cl_set_pos (void);
+  const char *prompt_translated = _(prompt);
 
   void cl_set_pos (void)
     {
@@ -266,14 +268,14 @@ grub_cmdline_get (const char *prompt, char cmdline[], unsigned max_len,
       grub_refresh ();
     }
 
-  plen = grub_strlen (prompt);
+  plen = grub_strlen (prompt_translated);
   lpos = llen = 0;
   buf[0] = '\0';
 
   if ((grub_getxy () >> 8) != 0)
     grub_putchar ('\n');
 
-  grub_printf ("%s", prompt);
+  grub_printf ("%s", prompt_translated);
 
   xpos = plen;
   ystart = ypos = (grub_getxy () & 0xFF);
@@ -334,7 +336,7 @@ grub_cmdline_get (const char *prompt, char cmdline[], unsigned max_len,
 		if (restore)
 		  {
 		    /* Restore the prompt.  */
-		    grub_printf ("\n%s%s", prompt, buf);
+		    grub_printf ("\n%s %s", prompt_translated, buf);
 		    xpos = plen;
 		    ystart = ypos = (grub_getxy () & 0xFF);
 		  }
diff --git a/normal/color.c b/normal/color.c
index 340e43a02..0b9868d3b 100644
--- a/normal/color.c
+++ b/normal/color.c
@@ -20,6 +20,7 @@
 #include <grub/mm.h>
 #include <grub/normal.h>
 #include <grub/term.h>
+#include <grub/i18n.h>
 
 /* Borrowed from GRUB Legacy */
 static char *color_list[16] =
@@ -76,7 +77,7 @@ grub_parse_color_name_pair (grub_uint8_t *ret, const char *name)
   bg_name = grub_strchr (fg_name, '/');
   if (bg_name == NULL)
     {
-      grub_printf ("Warning: syntax error (missing slash) in `%s'\n", fg_name);
+      grub_printf_ (N_("Warning: syntax error (missing slash) in `%s'\n"), fg_name);
       grub_wait_after_message ();
       goto free_and_return;
     }
@@ -85,13 +86,13 @@ grub_parse_color_name_pair (grub_uint8_t *ret, const char *name)
 
   if (parse_color_name (&fg, fg_name) == -1)
     {
-      grub_printf ("Warning: invalid foreground color `%s'\n", fg_name);
+      grub_printf_ (N_("Warning: invalid foreground color `%s'\n"), fg_name);
       grub_wait_after_message ();
       goto free_and_return;
     }
   if (parse_color_name (&bg, bg_name) == -1)
     {
-      grub_printf ("Warning: invalid background color `%s'\n", bg_name);
+      grub_printf_ (N_("Warning: invalid background color `%s'\n"), bg_name);
       grub_wait_after_message ();
       goto free_and_return;
     }
diff --git a/normal/completion.c b/normal/completion.c
index 4b38e334d..d264028cc 100644
--- a/normal/completion.c
+++ b/normal/completion.c
@@ -409,13 +409,16 @@ grub_normal_do_completion (char *buf, int *restore,
   if (grub_parser_split_cmdline (buf, 0, &argc, &argv))
     return 0;
 
-  current_word = argv[argc];
+  if (argc == 0)
+    current_word = "";
+  else
+    current_word = argv[argc - 1];
 
   /* Determine the state the command line is in, depending on the
      state, it can be determined how to complete.  */
   cmdline_state = get_state (buf);
 
-  if (argc == 0)
+  if (argc == 1 || argc == 0)
     {
       /* Complete a command.  */
       if (grub_command_iterate (iterate_command))
@@ -485,13 +488,15 @@ grub_normal_do_completion (char *buf, int *restore,
           goto fail;
 	}
 
-      grub_free (argv[0]);
+      if (argc != 0)
+	grub_free (argv[0]);
       grub_free (match);
       return ret;
     }
 
  fail:
-  grub_free (argv[0]);
+  if (argc != 0)
+    grub_free (argv[0]);
   grub_free (match);
   grub_errno = GRUB_ERR_NONE;
 
diff --git a/normal/main.c b/normal/main.c
index f080a6971..3166ea146 100644
--- a/normal/main.c
+++ b/normal/main.c
@@ -385,22 +385,35 @@ read_config_file (const char *config)
 void
 grub_normal_init_page (void)
 {
-  grub_uint8_t width, margin;
-
-#define TITLE ("GNU GRUB  version " PACKAGE_VERSION)
-
-  width = grub_getwh () >> 8;
-  margin = (width - (sizeof(TITLE) + 7)) / 2;
+  int msg_len;
+  int posx;
+  const char *msg = _("GNU GRUB  version %s");
 
+  char *msg_formatted = grub_malloc (grub_strlen(msg) +
+  				     grub_strlen(PACKAGE_VERSION));
+  
   grub_cls ();
-  grub_putchar ('\n');
 
-  while (margin--)
-    grub_putchar (' ');
+  grub_sprintf (msg_formatted, msg, PACKAGE_VERSION);
 
-  grub_printf ("%s\n\n", TITLE);
+  grub_uint32_t *unicode_msg;
+  grub_uint32_t *last_position;
+  
+  msg_len = grub_utf8_to_ucs4_alloc (msg_formatted, 
+  				     &unicode_msg, &last_position);
+  
+  if (msg_len < 0)
+    {
+      return;
+    }
 
-#undef TITLE
+  posx = grub_getstringwidth (unicode_msg, last_position);
+  posx = (GRUB_TERM_WIDTH - posx) / 2;
+  grub_gotoxy (posx, 1);
+
+  grub_print_ucs4 (unicode_msg, last_position);
+  grub_printf("\n\n");
+  grub_free (unicode_msg);
 }
 
 static int reader_nested;
@@ -509,12 +522,21 @@ grub_normal_reader_init (void)
   grub_normal_init_page ();
   grub_setcursor (1);
 
-  grub_printf_ (N_("\
- [ Minimal BASH-like line editing is supported. For the first word, TAB\n\
-   lists possible command completions. Anywhere else TAB lists possible\n\
-   device/file completions.%s ]\n\n"),
-	       reader_nested ? " ESC at any time exits." : "");
+  const char *msg = _("Minimal BASH-like line editing is supported. For "
+		      "the first word, TAB lists possible command completions. Anywhere "
+		      "else TAB lists possible device or file completions. %s");
 
+  const char *msg_esc = _("ESC at any time exits.");
+
+  char *msg_formatted = grub_malloc (sizeof (char) * (grub_strlen (msg) + 
+                grub_strlen(msg_esc) + 1));
+
+  grub_sprintf (msg_formatted, msg, reader_nested ? msg_esc : "");
+  grub_print_message_indented (msg_formatted, 3, STANDARD_MARGIN);
+  grub_puts ("\n");
+
+  grub_free (msg_formatted);
+  
   return 0;
 }
 
diff --git a/normal/menu_text.c b/normal/menu_text.c
index bb1f52203..45cf95500 100644
--- a/normal/menu_text.c
+++ b/normal/menu_text.c
@@ -53,7 +53,7 @@ print_spaces (int number_spaces)
     grub_putchar (' ');
 }
 
-static void
+void
 grub_print_ucs4 (const grub_uint32_t * str,
                 const grub_uint32_t * last_position)
 {
@@ -64,8 +64,35 @@ grub_print_ucs4 (const grub_uint32_t * str,
     }
 }
 
-static grub_ssize_t
-getstringwidth (grub_uint32_t * str, const grub_uint32_t * last_position)
+int
+grub_utf8_to_ucs4_alloc (const char *msg, grub_uint32_t **unicode_msg,
+			grub_uint32_t **last_position)
+{
+  grub_ssize_t msg_len = grub_strlen (msg);
+
+  *unicode_msg = grub_malloc (grub_strlen (msg) * sizeof (grub_uint32_t));
+  
+  if (!*unicode_msg)
+    {
+      grub_printf ("utf8_to_ucs4 ERROR1: %s", msg);
+      return -1;
+    }
+
+  msg_len = grub_utf8_to_ucs4 (*unicode_msg, msg_len,
+  			      (grub_uint8_t *) msg, -1, 0);
+
+  *last_position = *unicode_msg + msg_len;
+
+  if (msg_len < 0)
+    {
+      grub_printf ("utf8_to_ucs4 ERROR2: %s", msg);
+      grub_free (*unicode_msg);
+    }
+  return msg_len;
+}
+
+grub_ssize_t
+grub_getstringwidth (grub_uint32_t * str, const grub_uint32_t * last_position)
 {
   grub_ssize_t width = 0;
 
@@ -77,44 +104,39 @@ getstringwidth (grub_uint32_t * str, const grub_uint32_t * last_position)
   return width;
 }
 
-static void
-print_message_indented (const char *msg)
+void
+grub_print_message_indented (const char *msg, int margin_left, int margin_right)
 {
-  const int line_len = GRUB_TERM_WIDTH - grub_getcharwidth ('m') * 15;
+  int line_len;
+  line_len = GRUB_TERM_WIDTH - grub_getcharwidth ('m') *
+    (margin_left + margin_right);
 
   grub_uint32_t *unicode_msg;
+  grub_uint32_t *last_position;
 
-  grub_ssize_t msg_len = grub_strlen (msg);
+  int msg_len;
 
-  unicode_msg = grub_malloc (msg_len * sizeof (*unicode_msg));
-
-  msg_len = grub_utf8_to_ucs4 (unicode_msg, msg_len,
-                              (grub_uint8_t *) msg, -1, 0);
-
-  if (!unicode_msg)
-    {
-      grub_printf ("print_message_indented ERROR1: %s", msg);
-      return;
-    }
+  msg_len = grub_utf8_to_ucs4_alloc (msg, &unicode_msg, &last_position);
 
   if (msg_len < 0)
     {
-      grub_printf ("print_message_indented ERROR2: %s", msg);
-      grub_free (unicode_msg);
       return;
     }
 
-  const grub_uint32_t *last_position = unicode_msg + msg_len;
-
   grub_uint32_t *current_position = unicode_msg;
 
   grub_uint32_t *next_new_line = unicode_msg;
 
+  int first_loop = 1;
+
   while (current_position < last_position)
     {
+      if (! first_loop)
+        grub_putchar ('\n');
+      
       next_new_line = (grub_uint32_t *) last_position;
 
-      while (getstringwidth (current_position, next_new_line) > line_len
+      while (grub_getstringwidth (current_position, next_new_line) > line_len
             || (*next_new_line != ' ' && next_new_line > current_position &&
                 next_new_line != last_position))
        {
@@ -127,12 +149,12 @@ print_message_indented (const char *msg)
            (grub_uint32_t *) last_position : next_new_line + line_len;
        }
 
-      print_spaces (6);
+      print_spaces (margin_left);
       grub_print_ucs4 (current_position, next_new_line);
-      grub_putchar ('\n');
 
       next_new_line++;
       current_position = next_new_line;
+      first_loop = 0;
     }
   grub_free (unicode_msg);
 }
@@ -182,26 +204,26 @@ print_message (int nested, int edit)
   if (edit)
     {
       grub_putchar ('\n');
-      print_message_indented (_("Minimum Emacs-like screen editing is \
+      grub_print_message_indented (_("Minimum Emacs-like screen editing is \
 supported. TAB lists completions. Press Ctrl-x to boot, Ctrl-c for a \
-command-line or ESC to return menu."));
+command-line or ESC to return menu."), STANDARD_MARGIN, STANDARD_MARGIN);
     }
   else
     {
       const char *msg = _("Use the %C and %C keys to select which \
-entry is highlighted.");
+entry is highlighted.\n");
       char *msg_translated =
        grub_malloc (sizeof (char) * grub_strlen (msg) + 1);
 
       grub_sprintf (msg_translated, msg, (grub_uint32_t) GRUB_TERM_DISP_UP,
                    (grub_uint32_t) GRUB_TERM_DISP_DOWN);
       grub_putchar ('\n');
-      print_message_indented (msg_translated);
+      grub_print_message_indented (msg_translated, STANDARD_MARGIN, STANDARD_MARGIN);
 
       grub_free (msg_translated);
 
-      print_message_indented (_("Press enter to boot the selected OS, \
-\'e\' to edit the commands before booting or \'c\' for a command-line."));
+      grub_print_message_indented (_("Press enter to boot the selected OS, \
+\'e\' to edit the commands before booting or \'c\' for a command-line.\n"), STANDARD_MARGIN, STANDARD_MARGIN);
 
       if (nested)
         {
@@ -368,22 +390,26 @@ get_entry_number (const char *name)
 }
 
 static void
-print_timeout (int timeout, int offset, int second_stage)
+print_timeout (int timeout, int offset)
 {
   const char *msg =
     _("The highlighted entry will be booted automatically in %ds.");
-  const int msg_localized_len = grub_strlen (msg);
-  const int number_spaces = GRUB_TERM_WIDTH - msg_localized_len - 3;
 
-  char *msg_end = grub_strchr (msg, '%');
+  grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
 
-  grub_gotoxy (second_stage ? (msg_end - msg + 3) : 3, GRUB_TERM_HEIGHT - 3);
-  grub_printf (second_stage ? msg_end : msg, timeout);
-  print_spaces (second_stage ? number_spaces : 0);
+  char *msg_translated =
+    grub_malloc (sizeof (char) * grub_strlen (msg) + 5);
+
+  grub_sprintf (msg_translated, msg, timeout);
+  grub_print_message_indented (msg_translated, 3, 0);
+  
+  int posx;
+  posx = grub_getxy() >> 8;
+  print_spaces (GRUB_TERM_WIDTH - posx - 1);
 
   grub_gotoxy (GRUB_TERM_CURSOR_X, GRUB_TERM_FIRST_ENTRY_Y + offset);
   grub_refresh ();
-};
+}
 
 /* Show the menu and handle menu entry selection.  Returns the menu entry
    index that should be executed or -1 if no entry should be executed (e.g.,
@@ -434,7 +460,7 @@ run_menu (grub_menu_t menu, int nested, int *auto_boot)
   timeout = grub_menu_get_timeout ();
 
   if (timeout > 0)
-    print_timeout (timeout, offset, 0);
+    print_timeout (timeout, offset);
 
   while (1)
     {
@@ -451,7 +477,7 @@ run_menu (grub_menu_t menu, int nested, int *auto_boot)
 	      timeout--;
 	      grub_menu_set_timeout (timeout);
 	      saved_time = current_time;
-	      print_timeout (timeout, offset, 1);
+	      print_timeout (timeout, offset);
 	    }
 	}
 
diff --git a/normal/misc.c b/normal/misc.c
index 0a1a2f052..18e20d2fc 100644
--- a/normal/misc.c
+++ b/normal/misc.c
@@ -1,7 +1,7 @@
 /* misc.c - miscellaneous functions */
 /*
  *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2005,2007,2008  Free Software Foundation, Inc.
+ *  Copyright (C) 2005,2007,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
@@ -24,6 +24,8 @@
 #include <grub/misc.h>
 #include <grub/mm.h>
 #include <grub/datetime.h>
+#include <grub/term.h>
+#include <grub/i18n.h>
 
 /* Print the information on the device NAME.  */
 grub_err_t
@@ -34,13 +36,20 @@ grub_normal_print_device_info (const char *name)
 
   p = grub_strchr (name, ',');
   if (p)
-    grub_printf ("\tPartition %s: ", name);
+    {
+      grub_putchar ('\t');
+      grub_printf_ (N_("Partition %s:"), name);
+      grub_putchar (' ');
+    }
   else
-    grub_printf ("Device %s: ", name);
+    {
+      grub_printf_ (N_("Device %s:"), name);
+      grub_putchar (' ');
+    }
 
   dev = grub_device_open (name);
   if (! dev)
-    grub_printf ("Filesystem cannot be accessed");
+    grub_printf ("%s", _("Filesystem cannot be accessed"));
   else if (dev->disk)
     {
       grub_fs_t fs;
@@ -51,7 +60,7 @@ grub_normal_print_device_info (const char *name)
 
       if (fs)
 	{
-	  grub_printf ("Filesystem type %s", fs->name);
+	  grub_printf_ (N_("Filesystem type %s"), fs->name);
 	  if (fs->label)
 	    {
 	      char *label;
@@ -59,7 +68,7 @@ grub_normal_print_device_info (const char *name)
 	      if (grub_errno == GRUB_ERR_NONE)
 		{
 		  if (label && grub_strlen (label))
-		    grub_printf (", Label %s", label);
+		    grub_printf_ (N_("- Label %s"), label);
 		  grub_free (label);
 		}
 	      grub_errno = GRUB_ERR_NONE;
@@ -72,8 +81,8 @@ grub_normal_print_device_info (const char *name)
 	      if (grub_errno == GRUB_ERR_NONE)
 		{
 		  grub_unixtime2datetime (tm, &datetime);
-		  grub_printf (", Last modification time %d-%02d-%02d "
-			       "%02d:%02d:%02d %s",
+		  grub_printf_ (N_("- Last modification time %d-%02d-%02d "
+			       "%02d:%02d:%02d %s"),
 			       datetime.year, datetime.month, datetime.day,
 			       datetime.hour, datetime.minute, datetime.second,
 			       grub_get_weekday_name (&datetime));
@@ -95,13 +104,13 @@ grub_normal_print_device_info (const char *name)
 	    }
 	}
       else if (! dev->disk->has_partitions || dev->disk->partition)
-	grub_printf ("Unknown filesystem");
+	grub_printf ("%s", _("Unknown filesystem"));
       else
-	grub_printf ("Partition table");
+	grub_printf ("%s", _("Partition table"));
 
       grub_device_close (dev);
     }
 
-  grub_printf ("\n");
+  grub_putchar ('\n');
   return grub_errno;
 }
diff --git a/po/POTFILES b/po/POTFILES
index 7d213c357..c214eb968 100644
--- a/po/POTFILES
+++ b/po/POTFILES
@@ -1,4 +1,6 @@
 # List of files which contain translatable strings.
+commands/loadenv.c
+
 util/i386/pc/grub-mkimage.c
 util/i386/pc/grub-setup.c
 
@@ -11,5 +13,9 @@ util/mkisofs/rock.c
 util/mkisofs/tree.c
 util/mkisofs/write.c
 
+normal/auth.c
+normal/color.c
+normal/main.c
 normal/menu_entry.c
 normal/menu_text.c
+normal/misc.c
diff --git a/term/ieee1275/ofconsole.c b/term/ieee1275/ofconsole.c
index c61e16eb7..ab11e9fb2 100644
--- a/term/ieee1275/ofconsole.c
+++ b/term/ieee1275/ofconsole.c
@@ -1,7 +1,7 @@
 /*  ofconsole.c -- Open Firmware console for GRUB.  */
 /*
  *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2003,2004,2005,2007,2008  Free Software Foundation, Inc.
+ *  Copyright (C) 2003,2004,2005,2007,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
@@ -43,17 +43,17 @@ struct color
   int blue;
 };
 
-#define	MAX 0xff
-static struct color colors[8] =
+static struct color colors[] =
   {
-    { 0,   0,   0},
-    { MAX, 0,   0},
-    { 0,   MAX, 0},
-    { MAX, MAX, 0},
-    { 0,   0,   MAX},
-    { MAX, 0,   MAX},
-    { 0,   MAX, MAX},
-    { MAX, MAX, MAX}
+    // {R, G, B}
+    {0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xA8}, // 1 = blue
+    {0x00, 0xA8, 0x00}, // 2 = green
+    {0x00, 0xA8, 0xA8}, // 3 = cyan
+    {0xA8, 0x00, 0x00}, // 4 = red
+    {0xA8, 0x00, 0xA8}, // 5 = magenta
+    {0xFE, 0xFE, 0x54}, // 6 = yellow
+    {0xFE, 0xFE, 0xFE}  // 7 = white
   };
 
 static grub_uint8_t grub_ofconsole_normal_color = 0x7;
@@ -131,8 +131,9 @@ static void
 grub_ofconsole_setcolor (grub_uint8_t normal_color,
 			 grub_uint8_t highlight_color)
 {
-  grub_ofconsole_normal_color = normal_color;
-  grub_ofconsole_highlight_color = highlight_color;
+  /* Discard bright bit.  */
+  grub_ofconsole_normal_color = normal_color & 0x77;
+  grub_ofconsole_highlight_color = highlight_color & 0x77;
 }
 
 static void
@@ -354,7 +355,6 @@ static grub_err_t
 grub_ofconsole_init_output (void)
 {
   grub_ssize_t actual;
-  int col;
 
   /* The latest PowerMacs don't actually initialize the screen for us, so we
    * use this trick to re-open the output device (but we avoid doing this on
@@ -370,7 +370,8 @@ grub_ofconsole_init_output (void)
   /* Initialize colors.  */
   if (! grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_CANNOT_SET_COLORS))
     {
-      for (col = 0; col < 7; col++)
+      unsigned col;
+      for (col = 0; col < ARRAY_SIZE (colors); col++)
 	grub_ieee1275_set_color (stdout_ihandle, col, colors[col].red,
 				 colors[col].green, colors[col].blue);
 
diff --git a/util/getroot.c b/util/getroot.c
index c6c229967..db772b968 100644
--- a/util/getroot.c
+++ b/util/getroot.c
@@ -488,7 +488,7 @@ grub_util_is_dmraid (const char *os_dev)
 }
 
 int
-grub_util_get_dev_abstraction (const char *os_dev UNUSED)
+grub_util_get_dev_abstraction (const char *os_dev __attribute__((unused)))
 {
 #ifdef __linux__
   /* Check for LVM.  */
diff --git a/util/grub-mkrescue.in b/util/grub-mkrescue.in
index 8e4a77f58..fd3a86c95 100644
--- a/util/grub-mkrescue.in
+++ b/util/grub-mkrescue.in
@@ -94,8 +94,7 @@ process_input_dir ()
     platform="$2"
     mkdir -p ${iso9660_dir}/boot/grub/${target_cpu}-${platform}
     for file in ${input_dir}/*.mod ${input_dir}/efiemu??.o \
-        ${input_dir}/command.lst ${input_dir}/moddep.lst ${input_dir}/fs.lst \
-        ${input_dir}/handler.lst ${input_dir}/parttool.lst; do
+        ${input_dir}/*.lst; do
         if test -f "$file"; then
             cp -f "$file" ${iso9660_dir}/boot/grub/${target_cpu}-${platform}/
         fi
@@ -128,7 +127,7 @@ fi
 
 # build coreboot core.img
 if test -e "${coreboot_dir}" ; then
-    echo "Generates coreboot"
+    echo "Enabling coreboot support ..."
     memdisk_img=`mktemp`
     memdisk_dir=`mktemp -d`
     mkdir -p ${memdisk_dir}/boot/grub
@@ -155,14 +154,17 @@ EOF
     grub_mkisofs_arguments="${grub_mkisofs_arguments} --modification-date=$(echo ${iso_uuid} | sed -e s/-//g)"
 fi
 
-# build eltorito core.img
+# build BIOS core.img
 if test -e "${pc_dir}" ; then
-    echo "Generates eltorito"
+    echo "Enabling BIOS support ..."
     core_img=`mktemp`
     grub-mkimage -d ${pc_dir}/ -o ${core_img} --prefix=/boot/grub/i386-pc \
-        memdisk tar search iso9660 configfile sh \
-        biosdisk
+        iso9660 biosdisk
     cat ${pc_dir}/cdboot.img ${core_img} > ${iso9660_dir}/boot/grub/i386-pc/eltorito.img
+
+    embed_img=`mktemp`
+    cat ${pc_dir}/boot.img ${core_img} > ${embed_img}
+
     rm -f ${core_img}
 
     modules="$(cat ${pc_dir}/partmap.lst) ${modules}"
@@ -172,11 +174,14 @@ if test -e "${pc_dir}" ; then
     echo "source /boot/grub/grub.cfg") \
     > ${iso9660_dir}/boot/grub/i386-pc/grub.cfg
 
-    grub_mkisofs_arguments="${grub_mkisofs_arguments} -b boot/grub/i386-pc/eltorito.img -boot-info-table"
+    grub_mkisofs_arguments="${grub_mkisofs_arguments} -b boot/grub/i386-pc/eltorito.img -boot-info-table \
+		--embedded-boot ${embed_img}"
 fi
 
 # build iso image
-grub-mkisofs ${grub_mkisofs_arguments} -o ${output_image} -r ${iso9660_dir} ${source}
+grub-mkisofs ${grub_mkisofs_arguments} --protective-msdos-label -o ${output_image} -r ${iso9660_dir} ${source}
 rm -rf ${iso9660_dir}
 
+rm -f ${embed_img}
+
 exit 0
diff --git a/util/grub.d/30_os-prober.in b/util/grub.d/30_os-prober.in
index 5c95e5f88..0ab54bbaa 100644
--- a/util/grub.d/30_os-prober.in
+++ b/util/grub.d/30_os-prober.in
@@ -37,6 +37,56 @@ if [ -z "${OSPROBED}" ] ; then
   exit 0
 fi
 
+osx_entry {
+        cat << EOF
+menuentry "${LONGNAME} (${2}-bit) (on ${DEVICE})" {
+EOF
+	prepare_grub_to_access_device ${DEVICE} | sed -e "s/^/\t/"
+	cat << EOF
+        insmod ${GRUB_VIDEO_BACKEND}
+        do_resume=0
+        if [ /var/vm/sleepimage -nt10 / ]; then
+           if xnu_resume /var/vm/sleepimage; then
+             do_resume=1
+           fi
+        fi
+        if [ \$do_resume == 0 ]; then
+           xnu_uuid ${OSXUUID} uuid
+           if [ -f /Extra/DSDT.aml ]; then
+              acpi -e /Extra/DSDT.aml
+           fi
+           $1 /mach_kernel boot-uuid=\${uuid} rd=*uuid
+           if [ /System/Library/Extensions.mkext -nt /System/Library/Extensions ]; then
+              xnu_mkext /System/Library/Extensions.mkext
+           else
+              xnu_kextdir /System/Library/Extensions
+           fi
+           if [ -f /Extra/Extensions.mkext ]; then
+              xnu_mkext /Extra/Extensions.mkext
+           fi
+           if [ -d /Extra/Extensions ]; then
+              xnu_kextdir /Extra/Extensions
+           fi
+           if [ -f /Extra/devprop.bin ]; then
+              xnu_devprop_load /Extra/devprop.bin
+           fi
+           if [ -f /Extra/splash.jpg ]; then
+              insmod jpeg
+              xnu_splash /Extra/splash.jpg
+           fi
+           if [ -f /Extra/splash.png ]; then
+              insmod png
+              xnu_splash /Extra/splash.png
+           fi
+           if [ -f /Extra/splash.tga ]; then
+              insmod tga
+              xnu_splash /Extra/splash.tga
+           fi
+        fi
+}
+EOF
+}
+
 for OS in ${OSPROBED} ; do
   DEVICE="`echo ${OS} | cut -d ':' -f 1`"
   LONGNAME="`echo ${OS} | cut -d ':' -f 2 | tr '^' ' '`"
@@ -115,53 +165,8 @@ EOF
     ;;
     macosx)
       OSXUUID="`grub-probe --target=fs_uuid --device ${DEVICE} 2> /dev/null`"
-        cat << EOF
-menuentry "${LONGNAME} (on ${DEVICE})" {
-EOF
-	prepare_grub_to_access_device ${DEVICE} | sed -e "s/^/\t/"
-	cat << EOF
-        insmod ${GRUB_VIDEO_BACKEND}
-        do_resume=0
-        if [ /var/vm/sleepimage -nt10 / ]; then
-           if xnu_resume /var/vm/sleepimage; then
-             do_resume=1
-           fi
-        fi
-        if [ \$do_resume == 0 ]; then
-           xnu_uuid ${OSXUUID} uuid
-           if [ -f /Extra/DSDT.aml ]; then
-              acpi -e /Extra/DSDT.aml
-           fi
-           xnu_kernel /mach_kernel boot-uuid=\${uuid} rd=*uuid
-           if [ /System/Library/Extensions.mkext -nt /System/Library/Extensions ]; then
-              xnu_mkext /System/Library/Extensions.mkext
-           else
-              xnu_kextdir /System/Library/Extensions
-           fi
-           if [ -f /Extra/Extensions.mkext ]; then
-              xnu_mkext /Extra/Extensions.mkext
-           fi
-           if [ -d /Extra/Extensions ]; then
-              xnu_kextdir /Extra/Extensions
-           fi
-           if [ -f /Extra/devtree.txt ]; then
-              xnu_devtree /Extra/devtree.txt
-           fi
-           if [ -f /Extra/splash.jpg ]; then
-              insmod jpeg
-              xnu_splash /Extra/splash.jpg
-           fi
-           if [ -f /Extra/splash.png ]; then
-              insmod png
-              xnu_splash /Extra/splash.png
-           fi
-           if [ -f /Extra/splash.tga ]; then
-              insmod tga
-              xnu_splash /Extra/splash.tga
-           fi
-        fi
-}
-EOF
+      osx_entry xnu_kernel 32
+      osx_entry xnu_kernel64 64
     ;;
     hurd)
       cat << EOF
diff --git a/util/i386/efi/grub-dumpdevtree b/util/i386/efi/grub-dumpdevtree
index bc13e3c35..25aa35e23 100644
--- a/util/i386/efi/grub-dumpdevtree
+++ b/util/i386/efi/grub-dumpdevtree
@@ -15,11 +15,8 @@
 # You should have received a copy of the GNU General Public License
 # along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 
-hexify()
-{
-  echo -n "$@" | od -A n -t x1 - | sed -e 's/ //g' | tr '\n' '\0'
-}
+if [ x$1 == x ]; then
+   echo "Filename required".
+fi
 
-echo "`hexify efi`{	`hexify device-properties`:"
-ioreg -lw0 -p IODeviceTree -n efi -r -x |grep device-properties | sed 's/.*<//;s/>.*//;'
-echo ";}"
+ioreg -lw0 -p IODeviceTree -n efi -r -x |grep device-properties | sed 's/.*<//;s/>.*//;' | xxd -r -p > $1
diff --git a/util/i386/pc/grub-setup.c b/util/i386/pc/grub-setup.c
index 1c7e8452f..c2b9b9268 100644
--- a/util/i386/pc/grub-setup.c
+++ b/util/i386/pc/grub-setup.c
@@ -356,8 +356,12 @@ setup (const char *dir,
       goto unable_to_embed;
     }
 
-  grub_partition_iterate (dest_dev->disk, (strcmp (dest_partmap, "part_msdos") ?
-					   find_usable_region_gpt : find_usable_region_msdos));
+  if (strcmp (dest_partmap, "part_msdos") == 0)
+    grub_partition_iterate (dest_dev->disk, find_usable_region_msdos);
+  else if (strcmp (dest_partmap, "part_gpt") == 0)
+    grub_partition_iterate (dest_dev->disk, find_usable_region_gpt);
+  else
+    grub_util_error (_("No DOS-style partitions found"));
 
   if (embed_region.end == embed_region.start)
     {
diff --git a/util/ieee1275/devicemap.c b/util/ieee1275/devicemap.c
index bddfc17e7..19ab746ef 100644
--- a/util/ieee1275/devicemap.c
+++ b/util/ieee1275/devicemap.c
@@ -35,8 +35,10 @@ escape_of_path (const char *orig_path)
 }
 
 void
-grub_util_emit_devicemap_entry (FILE *fp, char *name, int is_floppy UNUSED,
-				int *num_fd UNUSED, int *num_hd UNUSED)
+grub_util_emit_devicemap_entry (FILE *fp, char *name,
+				int is_floppy __attribute__((unused)),
+				int *num_fd __attribute__((unused)),
+				int *num_hd __attribute__((unused)))
 {
   const char *orig_path = grub_util_devname_to_ofpath (name);
   char *ofpath = escape_of_path (orig_path);
diff --git a/util/ieee1275/ofpath.c b/util/ieee1275/ofpath.c
index 7b464bf09..e90488fc3 100644
--- a/util/ieee1275/ofpath.c
+++ b/util/ieee1275/ofpath.c
@@ -39,7 +39,6 @@
 #include <ctype.h>
 
 #ifdef OFPATH_STANDALONE
-#define UNUSED __attribute__((unused))
 #define xmalloc malloc
 void
 grub_util_error (const char *fmt, ...)
@@ -199,8 +198,10 @@ get_basename(char *p)
 
 static void
 of_path_of_vdisk(char *of_path,
-		 const char *devname UNUSED, const char *device,
-		 const char *devnode UNUSED, const char *devicenode)
+		 const char *devname __attribute__((unused)),
+		 const char *device,
+		 const char *devnode __attribute__((unused)),
+		 const char *devicenode)
 {
   char *sysfs_path, *p;
   int devno, junk;
@@ -217,8 +218,9 @@ of_path_of_vdisk(char *of_path,
 
 static void
 of_path_of_ide(char *of_path,
-	       const char *devname UNUSED, const char *device,
-	       const char *devnode UNUSED, const char *devicenode)
+	       const char *devname __attribute__((unused)), const char *device,
+	       const char *devnode __attribute__((unused)),
+	       const char *devicenode)
 {
   char *sysfs_path, *p;
   int chan, devno;
@@ -299,8 +301,9 @@ check_sas (char *sysfs_path, int *tgt)
 
 static void
 of_path_of_scsi(char *of_path,
-		const char *devname UNUSED, const char *device,
-		const char *devnode UNUSED, const char *devicenode)
+		const char *devname __attribute__((unused)), const char *device,
+		const char *devnode __attribute__((unused)),
+		const char *devicenode)
 {
   const char *p, *digit_string, *disk_name;
   int host, bus, tgt, lun;
diff --git a/util/mkisofs/mkisofs.c b/util/mkisofs/mkisofs.c
index 803317ba0..e6386fba4 100644
--- a/util/mkisofs/mkisofs.c
+++ b/util/mkisofs/mkisofs.c
@@ -90,6 +90,8 @@ int extension_record_size = 0;
 /* These variables are associated with command line options */
 int use_eltorito = 0;
 int use_eltorito_emul_floppy = 0;
+int use_embedded_boot = 0;
+int use_protective_msdos_label = 0;
 int use_boot_info_table = 0;
 int use_RockRidge = 0;
 int use_Joliet = 0;
@@ -100,17 +102,18 @@ int rationalize = 0;
 int generate_tables = 0;
 int print_size = 0;
 int split_output = 0;
-char * preparer = PREPARER_DEFAULT;
-char * publisher = PUBLISHER_DEFAULT;
-char * appid = APPID_DEFAULT;
-char * copyright = COPYRIGHT_DEFAULT;
-char * biblio = BIBLIO_DEFAULT;
-char * abstract = ABSTRACT_DEFAULT;
-char * volset_id = VOLSET_ID_DEFAULT;
-char * volume_id = VOLUME_ID_DEFAULT;
-char * system_id = SYSTEM_ID_DEFAULT;
-char * boot_catalog = BOOT_CATALOG_DEFAULT;
-char * boot_image = BOOT_IMAGE_DEFAULT;
+char *preparer = PREPARER_DEFAULT;
+char *publisher = PUBLISHER_DEFAULT;
+char *appid = APPID_DEFAULT;
+char *copyright = COPYRIGHT_DEFAULT;
+char *biblio = BIBLIO_DEFAULT;
+char *abstract = ABSTRACT_DEFAULT;
+char *volset_id = VOLSET_ID_DEFAULT;
+char *volume_id = VOLUME_ID_DEFAULT;
+char *system_id = SYSTEM_ID_DEFAULT;
+char *boot_catalog = BOOT_CATALOG_DEFAULT;
+char *boot_image = BOOT_IMAGE_DEFAULT;
+char *boot_image_embed = NULL;
 int volume_set_size = 1;
 int volume_sequence_number = 1;
 
@@ -197,6 +200,8 @@ struct ld_option
 
 #define OPTION_VERSION			173
 
+#define OPTION_PROTECTIVE_MSDOS_LABEL	174
+
 static const struct ld_option ld_options[] =
 {
   { {"all-files", no_argument, NULL, 'a'},
@@ -209,6 +214,10 @@ static const struct ld_option ld_options[] =
       '\0', N_("FILE"), N_("Set Bibliographic filename"), ONE_DASH },
   { {"copyright", required_argument, NULL, OPTION_COPYRIGHT},
       '\0', N_("FILE"), N_("Set Copyright filename"), ONE_DASH },
+  { {"embedded-boot", required_argument, NULL, 'G'},
+      'G', N_("FILE"), N_("Set embedded boot image name"), TWO_DASHES },
+  { {"protective-msdos-label", no_argument, NULL, OPTION_PROTECTIVE_MSDOS_LABEL },
+      '\0', NULL, N_("Patch a protective DOS-style label in the image"), TWO_DASHES },
   { {"eltorito-boot", required_argument, NULL, 'b'},
       'b', N_("FILE"), N_("Set El Torito boot image name"), ONE_DASH },
   { {"eltorito-catalog", required_argument, NULL, 'c'},
@@ -719,10 +728,16 @@ int FDECL2(main, int, argc, char **, argv){
 	use_eltorito++;
 	boot_image = optarg;  /* pathname of the boot image on cd */
 	if (boot_image == NULL)
-	  {
-	    fprintf (stderr, _("Required boot image pathname missing\n"));
-	    exit (1);
-	  }
+	  error (1, 0, _("Required boot image pathname missing"));
+	break;
+      case 'G':
+	use_embedded_boot = 1;
+	boot_image_embed = optarg;  /* pathname of the boot image on host filesystem */
+	if (boot_image_embed == NULL)
+	  error (1, 0, _("Required boot image pathname missing"));
+	break;
+      case OPTION_PROTECTIVE_MSDOS_LABEL:
+	use_protective_msdos_label = 1;
 	break;
       case 'c':
 	use_eltorito++;
diff --git a/util/mkisofs/mkisofs.h b/util/mkisofs/mkisofs.h
index a1638d80e..1f1ef99ac 100644
--- a/util/mkisofs/mkisofs.h
+++ b/util/mkisofs/mkisofs.h
@@ -296,6 +296,8 @@ extern struct iso_directory_record root_record;
 extern struct iso_directory_record jroot_record;
 
 extern int use_eltorito;
+extern int use_embedded_boot;
+extern int use_protective_msdos_label;
 extern int use_eltorito_emul_floppy;
 extern int use_boot_info_table;
 extern int use_RockRidge;
@@ -438,20 +440,21 @@ extern char * extension_record;
 extern int extension_record_extent;
 extern int n_data_extents;
 
-/* These are a few goodies that can be specified on the command line, and  are
+/* These are a few goodies that can be specified on the command line, and are
    filled into the root record */
 
-extern char * preparer;
-extern char * publisher;
-extern char * copyright;
-extern char * biblio;
-extern char * abstract;
-extern char * appid;
-extern char * volset_id;
-extern char * system_id;
-extern char * volume_id;
-extern char * boot_catalog;
-extern char * boot_image;
+extern char *preparer;
+extern char *publisher;
+extern char *copyright;
+extern char *biblio;
+extern char *abstract;
+extern char *appid;
+extern char *volset_id;
+extern char *system_id;
+extern char *volume_id;
+extern char *boot_catalog;
+extern char *boot_image;
+extern char *boot_image_embed;
 extern int volume_set_size;
 extern int volume_sequence_number;
 
diff --git a/util/mkisofs/msdos_partition.h b/util/mkisofs/msdos_partition.h
new file mode 100644
index 000000000..13985f7bb
--- /dev/null
+++ b/util/mkisofs/msdos_partition.h
@@ -0,0 +1,75 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2004,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/>.
+ */
+
+#ifndef MSDOS_PARTITION_H
+#define MSDOS_PARTITION_H	1
+
+#include <stdint.h>
+
+/* The signature.  */
+#define MSDOS_PARTITION_SIGNATURE		((0xaa << 8) | 0x55)
+
+/* This is not a flag actually, but used as if it were a flag.  */
+#define MSDOS_PARTITION_TYPE_HIDDEN_FLAG	0x10
+
+/* The partition entry.  */
+struct msdos_partition_entry
+{
+  /* If active, 0x80, otherwise, 0x00.  */
+  uint8_t flag;
+
+  /* The head of the start.  */
+  uint8_t start_head;
+
+  /* (S | ((C >> 2) & 0xC0)) where S is the sector of the start and C
+     is the cylinder of the start. Note that S is counted from one.  */
+  uint8_t start_sector;
+
+  /* (C & 0xFF) where C is the cylinder of the start.  */
+  uint8_t start_cylinder;
+
+  /* The partition type.  */
+  uint8_t type;
+
+  /* The end versions of start_head, start_sector and start_cylinder,
+     respectively.  */
+  uint8_t end_head;
+  uint8_t end_sector;
+  uint8_t end_cylinder;
+
+  /* The start sector. Note that this is counted from zero.  */
+  uint32_t start;
+
+  /* The length in sector units.  */
+  uint32_t length;
+} __attribute__ ((packed));
+
+/* The structure of MBR.  */
+struct msdos_partition_mbr
+{
+  /* The code area (actually, including BPB).  */
+  uint8_t code[446];
+
+  /* Four partition entries.  */
+  struct msdos_partition_entry entries[4];
+
+  /* The signature 0xaa55.  */
+  uint16_t signature;
+} __attribute__ ((packed));
+
+#endif
diff --git a/util/mkisofs/write.c b/util/mkisofs/write.c
index 73c220827..987ca1512 100644
--- a/util/mkisofs/write.c
+++ b/util/mkisofs/write.c
@@ -21,11 +21,10 @@
    along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "config.h"
+
 #include <string.h>
 #include <stdlib.h>
-#include "config.h"
-#include "mkisofs.h"
-#include "iso9660.h"
 #include <time.h>
 #include <errno.h>
 
@@ -37,6 +36,10 @@
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+
+#include "mkisofs.h"
+#include "iso9660.h"
+#include "msdos_partition.h"
  
 #ifdef __SVR4
 extern char * strdup(const char *);
@@ -1344,6 +1347,9 @@ int FDECL1(oneblock_size, int, starting_extent)
 /*
  * Functions to describe padding block at the start of the disc.
  */
+
+#define PADBLOCK_SIZE	16
+
 static int FDECL1(pathtab_size, int, starting_extent)
 {
   path_table[0] = starting_extent;
@@ -1357,7 +1363,7 @@ static int FDECL1(pathtab_size, int, starting_extent)
 
 static int FDECL1(padblock_size, int, starting_extent)
 {
-  last_extent += 16;
+  last_extent += PADBLOCK_SIZE;
   return 0;
 }
 
@@ -1420,17 +1426,45 @@ static int FDECL1(dirtree_cleanup, FILE *, outfile)
 
 static int FDECL1(padblock_write, FILE *, outfile)
 {
-  char				buffer[2048];
-  int				i;
+  char *buffer;
 
-  memset(buffer, 0, sizeof(buffer));
+  buffer = e_malloc (2048 * PADBLOCK_SIZE);
+  memset (buffer, 0, 2048 * PADBLOCK_SIZE);
 
-  for(i=0; i<16; i++)
+  if (use_embedded_boot)
     {
-      xfwrite(buffer, 1, sizeof(buffer), outfile);
+      FILE *fp = fopen (boot_image_embed, "rb");
+      if (! fp)
+	error (1, errno, _("Unable to open %s"), boot_image_embed);
+      fread (buffer, 2048 * PADBLOCK_SIZE, 1, fp);
     }
 
-  last_extent_written += 16;
+  if (use_protective_msdos_label)
+    {
+      struct msdos_partition_mbr *mbr = (void *) buffer;
+
+      memset (mbr->entries, 0, sizeof(mbr->entries));
+
+      /* Some idiotic BIOSes refuse to boot if they don't find at least
+	 one partition with active bit set.  */
+      mbr->entries[0].flag = 0x80;
+
+      /* Doesn't really matter, as long as it's non-zero.  It seems that
+         0xCD is used elsewhere, so we follow suit.  */
+      mbr->entries[0].type = 0xcd;
+
+      /* Start immediately (sector 1).  */
+      mbr->entries[0].start = 1;
+
+      /* We don't know yet.  Let's keep it safe.  */
+      mbr->entries[0].length = UINT32_MAX;
+
+      mbr->signature = MSDOS_PARTITION_SIGNATURE;
+    }
+
+  xfwrite (buffer, 1, 2048 * PADBLOCK_SIZE, outfile);
+  last_extent_written += PADBLOCK_SIZE;
+
   return 0;
 }
 
diff --git a/video/i386/pc/vbe.c b/video/i386/pc/vbe.c
index 8759ba652..0c0087a70 100644
--- a/video/i386/pc/vbe.c
+++ b/video/i386/pc/vbe.c
@@ -33,6 +33,9 @@ static int vbe_detected = -1;
 static struct grub_vbe_info_block controller_info;
 static struct grub_vbe_mode_info_block active_vbe_mode_info;
 
+/* Track last mode to support cards which fail on get_mode.  */
+static grub_uint32_t last_set_mode = 3;
+
 static struct
 {
   struct grub_video_mode_info mode_info;
@@ -160,6 +163,7 @@ grub_vbe_set_video_mode (grub_uint32_t vbe_mode,
   status = grub_vbe_bios_set_mode (vbe_mode, 0);
   if (status != GRUB_VBE_STATUS_OK)
     return grub_error (GRUB_ERR_BAD_DEVICE, "cannot set VBE mode %x", vbe_mode);
+  last_set_mode = vbe_mode;
 
   /* Save information for later usage.  */
   framebuffer.active_vbe_mode = vbe_mode;
@@ -203,6 +207,7 @@ grub_vbe_set_video_mode (grub_uint32_t vbe_mode,
 	case 8: framebuffer.bytes_per_pixel = 1; break;
 	default:
 	  grub_vbe_bios_set_mode (old_vbe_mode, 0);
+	  last_set_mode = old_vbe_mode;
 	  return grub_error (GRUB_ERR_BAD_DEVICE,
 			     "cannot set VBE mode %x",
 			     vbe_mode);
@@ -256,8 +261,9 @@ grub_vbe_get_video_mode (grub_uint32_t *mode)
 
   /* Try to query current mode from VESA BIOS.  */
   status = grub_vbe_bios_get_mode (mode);
+  /* XXX: ATI cards don't support get_mode.  */
   if (status != GRUB_VBE_STATUS_OK)
-    return grub_error (GRUB_ERR_BAD_DEVICE, "cannot get current VBE mode");
+    *mode = last_set_mode;
 
   return GRUB_ERR_NONE;
 }
@@ -350,6 +356,7 @@ grub_video_vbe_fini (void)
   if (status != GRUB_VBE_STATUS_OK)
     /* TODO: Decide, is this something we want to do.  */
     return grub_errno;
+  last_set_mode = initial_vbe_mode;
 
   /* TODO: Free any resources allocated by driver.  */
   grub_free (vbe_mode_list);
@@ -391,10 +398,6 @@ grub_video_vbe_setup (unsigned int width, unsigned int height,
         /* If not available, skip it.  */
         continue;
 
-      if ((vbe_mode_info.mode_attributes & 0x002) == 0)
-        /* Not enough information.  */
-        continue;
-
       if ((vbe_mode_info.mode_attributes & 0x008) == 0)
         /* Monochrome is unusable.  */
         continue;