Merge lp:~madengineer10/ubuntu/trusty/grub/linux-pref-substr into lp:ubuntu/trusty/grub

[Doug Brunner]

Adds an option, GRUB_LINUX_PREF_VERSION_SUBSTR, that can be set to prioritize Linux kernels containing a given substring. This takes precedence over version ordering, so if you have 3.14.1-generic, 3.14.2-generic, 3.8.13-fnord1, and 3.8.13-fnord2 and the substring is 'fnord', the order is:
3.8.13-fnord2
3.8.13-fnord1
3.14.2-generic
3.14.1-generic

Rationale: I (and apparently a number of others, see e.g. http://askubuntu.com/questions/216398/set-older-kernel-as-default-grub-entry) found myself needing to change the Linux kernel version GRUB sets as default. The process is rather clunky and error-prone; you have to figure out where in the GRUB menu it will appear, then enter that in /etc/default/grub, and if the menu position changes due to new kernels added to the system you have to do it all over again. I had older kernels with a distinctive local version naming scheme that I wanted preferred over the stock kernels, but it could also be used to specify a particular kernel version.

Testing: Kernels that do not have the substring from GRUB_LINUX_PREF_VERSION_SUBSTR should be ordered below kernels that do. The group of kernels with the substring should be sorted by version, as should kernels without.

[Colin Watson (cjwatson)]

Aside from the grub/grub2 thing (as per https://code.launchpad.net/~madengineer10/ubuntu/utopic/grub/linux-pref-substr/+merge/232023), we wouldn't do this sort of thing in stable updates until it's all sorted in utopic. Please drop this for now, let's get whatever we need to agreed and implemented in the development release, and only then consider an SRU.

review: Disapprove

[Doug Brunner (madengineer10)]

Sorry, I didn't know how backporting to current releases was done. I apologize for the inconvenience.

Unmerged revisions

191. By Doug Brunner on 2014-08-24

debian/patches/99-linux-pref-substr.patch: Add option to prefer Linux kernels containing substring

190. By Colin Watson on 2014-04-10

* Backport from upstream:
  - Tolerate devices with no filesystem UUID returned by os-prober
    (LP: #1287436).

189. By Colin Watson on 2014-03-31

[ Colin Watson ]
* Backport from upstream:
  - ieee1275: check for IBM pseries emulated machine.
  - Fix partmap, cryptodisk, and abstraction handling in grub-mkconfig
    (closes: #735935).
  - btrfs: fix get_root key comparison failures due to endianness.
* Build-depend on automake (>= 1.10.1) to ensure that it meets configure's
  requirements (LP: #1299041).
* When installing an image for use with UEFI Secure Boot, generate a
  load.cfg even if there are no device abstractions in use (LP: #1298399).

[ Jon Severinsson ]
* Add Tanglu support, as in Debian except:
  - Enable splash screen by default (as Ubuntu)
  - Enable quiet and quick boot (as Ubuntu)
  - Enable the grub-common init script (as Ubuntu)
  - Enable dynamic gfxpayload (as Ubuntu)
  - Enable vt handover (as Ubuntu)
  - Use monochromatic theme by default (as Ubuntu)
  - Use Tanglu GRUB wallpaper by default.

188. By Colin Watson on 2014-03-10

* Fix shift-held-down test not to clear other modifier key states
  (LP: #843804).
* Explicitly pass an appropriate --target to grub-install in the postinst
  (suggested by Jordan Uggla).
* Backport from upstream:
  - Use bootaa64.efi instead of bootaarch64.efi on arm64 to comply with
    EFI specification. Also use grubaa64.efi for consistency.

187. By Colin Watson on 2014-01-28

* Install bootinfo.txt and grub.chrp into grub-ieee1275-bin on powerpc and
  ppc64el.
* Port yaboot logic to improve installation for various powerpc machine
  types.
* Improve parsing of /etc/default/grub.d/*.cfg in C utilities
  (LP: #1273694).
* Run grub-install on install or upgrade on grub-ieee1275/ppc64el.

186. By Colin Watson on 2014-01-27

* Add a number of EFI debugging commands to the signed image (lsefi,
  lsefimmap, lsefisystab, lssal).
* Add gfxterm_background to the signed image so that background_image
  works in UEFI Secure Boot mode. Thanks to syscon-hh for the report.

185. By Colin Watson on 2014-01-20

* Remove redundant build-dependencies on autoconf and automake, covered by
  dh-autoreconf.
* In --enable-quick-boot mode, restore previous behaviour of using a
  hidden timeout if GRUB_HIDDEN_TIMEOUT=0 (thanks to Sebastien Bacher for
  the report).
* Disable cpio test on kFreeBSD again for now; it fails within cpio itself
  with "field width not sufficient for storing rdev minor".
* Copy shim.efi.signed to the correct path in UEFI Secure Boot mode.
  Thanks to syscon-hh for the report.

184. By Colin Watson on 2014-01-16

* Convert patch handling to git-dpm.
* Add bi-endian support to ELF parser (Tomohiro B Berry).
* Adjust restore_mkdevicemap.patch to mark get_kfreebsd_version as static,
  to appease "gcc -Werror=missing-prototypes".
* Cherry-pick from upstream:
  - Change grub-macbless' manual page section to 8.
* Install grub-glue-efi, grub-macbless, grub-render-label, and
  grub-syslinux2cfg.
* grub-shell: Pass -no-pad to xorriso when building floppy images.

183. By Colin Watson on 2013-12-12

* Backport from upstream:
  - On Linux, read partition start offsets from sysfs if possible
    (LP: #1237519).
  - Fix sector number when writing to non-512B disks (LP: #1253443).
* Regularise indentation of "recordfail" in /etc/grub.d/10_linux.

182. By Colin Watson on 2013-12-03

[ Robert Millan ]
* Backport from upstream:
  - Accept ZFS version 5000 (feature based).

[ Colin Watson ]
* Silence error message on initial installation when /etc/default/grub
  does not yet exist.
* Add GRUB_RECOVERY_TITLE option, to allow the controversial "recovery
  mode" text to be customised (LP: #1240360).
* Backport from upstream:
  - Revamp hidden timeout handling by adding a new timeout_style
    environment variable and a corresponding GRUB_TIMEOUT_STYLE
    configuration key for grub-mkconfig. This controls hidden-timeout
    handling more simply than the previous arrangements, and pressing any
    hotkeys associated with menu entries during the hidden timeout will
    now boot the corresponding menu entry immediately (LP: #1178618). As
    part of merging this, radically simplify the mess that
    quick_boot.patch had made of /etc/grub.d/30_os-prober; if it finds
    other OSes it can now just set timeout_style=menu and make sure the
    timeout is non-zero.
  - Fix build with FreeType 2.5.1.

=== added directory '.pc'
=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2014-08-24 23:28:48 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2014-08-24 23:28:48 +0000
@@ -0,0 +1,1 @@
+series

=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2014-08-24 23:28:48 +0000
@@ -0,0 +1,1 @@
+2

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2014-08-24 23:28:48 +0000
@@ -0,0 +1,51 @@
+olpc_prefix_hack.patch
+core_in_fs.patch
+dpkg_version_comparison.patch
+grub_legacy_0_based_partitions.patch
+disable_floppies.patch
+grub.cfg_400.patch
+gfxpayload_keep_default.patch
+install_stage2_confusion.patch
+mkrescue_efi_modules.patch
+mkconfig_loopback.patch
+restore_mkdevicemap.patch
+gettext_quiet.patch
+mkconfig_mid_upgrade.patch
+install_efi_fallback.patch
+mkconfig_ubuntu_recovery.patch
+install_locale_langpack.patch
+mkconfig_nonexistent_loopback.patch
+no_insmod_on_sb.patch
+default_grub_d.patch
+blacklist_1440x900x32.patch
+uefi_firmware_setup.patch
+mkconfig_ubuntu_distributor.patch
+linuxefi.patch
+linuxefi_amd64_only.patch
+linuxefi_debug.patch
+linuxefi_require_shim.patch
+linuxefi_non_sb_fallback.patch
+mkconfig_signed_kernel.patch
+install_signed.patch
+sleep_shift.patch
+wubi_no_windows.patch
+maybe_quiet.patch
+install_efi_ubuntu_flavours.patch
+quick_boot.patch
+gfxpayload_dynamic.patch
+vt_handoff.patch
+probe_fusionio.patch
+ignore_grub_func_test_failures.patch
+mkconfig_recovery_title.patch
+skip_gettext_strings_test.patch
+elf_bi_endian.patch
+macbless_mansection.patch
+grub-shell-no-pad.patch
+freebsd_debugflags_eperm.patch
+install_powerpc_machtypes.patch
+install_arm64_naming.patch
+mkrescue_arm64_naming.patch
+ieee1275-pseries-emulation.patch
+probe-delimiter.patch
+btrfs-endian.patch
+tolerate-lvm-snapshots.patch

=== added directory '.pc/blacklist_1440x900x32.patch'
=== added directory '.pc/blacklist_1440x900x32.patch/grub-core'
=== added directory '.pc/blacklist_1440x900x32.patch/grub-core/video'
=== added directory '.pc/blacklist_1440x900x32.patch/grub-core/video/i386'
=== added directory '.pc/blacklist_1440x900x32.patch/grub-core/video/i386/pc'
=== added file '.pc/blacklist_1440x900x32.patch/grub-core/video/i386/pc/vbe.c'
--- .pc/blacklist_1440x900x32.patch/grub-core/video/i386/pc/vbe.c	1970-01-01 00:00:00 +0000
+++ .pc/blacklist_1440x900x32.patch/grub-core/video/i386/pc/vbe.c	2014-08-24 23:28:48 +0000
@@ -0,0 +1,1249 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 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/>.
+ */
+
+#define grub_video_render_target grub_video_fbrender_target
+
+#include <grub/err.h>
+#include <grub/machine/memory.h>
+#include <grub/i386/pc/vbe.h>
+#include <grub/video_fb.h>
+#include <grub/types.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/video.h>
+#include <grub/i386/pc/int.h>
+#include <grub/i18n.h>
+#include <grub/cpu/cpuid.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static int vbe_detected = -1;
+
+static struct grub_vbe_info_block controller_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;
+
+  grub_uint8_t *ptr;
+  int mtrr;
+} framebuffer;
+
+static grub_uint32_t initial_vbe_mode;
+static grub_uint16_t *vbe_mode_list;
+
+static void *
+real2pm (grub_vbe_farptr_t ptr)
+{
+  return (void *) ((((unsigned long) ptr & 0xFFFF0000) >> 12UL)
+                   + ((unsigned long) ptr & 0x0000FFFF));
+}
+
+#define rdmsr(num,a,d) \
+  asm volatile ("rdmsr" : "=a" (a), "=d" (d) : "c" (num))
+
+#define wrmsr(num,lo,hi) \
+  asm volatile ("wrmsr" : : "c" (num), "a" (lo), "d" (hi) : "memory")
+
+#define mtrr_base(reg) (0x200 + (reg) * 2)
+#define mtrr_mask(reg) (0x200 + (reg) * 2 + 1)
+
+/* Try to set up a variable-range write-combining MTRR for a memory region.
+   This is best-effort; if it seems too hard, we just accept the performance
+   degradation rather than risking undefined behaviour.  It is intended
+   exclusively to work around BIOS bugs, as the BIOS should already be
+   setting up a suitable MTRR.  */
+static void
+grub_vbe_enable_mtrr_entry (int mtrr)
+{
+  grub_uint32_t eax, edx;
+  grub_uint32_t mask_lo, mask_hi;
+
+  rdmsr (mtrr_mask (mtrr), eax, edx);
+  mask_lo = eax;
+  mask_hi = edx;
+
+  mask_lo |= 0x800 /* valid */;
+  wrmsr (mtrr_mask (mtrr), mask_lo, mask_hi);
+}
+
+static void
+grub_vbe_enable_mtrr (grub_uint8_t *base, grub_size_t size)
+{
+  grub_uint32_t eax, ebx, ecx, edx;
+  grub_uint32_t features;
+  grub_uint32_t mtrrcap;
+  int var_mtrrs;
+  grub_uint32_t max_extended_cpuid;
+  grub_uint32_t maxphyaddr;
+  grub_uint64_t fb_base, fb_size;
+  grub_uint64_t size_bits, fb_mask;
+  grub_uint32_t bits_lo, bits_hi;
+  grub_uint64_t bits;
+  int i, first_unused = -1;
+  grub_uint32_t base_lo, base_hi, mask_lo, mask_hi;
+
+  fb_base = (grub_uint64_t) (grub_size_t) base;
+  fb_size = (grub_uint64_t) size;
+
+  /* Check that fb_base and fb_size can be represented using a single
+     MTRR.  */
+
+  if (fb_base < (1 << 20))
+    return; /* under 1MB, so covered by fixed-range MTRRs */
+  if (fb_base >= (1LL << 36))
+    return; /* over 36 bits, so out of range */
+  if (fb_size < (1 << 12))
+    return; /* variable-range MTRRs must cover at least 4KB */
+
+  size_bits = fb_size;
+  while (size_bits > 1)
+    size_bits >>= 1;
+  if (size_bits != 1)
+    return; /* not a power of two */
+
+  if (fb_base & (fb_size - 1))
+    return; /* not aligned on size boundary */
+
+  fb_mask = ~(fb_size - 1);
+
+  /* Check CPU capabilities.  */
+
+  if (! grub_cpu_is_cpuid_supported ())
+    return;
+
+  grub_cpuid (1, eax, ebx, ecx, edx);
+  features = edx;
+  if (! (features & 0x00001000)) /* MTRR */
+    return;
+
+  rdmsr (0xFE, eax, edx);
+  mtrrcap = eax;
+  if (! (mtrrcap & 0x00000400)) /* write-combining */
+    return;
+  var_mtrrs = (mtrrcap & 0xFF);
+
+  grub_cpuid (0x80000000, eax, ebx, ecx, edx);
+  max_extended_cpuid = eax;
+  if (max_extended_cpuid >= 0x80000008)
+    {
+      grub_cpuid (0x80000008, eax, ebx, ecx, edx);
+      maxphyaddr = (eax & 0xFF);
+    }
+  else
+    maxphyaddr = 36;
+  bits_lo = 0xFFFFF000; /* assume maxphyaddr >= 36 */
+  bits_hi = (1 << (maxphyaddr - 32)) - 1;
+  bits = bits_lo | ((grub_uint64_t) bits_hi << 32);
+
+  /* Check whether an MTRR already covers this region.  If not, take an
+     unused one if possible.  */
+  for (i = 0; i < var_mtrrs; i++)
+    {
+      rdmsr (mtrr_mask (i), eax, edx);
+      mask_lo = eax;
+      mask_hi = edx;
+      if (mask_lo & 0x800) /* valid */
+	{
+	  grub_uint64_t real_base, real_mask;
+
+	  rdmsr (mtrr_base (i), eax, edx);
+	  base_lo = eax;
+	  base_hi = edx;
+
+	  real_base = ((grub_uint64_t) (base_hi & bits_hi) << 32) |
+		      (base_lo & bits_lo);
+	  real_mask = ((grub_uint64_t) (mask_hi & bits_hi) << 32) |
+		       (mask_lo & bits_lo);
+	  if (real_base < (fb_base + fb_size) &&
+	      real_base + (~real_mask & bits) >= fb_base)
+	    return; /* existing MTRR overlaps this region */
+	}
+      else if (first_unused < 0)
+	first_unused = i;
+    }
+
+  if (first_unused < 0)
+    return; /* all MTRRs in use */
+
+  /* Set up the first unused MTRR we found.  */
+  rdmsr (mtrr_base (first_unused), eax, edx);
+  base_lo = eax;
+  base_hi = edx;
+  rdmsr (mtrr_mask (first_unused), eax, edx);
+  mask_lo = eax;
+  mask_hi = edx;
+
+  base_lo = (base_lo & ~bits_lo & ~0xFF) |
+	    (fb_base & bits_lo) | 0x01 /* WC */;
+  base_hi = (base_hi & ~bits_hi) | ((fb_base >> 32) & bits_hi);
+  wrmsr (mtrr_base (first_unused), base_lo, base_hi);
+  mask_lo = (mask_lo & ~bits_lo) | (fb_mask & bits_lo) | 0x800 /* valid */;
+  mask_hi = (mask_hi & ~bits_hi) | ((fb_mask >> 32) & bits_hi);
+  wrmsr (mtrr_mask (first_unused), mask_lo, mask_hi);
+
+  framebuffer.mtrr = first_unused;
+}
+
+static void
+grub_vbe_disable_mtrr (int mtrr)
+{
+  grub_uint32_t eax, edx;
+  grub_uint32_t mask_lo, mask_hi;
+
+  rdmsr (mtrr_mask (mtrr), eax, edx);
+  mask_lo = eax;
+  mask_hi = edx;
+
+  mask_lo &= ~0x800 /* valid */;
+  wrmsr (mtrr_mask (mtrr), mask_lo, mask_hi);
+}
+
+/* Call VESA BIOS 0x4f09 to set palette data, return status.  */
+static grub_vbe_status_t 
+grub_vbe_bios_set_palette_data (grub_uint32_t color_count,
+				grub_uint32_t start_index,
+				struct grub_vbe_palette_data *palette_data)
+{
+  struct grub_bios_int_registers regs;
+  regs.eax = 0x4f09;
+  regs.ebx = 0;
+  regs.ecx = color_count;
+  regs.edx = start_index;
+  regs.es = (((grub_addr_t) palette_data) & 0xffff0000) >> 4;
+  regs.edi = ((grub_addr_t) palette_data) & 0xffff;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f00 to get VBE Controller Information, return status.  */
+grub_vbe_status_t 
+grub_vbe_bios_get_controller_info (struct grub_vbe_info_block *ci)
+{
+  struct grub_bios_int_registers regs;
+  /* Store *controller_info to %es:%di.  */
+  regs.es = (((grub_addr_t) ci) & 0xffff0000) >> 4;
+  regs.edi = ((grub_addr_t) ci) & 0xffff;
+  regs.eax = 0x4f00;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f01 to get VBE Mode Information, return status.  */
+grub_vbe_status_t 
+grub_vbe_bios_get_mode_info (grub_uint32_t mode,
+			     struct grub_vbe_mode_info_block *mode_info)
+{
+  struct grub_bios_int_registers regs;
+  regs.eax = 0x4f01;
+  regs.ecx = mode;
+  /* Store *mode_info to %es:%di.  */
+  regs.es = ((grub_addr_t) mode_info & 0xffff0000) >> 4;
+  regs.edi = (grub_addr_t) mode_info & 0x0000ffff;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f02 to set video mode, return status.  */
+static grub_vbe_status_t
+grub_vbe_bios_set_mode (grub_uint32_t mode,
+			struct grub_vbe_crtc_info_block *crtc_info)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f02;
+  regs.ebx = mode;
+  /* Store *crtc_info to %es:%di.  */
+  regs.es = (((grub_addr_t) crtc_info) & 0xffff0000) >> 4;
+  regs.edi = ((grub_addr_t) crtc_info) & 0xffff;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f03 to return current VBE Mode, return status.  */
+grub_vbe_status_t 
+grub_vbe_bios_get_mode (grub_uint32_t *mode)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f03;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  *mode = regs.ebx & 0xffff;
+
+  return regs.eax & 0xffff;
+}
+
+grub_vbe_status_t 
+grub_vbe_bios_getset_dac_palette_width (int set, int *dac_mask_size)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f08;
+  regs.ebx = (*dac_mask_size & 0xff) >> 8;
+  regs.ebx = set ? 1 : 0;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  *dac_mask_size = (regs.ebx >> 8) & 0xff;
+
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f05 to set memory window, return status.  */
+grub_vbe_status_t
+grub_vbe_bios_set_memory_window (grub_uint32_t window,
+				 grub_uint32_t position)
+{
+  struct grub_bios_int_registers regs;
+
+  /* BL = window, BH = 0, Set memory window.  */
+  regs.ebx = window & 0x00ff;
+  regs.edx = position;
+  regs.eax = 0x4f05;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f05 to return memory window, return status.  */
+grub_vbe_status_t
+grub_vbe_bios_get_memory_window (grub_uint32_t window,
+				 grub_uint32_t *position)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f05;
+  /* BH = 1, Get memory window. BL = window.  */
+  regs.ebx = (window & 0x00ff) | 0x100;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+
+  *position = regs.edx & 0xffff;
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f06 to set scanline length (in bytes), return status.  */
+grub_vbe_status_t 
+grub_vbe_bios_set_scanline_length (grub_uint32_t length)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.ecx = length;
+  regs.eax = 0x4f06;
+  /* BL = 2, Set Scan Line in Bytes.  */
+  regs.ebx = 0x0002;	
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f06 to return scanline length (in bytes), return status.  */
+grub_vbe_status_t 
+grub_vbe_bios_get_scanline_length (grub_uint32_t *length)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f06;
+  regs.ebx = 0x0001;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  /* BL = 1, Get Scan Line Length (in bytes).  */
+  grub_bios_interrupt (0x10, &regs);
+
+  *length = regs.ebx & 0xffff;
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f07 to set display start, return status.  */
+static grub_vbe_status_t 
+grub_vbe_bios_set_display_start (grub_uint32_t x, grub_uint32_t y)
+{
+  struct grub_bios_int_registers regs;
+
+  if (framebuffer.mtrr >= 0)
+    grub_vbe_disable_mtrr (framebuffer.mtrr);
+
+  /* Store x in %ecx.  */
+  regs.ecx = x;
+  regs.edx = y;
+  regs.eax = 0x4f07;
+  /* BL = 80h, Set Display Start during Vertical Retrace.  */
+  regs.ebx = 0x0080;	
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+
+  if (framebuffer.mtrr >= 0)
+    grub_vbe_enable_mtrr_entry (framebuffer.mtrr);
+
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f07 to get display start, return status.  */
+grub_vbe_status_t 
+grub_vbe_bios_get_display_start (grub_uint32_t *x,
+				 grub_uint32_t *y)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f07;
+  /* BL = 1, Get Display Start.  */
+  regs.ebx = 0x0001;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+
+  *x = regs.ecx & 0xffff;
+  *y = regs.edx & 0xffff;
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f0a.  */
+grub_vbe_status_t 
+grub_vbe_bios_get_pm_interface (grub_uint16_t *segment, grub_uint16_t *offset,
+				grub_uint16_t *length)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f0a;
+  regs.ebx = 0x0000;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+
+  if ((regs.eax & 0xffff) != GRUB_VBE_STATUS_OK)
+    {
+      *segment = 0;
+      *offset = 0;
+      *length = 0;
+    }
+
+  *segment = regs.es & 0xffff;
+  *offset = regs.edi & 0xffff;
+  *length = regs.ecx & 0xffff;
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f11 to get flat panel information, return status.  */
+static grub_vbe_status_t
+grub_vbe_bios_get_flat_panel_info (struct grub_vbe_flat_panel_info *flat_panel_info)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f11;
+  regs.ebx = 0x0001;
+  regs.es = (((grub_addr_t) flat_panel_info) & 0xffff0000) >> 4;
+  regs.edi = ((grub_addr_t) flat_panel_info) & 0xffff;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f15 to get DDC availability, return status.  */
+static grub_vbe_status_t
+grub_vbe_bios_get_ddc_capabilities (grub_uint8_t *level)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f15;
+  regs.ebx = 0x0000;
+  regs.ecx = 0x0000;
+  regs.es = 0x0000;
+  regs.edi = 0x0000;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+
+  *level = regs.ebx & 0xff;
+  return regs.eax & 0xffff;
+}
+
+/* Call VESA BIOS 0x4f15 to read EDID information, return status.  */
+static grub_vbe_status_t
+grub_vbe_bios_read_edid (struct grub_video_edid_info *edid_info)
+{
+  struct grub_bios_int_registers regs;
+
+  regs.eax = 0x4f15;
+  regs.ebx = 0x0001;
+  regs.ecx = 0x0000;
+  regs.edx = 0x0000;
+  regs.es = (((grub_addr_t) edid_info) & 0xffff0000) >> 4;
+  regs.edi = ((grub_addr_t) edid_info) & 0xffff;
+  regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
+  grub_bios_interrupt (0x10, &regs);
+  return regs.eax & 0xffff;
+}
+
+grub_err_t
+grub_vbe_probe (struct grub_vbe_info_block *info_block)
+{
+  struct grub_vbe_info_block *vbe_ib;
+  grub_vbe_status_t status;
+
+  /* Clear caller's controller info block.  */
+  if (info_block)
+    grub_memset (info_block, 0, sizeof (*info_block));
+
+  /* Do not probe more than one time, if not necessary.  */
+  if (vbe_detected == -1 || info_block)
+    {
+      /* Clear old copy of controller info block.  */
+      grub_memset (&controller_info, 0, sizeof (controller_info));
+
+      /* Mark VESA BIOS extension as undetected.  */
+      vbe_detected = 0;
+
+      /* Use low memory scratch area as temporary storage
+         for VESA BIOS call.  */
+      vbe_ib = (struct grub_vbe_info_block *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
+
+      /* Prepare info block.  */
+      grub_memset (vbe_ib, 0, sizeof (*vbe_ib));
+
+      vbe_ib->signature[0] = 'V';
+      vbe_ib->signature[1] = 'B';
+      vbe_ib->signature[2] = 'E';
+      vbe_ib->signature[3] = '2';
+
+      /* Try to get controller info block.  */
+      status = grub_vbe_bios_get_controller_info (vbe_ib);
+      if (status == GRUB_VBE_STATUS_OK)
+        {
+          /* Copy it for later usage.  */
+          grub_memcpy (&controller_info, vbe_ib, sizeof (controller_info));
+
+          /* Mark VESA BIOS extension as detected.  */
+          vbe_detected = 1;
+        }
+    }
+
+  if (! vbe_detected)
+    return grub_error (GRUB_ERR_BAD_DEVICE, "VESA BIOS Extension not found");
+
+  /* Make copy of controller info block to caller.  */
+  if (info_block)
+    grub_memcpy (info_block, &controller_info, sizeof (*info_block));
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_video_vbe_get_edid (struct grub_video_edid_info *edid_info)
+{
+  struct grub_video_edid_info *edid_info_lowmem;
+
+  /* Use low memory scratch area as temporary storage for VESA BIOS calls.  */
+  edid_info_lowmem =
+    (struct grub_video_edid_info *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
+  grub_memset (edid_info_lowmem, 0, sizeof (*edid_info_lowmem));
+
+  if (grub_vbe_bios_read_edid (edid_info_lowmem) != GRUB_VBE_STATUS_OK)
+    return grub_error (GRUB_ERR_BAD_DEVICE, "EDID information not available");
+
+  grub_memcpy (edid_info, edid_info_lowmem, sizeof (*edid_info));
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_vbe_get_preferred_mode (unsigned int *width, unsigned int *height)
+{
+  grub_vbe_status_t status;
+  grub_uint8_t ddc_level;
+  struct grub_video_edid_info edid_info;
+  struct grub_vbe_flat_panel_info *flat_panel_info;
+
+  /* Use low memory scratch area as temporary storage for VESA BIOS calls.  */
+  flat_panel_info = (struct grub_vbe_flat_panel_info *)
+    (GRUB_MEMORY_MACHINE_SCRATCH_ADDR + sizeof (struct grub_video_edid_info));
+
+  if (controller_info.version >= 0x200
+      && (grub_vbe_bios_get_ddc_capabilities (&ddc_level) & 0xff)
+	 == GRUB_VBE_STATUS_OK)
+    {
+      if (grub_video_vbe_get_edid (&edid_info) == GRUB_ERR_NONE
+	  && grub_video_edid_checksum (&edid_info) == GRUB_ERR_NONE
+	  && grub_video_edid_preferred_mode (&edid_info, width, height)
+	      == GRUB_ERR_NONE && *width < 4096 && *height < 4096)
+	return GRUB_ERR_NONE;
+
+      grub_errno = GRUB_ERR_NONE;
+    }
+
+  grub_memset (flat_panel_info, 0, sizeof (*flat_panel_info));
+  status = grub_vbe_bios_get_flat_panel_info (flat_panel_info);
+  if (status == GRUB_VBE_STATUS_OK
+      && flat_panel_info->horizontal_size && flat_panel_info->vertical_size
+      && flat_panel_info->horizontal_size < 4096
+      && flat_panel_info->vertical_size < 4096)
+    {
+      *width = flat_panel_info->horizontal_size;
+      *height = flat_panel_info->vertical_size;
+      return GRUB_ERR_NONE;
+    }
+
+  return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "cannot get preferred mode");
+}
+
+static grub_err_t
+grub_vbe_set_video_mode (grub_uint32_t vbe_mode,
+			 struct grub_vbe_mode_info_block *vbe_mode_info)
+{
+  grub_vbe_status_t status;
+  grub_uint32_t old_vbe_mode;
+  struct grub_vbe_mode_info_block new_vbe_mode_info;
+  grub_err_t err;
+
+  /* Make sure that VBE is supported.  */
+  grub_vbe_probe (0);
+  if (grub_errno != GRUB_ERR_NONE)
+    return grub_errno;
+
+  /* Try to get mode info.  */
+  grub_vbe_get_video_mode_info (vbe_mode, &new_vbe_mode_info);
+  if (grub_errno != GRUB_ERR_NONE)
+    return grub_errno;
+
+  /* For all VESA BIOS modes, force linear frame buffer.  */
+  if (vbe_mode >= 0x100)
+    {
+      /* We only want linear frame buffer modes.  */
+      vbe_mode |= 1 << 14;
+
+      /* Determine frame buffer pixel format.  */
+      if (new_vbe_mode_info.memory_model != GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL
+	  && new_vbe_mode_info.memory_model
+	  != GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR)
+	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+			   "unsupported pixel format 0x%x",
+			   new_vbe_mode_info.memory_model);
+    }
+
+  /* Get current mode.  */
+  grub_vbe_get_video_mode (&old_vbe_mode);
+  if (grub_errno != GRUB_ERR_NONE)
+    return grub_errno;
+
+  /* Try to set video 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;
+
+  if (vbe_mode < 0x100)
+    {
+      /* If this is not a VESA mode, guess address.  */
+      framebuffer.ptr = (grub_uint8_t *) 0xa0000;
+    }
+  else
+    {
+      framebuffer.ptr = (grub_uint8_t *) new_vbe_mode_info.phys_base_addr;
+    }
+
+  /* Check whether mode is text mode or graphics mode.  */
+  if (new_vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_TEXT)
+    {
+      /* Text mode.  */
+
+      /* No special action needed for text mode as it is not supported for
+         graphical support.  */
+    }
+  else
+    {
+      /* Graphics mode.  */
+
+      /* If video mode is in indexed color, setup default VGA palette.  */
+      if (vbe_mode < 0x100 || new_vbe_mode_info.memory_model
+	  == GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL)
+	{
+	  struct grub_vbe_palette_data *palette
+	    = (struct grub_vbe_palette_data *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
+	  unsigned i;
+
+	  /* Make sure that the BIOS can reach the palette.  */
+	  for (i = 0; i < GRUB_VIDEO_FBSTD_NUMCOLORS; i++)
+	    {
+	      palette[i].red = grub_video_fbstd_colors[i].r;
+	      palette[i].green = grub_video_fbstd_colors[i].g;
+	      palette[i].blue = grub_video_fbstd_colors[i].b;
+	      palette[i].alignment = 0;
+	    }
+
+	  status = grub_vbe_bios_set_palette_data (GRUB_VIDEO_FBSTD_NUMCOLORS,
+						   0, palette);
+
+	  /* Just ignore the status.  */
+	  err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
+					   grub_video_fbstd_colors);
+	  if (err)
+	    return err;
+
+	}
+    }
+
+  /* Copy mode info for caller.  */
+  if (vbe_mode_info)
+    grub_memcpy (vbe_mode_info, &new_vbe_mode_info, sizeof (*vbe_mode_info));
+
+  return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_vbe_get_video_mode (grub_uint32_t *mode)
+{
+  grub_vbe_status_t status;
+
+  /* Make sure that VBE is supported.  */
+  grub_vbe_probe (0);
+  if (grub_errno != GRUB_ERR_NONE)
+    return grub_errno;
+
+  /* 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)
+    *mode = last_set_mode;
+
+  return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_vbe_get_video_mode_info (grub_uint32_t mode,
+                              struct grub_vbe_mode_info_block *mode_info)
+{
+  struct grub_vbe_mode_info_block *mi_tmp
+    = (struct grub_vbe_mode_info_block *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
+  grub_vbe_status_t status;
+
+  /* Make sure that VBE is supported.  */
+  grub_vbe_probe (0);
+  if (grub_errno != GRUB_ERR_NONE)
+    return grub_errno;
+
+  /* If mode is not VESA mode, skip mode info query.  */
+  if (mode >= 0x100)
+    {
+      /* Try to get mode info from VESA BIOS.  */
+      status = grub_vbe_bios_get_mode_info (mode, mi_tmp);
+      if (status != GRUB_VBE_STATUS_OK)
+        return grub_error (GRUB_ERR_BAD_DEVICE,
+                           "cannot get information on the mode %x", mode);
+
+      /* Make copy of mode info block.  */
+      grub_memcpy (mode_info, mi_tmp, sizeof (*mode_info));
+    }
+  else
+    /* Just clear mode info block if it isn't a VESA mode.  */
+    grub_memset (mode_info, 0, sizeof (*mode_info));
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_video_vbe_init (void)
+{
+  grub_uint16_t *rm_vbe_mode_list;
+  grub_uint16_t *p;
+  grub_size_t vbe_mode_list_size;
+  struct grub_vbe_info_block info_block;
+
+  /* Check if there is adapter present.
+
+     Firmware note: There has been a report that some cards store video mode
+     list in temporary memory.  So we must first use vbe probe to get
+     refreshed information to receive valid pointers and data, and then
+     copy this information to somewhere safe.  */
+  grub_vbe_probe (&info_block);
+  if (grub_errno != GRUB_ERR_NONE)
+    return grub_errno;
+
+  /* Copy modelist to local memory.  */
+  p = rm_vbe_mode_list = real2pm (info_block.video_mode_ptr);
+  while(*p++ != 0xFFFF)
+    ;
+
+  vbe_mode_list_size = (grub_addr_t) p - (grub_addr_t) rm_vbe_mode_list;
+  vbe_mode_list = grub_malloc (vbe_mode_list_size);
+  if (! vbe_mode_list)
+    return grub_errno;
+  grub_memcpy (vbe_mode_list, rm_vbe_mode_list, vbe_mode_list_size);
+
+  /* Adapter could be found, figure out initial video mode.  */
+  grub_vbe_get_video_mode (&initial_vbe_mode);
+  if (grub_errno != GRUB_ERR_NONE)
+    {
+      /* Free allocated resources.  */
+      grub_free (vbe_mode_list);
+      vbe_mode_list = NULL;
+
+      return grub_errno;
+    }
+
+  /* Reset frame buffer.  */
+  grub_memset (&framebuffer, 0, sizeof(framebuffer));
+  framebuffer.mtrr = -1;
+
+  return grub_video_fb_init ();
+}
+
+static grub_err_t
+grub_video_vbe_fini (void)
+{
+  grub_vbe_status_t status;
+  grub_err_t err;
+
+  /* Restore old video mode.  */
+  if (last_set_mode != initial_vbe_mode)
+    {
+      status = grub_vbe_bios_set_mode (initial_vbe_mode, 0);
+      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);
+  vbe_mode_list = NULL;
+
+  err = grub_video_fb_fini ();
+  if (framebuffer.mtrr >= 0)
+    {
+      grub_vbe_disable_mtrr (framebuffer.mtrr);
+      framebuffer.mtrr = -1;
+    }
+  return err;
+}
+
+/*
+  Set framebuffer render target page and display the proper page, based on
+  `doublebuf_state.render_page' and `doublebuf_state.displayed_page',
+  respectively.
+*/
+static grub_err_t
+doublebuf_pageflipping_set_page (int page)
+{
+  /* Tell the video adapter to display the new front page.  */
+  int display_start_line
+    = framebuffer.mode_info.height * page;
+
+  grub_vbe_status_t vbe_err =
+    grub_vbe_bios_set_display_start (0, display_start_line);
+
+  if (vbe_err != GRUB_VBE_STATUS_OK)
+    return grub_error (GRUB_ERR_IO, "couldn't commit pageflip");
+
+  return 0;
+}
+
+static void
+vbe2videoinfo (grub_uint32_t mode,
+	       const struct grub_vbe_mode_info_block *vbeinfo,
+	       struct grub_video_mode_info *mode_info)
+{
+  mode_info->mode_number = mode;
+
+  mode_info->width = vbeinfo->x_resolution;
+  mode_info->height = vbeinfo->y_resolution;
+  mode_info->mode_type = 0;
+  switch (vbeinfo->memory_model)
+    {
+    case GRUB_VBE_MEMORY_MODEL_TEXT:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_PURE_TEXT;
+      break;
+
+      /* CGA is basically 4-bit packed pixel.  */
+    case GRUB_VBE_MEMORY_MODEL_CGA:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_CGA;
+    case GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
+      break;
+
+    case GRUB_VBE_MEMORY_MODEL_HERCULES:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_HERCULES
+	| GRUB_VIDEO_MODE_TYPE_1BIT_BITMAP;
+      break;
+
+      /* Non chain 4 is a special case of planar.  */
+    case GRUB_VBE_MEMORY_MODEL_NONCHAIN4_256:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_NONCHAIN4;
+    case GRUB_VBE_MEMORY_MODEL_PLANAR:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_PLANAR
+	| GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
+      break;
+
+    case GRUB_VBE_MEMORY_MODEL_YUV:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_YUV;
+      break;
+      
+    case GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_RGB;
+      break;
+    default:
+      mode_info->mode_type |= GRUB_VIDEO_MODE_TYPE_UNKNOWN;
+      break;
+    }
+
+  mode_info->bpp = vbeinfo->bits_per_pixel;
+  /* Calculate bytes_per_pixel value.  */
+  switch(vbeinfo->bits_per_pixel)
+    {
+    case 32:
+      mode_info->bytes_per_pixel = 4;
+      break;
+    case 24:
+      mode_info->bytes_per_pixel = 3;
+      break;
+    case 16:
+      mode_info->bytes_per_pixel = 2;
+      break;
+    case 15:
+      mode_info->bytes_per_pixel = 2;
+      break;
+    case 8:
+      mode_info->bytes_per_pixel = 1;
+      break;  
+    case 4:
+      mode_info->bytes_per_pixel = 0;
+      break;  
+    }
+
+  if (controller_info.version >= 0x300)
+    mode_info->pitch = vbeinfo->lin_bytes_per_scan_line;
+  else
+    mode_info->pitch = vbeinfo->bytes_per_scan_line;
+
+  if (mode_info->mode_type & GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)
+    mode_info->number_of_colors = 16;
+  else
+    mode_info->number_of_colors = 256;
+  mode_info->red_mask_size = vbeinfo->red_mask_size;
+  mode_info->red_field_pos = vbeinfo->red_field_position;
+  mode_info->green_mask_size = vbeinfo->green_mask_size;
+  mode_info->green_field_pos = vbeinfo->green_field_position;
+  mode_info->blue_mask_size = vbeinfo->blue_mask_size;
+  mode_info->blue_field_pos = vbeinfo->blue_field_position;
+  mode_info->reserved_mask_size = vbeinfo->rsvd_mask_size;
+  mode_info->reserved_field_pos = vbeinfo->rsvd_field_position;
+
+  mode_info->blit_format = grub_video_get_blit_format (mode_info);
+}
+
+static int
+grub_video_vbe_iterate (int (*hook) (const struct grub_video_mode_info *info, void *hook_arg), void *hook_arg)
+{
+  grub_uint16_t *p;
+  struct grub_vbe_mode_info_block vbe_mode_info;
+  struct grub_video_mode_info mode_info;
+
+  for (p = vbe_mode_list; *p != 0xFFFF; p++)
+    {
+      grub_vbe_get_video_mode_info (*p, &vbe_mode_info);
+      if (grub_errno != GRUB_ERR_NONE)
+        {
+          /* Could not retrieve mode info, retreat.  */
+          grub_errno = GRUB_ERR_NONE;
+          break;
+        }
+
+      vbe2videoinfo (*p, &vbe_mode_info, &mode_info);
+      if (hook (&mode_info, hook_arg))
+	return 1;
+    }
+  return 0;
+}
+
+static grub_err_t
+grub_video_vbe_setup (unsigned int width, unsigned int height,
+                      grub_video_mode_type_t mode_type, 
+		      grub_video_mode_type_t mode_mask)
+{
+  grub_uint16_t *p;
+  struct grub_vbe_mode_info_block vbe_mode_info;
+  struct grub_vbe_mode_info_block best_vbe_mode_info;
+  grub_uint32_t best_vbe_mode = 0;
+  int depth;
+  int preferred_mode = 0;
+
+  /* Decode depth from mode_type.  If it is zero, then autodetect.  */
+  depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
+          >> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
+
+  if (width == 0 && height == 0)
+    {
+      grub_vbe_get_preferred_mode (&width, &height);
+      if (grub_errno == GRUB_ERR_NONE)
+	preferred_mode = 1;
+      else
+	{
+	  /* Fall back to 640x480.  This is conservative, but the largest
+	     mode supported by the graphics card may not be safe for the
+	     display device.  */
+	  grub_errno = GRUB_ERR_NONE;
+	  width = 640;
+	  height = 480;
+	}
+    }
+
+  /* Walk thru mode list and try to find matching mode.  */
+  for (p = vbe_mode_list; *p != 0xFFFF; p++)
+    {
+      grub_uint32_t vbe_mode = *p;
+
+      grub_vbe_get_video_mode_info (vbe_mode, &vbe_mode_info);
+      if (grub_errno != GRUB_ERR_NONE)
+        {
+          /* Could not retrieve mode info, retreat.  */
+          grub_errno = GRUB_ERR_NONE;
+          break;
+        }
+
+      if ((vbe_mode_info.mode_attributes & GRUB_VBE_MODEATTR_SUPPORTED) == 0)
+        /* If not available, skip it.  */
+        continue;
+
+      if ((vbe_mode_info.mode_attributes & GRUB_VBE_MODEATTR_COLOR) == 0)
+        /* Monochrome is unusable.  */
+        continue;
+
+      if ((vbe_mode_info.mode_attributes & GRUB_VBE_MODEATTR_LFB_AVAIL) == 0)
+        /* We support only linear frame buffer modes.  */
+        continue;
+
+      if ((vbe_mode_info.mode_attributes & GRUB_VBE_MODEATTR_GRAPHICS) == 0)
+        /* We allow only graphical modes.  */
+        continue;
+
+      if ((vbe_mode_info.memory_model != GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL)
+          && (vbe_mode_info.memory_model != GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR))
+        /* Not compatible memory model.  */
+        continue;
+
+      if (vbe_mode_info.bits_per_pixel != 8
+	  && vbe_mode_info.bits_per_pixel != 15
+	  && vbe_mode_info.bits_per_pixel != 16
+	  && vbe_mode_info.bits_per_pixel != 24
+	  && vbe_mode_info.bits_per_pixel != 32)
+	/* Unsupported bitdepth . */
+        continue;
+
+      if (preferred_mode)
+	{
+	  if (vbe_mode_info.x_resolution > width
+	      || vbe_mode_info.y_resolution > height)
+	    /* Resolution exceeds that of preferred mode.  */
+	    continue;
+	}
+      else
+	{
+	  if (((vbe_mode_info.x_resolution != width)
+	       || (vbe_mode_info.y_resolution != height))
+	      && width != 0 && height != 0)
+	    /* Non matching resolution.  */
+	    continue;
+	}
+
+      /* Check if user requested RGB or index color mode.  */
+      if ((mode_mask & GRUB_VIDEO_MODE_TYPE_COLOR_MASK) != 0)
+        {
+	  unsigned my_mode_type = 0;
+
+	  if (vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL)
+	    my_mode_type |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
+
+	  if (vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR)
+	    my_mode_type |= GRUB_VIDEO_MODE_TYPE_RGB;
+
+	  if ((my_mode_type & mode_mask
+	       & (GRUB_VIDEO_MODE_TYPE_RGB | GRUB_VIDEO_MODE_TYPE_INDEX_COLOR))
+	      != (mode_type & mode_mask
+		  & (GRUB_VIDEO_MODE_TYPE_RGB
+		     | GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)))
+	    continue;
+        }
+
+      /* If there is a request for specific depth, ignore others.  */
+      if ((depth != 0) && (vbe_mode_info.bits_per_pixel != depth))
+        continue;
+
+      /* Select mode with most of "volume" (size of framebuffer in bits).  */
+      if (best_vbe_mode != 0)
+        if ((grub_uint64_t) vbe_mode_info.bits_per_pixel
+	    * vbe_mode_info.x_resolution * vbe_mode_info.y_resolution
+	    < (grub_uint64_t) best_vbe_mode_info.bits_per_pixel
+	    * best_vbe_mode_info.x_resolution * best_vbe_mode_info.y_resolution)
+          continue;
+
+      /* Save so far best mode information for later use.  */
+      best_vbe_mode = vbe_mode;
+      grub_memcpy (&best_vbe_mode_info, &vbe_mode_info, sizeof (vbe_mode_info));
+    }
+
+  /* Try to initialize best mode found.  */
+  if (best_vbe_mode != 0)
+    {
+      grub_err_t err;
+      static struct grub_vbe_mode_info_block active_vbe_mode_info;
+      /* If this fails, then we have mode selection heuristics problem,
+         or adapter failure.  */
+      grub_vbe_set_video_mode (best_vbe_mode, &active_vbe_mode_info);
+      if (grub_errno != GRUB_ERR_NONE)
+        return grub_errno;
+
+      /* Fill mode info details.  */
+      vbe2videoinfo (best_vbe_mode, &active_vbe_mode_info,
+		     &framebuffer.mode_info);
+
+      {
+	/* Get video RAM size in bytes.  */
+	grub_size_t vram_size = controller_info.total_memory << 16;
+	grub_size_t page_size;        /* The size of a page in bytes.  */
+
+	page_size = framebuffer.mode_info.pitch * framebuffer.mode_info.height;
+
+	if (vram_size >= 2 * page_size)
+	  err = grub_video_fb_setup (mode_type, mode_mask,
+				     &framebuffer.mode_info,
+				     framebuffer.ptr,
+				     doublebuf_pageflipping_set_page,
+				     framebuffer.ptr + page_size);
+	else
+	  err = grub_video_fb_setup (mode_type, mode_mask,
+				     &framebuffer.mode_info,
+				     framebuffer.ptr, 0, 0);
+      }
+
+      /* Copy default palette to initialize emulated palette.  */
+      err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
+				       grub_video_fbstd_colors);
+
+      grub_vbe_enable_mtrr (framebuffer.ptr,
+			    controller_info.total_memory << 16);
+
+      return err;
+    }
+
+  /* Couldn't found matching mode.  */
+  return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
+}
+
+static grub_err_t
+grub_video_vbe_set_palette (unsigned int start, unsigned int count,
+                            struct grub_video_palette_data *palette_data)
+{
+  if (framebuffer.mode_info.mode_type == GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)
+    {
+      /* TODO: Implement setting indexed color mode palette to hardware.  */
+      //status = grub_vbe_bios_set_palette_data (sizeof (vga_colors)
+      //                                         / sizeof (struct grub_vbe_palette_data),
+      //                                         0,
+      //                                         palette);
+
+    }
+
+  /* Then set color to emulated palette.  */
+
+  return grub_video_fb_set_palette (start, count, palette_data);
+}
+
+static grub_err_t
+grub_video_vbe_get_info_and_fini (struct grub_video_mode_info *mode_info,
+				  void **framebuf)
+{
+  grub_err_t err;
+  grub_free (vbe_mode_list);
+  vbe_mode_list = NULL;
+  err = grub_video_fb_get_info_and_fini (mode_info, framebuf);
+  if (err)
+    return err;
+  if (framebuffer.mtrr >= 0)
+    {
+      grub_vbe_disable_mtrr (framebuffer.mtrr);
+      framebuffer.mtrr = -1;
+    }
+  return GRUB_ERR_NONE;
+}
+
+static void
+grub_video_vbe_print_adapter_specific_info (void)
+{
+  grub_printf_ (N_("  VBE info:   version: %d.%d  OEM software rev: %d.%d\n"),
+		controller_info.version >> 8,
+		controller_info.version & 0xFF,
+		controller_info.oem_software_rev >> 8,
+		controller_info.oem_software_rev & 0xFF);
+  
+  /* The total_memory field is in 64 KiB units.  */
+  grub_printf_ (N_("              total memory: %d KiB\n"),
+		(controller_info.total_memory << 6));
+}
+
+static struct grub_video_adapter grub_video_vbe_adapter =
+  {
+    .name = "VESA BIOS Extension Video Driver",
+    .id = GRUB_VIDEO_DRIVER_VBE,
+
+    .prio = GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE,
+
+    .init = grub_video_vbe_init,
+    .fini = grub_video_vbe_fini,
+    .setup = grub_video_vbe_setup,
+    .get_info = grub_video_fb_get_info,
+    .get_info_and_fini = grub_video_vbe_get_info_and_fini,
+    .set_palette = grub_video_vbe_set_palette,
+    .get_palette = grub_video_fb_get_palette,
+    .set_viewport = grub_video_fb_set_viewport,
+    .get_viewport = grub_video_fb_get_viewport,
+    .set_region = grub_video_fb_set_region,
+    .get_region = grub_video_fb_get_region,
+    .set_area_status = grub_video_fb_set_area_status,
+    .get_area_status = grub_video_fb_get_area_status,
+    .map_color = grub_video_fb_map_color,
+    .map_rgb = grub_video_fb_map_rgb,
+    .map_rgba = grub_video_fb_map_rgba,
+    .unmap_color = grub_video_fb_unmap_color,
+    .fill_rect = grub_video_fb_fill_rect,
+    .blit_bitmap = grub_video_fb_blit_bitmap,
+    .blit_render_target = grub_video_fb_blit_render_target,
+    .scroll = grub_video_fb_scroll,
+    .swap_buffers = grub_video_fb_swap_buffers,
+    .create_render_target = grub_video_fb_create_render_target,
+    .delete_render_target = grub_video_fb_delete_render_target,
+    .set_active_render_target = grub_video_fb_set_active_render_target,
+    .get_active_render_target = grub_video_fb_get_active_render_target,
+    .iterate = grub_video_vbe_iterate,
+    .get_edid = grub_video_vbe_get_edid,
+    .print_adapter_specific_info = grub_video_vbe_print_adapter_specific_info,
+
+    .next = 0
+  };
+
+GRUB_MOD_INIT(video_i386_pc_vbe)
+{
+  grub_video_register (&grub_video_vbe_adapter);
+}
+
+GRUB_MOD_FINI(video_i386_pc_vbe)
+{
+  grub_video_unregister (&grub_video_vbe_adapter);
+}

=== added directory '.pc/btrfs-endian.patch'
=== added directory '.pc/btrfs-endian.patch/grub-core'
=== added directory '.pc/btrfs-endian.patch/grub-core/fs'
=== added file '.pc/btrfs-endian.patch/grub-core/fs/btrfs.c'
--- .pc/btrfs-endian.patch/grub-core/fs/btrfs.c	1970-01-01 00:00:00 +0000
+++ .pc/btrfs-endian.patch/grub-core/fs/btrfs.c	2014-08-24 23:28:48 +0000
@@ -0,0 +1,1768 @@
+/* btrfs.c - B-tree file system.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010,2011,2012,2013  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/err.h>
+#include <grub/file.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/disk.h>
+#include <grub/dl.h>
+#include <grub/types.h>
+#include <grub/lib/crc.h>
+#include <grub/deflate.h>
+#include <minilzo.h>
+#include <grub/i18n.h>
+#include <grub/btrfs.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+#define GRUB_BTRFS_SIGNATURE "_BHRfS_M"
+
+/* From http://www.oberhumer.com/opensource/lzo/lzofaq.php
+ * LZO will expand incompressible data by a little amount. I still haven't
+ * computed the exact values, but I suggest using these formulas for
+ * a worst-case expansion calculation:
+ *
+ * output_block_size = input_block_size + (input_block_size / 16) + 64 + 3
+ *  */
+#define GRUB_BTRFS_LZO_BLOCK_SIZE 4096
+#define GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE (GRUB_BTRFS_LZO_BLOCK_SIZE + \
+				     (GRUB_BTRFS_LZO_BLOCK_SIZE / 16) + 64 + 3)
+
+typedef grub_uint8_t grub_btrfs_checksum_t[0x20];
+typedef grub_uint16_t grub_btrfs_uuid_t[8];
+
+struct grub_btrfs_device
+{
+  grub_uint64_t device_id;
+  grub_uint64_t size;
+  grub_uint8_t dummy[0x62 - 0x10];
+} GRUB_PACKED;
+
+struct grub_btrfs_superblock
+{
+  grub_btrfs_checksum_t checksum;
+  grub_btrfs_uuid_t uuid;
+  grub_uint8_t dummy[0x10];
+  grub_uint8_t signature[sizeof (GRUB_BTRFS_SIGNATURE) - 1];
+  grub_uint64_t generation;
+  grub_uint64_t root_tree;
+  grub_uint64_t chunk_tree;
+  grub_uint8_t dummy2[0x20];
+  grub_uint64_t root_dir_objectid;
+  grub_uint8_t dummy3[0x41];
+  struct grub_btrfs_device this_device;
+  char label[0x100];
+  grub_uint8_t dummy4[0x100];
+  grub_uint8_t bootstrap_mapping[0x800];
+} GRUB_PACKED;
+
+struct btrfs_header
+{
+  grub_btrfs_checksum_t checksum;
+  grub_btrfs_uuid_t uuid;
+  grub_uint8_t dummy[0x30];
+  grub_uint32_t nitems;
+  grub_uint8_t level;
+} GRUB_PACKED;
+
+struct grub_btrfs_device_desc
+{
+  grub_device_t dev;
+  grub_uint64_t id;
+};
+
+struct grub_btrfs_data
+{
+  struct grub_btrfs_superblock sblock;
+  grub_uint64_t tree;
+  grub_uint64_t inode;
+
+  struct grub_btrfs_device_desc *devices_attached;
+  unsigned n_devices_attached;
+  unsigned n_devices_allocated;
+
+  /* Cached extent data.  */
+  grub_uint64_t extstart;
+  grub_uint64_t extend;
+  grub_uint64_t extino;
+  grub_uint64_t exttree;
+  grub_size_t extsize;
+  struct grub_btrfs_extent_data *extent;
+};
+
+struct grub_btrfs_chunk_item
+{
+  grub_uint64_t size;
+  grub_uint64_t dummy;
+  grub_uint64_t stripe_length;
+  grub_uint64_t type;
+#define GRUB_BTRFS_CHUNK_TYPE_BITS_DONTCARE 0x07
+#define GRUB_BTRFS_CHUNK_TYPE_SINGLE        0x00
+#define GRUB_BTRFS_CHUNK_TYPE_RAID0         0x08
+#define GRUB_BTRFS_CHUNK_TYPE_RAID1         0x10
+#define GRUB_BTRFS_CHUNK_TYPE_DUPLICATED    0x20
+#define GRUB_BTRFS_CHUNK_TYPE_RAID10        0x40
+  grub_uint8_t dummy2[0xc];
+  grub_uint16_t nstripes;
+  grub_uint16_t nsubstripes;
+} GRUB_PACKED;
+
+struct grub_btrfs_chunk_stripe
+{
+  grub_uint64_t device_id;
+  grub_uint64_t offset;
+  grub_btrfs_uuid_t device_uuid;
+} GRUB_PACKED;
+
+struct grub_btrfs_leaf_node
+{
+  struct grub_btrfs_key key;
+  grub_uint32_t offset;
+  grub_uint32_t size;
+} GRUB_PACKED;
+
+struct grub_btrfs_internal_node
+{
+  struct grub_btrfs_key key;
+  grub_uint64_t addr;
+  grub_uint64_t dummy;
+} GRUB_PACKED;
+
+struct grub_btrfs_dir_item
+{
+  struct grub_btrfs_key key;
+  grub_uint8_t dummy[8];
+  grub_uint16_t m;
+  grub_uint16_t n;
+#define GRUB_BTRFS_DIR_ITEM_TYPE_REGULAR 1
+#define GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY 2
+#define GRUB_BTRFS_DIR_ITEM_TYPE_SYMLINK 7
+  grub_uint8_t type;
+  char name[0];
+} GRUB_PACKED;
+
+struct grub_btrfs_leaf_descriptor
+{
+  unsigned depth;
+  unsigned allocated;
+  struct
+  {
+    grub_disk_addr_t addr;
+    unsigned iter;
+    unsigned maxiter;
+    int leaf;
+  } *data;
+};
+
+struct grub_btrfs_time
+{
+  grub_int64_t sec;
+  grub_uint32_t nanosec;
+} __attribute__ ((aligned (4)));
+
+struct grub_btrfs_inode
+{
+  grub_uint8_t dummy1[0x10];
+  grub_uint64_t size;
+  grub_uint8_t dummy2[0x70];
+  struct grub_btrfs_time mtime;
+} GRUB_PACKED;
+
+struct grub_btrfs_extent_data
+{
+  grub_uint64_t dummy;
+  grub_uint64_t size;
+  grub_uint8_t compression;
+  grub_uint8_t encryption;
+  grub_uint16_t encoding;
+  grub_uint8_t type;
+  union
+  {
+    char inl[0];
+    struct
+    {
+      grub_uint64_t laddr;
+      grub_uint64_t compressed_size;
+      grub_uint64_t offset;
+      grub_uint64_t filled;
+    };
+  };
+} GRUB_PACKED;
+
+#define GRUB_BTRFS_EXTENT_INLINE 0
+#define GRUB_BTRFS_EXTENT_REGULAR 1
+
+#define GRUB_BTRFS_COMPRESSION_NONE 0
+#define GRUB_BTRFS_COMPRESSION_ZLIB 1
+#define GRUB_BTRFS_COMPRESSION_LZO  2
+
+#define GRUB_BTRFS_OBJECT_ID_CHUNK 0x100
+
+static grub_disk_addr_t superblock_sectors[] = { 64 * 2, 64 * 1024 * 2,
+  256 * 1048576 * 2, 1048576ULL * 1048576ULL * 2
+};
+
+static grub_err_t
+grub_btrfs_read_logical (struct grub_btrfs_data *data,
+			 grub_disk_addr_t addr, void *buf, grub_size_t size,
+			 int recursion_depth);
+
+static grub_err_t
+read_sblock (grub_disk_t disk, struct grub_btrfs_superblock *sb)
+{
+  unsigned i;
+  grub_err_t err = GRUB_ERR_NONE;
+  for (i = 0; i < ARRAY_SIZE (superblock_sectors); i++)
+    {
+      struct grub_btrfs_superblock sblock;
+      /* Don't try additional superblocks beyond device size.  */
+      if (i && (grub_le_to_cpu64 (sblock.this_device.size)
+		>> GRUB_DISK_SECTOR_BITS) <= superblock_sectors[i])
+	break;
+      err = grub_disk_read (disk, superblock_sectors[i], 0,
+			    sizeof (sblock), &sblock);
+      if (err == GRUB_ERR_OUT_OF_RANGE)
+	break;
+
+      if (grub_memcmp ((char *) sblock.signature, GRUB_BTRFS_SIGNATURE,
+		       sizeof (GRUB_BTRFS_SIGNATURE) - 1) != 0)
+	break;
+      if (i == 0 || grub_le_to_cpu64 (sblock.generation)
+	  > grub_le_to_cpu64 (sb->generation))
+	grub_memcpy (sb, &sblock, sizeof (sblock));
+    }
+
+  if ((err == GRUB_ERR_OUT_OF_RANGE || !err) && i == 0)
+    return grub_error (GRUB_ERR_BAD_FS, "not a Btrfs filesystem");
+
+  if (err == GRUB_ERR_OUT_OF_RANGE)
+    grub_errno = err = GRUB_ERR_NONE;
+
+  return err;
+}
+
+static int
+key_cmp (const struct grub_btrfs_key *a, const struct grub_btrfs_key *b)
+{
+  if (grub_le_to_cpu64 (a->object_id) < grub_le_to_cpu64 (b->object_id))
+    return -1;
+  if (grub_le_to_cpu64 (a->object_id) > grub_le_to_cpu64 (b->object_id))
+    return +1;
+
+  if (a->type < b->type)
+    return -1;
+  if (a->type > b->type)
+    return +1;
+
+  if (grub_le_to_cpu64 (a->offset) < grub_le_to_cpu64 (b->offset))
+    return -1;
+  if (grub_le_to_cpu64 (a->offset) > grub_le_to_cpu64 (b->offset))
+    return +1;
+  return 0;
+}
+
+static void
+free_iterator (struct grub_btrfs_leaf_descriptor *desc)
+{
+  grub_free (desc->data);
+}
+
+static grub_err_t
+save_ref (struct grub_btrfs_leaf_descriptor *desc,
+	  grub_disk_addr_t addr, unsigned i, unsigned m, int l)
+{
+  desc->depth++;
+  if (desc->allocated < desc->depth)
+    {
+      void *newdata;
+      desc->allocated *= 2;
+      newdata = grub_realloc (desc->data, sizeof (desc->data[0])
+			      * desc->allocated);
+      if (!newdata)
+	return grub_errno;
+      desc->data = newdata;
+    }
+  desc->data[desc->depth - 1].addr = addr;
+  desc->data[desc->depth - 1].iter = i;
+  desc->data[desc->depth - 1].maxiter = m;
+  desc->data[desc->depth - 1].leaf = l;
+  return GRUB_ERR_NONE;
+}
+
+static int
+next (struct grub_btrfs_data *data,
+      struct grub_btrfs_leaf_descriptor *desc,
+      grub_disk_addr_t * outaddr, grub_size_t * outsize,
+      struct grub_btrfs_key *key_out)
+{
+  grub_err_t err;
+  struct grub_btrfs_leaf_node leaf;
+
+  for (; desc->depth > 0; desc->depth--)
+    {
+      desc->data[desc->depth - 1].iter++;
+      if (desc->data[desc->depth - 1].iter
+	  < desc->data[desc->depth - 1].maxiter)
+	break;
+    }
+  if (desc->depth == 0)
+    return 0;
+  while (!desc->data[desc->depth - 1].leaf)
+    {
+      struct grub_btrfs_internal_node node;
+      struct btrfs_header head;
+
+      err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter
+				     * sizeof (node)
+				     + sizeof (struct btrfs_header)
+				     + desc->data[desc->depth - 1].addr,
+				     &node, sizeof (node), 0);
+      if (err)
+	return -err;
+
+      err = grub_btrfs_read_logical (data, grub_le_to_cpu64 (node.addr),
+				     &head, sizeof (head), 0);
+      if (err)
+	return -err;
+
+      save_ref (desc, grub_le_to_cpu64 (node.addr), 0,
+		grub_le_to_cpu32 (head.nitems), !head.level);
+    }
+  err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter
+				 * sizeof (leaf)
+				 + sizeof (struct btrfs_header)
+				 + desc->data[desc->depth - 1].addr, &leaf,
+				 sizeof (leaf), 0);
+  if (err)
+    return -err;
+  *outsize = grub_le_to_cpu32 (leaf.size);
+  *outaddr = desc->data[desc->depth - 1].addr + sizeof (struct btrfs_header)
+    + grub_le_to_cpu32 (leaf.offset);
+  *key_out = leaf.key;
+  return 1;
+}
+
+static grub_err_t
+lower_bound (struct grub_btrfs_data *data,
+	     const struct grub_btrfs_key *key_in,
+	     struct grub_btrfs_key *key_out,
+	     grub_uint64_t root,
+	     grub_disk_addr_t *outaddr, grub_size_t *outsize,
+	     struct grub_btrfs_leaf_descriptor *desc,
+	     int recursion_depth)
+{
+  grub_disk_addr_t addr = grub_le_to_cpu64 (root);
+  int depth = -1;
+
+  if (desc)
+    {
+      desc->allocated = 16;
+      desc->depth = 0;
+      desc->data = grub_malloc (sizeof (desc->data[0]) * desc->allocated);
+      if (!desc->data)
+	return grub_errno;
+    }
+
+  /* > 2 would work as well but be robust and allow a bit more just in case.
+   */
+  if (recursion_depth > 10)
+    return grub_error (GRUB_ERR_BAD_FS, "too deep btrfs virtual nesting");
+
+  grub_dprintf ("btrfs",
+		"retrieving %" PRIxGRUB_UINT64_T
+		" %x %" PRIxGRUB_UINT64_T "\n",
+		key_in->object_id, key_in->type, key_in->offset);
+
+  while (1)
+    {
+      grub_err_t err;
+      struct btrfs_header head;
+
+    reiter:
+      depth++;
+      /* FIXME: preread few nodes into buffer. */
+      err = grub_btrfs_read_logical (data, addr, &head, sizeof (head),
+				     recursion_depth + 1);
+      if (err)
+	return err;
+      addr += sizeof (head);
+      if (head.level)
+	{
+	  unsigned i;
+	  struct grub_btrfs_internal_node node, node_last;
+	  int have_last = 0;
+	  grub_memset (&node_last, 0, sizeof (node_last));
+	  for (i = 0; i < grub_le_to_cpu32 (head.nitems); i++)
+	    {
+	      err = grub_btrfs_read_logical (data, addr + i * sizeof (node),
+					     &node, sizeof (node),
+					     recursion_depth + 1);
+	      if (err)
+		return err;
+
+	      grub_dprintf ("btrfs",
+			    "internal node (depth %d) %" PRIxGRUB_UINT64_T
+			    " %x %" PRIxGRUB_UINT64_T "\n", depth,
+			    node.key.object_id, node.key.type,
+			    node.key.offset);
+
+	      if (key_cmp (&node.key, key_in) == 0)
+		{
+		  err = GRUB_ERR_NONE;
+		  if (desc)
+		    err = save_ref (desc, addr - sizeof (head), i,
+				    grub_le_to_cpu32 (head.nitems), 0);
+		  if (err)
+		    return err;
+		  addr = grub_le_to_cpu64 (node.addr);
+		  goto reiter;
+		}
+	      if (key_cmp (&node.key, key_in) > 0)
+		break;
+	      node_last = node;
+	      have_last = 1;
+	    }
+	  if (have_last)
+	    {
+	      err = GRUB_ERR_NONE;
+	      if (desc)
+		err = save_ref (desc, addr - sizeof (head), i - 1,
+				grub_le_to_cpu32 (head.nitems), 0);
+	      if (err)
+		return err;
+	      addr = grub_le_to_cpu64 (node_last.addr);
+	      goto reiter;
+	    }
+	  *outsize = 0;
+	  *outaddr = 0;
+	  grub_memset (key_out, 0, sizeof (*key_out));
+	  if (desc)
+	    return save_ref (desc, addr - sizeof (head), -1,
+			     grub_le_to_cpu32 (head.nitems), 0);
+	  return GRUB_ERR_NONE;
+	}
+      {
+	unsigned i;
+	struct grub_btrfs_leaf_node leaf, leaf_last;
+	int have_last = 0;
+	for (i = 0; i < grub_le_to_cpu32 (head.nitems); i++)
+	  {
+	    err = grub_btrfs_read_logical (data, addr + i * sizeof (leaf),
+					   &leaf, sizeof (leaf),
+					   recursion_depth + 1);
+	    if (err)
+	      return err;
+
+	    grub_dprintf ("btrfs",
+			  "leaf (depth %d) %" PRIxGRUB_UINT64_T
+			  " %x %" PRIxGRUB_UINT64_T "\n", depth,
+			  leaf.key.object_id, leaf.key.type, leaf.key.offset);
+
+	    if (key_cmp (&leaf.key, key_in) == 0)
+	      {
+		grub_memcpy (key_out, &leaf.key, sizeof (*key_out));
+		*outsize = grub_le_to_cpu32 (leaf.size);
+		*outaddr = addr + grub_le_to_cpu32 (leaf.offset);
+		if (desc)
+		  return save_ref (desc, addr - sizeof (head), i,
+				   grub_le_to_cpu32 (head.nitems), 1);
+		return GRUB_ERR_NONE;
+	      }
+
+	    if (key_cmp (&leaf.key, key_in) > 0)
+	      break;
+
+	    have_last = 1;
+	    leaf_last = leaf;
+	  }
+
+	if (have_last)
+	  {
+	    grub_memcpy (key_out, &leaf_last.key, sizeof (*key_out));
+	    *outsize = grub_le_to_cpu32 (leaf_last.size);
+	    *outaddr = addr + grub_le_to_cpu32 (leaf_last.offset);
+	    if (desc)
+	      return save_ref (desc, addr - sizeof (head), i - 1,
+			       grub_le_to_cpu32 (head.nitems), 1);
+	    return GRUB_ERR_NONE;
+	  }
+	*outsize = 0;
+	*outaddr = 0;
+	grub_memset (key_out, 0, sizeof (*key_out));
+	if (desc)
+	  return save_ref (desc, addr - sizeof (head), -1,
+			   grub_le_to_cpu32 (head.nitems), 1);
+	return GRUB_ERR_NONE;
+      }
+    }
+}
+
+/* Context for find_device.  */
+struct find_device_ctx
+{
+  struct grub_btrfs_data *data;
+  grub_uint64_t id;
+  grub_device_t dev_found;
+};
+
+/* Helper for find_device.  */
+static int
+find_device_iter (const char *name, void *data)
+{
+  struct find_device_ctx *ctx = data;
+  grub_device_t dev;
+  grub_err_t err;
+  struct grub_btrfs_superblock sb;
+
+  dev = grub_device_open (name);
+  if (!dev)
+    return 0;
+  if (!dev->disk)
+    {
+      grub_device_close (dev);
+      return 0;
+    }
+  err = read_sblock (dev->disk, &sb);
+  if (err == GRUB_ERR_BAD_FS)
+    {
+      grub_device_close (dev);
+      grub_errno = GRUB_ERR_NONE;
+      return 0;
+    }
+  if (err)
+    {
+      grub_device_close (dev);
+      grub_print_error ();
+      return 0;
+    }
+  if (grub_memcmp (ctx->data->sblock.uuid, sb.uuid, sizeof (sb.uuid)) != 0
+      || sb.this_device.device_id != ctx->id)
+    {
+      grub_device_close (dev);
+      return 0;
+    }
+
+  ctx->dev_found = dev;
+  return 1;
+}
+
+static grub_device_t
+find_device (struct grub_btrfs_data *data, grub_uint64_t id, int do_rescan)
+{
+  struct find_device_ctx ctx = {
+    .data = data,
+    .id = id,
+    .dev_found = NULL
+  };
+  unsigned i;
+
+  for (i = 0; i < data->n_devices_attached; i++)
+    if (id == data->devices_attached[i].id)
+      return data->devices_attached[i].dev;
+  if (do_rescan)
+    grub_device_iterate (find_device_iter, &ctx);
+  if (!ctx.dev_found)
+    {
+      grub_error (GRUB_ERR_BAD_FS,
+		  N_("couldn't find a necessary member device "
+		     "of multi-device filesystem"));
+      return NULL;
+    }
+  data->n_devices_attached++;
+  if (data->n_devices_attached > data->n_devices_allocated)
+    {
+      void *tmp;
+      data->n_devices_allocated = 2 * data->n_devices_attached + 1;
+      data->devices_attached
+	= grub_realloc (tmp = data->devices_attached,
+			data->n_devices_allocated
+			* sizeof (data->devices_attached[0]));
+      if (!data->devices_attached)
+	{
+	  grub_device_close (ctx.dev_found);
+	  data->devices_attached = tmp;
+	  return NULL;
+	}
+    }
+  data->devices_attached[data->n_devices_attached - 1].id = id;
+  data->devices_attached[data->n_devices_attached - 1].dev = ctx.dev_found;
+  return ctx.dev_found;
+}
+
+static grub_err_t
+grub_btrfs_read_logical (struct grub_btrfs_data *data, grub_disk_addr_t addr,
+			 void *buf, grub_size_t size, int recursion_depth)
+{
+  while (size > 0)
+    {
+      grub_uint8_t *ptr;
+      struct grub_btrfs_key *key;
+      struct grub_btrfs_chunk_item *chunk;
+      grub_uint64_t csize;
+      grub_err_t err = 0;
+      struct grub_btrfs_key key_out;
+      int challoc = 0;
+      grub_device_t dev;
+      struct grub_btrfs_key key_in;
+      grub_size_t chsize;
+      grub_disk_addr_t chaddr;
+
+      grub_dprintf ("btrfs", "searching for laddr %" PRIxGRUB_UINT64_T "\n",
+		    addr);
+      for (ptr = data->sblock.bootstrap_mapping;
+	   ptr < data->sblock.bootstrap_mapping
+	   + sizeof (data->sblock.bootstrap_mapping)
+	   - sizeof (struct grub_btrfs_key);)
+	{
+	  key = (struct grub_btrfs_key *) ptr;
+	  if (key->type != GRUB_BTRFS_ITEM_TYPE_CHUNK)
+	    break;
+	  chunk = (struct grub_btrfs_chunk_item *) (key + 1);
+	  grub_dprintf ("btrfs",
+			"%" PRIxGRUB_UINT64_T " %" PRIxGRUB_UINT64_T " \n",
+			grub_le_to_cpu64 (key->offset),
+			grub_le_to_cpu64 (chunk->size));
+	  if (grub_le_to_cpu64 (key->offset) <= addr
+	      && addr < grub_le_to_cpu64 (key->offset)
+	      + grub_le_to_cpu64 (chunk->size))
+	    goto chunk_found;
+	  ptr += sizeof (*key) + sizeof (*chunk)
+	    + sizeof (struct grub_btrfs_chunk_stripe)
+	    * grub_le_to_cpu16 (chunk->nstripes);
+	}
+
+      key_in.object_id = grub_cpu_to_le64_compile_time (GRUB_BTRFS_OBJECT_ID_CHUNK);
+      key_in.type = GRUB_BTRFS_ITEM_TYPE_CHUNK;
+      key_in.offset = grub_cpu_to_le64 (addr);
+      err = lower_bound (data, &key_in, &key_out,
+			 data->sblock.chunk_tree,
+			 &chaddr, &chsize, NULL, recursion_depth);
+      if (err)
+	return err;
+      key = &key_out;
+      if (key->type != GRUB_BTRFS_ITEM_TYPE_CHUNK
+	  || !(grub_le_to_cpu64 (key->offset) <= addr))
+	return grub_error (GRUB_ERR_BAD_FS,
+			   "couldn't find the chunk descriptor");
+
+      chunk = grub_malloc (chsize);
+      if (!chunk)
+	return grub_errno;
+
+      challoc = 1;
+      err = grub_btrfs_read_logical (data, chaddr, chunk, chsize,
+				     recursion_depth);
+      if (err)
+	{
+	  grub_free (chunk);
+	  return err;
+	}
+
+    chunk_found:
+      {
+	grub_uint64_t stripen;
+	grub_uint64_t stripe_offset;
+	grub_uint64_t off = addr - grub_le_to_cpu64 (key->offset);
+	unsigned redundancy = 1;
+	unsigned i, j;
+
+	if (grub_le_to_cpu64 (chunk->size) <= off)
+	  {
+	    grub_dprintf ("btrfs", "no chunk\n");
+	    return grub_error (GRUB_ERR_BAD_FS,
+			       "couldn't find the chunk descriptor");
+	  }
+
+	grub_dprintf ("btrfs", "chunk 0x%" PRIxGRUB_UINT64_T
+		      "+0x%" PRIxGRUB_UINT64_T
+		      " (%d stripes (%d substripes) of %"
+		      PRIxGRUB_UINT64_T ")\n",
+		      grub_le_to_cpu64 (key->offset),
+		      grub_le_to_cpu64 (chunk->size),
+		      grub_le_to_cpu16 (chunk->nstripes),
+		      grub_le_to_cpu16 (chunk->nsubstripes),
+		      grub_le_to_cpu64 (chunk->stripe_length));
+
+	switch (grub_le_to_cpu64 (chunk->type)
+		& ~GRUB_BTRFS_CHUNK_TYPE_BITS_DONTCARE)
+	  {
+	  case GRUB_BTRFS_CHUNK_TYPE_SINGLE:
+	    {
+	      grub_uint64_t stripe_length;
+	      grub_dprintf ("btrfs", "single\n");
+	      stripe_length = grub_divmod64 (grub_le_to_cpu64 (chunk->size),
+					     grub_le_to_cpu16 (chunk->nstripes),
+					     NULL);
+	      stripen = grub_divmod64 (off, stripe_length, &stripe_offset);
+	      csize = (stripen + 1) * stripe_length - off;
+	      break;
+	    }
+	  case GRUB_BTRFS_CHUNK_TYPE_DUPLICATED:
+	  case GRUB_BTRFS_CHUNK_TYPE_RAID1:
+	    {
+	      grub_dprintf ("btrfs", "RAID1\n");
+	      stripen = 0;
+	      stripe_offset = off;
+	      csize = grub_le_to_cpu64 (chunk->size) - off;
+	      redundancy = 2;
+	      break;
+	    }
+	  case GRUB_BTRFS_CHUNK_TYPE_RAID0:
+	    {
+	      grub_uint64_t middle, high;
+	      grub_uint64_t low;
+	      grub_dprintf ("btrfs", "RAID0\n");
+	      middle = grub_divmod64 (off,
+				      grub_le_to_cpu64 (chunk->stripe_length),
+				      &low);
+
+	      high = grub_divmod64 (middle, grub_le_to_cpu16 (chunk->nstripes),
+				    &stripen);
+	      stripe_offset =
+		low + grub_le_to_cpu64 (chunk->stripe_length) * high;
+	      csize = grub_le_to_cpu64 (chunk->stripe_length) - low;
+	      break;
+	    }
+	  case GRUB_BTRFS_CHUNK_TYPE_RAID10:
+	    {
+	      grub_uint64_t middle, high;
+	      grub_uint64_t low;
+	      middle = grub_divmod64 (off,
+				      grub_le_to_cpu64 (chunk->stripe_length),
+				      &low);
+
+	      high = grub_divmod64 (middle,
+				    grub_le_to_cpu16 (chunk->nstripes)
+				    / grub_le_to_cpu16 (chunk->nsubstripes),
+				    &stripen);
+	      stripen *= grub_le_to_cpu16 (chunk->nsubstripes);
+	      redundancy = grub_le_to_cpu16 (chunk->nsubstripes);
+	      stripe_offset = low + grub_le_to_cpu64 (chunk->stripe_length)
+		* high;
+	      csize = grub_le_to_cpu64 (chunk->stripe_length) - low;
+	      break;
+	    }
+	  default:
+	    grub_dprintf ("btrfs", "unsupported RAID\n");
+	    return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+			       "unsupported RAID flags %" PRIxGRUB_UINT64_T,
+			       grub_le_to_cpu64 (chunk->type));
+	  }
+	if (csize == 0)
+	  return grub_error (GRUB_ERR_BUG,
+			     "couldn't find the chunk descriptor");
+	if (csize > (grub_uint64_t) size)
+	  csize = size;
+
+	for (j = 0; j < 2; j++)
+	  {
+	    for (i = 0; i < redundancy; i++)
+	      {
+		struct grub_btrfs_chunk_stripe *stripe;
+		grub_disk_addr_t paddr;
+
+		stripe = (struct grub_btrfs_chunk_stripe *) (chunk + 1);
+		/* Right now the redundancy handling is easy.
+		   With RAID5-like it will be more difficult.  */
+		stripe += stripen + i;
+
+		paddr = grub_le_to_cpu64 (stripe->offset) + stripe_offset;
+
+		grub_dprintf ("btrfs", "chunk 0x%" PRIxGRUB_UINT64_T
+			      "+0x%" PRIxGRUB_UINT64_T
+			      " (%d stripes (%d substripes) of %"
+			      PRIxGRUB_UINT64_T ") stripe %" PRIxGRUB_UINT64_T
+			      " maps to 0x%" PRIxGRUB_UINT64_T "\n",
+			      grub_le_to_cpu64 (key->offset),
+			      grub_le_to_cpu64 (chunk->size),
+			      grub_le_to_cpu16 (chunk->nstripes),
+			      grub_le_to_cpu16 (chunk->nsubstripes),
+			      grub_le_to_cpu64 (chunk->stripe_length),
+			      stripen, stripe->offset);
+		grub_dprintf ("btrfs", "reading paddr 0x%" PRIxGRUB_UINT64_T
+			      " for laddr 0x%" PRIxGRUB_UINT64_T "\n", paddr,
+			      addr);
+
+		dev = find_device (data, stripe->device_id, j);
+		if (!dev)
+		  {
+		    err = grub_errno;
+		    grub_errno = GRUB_ERR_NONE;
+		    continue;
+		  }
+
+		err = grub_disk_read (dev->disk, paddr >> GRUB_DISK_SECTOR_BITS,
+				      paddr & (GRUB_DISK_SECTOR_SIZE - 1),
+				      csize, buf);
+		if (!err)
+		  break;
+		grub_errno = GRUB_ERR_NONE;
+	      }
+	    if (i != redundancy)
+	      break;
+	  }
+	if (err)
+	  return grub_errno = err;
+      }
+      size -= csize;
+      buf = (grub_uint8_t *) buf + csize;
+      addr += csize;
+      if (challoc)
+	grub_free (chunk);
+    }
+  return GRUB_ERR_NONE;
+}
+
+static struct grub_btrfs_data *
+grub_btrfs_mount (grub_device_t dev)
+{
+  struct grub_btrfs_data *data;
+  grub_err_t err;
+
+  if (!dev->disk)
+    {
+      grub_error (GRUB_ERR_BAD_FS, "not BtrFS");
+      return NULL;
+    }
+
+  data = grub_zalloc (sizeof (*data));
+  if (!data)
+    return NULL;
+
+  err = read_sblock (dev->disk, &data->sblock);
+  if (err)
+    {
+      grub_free (data);
+      return NULL;
+    }
+
+  data->n_devices_allocated = 16;
+  data->devices_attached = grub_malloc (sizeof (data->devices_attached[0])
+					* data->n_devices_allocated);
+  if (!data->devices_attached)
+    {
+      grub_free (data);
+      return NULL;
+    }
+  data->n_devices_attached = 1;
+  data->devices_attached[0].dev = dev;
+  data->devices_attached[0].id = data->sblock.this_device.device_id;
+
+  return data;
+}
+
+static void
+grub_btrfs_unmount (struct grub_btrfs_data *data)
+{
+  unsigned i;
+  /* The device 0 is closed one layer upper.  */
+  for (i = 1; i < data->n_devices_attached; i++)
+    grub_device_close (data->devices_attached[i].dev);
+  grub_free (data->devices_attached);
+  grub_free (data->extent);
+  grub_free (data);
+}
+
+static grub_err_t
+grub_btrfs_read_inode (struct grub_btrfs_data *data,
+		       struct grub_btrfs_inode *inode, grub_uint64_t num,
+		       grub_uint64_t tree)
+{
+  struct grub_btrfs_key key_in, key_out;
+  grub_disk_addr_t elemaddr;
+  grub_size_t elemsize;
+  grub_err_t err;
+
+  key_in.object_id = num;
+  key_in.type = GRUB_BTRFS_ITEM_TYPE_INODE_ITEM;
+  key_in.offset = 0;
+
+  err = lower_bound (data, &key_in, &key_out, tree, &elemaddr, &elemsize, NULL,
+		     0);
+  if (err)
+    return err;
+  if (num != key_out.object_id
+      || key_out.type != GRUB_BTRFS_ITEM_TYPE_INODE_ITEM)
+    return grub_error (GRUB_ERR_BAD_FS, "inode not found");
+
+  return grub_btrfs_read_logical (data, elemaddr, inode, sizeof (*inode), 0);
+}
+
+static grub_ssize_t
+grub_btrfs_lzo_decompress(char *ibuf, grub_size_t isize, grub_off_t off,
+			  char *obuf, grub_size_t osize)
+{
+  grub_uint32_t total_size, cblock_size;
+  grub_size_t ret = 0;
+  char *ibuf0 = ibuf;
+
+  total_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf));
+  ibuf += sizeof (total_size);
+
+  if (isize < total_size)
+    return -1;
+
+  /* Jump forward to first block with requested data.  */
+  while (off >= GRUB_BTRFS_LZO_BLOCK_SIZE)
+    {
+      /* Don't let following uint32_t cross the page boundary.  */
+      if (((ibuf - ibuf0) & 0xffc) == 0xffc)
+	ibuf = ((ibuf - ibuf0 + 3) & ~3) + ibuf0;
+
+      cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf));
+      ibuf += sizeof (cblock_size);
+
+      if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE)
+	return -1;
+
+      off -= GRUB_BTRFS_LZO_BLOCK_SIZE;
+      ibuf += cblock_size;
+    }
+
+  while (osize > 0)
+    {
+      lzo_uint usize = GRUB_BTRFS_LZO_BLOCK_SIZE;
+
+      /* Don't let following uint32_t cross the page boundary.  */
+      if (((ibuf - ibuf0) & 0xffc) == 0xffc)
+	ibuf = ((ibuf - ibuf0 + 3) & ~3) + ibuf0;
+
+      cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf));
+      ibuf += sizeof (cblock_size);
+
+      if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE)
+	return -1;
+
+      /* Block partially filled with requested data.  */
+      if (off > 0 || osize < GRUB_BTRFS_LZO_BLOCK_SIZE)
+	{
+	  grub_size_t to_copy = GRUB_BTRFS_LZO_BLOCK_SIZE - off;
+	  grub_uint8_t *buf;
+
+	  if (to_copy > osize)
+	    to_copy = osize;
+
+	  buf = grub_malloc (GRUB_BTRFS_LZO_BLOCK_SIZE);
+	  if (!buf)
+	    return -1;
+
+	  if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, buf, &usize,
+	      NULL) != LZO_E_OK)
+	    {
+	      grub_free (buf);
+	      return -1;
+	    }
+
+	  if (to_copy > usize)
+	    to_copy = usize;
+	  grub_memcpy(obuf, buf + off, to_copy);
+
+	  osize -= to_copy;
+	  ret += to_copy;
+	  obuf += to_copy;
+	  ibuf += cblock_size;
+	  off = 0;
+
+	  grub_free (buf);
+	  continue;
+	}
+
+      /* Decompress whole block directly to output buffer.  */
+      if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, (lzo_bytep)obuf,
+	  &usize, NULL) != LZO_E_OK)
+	return -1;
+
+      osize -= usize;
+      ret += usize;
+      obuf += usize;
+      ibuf += cblock_size;
+    }
+
+  return ret;
+}
+
+static grub_ssize_t
+grub_btrfs_extent_read (struct grub_btrfs_data *data,
+			grub_uint64_t ino, grub_uint64_t tree,
+			grub_off_t pos0, char *buf, grub_size_t len)
+{
+  grub_off_t pos = pos0;
+  while (len)
+    {
+      grub_size_t csize;
+      grub_err_t err;
+      grub_off_t extoff;
+      if (!data->extent || data->extstart > pos || data->extino != ino
+	  || data->exttree != tree || data->extend <= pos)
+	{
+	  struct grub_btrfs_key key_in, key_out;
+	  grub_disk_addr_t elemaddr;
+	  grub_size_t elemsize;
+
+	  grub_free (data->extent);
+	  key_in.object_id = ino;
+	  key_in.type = GRUB_BTRFS_ITEM_TYPE_EXTENT_ITEM;
+	  key_in.offset = grub_cpu_to_le64 (pos);
+	  err = lower_bound (data, &key_in, &key_out, tree,
+			     &elemaddr, &elemsize, NULL, 0);
+	  if (err)
+	    return -1;
+	  if (key_out.object_id != ino
+	      || key_out.type != GRUB_BTRFS_ITEM_TYPE_EXTENT_ITEM)
+	    {
+	      grub_error (GRUB_ERR_BAD_FS, "extent not found");
+	      return -1;
+	    }
+	  if ((grub_ssize_t) elemsize < ((char *) &data->extent->inl
+					 - (char *) data->extent))
+	    {
+	      grub_error (GRUB_ERR_BAD_FS, "extent descriptor is too short");
+	      return -1;
+	    }
+	  data->extstart = grub_le_to_cpu64 (key_out.offset);
+	  data->extsize = elemsize;
+	  data->extent = grub_malloc (elemsize);
+	  data->extino = ino;
+	  data->exttree = tree;
+	  if (!data->extent)
+	    return grub_errno;
+
+	  err = grub_btrfs_read_logical (data, elemaddr, data->extent,
+					 elemsize, 0);
+	  if (err)
+	    return err;
+
+	  data->extend = data->extstart + grub_le_to_cpu64 (data->extent->size);
+	  if (data->extent->type == GRUB_BTRFS_EXTENT_REGULAR
+	      && (char *) &data->extent + elemsize
+	      >= (char *) &data->extent->filled + sizeof (data->extent->filled))
+	    data->extend =
+	      data->extstart + grub_le_to_cpu64 (data->extent->filled);
+
+	  grub_dprintf ("btrfs", "regular extent 0x%" PRIxGRUB_UINT64_T "+0x%"
+			PRIxGRUB_UINT64_T "\n",
+			grub_le_to_cpu64 (key_out.offset),
+			grub_le_to_cpu64 (data->extent->size));
+	  if (data->extend <= pos)
+	    {
+	      grub_error (GRUB_ERR_BAD_FS, "extent not found");
+	      return -1;
+	    }
+	}
+      csize = data->extend - pos;
+      extoff = pos - data->extstart;
+      if (csize > len)
+	csize = len;
+
+      if (data->extent->encryption)
+	{
+	  grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+		      "encryption not supported");
+	  return -1;
+	}
+
+      if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE
+	  && data->extent->compression != GRUB_BTRFS_COMPRESSION_ZLIB
+	  && data->extent->compression != GRUB_BTRFS_COMPRESSION_LZO)
+	{
+	  grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+		      "compression type 0x%x not supported",
+		      data->extent->compression);
+	  return -1;
+	}
+
+      if (data->extent->encoding)
+	{
+	  grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "encoding not supported");
+	  return -1;
+	}
+
+      switch (data->extent->type)
+	{
+	case GRUB_BTRFS_EXTENT_INLINE:
+	  if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB)
+	    {
+	      if (grub_zlib_decompress (data->extent->inl, data->extsize -
+					((grub_uint8_t *) data->extent->inl
+					 - (grub_uint8_t *) data->extent),
+					extoff, buf, csize)
+		  != (grub_ssize_t) csize)
+		{
+		  if (!grub_errno)
+		    grub_error (GRUB_ERR_BAD_COMPRESSED_DATA,
+				"premature end of compressed");
+		  return -1;
+		}
+	    }
+	  else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO)
+	    {
+	      if (grub_btrfs_lzo_decompress(data->extent->inl, data->extsize -
+					   ((grub_uint8_t *) data->extent->inl
+					    - (grub_uint8_t *) data->extent),
+					   extoff, buf, csize)
+		  != (grub_ssize_t) csize)
+		return -1;
+	    }
+	  else
+	    grub_memcpy (buf, data->extent->inl + extoff, csize);
+	  break;
+	case GRUB_BTRFS_EXTENT_REGULAR:
+	  if (!data->extent->laddr)
+	    {
+	      grub_memset (buf, 0, csize);
+	      break;
+	    }
+
+	  if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE)
+	    {
+	      char *tmp;
+	      grub_uint64_t zsize;
+	      grub_ssize_t ret;
+
+	      zsize = grub_le_to_cpu64 (data->extent->compressed_size);
+	      tmp = grub_malloc (zsize);
+	      if (!tmp)
+		return -1;
+	      err = grub_btrfs_read_logical (data,
+					     grub_le_to_cpu64 (data->extent->laddr),
+					     tmp, zsize, 0);
+	      if (err)
+		{
+		  grub_free (tmp);
+		  return -1;
+		}
+
+	      if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB)
+		ret = grub_zlib_decompress (tmp, zsize, extoff
+				    + grub_le_to_cpu64 (data->extent->offset),
+				    buf, csize);
+	      else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO)
+		ret = grub_btrfs_lzo_decompress (tmp, zsize, extoff
+				    + grub_le_to_cpu64 (data->extent->offset),
+				    buf, csize);
+	      else
+		ret = -1;
+
+	      grub_free (tmp);
+
+	      if (ret != (grub_ssize_t) csize)
+		{
+		  if (!grub_errno)
+		    grub_error (GRUB_ERR_BAD_COMPRESSED_DATA,
+				"premature end of compressed");
+		  return -1;
+		}
+
+	      break;
+	    }
+	  err = grub_btrfs_read_logical (data,
+					 grub_le_to_cpu64 (data->extent->laddr)
+					 + grub_le_to_cpu64 (data->extent->offset)
+					 + extoff, buf, csize, 0);
+	  if (err)
+	    return -1;
+	  break;
+	default:
+	  grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+		      "unsupported extent type 0x%x", data->extent->type);
+	  return -1;
+	}
+      buf += csize;
+      pos += csize;
+      len -= csize;
+    }
+  return pos - pos0;
+}
+
+static grub_err_t
+get_root (struct grub_btrfs_data *data, struct grub_btrfs_key *key,
+	  grub_uint64_t *tree, grub_uint8_t *type)
+{
+  grub_err_t err;
+  grub_disk_addr_t elemaddr;
+  grub_size_t elemsize;
+  struct grub_btrfs_key key_out, key_in;
+  struct grub_btrfs_root_item ri;
+
+  key_in.object_id = GRUB_BTRFS_ROOT_VOL_OBJECTID;
+  key_in.offset = 0;
+  key_in.type = GRUB_BTRFS_ITEM_TYPE_ROOT_ITEM;
+  err = lower_bound (data, &key_in, &key_out,
+		     data->sblock.root_tree,
+		     &elemaddr, &elemsize, NULL, 0);
+  if (err)
+    return err;
+  if (key_in.object_id != key_out.object_id
+      || key_in.type != key_out.type
+      || key_in.offset != key_out.offset)
+    return grub_error (GRUB_ERR_BAD_FS, "no root");
+  err = grub_btrfs_read_logical (data, elemaddr, &ri,
+				 sizeof (ri), 0);
+  if (err)
+    return err;
+  key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
+  key->offset = 0;
+  key->object_id = grub_cpu_to_le64_compile_time (GRUB_BTRFS_OBJECT_ID_CHUNK);
+  *tree = ri.tree;
+  *type = GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY;
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+find_path (struct grub_btrfs_data *data,
+	   const char *path, struct grub_btrfs_key *key,
+	   grub_uint64_t *tree, grub_uint8_t *type)
+{
+  const char *slash = path;
+  grub_err_t err;
+  grub_disk_addr_t elemaddr;
+  grub_size_t elemsize;
+  grub_size_t allocated = 0;
+  struct grub_btrfs_dir_item *direl = NULL;
+  struct grub_btrfs_key key_out;
+  const char *ctoken;
+  grub_size_t ctokenlen;
+  char *path_alloc = NULL;
+  char *origpath = NULL;
+  unsigned symlinks_max = 32;
+
+  err = get_root (data, key, tree, type);
+  if (err)
+    return err;
+
+  origpath = grub_strdup (path);
+  if (!origpath)
+    return grub_errno;
+
+  while (1)
+    {
+      while (path[0] == '/')
+	path++;
+      if (!path[0])
+	break;
+      slash = grub_strchr (path, '/');
+      if (!slash)
+	slash = path + grub_strlen (path);
+      ctoken = path;
+      ctokenlen = slash - path;
+
+      if (*type != GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY)
+	{
+	  grub_free (path_alloc);
+	  grub_free (origpath);
+	  return grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a directory"));
+	}
+
+      if (ctokenlen == 1 && ctoken[0] == '.')
+	{
+	  path = slash;
+	  continue;
+	}
+      if (ctokenlen == 2 && ctoken[0] == '.' && ctoken[1] == '.')
+	{
+	  key->type = GRUB_BTRFS_ITEM_TYPE_INODE_REF;
+	  key->offset = -1;
+
+	  err = lower_bound (data, key, &key_out, *tree, &elemaddr, &elemsize,
+			     NULL, 0);
+	  if (err)
+	    {
+	      grub_free (direl);
+	      grub_free (path_alloc);
+	      grub_free (origpath);
+	      return err;
+	    }
+
+	  if (key_out.type != key->type
+	      || key->object_id != key_out.object_id)
+	    {
+	      grub_free (direl);
+	      grub_free (path_alloc);
+	      err = grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), origpath);
+	      grub_free (origpath);
+	      return err;
+	    }
+
+	  *type = GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY;
+	  key->object_id = key_out.offset;
+
+	  path = slash;
+
+	  continue;
+	}
+
+      key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
+      key->offset = grub_cpu_to_le64 (~grub_getcrc32c (1, ctoken, ctokenlen));
+
+      err = lower_bound (data, key, &key_out, *tree, &elemaddr, &elemsize,
+			 NULL, 0);
+      if (err)
+	{
+	  grub_free (direl);
+	  grub_free (path_alloc);
+	  grub_free (origpath);
+	  return err;
+	}
+      if (key_cmp (key, &key_out) != 0)
+	{
+	  grub_free (direl);
+	  grub_free (path_alloc);
+	  err = grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), origpath);
+	  grub_free (origpath);
+	  return err;
+	}
+
+      struct grub_btrfs_dir_item *cdirel;
+      if (elemsize > allocated)
+	{
+	  allocated = 2 * elemsize;
+	  grub_free (direl);
+	  direl = grub_malloc (allocated + 1);
+	  if (!direl)
+	    {
+	      grub_free (path_alloc);
+	      grub_free (origpath);
+	      return grub_errno;
+	    }
+	}
+
+      err = grub_btrfs_read_logical (data, elemaddr, direl, elemsize, 0);
+      if (err)
+	{
+	  grub_free (direl);
+	  grub_free (path_alloc);
+	  grub_free (origpath);
+	  return err;
+	}
+
+      for (cdirel = direl;
+	   (grub_uint8_t *) cdirel - (grub_uint8_t *) direl
+	   < (grub_ssize_t) elemsize;
+	   cdirel = (void *) ((grub_uint8_t *) (direl + 1)
+			      + grub_le_to_cpu16 (cdirel->n)
+			      + grub_le_to_cpu16 (cdirel->m)))
+	{
+	  if (ctokenlen == grub_le_to_cpu16 (cdirel->n)
+	      && grub_memcmp (cdirel->name, ctoken, ctokenlen) == 0)
+	    break;
+	}
+      if ((grub_uint8_t *) cdirel - (grub_uint8_t *) direl
+	  >= (grub_ssize_t) elemsize)
+	{
+	  grub_free (direl);
+	  grub_free (path_alloc);
+	  err = grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), origpath);
+	  grub_free (origpath);
+	  return err;
+	}
+
+      path = slash;
+      if (cdirel->type == GRUB_BTRFS_DIR_ITEM_TYPE_SYMLINK)
+	{
+	  struct grub_btrfs_inode inode;
+	  char *tmp;
+	  if (--symlinks_max == 0)
+	    {
+	      grub_free (direl);
+	      grub_free (path_alloc);
+	      grub_free (origpath);
+	      return grub_error (GRUB_ERR_SYMLINK_LOOP,
+				 N_("too deep nesting of symlinks"));
+	    }
+
+	  err = grub_btrfs_read_inode (data, &inode,
+				       cdirel->key.object_id, *tree);
+	  if (err)
+	    {
+	      grub_free (direl);
+	      grub_free (path_alloc);
+	      grub_free (origpath);
+	      return err;
+	    }
+	  tmp = grub_malloc (grub_le_to_cpu64 (inode.size)
+			     + grub_strlen (path) + 1);
+	  if (!tmp)
+	    {
+	      grub_free (direl);
+	      grub_free (path_alloc);
+	      grub_free (origpath);
+	      return grub_errno;
+	    }
+
+	  if (grub_btrfs_extent_read (data, cdirel->key.object_id,
+				      *tree, 0, tmp,
+				      grub_le_to_cpu64 (inode.size))
+	      != (grub_ssize_t) grub_le_to_cpu64 (inode.size))
+	    {
+	      grub_free (direl);
+	      grub_free (path_alloc);
+	      grub_free (origpath);
+	      grub_free (tmp);
+	      return grub_errno;
+	    }
+	  grub_memcpy (tmp + grub_le_to_cpu64 (inode.size), path,
+		       grub_strlen (path) + 1);
+	  grub_free (path_alloc);
+	  path = path_alloc = tmp;
+	  if (path[0] == '/')
+	    {
+	      err = get_root (data, key, tree, type);
+	      if (err)
+		return err;
+	    }
+	  continue;
+	}
+      *type = cdirel->type;
+
+      switch (cdirel->key.type)
+	{
+	case GRUB_BTRFS_ITEM_TYPE_ROOT_ITEM:
+	  {
+	    struct grub_btrfs_root_item ri;
+	    err = lower_bound (data, &cdirel->key, &key_out,
+			       data->sblock.root_tree,
+			       &elemaddr, &elemsize, NULL, 0);
+	    if (err)
+	      {
+		grub_free (direl);
+		grub_free (path_alloc);
+		grub_free (origpath);
+		return err;
+	      }
+	    if (cdirel->key.object_id != key_out.object_id
+		|| cdirel->key.type != key_out.type)
+	      {
+		grub_free (direl);
+		grub_free (path_alloc);
+		err = grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), origpath);
+		grub_free (origpath);
+		return err;
+	      }
+	    err = grub_btrfs_read_logical (data, elemaddr, &ri,
+					   sizeof (ri), 0);
+	    if (err)
+	      {
+		grub_free (direl);
+		grub_free (path_alloc);
+		grub_free (origpath);
+		return err;
+	      }
+	    key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
+	    key->offset = 0;
+	    key->object_id = grub_cpu_to_le64_compile_time (GRUB_BTRFS_OBJECT_ID_CHUNK);
+	    *tree = ri.tree;
+	    break;
+	  }
+	case GRUB_BTRFS_ITEM_TYPE_INODE_ITEM:
+	  if (*slash && *type == GRUB_BTRFS_DIR_ITEM_TYPE_REGULAR)
+	    {
+	      grub_free (direl);
+	      grub_free (path_alloc);
+	      err = grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), origpath);
+	      grub_free (origpath);
+	      return err;
+	    }
+	  *key = cdirel->key;
+	  if (*type == GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY)
+	    key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
+	  break;
+	default:
+	  grub_free (path_alloc);
+	  grub_free (origpath);
+	  grub_free (direl);
+	  return grub_error (GRUB_ERR_BAD_FS, "unrecognised object type 0x%x",
+			     cdirel->key.type);
+	}
+    }
+
+  grub_free (direl);
+  grub_free (origpath);
+  grub_free (path_alloc);
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_btrfs_dir (grub_device_t device, const char *path,
+		grub_fs_dir_hook_t hook, void *hook_data)
+{
+  struct grub_btrfs_data *data = grub_btrfs_mount (device);
+  struct grub_btrfs_key key_in, key_out;
+  grub_err_t err;
+  grub_disk_addr_t elemaddr;
+  grub_size_t elemsize;
+  grub_size_t allocated = 0;
+  struct grub_btrfs_dir_item *direl = NULL;
+  struct grub_btrfs_leaf_descriptor desc;
+  int r = 0;
+  grub_uint64_t tree;
+  grub_uint8_t type;
+
+  if (!data)
+    return grub_errno;
+
+  err = find_path (data, path, &key_in, &tree, &type);
+  if (err)
+    {
+      grub_btrfs_unmount (data);
+      return err;
+    }
+  if (type != GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY)
+    {
+      grub_btrfs_unmount (data);
+      return grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a directory"));
+    }
+
+  err = lower_bound (data, &key_in, &key_out, tree,
+		     &elemaddr, &elemsize, &desc, 0);
+  if (err)
+    {
+      grub_btrfs_unmount (data);
+      return err;
+    }
+  if (key_out.type != GRUB_BTRFS_ITEM_TYPE_DIR_ITEM
+      || key_out.object_id != key_in.object_id)
+    {
+      r = next (data, &desc, &elemaddr, &elemsize, &key_out);
+      if (r <= 0)
+	goto out;
+    }
+  do
+    {
+      struct grub_btrfs_dir_item *cdirel;
+      if (key_out.type != GRUB_BTRFS_ITEM_TYPE_DIR_ITEM
+	  || key_out.object_id != key_in.object_id)
+	{
+	  r = 0;
+	  break;
+	}
+      if (elemsize > allocated)
+	{
+	  allocated = 2 * elemsize;
+	  grub_free (direl);
+	  direl = grub_malloc (allocated + 1);
+	  if (!direl)
+	    {
+	      r = -grub_errno;
+	      break;
+	    }
+	}
+
+      err = grub_btrfs_read_logical (data, elemaddr, direl, elemsize, 0);
+      if (err)
+	{
+	  r = -err;
+	  break;
+	}
+
+      for (cdirel = direl;
+	   (grub_uint8_t *) cdirel - (grub_uint8_t *) direl
+	   < (grub_ssize_t) elemsize;
+	   cdirel = (void *) ((grub_uint8_t *) (direl + 1)
+			      + grub_le_to_cpu16 (cdirel->n)
+			      + grub_le_to_cpu16 (cdirel->m)))
+	{
+	  char c;
+	  struct grub_btrfs_inode inode;
+	  struct grub_dirhook_info info;
+	  err = grub_btrfs_read_inode (data, &inode, cdirel->key.object_id,
+				       tree);
+	  grub_memset (&info, 0, sizeof (info));
+	  if (err)
+	    grub_errno = GRUB_ERR_NONE;
+	  else
+	    {
+	      info.mtime = grub_le_to_cpu64 (inode.mtime.sec);
+	      info.mtimeset = 1;
+	    }
+	  c = cdirel->name[grub_le_to_cpu16 (cdirel->n)];
+	  cdirel->name[grub_le_to_cpu16 (cdirel->n)] = 0;
+	  info.dir = (cdirel->type == GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY);
+	  if (hook (cdirel->name, &info, hook_data))
+	    goto out;
+	  cdirel->name[grub_le_to_cpu16 (cdirel->n)] = c;
+	}
+      r = next (data, &desc, &elemaddr, &elemsize, &key_out);
+    }
+  while (r > 0);
+
+out:
+  grub_free (direl);
+
+  free_iterator (&desc);
+  grub_btrfs_unmount (data);
+
+  return -r;
+}
+
+static grub_err_t
+grub_btrfs_open (struct grub_file *file, const char *name)
+{
+  struct grub_btrfs_data *data = grub_btrfs_mount (file->device);
+  grub_err_t err;
+  struct grub_btrfs_inode inode;
+  grub_uint8_t type;
+  struct grub_btrfs_key key_in;
+
+  if (!data)
+    return grub_errno;
+
+  err = find_path (data, name, &key_in, &data->tree, &type);
+  if (err)
+    {
+      grub_btrfs_unmount (data);
+      return err;
+    }
+  if (type != GRUB_BTRFS_DIR_ITEM_TYPE_REGULAR)
+    {
+      grub_btrfs_unmount (data);
+      return grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a regular file"));
+    }
+
+  data->inode = key_in.object_id;
+  err = grub_btrfs_read_inode (data, &inode, data->inode, data->tree);
+  if (err)
+    {
+      grub_btrfs_unmount (data);
+      return err;
+    }
+
+  file->data = data;
+  file->size = grub_le_to_cpu64 (inode.size);
+
+  return err;
+}
+
+static grub_err_t
+grub_btrfs_close (grub_file_t file)
+{
+  grub_btrfs_unmount (file->data);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_ssize_t
+grub_btrfs_read (grub_file_t file, char *buf, grub_size_t len)
+{
+  struct grub_btrfs_data *data = file->data;
+
+  return grub_btrfs_extent_read (data, data->inode,
+				 data->tree, file->offset, buf, len);
+}
+
+static grub_err_t
+grub_btrfs_uuid (grub_device_t device, char **uuid)
+{
+  struct grub_btrfs_data *data;
+
+  *uuid = NULL;
+
+  data = grub_btrfs_mount (device);
+  if (!data)
+    return grub_errno;
+
+  *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+			  grub_be_to_cpu16 (data->sblock.uuid[0]),
+			  grub_be_to_cpu16 (data->sblock.uuid[1]),
+			  grub_be_to_cpu16 (data->sblock.uuid[2]),
+			  grub_be_to_cpu16 (data->sblock.uuid[3]),
+			  grub_be_to_cpu16 (data->sblock.uuid[4]),
+			  grub_be_to_cpu16 (data->sblock.uuid[5]),
+			  grub_be_to_cpu16 (data->sblock.uuid[6]),
+			  grub_be_to_cpu16 (data->sblock.uuid[7]));
+
+  grub_btrfs_unmount (data);
+
+  return grub_errno;
+}
+
+static grub_err_t
+grub_btrfs_label (grub_device_t device, char **label)
+{
+  struct grub_btrfs_data *data;
+
+  *label = NULL;
+
+  data = grub_btrfs_mount (device);
+  if (!data)
+    return grub_errno;
+
+  *label = grub_strndup (data->sblock.label, sizeof (data->sblock.label));
+
+  grub_btrfs_unmount (data);
+
+  return grub_errno;
+}
+
+#ifdef GRUB_UTIL
+static grub_err_t
+grub_btrfs_embed (grub_device_t device __attribute__ ((unused)),
+		  unsigned int *nsectors,
+		  unsigned int max_nsectors,
+		  grub_embed_type_t embed_type,
+		  grub_disk_addr_t **sectors)
+{
+  unsigned i;
+
+  if (embed_type != GRUB_EMBED_PCBIOS)
+    return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+		       "BtrFS currently supports only PC-BIOS embedding");
+
+  if (64 * 2 - 1 < *nsectors)
+    return grub_error (GRUB_ERR_OUT_OF_RANGE,
+		       N_("your core.img is unusually large.  "
+			  "It won't fit in the embedding area"));
+
+  *nsectors = 64 * 2 - 1;
+  if (*nsectors > max_nsectors)
+    *nsectors = max_nsectors;
+  *sectors = grub_malloc (*nsectors * sizeof (**sectors));
+  if (!*sectors)
+    return grub_errno;
+  for (i = 0; i < *nsectors; i++)
+    (*sectors)[i] = i + 1;
+
+  return GRUB_ERR_NONE;
+}
+#endif
+
+static struct grub_fs grub_btrfs_fs = {
+  .name = "btrfs",
+  .dir = grub_btrfs_dir,
+  .open = grub_btrfs_open,
+  .read = grub_btrfs_read,
+  .close = grub_btrfs_close,
+  .uuid = grub_btrfs_uuid,
+  .label = grub_btrfs_label,
+#ifdef GRUB_UTIL
+  .embed = grub_btrfs_embed,
+  .reserved_first_sector = 1,
+  .blocklist_install = 0,
+#endif
+};
+
+GRUB_MOD_INIT (btrfs)
+{
+  grub_fs_register (&grub_btrfs_fs);
+}
+
+GRUB_MOD_FINI (btrfs)
+{
+  grub_fs_unregister (&grub_btrfs_fs);
+}

=== added directory '.pc/core_in_fs.patch'
=== added directory '.pc/core_in_fs.patch/util'
=== added file '.pc/core_in_fs.patch/util/setup.c'
--- .pc/core_in_fs.patch/util/setup.c	1970-01-01 00:00:00 +0000
+++ .pc/core_in_fs.patch/util/setup.c	2014-08-24 23:28:48 +0000
@@ -0,0 +1,778 @@
+/* grub-setup.c - make GRUB usable */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <grub/types.h>
+#include <grub/emu/misc.h>
+#include <grub/util/misc.h>
+#include <grub/device.h>
+#include <grub/disk.h>
+#include <grub/file.h>
+#include <grub/fs.h>
+#include <grub/partition.h>
+#include <grub/env.h>
+#include <grub/emu/hostdisk.h>
+#include <grub/term.h>
+#include <grub/i18n.h>
+
+#ifdef GRUB_SETUP_SPARC64
+#include <grub/util/ofpath.h>
+#include <grub/sparc64/ieee1275/boot.h>
+#include <grub/sparc64/ieee1275/kernel.h>
+#else
+#include <grub/i386/pc/boot.h>
+#include <grub/i386/pc/kernel.h>
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <assert.h>
+#include <grub/emu/getroot.h>
+#include "progname.h"
+#include <grub/reed_solomon.h>
+#include <grub/msdos_partition.h>
+#include <grub/crypto.h>
+#include <grub/util/install.h>
+#include <grub/emu/hostfile.h>
+
+#include <errno.h>
+
+/* On SPARC this program fills in various fields inside of the 'boot' and 'core'
+ * image files.
+ *
+ * The 'boot' image needs to know the OBP path name of the root
+ * device.  It also needs to know the initial block number of
+ * 'core' (which is 'diskboot' concatenated with 'kernel' and
+ * all the modules, this is created by grub-mkimage).  This resulting
+ * 'boot' image is 512 bytes in size and is placed in the second block
+ * of a partition.
+ *
+ * The initial 'diskboot' block acts as a loader for the actual GRUB
+ * kernel.  It contains the loading code and then a block list.
+ *
+ * The block list of 'core' starts at the end of the 'diskboot' image
+ * and works it's way backwards towards the end of the code of 'diskboot'.
+ *
+ * We patch up the images with the necessary values and write out the
+ * result.
+ */
+
+#ifdef GRUB_SETUP_SPARC64
+#define grub_target_to_host16(x)	grub_be_to_cpu16(x)
+#define grub_target_to_host32(x)	grub_be_to_cpu32(x)
+#define grub_target_to_host64(x)	grub_be_to_cpu64(x)
+#define grub_host_to_target16(x)	grub_cpu_to_be16(x)
+#define grub_host_to_target32(x)	grub_cpu_to_be32(x)
+#define grub_host_to_target64(x)	grub_cpu_to_be64(x)
+#elif defined (GRUB_SETUP_BIOS)
+#define grub_target_to_host16(x)	grub_le_to_cpu16(x)
+#define grub_target_to_host32(x)	grub_le_to_cpu32(x)
+#define grub_target_to_host64(x)	grub_le_to_cpu64(x)
+#define grub_host_to_target16(x)	grub_cpu_to_le16(x)
+#define grub_host_to_target32(x)	grub_cpu_to_le32(x)
+#define grub_host_to_target64(x)	grub_cpu_to_le64(x)
+#else
+#error Complete this
+#endif
+
+static void
+write_rootdev (grub_device_t root_dev,
+	       char *boot_img, grub_uint64_t first_sector)
+{
+#ifdef GRUB_SETUP_BIOS
+  {
+    grub_uint8_t *boot_drive;
+    void *kernel_sector;
+    boot_drive = (grub_uint8_t *) (boot_img + GRUB_BOOT_MACHINE_BOOT_DRIVE);
+    kernel_sector = (boot_img + GRUB_BOOT_MACHINE_KERNEL_SECTOR);
+
+    /* FIXME: can this be skipped?  */
+    *boot_drive = 0xFF;
+
+    grub_set_unaligned64 (kernel_sector, grub_cpu_to_le64 (first_sector));
+  }
+#endif
+#ifdef GRUB_SETUP_SPARC64
+  {
+    void *kernel_byte;
+    kernel_byte = (boot_img + GRUB_BOOT_AOUT_HEADER_SIZE
+		   + GRUB_BOOT_MACHINE_KERNEL_BYTE);
+    grub_set_unaligned64 (kernel_byte,
+			  grub_cpu_to_be64 (first_sector << GRUB_DISK_SECTOR_BITS));
+  }
+#endif
+}
+
+#ifdef GRUB_SETUP_SPARC64
+#define BOOT_SECTOR 1
+#else
+#define BOOT_SECTOR 0
+#endif
+
+/* Helper for setup.  */
+
+struct blocklists
+{
+  struct grub_boot_blocklist *first_block, *block;
+#ifdef GRUB_SETUP_BIOS
+  grub_uint16_t current_segment;
+#endif
+  grub_uint16_t last_length;
+  grub_disk_addr_t first_sector;
+};
+
+/* Helper for setup.  */
+static void
+save_blocklists (grub_disk_addr_t sector, unsigned offset, unsigned length,
+		 void *data)
+{
+  struct blocklists *bl = data;
+  struct grub_boot_blocklist *prev = bl->block + 1;
+  grub_uint64_t seclen;
+
+  grub_util_info ("saving <%"  GRUB_HOST_PRIuLONG_LONG ",%u,%u>",
+		  (unsigned long long) sector, offset, length);
+
+  if (bl->first_sector == (grub_disk_addr_t) -1)
+    {
+      if (offset != 0 || length < GRUB_DISK_SECTOR_SIZE)
+	grub_util_error ("%s", _("the first sector of the core file is not sector-aligned"));
+
+      bl->first_sector = sector;
+      sector++;
+      length -= GRUB_DISK_SECTOR_SIZE;
+      if (!length)
+	return;
+    }
+
+  if (offset != 0 || bl->last_length != 0)
+    grub_util_error ("%s", _("non-sector-aligned data is found in the core file"));
+
+  seclen = (length + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS;
+
+  if (bl->block != bl->first_block
+      && (grub_target_to_host64 (prev->start)
+	  + grub_target_to_host16 (prev->len)) == sector)
+    {
+      grub_uint16_t t = grub_target_to_host16 (prev->len);
+      t += seclen;
+      prev->len = grub_host_to_target16 (t);
+    }
+  else
+    {
+      bl->block->start = grub_host_to_target64 (sector);
+      bl->block->len = grub_host_to_target16 (seclen);
+#ifdef GRUB_SETUP_BIOS
+      bl->block->segment = grub_host_to_target16 (bl->current_segment);
+#endif
+
+      bl->block--;
+      if (bl->block->len)
+	grub_util_error ("%s", _("the sectors of the core file are too fragmented"));
+    }
+
+  bl->last_length = length & (GRUB_DISK_SECTOR_SIZE - 1);
+#ifdef GRUB_SETUP_BIOS
+  bl->current_segment += seclen << (GRUB_DISK_SECTOR_BITS - 4);
+#endif
+}
+
+#ifdef GRUB_SETUP_BIOS
+/* Context for setup/identify_partmap.  */
+struct identify_partmap_ctx
+{
+  grub_partition_map_t dest_partmap;
+  grub_partition_t container;
+  int multiple_partmaps;
+};
+
+/* Helper for setup.
+   Unlike root_dev, with dest_dev we're interested in the partition map even
+   if dest_dev itself is a whole disk.  */
+static int
+identify_partmap (grub_disk_t disk __attribute__ ((unused)),
+		  const grub_partition_t p, void *data)
+{
+  struct identify_partmap_ctx *ctx = data;
+
+  if (p->parent != ctx->container)
+    return 0;
+  /* NetBSD and OpenBSD subpartitions have metadata inside a partition,
+     so they are safe to ignore.
+   */
+  if (grub_strcmp (p->partmap->name, "netbsd") == 0
+      || grub_strcmp (p->partmap->name, "openbsd") == 0)
+    return 0;
+  if (ctx->dest_partmap == NULL)
+    {
+      ctx->dest_partmap = p->partmap;
+      return 0;
+    }
+  if (ctx->dest_partmap == p->partmap)
+    return 0;
+  ctx->multiple_partmaps = 1;
+  return 1;
+}
+#endif
+
+#ifdef GRUB_SETUP_BIOS
+#define SETUP grub_util_bios_setup
+#elif GRUB_SETUP_SPARC64
+#define SETUP grub_util_sparc_setup
+#else
+#error "Shouldn't happen"
+#endif
+
+void
+SETUP (const char *dir,
+       const char *boot_file, const char *core_file,
+       const char *dest, int force,
+       int fs_probe, int allow_floppy,
+       int add_rs_codes __attribute__ ((unused))) /* unused on sparc64 */
+{
+  char *core_path;
+  char *boot_img, *core_img, *boot_path;
+  char *root = 0;
+  size_t boot_size, core_size;
+#ifdef GRUB_SETUP_BIOS
+  grub_uint16_t core_sectors;
+#endif
+  grub_device_t root_dev = 0, dest_dev, core_dev;
+  grub_util_fd_t fp;
+  struct blocklists bl;
+
+  bl.first_sector = (grub_disk_addr_t) -1;
+
+#ifdef GRUB_SETUP_BIOS
+  bl.current_segment =
+    GRUB_BOOT_I386_PC_KERNEL_SEG + (GRUB_DISK_SECTOR_SIZE >> 4);
+#endif
+  bl.last_length = 0;
+
+  /* Read the boot image by the OS service.  */
+  boot_path = grub_util_get_path (dir, boot_file);
+  boot_size = grub_util_get_image_size (boot_path);
+  if (boot_size != GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is not %u"),
+		     boot_path, GRUB_DISK_SECTOR_SIZE);
+  boot_img = grub_util_read_image (boot_path);
+  free (boot_path);
+
+  core_path = grub_util_get_path (dir, core_file);
+  core_size = grub_util_get_image_size (core_path);
+#ifdef GRUB_SETUP_BIOS
+  core_sectors = ((core_size + GRUB_DISK_SECTOR_SIZE - 1)
+		  >> GRUB_DISK_SECTOR_BITS);
+#endif
+  if (core_size < GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is too small"), core_path);
+#ifdef GRUB_SETUP_BIOS
+  if (core_size > 0xFFFF * GRUB_DISK_SECTOR_SIZE)
+    grub_util_error (_("the size of `%s' is too large"), core_path);
+#endif
+
+  core_img = grub_util_read_image (core_path);
+
+  /* Have FIRST_BLOCK to point to the first blocklist.  */
+  bl.first_block = (struct grub_boot_blocklist *) (core_img
+						   + GRUB_DISK_SECTOR_SIZE
+						   - sizeof (*bl.block));
+  grub_util_info ("root is `%s', dest is `%s'", root, dest);
+
+  grub_util_info ("Opening dest");
+  dest_dev = grub_device_open (dest);
+  if (! dest_dev)
+    grub_util_error ("%s", grub_errmsg);
+
+  core_dev = dest_dev;
+
+  {
+    char **root_devices = grub_guess_root_devices (dir);
+    char **cur;
+    int found = 0;
+
+    for (cur = root_devices; *cur; cur++)
+      {
+	char *drive;
+	grub_device_t try_dev;
+
+	drive = grub_util_get_grub_dev (*cur);
+	if (!drive)
+	  continue;
+	try_dev = grub_device_open (drive);
+	if (! try_dev)
+	  continue;
+	if (!found && try_dev->disk->id == dest_dev->disk->id
+	    && try_dev->disk->dev->id == dest_dev->disk->dev->id)
+	  {
+	    if (root_dev)
+	      grub_device_close (root_dev);
+	    free (root);
+	    root_dev = try_dev;
+	    root = drive;
+	    found = 1;
+	    continue;
+	  }
+	if (!root_dev)
+	  {
+	    root_dev = try_dev;
+	    root = drive;
+	    continue;
+	  }
+	grub_device_close (try_dev);	
+	free (drive);
+      }
+    if (!root_dev)
+      {
+	grub_util_error ("guessing the root device failed, because of `%s'",
+			 grub_errmsg);
+      }
+    grub_util_info ("guessed root_dev `%s' from "
+		    "dir `%s'", root_dev->disk->name, dir);
+  }
+
+  grub_util_info ("setting the root device to `%s'", root);
+  if (grub_env_set ("root", root) != GRUB_ERR_NONE)
+    grub_util_error ("%s", grub_errmsg);
+
+#ifdef GRUB_SETUP_BIOS
+  {
+    char *tmp_img;
+    grub_uint8_t *boot_drive_check;
+
+    /* Read the original sector from the disk.  */
+    tmp_img = xmalloc (GRUB_DISK_SECTOR_SIZE);
+    if (grub_disk_read (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, tmp_img))
+      grub_util_error ("%s", grub_errmsg);
+    
+    boot_drive_check = (grub_uint8_t *) (boot_img
+					  + GRUB_BOOT_MACHINE_DRIVE_CHECK);
+    /* Copy the possible DOS BPB.  */
+    memcpy (boot_img + GRUB_BOOT_MACHINE_BPB_START,
+	    tmp_img + GRUB_BOOT_MACHINE_BPB_START,
+	    GRUB_BOOT_MACHINE_BPB_END - GRUB_BOOT_MACHINE_BPB_START);
+
+    /* If DEST_DRIVE is a hard disk, enable the workaround, which is
+       for buggy BIOSes which don't pass boot drive correctly. Instead,
+       they pass 0x00 or 0x01 even when booted from 0x80.  */
+    if (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk))
+      {
+	/* Replace the jmp (2 bytes) with double nop's.  */
+	boot_drive_check[0] = 0x90;
+	boot_drive_check[1] = 0x90;
+      }
+
+    struct identify_partmap_ctx ctx = {
+      .dest_partmap = NULL,
+      .container = dest_dev->disk->partition,
+      .multiple_partmaps = 0
+    };
+    int is_ldm;
+    grub_err_t err;
+    grub_disk_addr_t *sectors;
+    int i;
+    grub_fs_t fs;
+    unsigned int nsec, maxsec;
+
+    grub_partition_iterate (dest_dev->disk, identify_partmap, &ctx);
+
+    /* Copy the partition table.  */
+    if (ctx.dest_partmap ||
+        (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk)))
+      memcpy (boot_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
+	      tmp_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC,
+	      GRUB_BOOT_MACHINE_PART_END - GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC);
+
+    free (tmp_img);
+
+    if (ctx.container
+	&& grub_strcmp (ctx.container->partmap->name, "msdos") == 0
+	&& ctx.dest_partmap
+	&& (ctx.container->msdostype == GRUB_PC_PARTITION_TYPE_NETBSD
+	    || ctx.container->msdostype == GRUB_PC_PARTITION_TYPE_OPENBSD))
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels or both partition label and filesystem.  This is not supported yet."));
+	goto unable_to_embed;
+      }
+
+    fs = grub_fs_probe (dest_dev);
+    if (!fs)
+      grub_errno = GRUB_ERR_NONE;
+
+    is_ldm = grub_util_is_ldm (dest_dev->disk);
+
+    if (fs_probe)
+      {
+	if (!fs && !ctx.dest_partmap)
+	  grub_util_error (_("unable to identify a filesystem in %s; safety check can't be performed"),
+			   dest_dev->disk->name);
+	if (fs && !fs->reserved_first_sector)
+	  /* TRANSLATORS: Filesystem may reserve the space just GRUB isn't sure about it.  */
+	  grub_util_error (_("%s appears to contain a %s filesystem which isn't known to "
+			     "reserve space for DOS-style boot.  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"), dest_dev->disk->name, fs->name);
+
+	if (ctx.dest_partmap && strcmp (ctx.dest_partmap->name, "msdos") != 0
+	    && strcmp (ctx.dest_partmap->name, "gpt") != 0
+	    && strcmp (ctx.dest_partmap->name, "bsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "netbsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "openbsd") != 0
+	    && strcmp (ctx.dest_partmap->name, "sunpc") != 0)
+	  /* TRANSLATORS: Partition map may reserve the space just GRUB isn't sure about it.  */
+	  grub_util_error (_("%s appears to contain a %s partition map which isn't known to "
+			     "reserve space for DOS-style boot.  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"), dest_dev->disk->name, ctx.dest_partmap->name);
+	if (is_ldm && ctx.dest_partmap && strcmp (ctx.dest_partmap->name, "msdos") != 0
+	    && strcmp (ctx.dest_partmap->name, "gpt") != 0)
+	  grub_util_error (_("%s appears to contain a %s partition map and "
+			     "LDM which isn't known to be a safe combination."
+			     "  Installing GRUB there could "
+			     "result in FILESYSTEM DESTRUCTION if valuable data"
+			     " is overwritten "
+			     "by grub-setup (--skip-fs-probe disables this "
+			     "check, use at your own risk)"),
+			   dest_dev->disk->name, ctx.dest_partmap->name);
+
+      }
+
+    if (! ctx.dest_partmap && ! fs && !is_ldm)
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a partitionless disk or to a partition.  This is a BAD idea."));
+	goto unable_to_embed;
+      }
+    if (ctx.multiple_partmaps || (ctx.dest_partmap && fs) || (is_ldm && fs))
+      {
+	grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels.  This is not supported yet."));
+	goto unable_to_embed;
+      }
+
+    if (ctx.dest_partmap && !ctx.dest_partmap->embed)
+      {
+	grub_util_warn (_("Partition style `%s' doesn't support embedding"),
+			ctx.dest_partmap->name);
+	goto unable_to_embed;
+      }
+
+    if (fs && !fs->embed)
+      {
+	grub_util_warn (_("File system `%s' doesn't support embedding"),
+			fs->name);
+	goto unable_to_embed;
+      }
+
+    nsec = core_sectors;
+
+    if (add_rs_codes)
+      maxsec = 2 * core_sectors;
+    else
+      maxsec = core_sectors;
+
+    if (maxsec > ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR)
+		>> GRUB_DISK_SECTOR_BITS))
+      maxsec = ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR)
+		>> GRUB_DISK_SECTOR_BITS);
+
+    if (is_ldm)
+      err = grub_util_ldm_embed (dest_dev->disk, &nsec, maxsec,
+				 GRUB_EMBED_PCBIOS, &sectors);
+    else if (ctx.dest_partmap)
+      err = ctx.dest_partmap->embed (dest_dev->disk, &nsec, maxsec,
+				     GRUB_EMBED_PCBIOS, &sectors);
+    else
+      err = fs->embed (dest_dev, &nsec, maxsec,
+		       GRUB_EMBED_PCBIOS, &sectors);
+    if (!err && nsec < core_sectors)
+      {
+	err = grub_error (GRUB_ERR_OUT_OF_RANGE,
+			  N_("Your embedding area is unusually small.  "
+			     "core.img won't fit in it."));
+      }
+    
+    if (err)
+      {
+	grub_util_warn ("%s", grub_errmsg);
+	grub_errno = GRUB_ERR_NONE;
+	goto unable_to_embed;
+      }
+
+    assert (nsec <= maxsec);
+
+    /* Clean out the blocklists.  */
+    bl.block = bl.first_block;
+    while (bl.block->len)
+      {
+	grub_memset (bl.block, 0, sizeof (bl.block));
+      
+	bl.block--;
+
+	if ((char *) bl.block <= core_img)
+	  grub_util_error ("%s", _("no terminator in the core image"));
+      }
+
+    bl.block = bl.first_block;
+    for (i = 0; i < nsec; i++)
+      save_blocklists (sectors[i] + grub_partition_get_start (ctx.container),
+		       0, GRUB_DISK_SECTOR_SIZE, &bl);
+
+    /* Make sure that the last blocklist is a terminator.  */
+    if (bl.block == bl.first_block)
+      bl.block--;
+    bl.block->start = 0;
+    bl.block->len = 0;
+    bl.block->segment = 0;
+
+    write_rootdev (root_dev, boot_img, bl.first_sector);
+
+    /* Round up to the nearest sector boundary, and zero the extra memory */
+    core_img = xrealloc (core_img, nsec * GRUB_DISK_SECTOR_SIZE);
+    assert (core_img && (nsec * GRUB_DISK_SECTOR_SIZE >= core_size));
+    memset (core_img + core_size, 0, nsec * GRUB_DISK_SECTOR_SIZE - core_size);
+
+    bl.first_block = (struct grub_boot_blocklist *) (core_img
+						     + GRUB_DISK_SECTOR_SIZE
+						     - sizeof (*bl.block));
+
+    grub_size_t no_rs_length;
+    no_rs_length = grub_target_to_host16 
+      (grub_get_unaligned16 (core_img
+			     + GRUB_DISK_SECTOR_SIZE
+			     + GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_LENGTH));
+
+    if (no_rs_length == 0xffff)
+      grub_util_error ("%s", _("core.img version mismatch"));
+
+    if (add_rs_codes)
+      {
+	grub_set_unaligned32 ((core_img + GRUB_DISK_SECTOR_SIZE
+			       + GRUB_KERNEL_I386_PC_REED_SOLOMON_REDUNDANCY),
+			      grub_host_to_target32 (nsec * GRUB_DISK_SECTOR_SIZE - core_size));
+
+	void *tmp = xmalloc (core_size);
+	grub_memcpy (tmp, core_img, core_size);
+	grub_reed_solomon_add_redundancy (core_img + no_rs_length + GRUB_DISK_SECTOR_SIZE,
+					  core_size - no_rs_length - GRUB_DISK_SECTOR_SIZE,
+					  nsec * GRUB_DISK_SECTOR_SIZE
+					  - core_size);
+	assert (grub_memcmp (tmp, core_img, core_size) == 0);
+	free (tmp);
+      }
+
+    /* Write the core image onto the disk.  */
+    for (i = 0; i < nsec; i++)
+      grub_disk_write (dest_dev->disk, sectors[i], 0,
+		       GRUB_DISK_SECTOR_SIZE,
+		       core_img + i * GRUB_DISK_SECTOR_SIZE);
+
+    grub_free (sectors);
+
+    goto finish;
+  }
+
+unable_to_embed:
+#endif
+
+  if (dest_dev->disk->dev->id != root_dev->disk->dev->id)
+    grub_util_error ("%s", _("embedding is not possible, but this is required for "
+			     "RAID and LVM install"));
+
+  {
+    grub_fs_t fs;
+    fs = grub_fs_probe (root_dev);
+    if (!fs)
+      grub_util_error (_("can't determine filesystem on %s"), root);
+
+    if (!fs->blocklist_install)
+      grub_util_error (_("filesystem `%s' doesn't support blocklists"),
+		       fs->name);
+  }
+
+#ifdef GRUB_SETUP_BIOS
+  if (dest_dev->disk->id != root_dev->disk->id
+      || dest_dev->disk->dev->id != root_dev->disk->dev->id)
+    /* TRANSLATORS: cross-disk refers to /boot being on one disk
+       but MBR on another.  */
+    grub_util_error ("%s", _("embedding is not possible, but this is required for "
+			     "cross-disk install"));
+#else
+  core_dev = root_dev;
+#endif
+
+  grub_util_warn ("%s", _("Embedding is not possible.  GRUB can only be installed in this "
+			  "setup by using blocklists.  However, blocklists are UNRELIABLE and "
+			  "their use is discouraged."));
+  if (! force)
+    /* TRANSLATORS: Here GRUB refuses to continue with blocklist install.  */
+    grub_util_error ("%s", _("will not proceed with blocklists"));
+
+  /* The core image must be put on a filesystem unfortunately.  */
+  grub_util_info ("will leave the core image on the filesystem");
+
+  grub_util_biosdisk_flush (root_dev->disk);
+
+  /* Clean out the blocklists.  */
+  bl.block = bl.first_block;
+  while (bl.block->len)
+    {
+      bl.block->start = 0;
+      bl.block->len = 0;
+#ifdef GRUB_SETUP_BIOS
+      bl.block->segment = 0;
+#endif
+
+      bl.block--;
+
+      if ((char *) bl.block <= core_img)
+	grub_util_error ("%s", _("no terminator in the core image"));
+    }
+
+  bl.block = bl.first_block;
+
+  grub_install_get_blocklist (root_dev, core_path, core_img, core_size,
+			      save_blocklists, &bl);
+
+  if (bl.first_sector == (grub_disk_addr_t)-1)
+    grub_util_error ("%s", _("can't retrieve blocklists"));
+
+#ifdef GRUB_SETUP_SPARC64
+  {
+    char *boot_devpath;
+    boot_devpath = (char *) (boot_img
+			     + GRUB_BOOT_AOUT_HEADER_SIZE
+			     + GRUB_BOOT_MACHINE_BOOT_DEVPATH);
+    if (dest_dev->disk->id != root_dev->disk->id
+	|| dest_dev->disk->dev->id != root_dev->disk->dev->id)
+      {
+	const char *dest_ofpath;
+	dest_ofpath
+	  = grub_util_devname_to_ofpath (grub_util_biosdisk_get_osdev (root_dev->disk));
+	grub_util_info ("dest_ofpath is `%s'", dest_ofpath);
+	strncpy (boot_devpath, dest_ofpath,
+		 GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		 - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1);
+	boot_devpath[GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		   - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1] = 0;
+      }
+    else
+      {
+	grub_util_info ("non cross-disk install");
+	memset (boot_devpath, 0, GRUB_BOOT_MACHINE_BOOT_DEVPATH_END
+		- GRUB_BOOT_MACHINE_BOOT_DEVPATH);
+      }
+    grub_util_info ("boot device path %s", boot_devpath);
+  }
+#endif
+
+  write_rootdev (root_dev, boot_img, bl.first_sector);
+
+  /* Write the first two sectors of the core image onto the disk.  */
+  grub_util_info ("opening the core image `%s'", core_path);
+  fp = grub_util_fd_open (core_path, GRUB_UTIL_FD_O_WRONLY);
+  if (! GRUB_UTIL_FD_IS_VALID (fp))
+    grub_util_error (_("cannot open `%s': %s"), core_path,
+		     grub_util_fd_strerror ());
+
+  if (grub_util_fd_write (fp, core_img, GRUB_DISK_SECTOR_SIZE * 2)
+      != GRUB_DISK_SECTOR_SIZE * 2)
+    grub_util_error (_("cannot write to `%s': %s"),
+		     core_path, strerror (errno));
+  grub_util_fd_sync (fp);
+  grub_util_fd_close (fp);
+  grub_util_biosdisk_flush (root_dev->disk);
+
+  grub_disk_cache_invalidate_all ();
+
+  {
+    char *buf, *ptr = core_img;
+    size_t len = core_size;
+    grub_uint64_t blk;
+    grub_partition_t container = core_dev->disk->partition;
+    grub_err_t err;
+
+    core_dev->disk->partition = 0;
+
+    buf = xmalloc (core_size);
+    blk = bl.first_sector;
+    err = grub_disk_read (core_dev->disk, blk, 0, GRUB_DISK_SECTOR_SIZE, buf);
+    if (err)
+      grub_util_error (_("cannot read `%s': %s"), core_dev->disk->name,
+		       grub_errmsg);
+    if (grub_memcmp (buf, ptr, GRUB_DISK_SECTOR_SIZE) != 0)
+      grub_util_error ("%s", _("blocklists are invalid"));
+
+    ptr += GRUB_DISK_SECTOR_SIZE;
+    len -= GRUB_DISK_SECTOR_SIZE;
+
+    bl.block = bl.first_block;
+    while (bl.block->len)
+      {
+	size_t cur = grub_target_to_host16 (bl.block->len) << GRUB_DISK_SECTOR_BITS;
+	blk = grub_target_to_host64 (bl.block->start);
+
+	if (cur > len)
+	  cur = len;
+
+	err = grub_disk_read (core_dev->disk, blk, 0, cur, buf);
+	if (err)
+	  grub_util_error (_("cannot read `%s': %s"), core_dev->disk->name,
+			   grub_errmsg);
+
+	if (grub_memcmp (buf, ptr, cur) != 0)
+	  grub_util_error ("%s", _("blocklists are invalid"));
+
+	ptr += cur;
+	len -= cur;
+	bl.block--;
+	
+	if ((char *) bl.block <= core_img)
+	  grub_util_error ("%s", _("no terminator in the core image"));
+      }
+    if (len)
+      grub_util_error ("%s", _("blocklists are incomplete"));
+    core_dev->disk->partition = container;
+    free (buf);
+  }
+
+#ifdef GRUB_SETUP_BIOS
+ finish:
+#endif
+
+  /* Write the boot image onto the disk.  */
+  if (grub_disk_write (dest_dev->disk, BOOT_SECTOR,
+		       0, GRUB_DISK_SECTOR_SIZE, boot_img))
+    grub_util_error ("%s", grub_errmsg);
+
+  grub_util_biosdisk_flush (root_dev->disk);
+  grub_util_biosdisk_flush (dest_dev->disk);
+
+  free (core_path);
+  free (core_img);
+  free (boot_img);
+  grub_device_close (dest_dev);
+  grub_device_close (root_dev);
+}
+

=== added directory '.pc/default_grub_d.patch'
=== added directory '.pc/default_grub_d.patch/grub-core'
=== added directory '.pc/default_grub_d.patch/grub-core/osdep'
=== added directory '.pc/default_grub_d.patch/grub-core/osdep/unix'
=== added file '.pc/default_grub_d.patch/grub-core/osdep/unix/config.c'
--- .pc/default_grub_d.patch/grub-core/osdep/unix/config.c	1970-01-01 00:00:00 +0000
+++ .pc/default_grub_d.patch/grub-core/osdep/unix/config.c	2014-08-24 23:28:48 +0000
@@ -0,0 +1,139 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2006,2007,2008,2009,2010,2011,2012,2013  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <config-util.h>
+
+#include <grub/emu/hostdisk.h>
+#include <grub/emu/exec.h>
+#include <grub/emu/config.h>
+#include <grub/util/install.h>
+#include <grub/util/misc.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <stdlib.h>
+
+const char *
+grub_util_get_config_filename (void)
+{
+  static char *value = NULL;
+  if (!value)
+    value = grub_util_path_concat (3, GRUB_SYSCONFDIR,
+				   "default", "grub");
+  return value;
+}
+
+const char *
+grub_util_get_pkgdatadir (void)
+{
+  const char *ret = getenv ("pkgdatadir");
+  if (ret)
+    return ret;
+  return GRUB_DATADIR "/" PACKAGE;
+}
+
+const char *
+grub_util_get_pkglibdir (void)
+{
+  return GRUB_LIBDIR "/" PACKAGE;
+}
+
+const char *
+grub_util_get_localedir (void)
+{
+  return LOCALEDIR;
+}
+
+void
+grub_util_load_config (struct grub_util_config *cfg)
+{
+  pid_t pid;
+  const char *argv[4];
+  char *script, *ptr;
+  const char *cfgfile, *iptr;
+  FILE *f = NULL;
+  int fd;
+  const char *v;
+
+  memset (cfg, 0, sizeof (*cfg));
+
+  v = getenv ("GRUB_ENABLE_CRYPTODISK");
+  if (v && v[0] == 'y' && v[1] == '\0')
+    cfg->is_cryptodisk_enabled = 1;
+
+  v = getenv ("GRUB_DISTRIBUTOR");
+  if (v)
+    cfg->grub_distributor = xstrdup (v);
+
+  cfgfile = grub_util_get_config_filename ();
+  if (!grub_util_is_regular (cfgfile))
+    return;
+
+  argv[0] = "sh";
+  argv[1] = "-c";
+
+  script = xmalloc (4 * strlen (cfgfile) + 300);
+
+  ptr = script;
+  memcpy (ptr, ". '", 3);
+  ptr += 3;
+  for (iptr = cfgfile; *iptr; iptr++)
+    {
+      if (*iptr == '\\')
+	{
+	  memcpy (ptr, "'\\''", 4);
+	  ptr += 4;
+	  continue;
+	}
+      *ptr++ = *iptr;
+    }
+
+  strcpy (ptr, "'; printf \"GRUB_ENABLE_CRYPTODISK=%s\\nGRUB_DISTRIBUTOR=%s\\n\", "
+	  "\"$GRUB_ENABLE_CRYPTODISK\", \"$GRUB_DISTRIBUTOR\"");
+
+  argv[2] = script;
+  argv[3] = '\0';
+
+  pid = grub_util_exec_pipe (argv, &fd);
+  if (pid)
+    f = fdopen (fd, "r");
+  if (f)
+    {
+      grub_util_parse_config (f, cfg, 1);
+      fclose (f);
+    }
+  if (pid)
+    {
+      close (fd);
+      waitpid (pid, NULL, 0);
+    }
+  if (f)
+    return;
+
+  f = grub_util_fopen (cfgfile, "r");
+  if (f)
+    {
+      grub_util_parse_config (f, cfg, 0);
+      fclose (f);
+    }
+  else
+    grub_util_warn (_("cannot open configuration file `%s': %s"),
+		    cfgfile, strerror (errno));
+}

=== added directory '.pc/default_grub_d.patch/util'
=== added file '.pc/default_grub_d.patch/util/grub-mkconfig.in'
--- .pc/default_grub_d.patch/util/grub-mkconfig.in	1970-01-01 00:00:00 +0000
+++ .pc/default_grub_d.patch/util/grub-mkconfig.in	2014-08-24 23:28:48 +0000
@@ -0,0 +1,291 @@
+#! /bin/sh
+set -e
+
+# Generate grub.cfg by inspecting /boot contents.
+# Copyright (C) 2006,2007,2008,2009,2010 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/>.
+
+prefix="@prefix@"
+exec_prefix="@exec_prefix@"
+datarootdir="@datarootdir@"
+
+prefix="@prefix@"
+exec_prefix="@exec_prefix@"
+sbindir="@sbindir@"
+bindir="@bindir@"
+sysconfdir="@sysconfdir@"
+PACKAGE_NAME=@PACKAGE_NAME@
+PACKAGE_VERSION=@PACKAGE_VERSION@
+host_os=@host_os@
+datadir="@datadir@"
+if [ "x$pkgdatadir" = x ]; then
+    pkgdatadir="${datadir}/@PACKAGE@"
+fi
+grub_cfg=""
+grub_mkconfig_dir="${sysconfdir}"/grub.d
+
+self=`basename $0`
+
+grub_probe="${sbindir}/@grub_probe@"
+grub_file="${bindir}/@grub_file@"
+grub_editenv="${bindir}/@grub_editenv@"
+grub_script_check="${bindir}/@grub_script_check@"
+
+export TEXTDOMAIN=@PACKAGE@
+export TEXTDOMAINDIR="@localedir@"
+
+. "${pkgdatadir}/grub-mkconfig_lib"
+
+# Usage: usage
+# Print the usage.
+usage () {
+    gettext_printf "Usage: %s [OPTION]\n" "$self"
+    gettext "Generate a grub config file"; echo
+    echo
+    print_option_help "-o, --output=$(gettext FILE)" "$(gettext "output generated config to FILE [default=stdout]")"
+    print_option_help "-h, --help" "$(gettext "print this message and exit")"
+    print_option_help "-v, --version" "$(gettext "print the version information and exit")"
+    echo
+    gettext "Report bugs to <[e-mail]>."; echo
+}
+
+argument () {
+  opt=$1
+  shift
+
+  if test $# -eq 0; then
+      gettext_printf "%s: option requires an argument -- \`%s'\n" "$self" "$opt" 1>&2
+      exit 1
+  fi
+  echo $1
+}
+
+# Check the arguments.
+while test $# -gt 0
+do
+    option=$1
+    shift
+
+    case "$option" in
+    -h | --help)
+	usage
+	exit 0 ;;
+    -v | --version)
+	echo "$self (${PACKAGE_NAME}) ${PACKAGE_VERSION}"
+	exit 0 ;;
+    -o | --output)
+	grub_cfg=`argument $option "$@"`; shift;;
+    --output=*)
+	grub_cfg=`echo "$option" | sed 's/--output=//'`
+	;;
+    -*)
+	gettext_printf "Unrecognized option \`%s'\n" "$option" 1>&2
+	usage
+	exit 1
+	;;
+    # Explicitly ignore non-option arguments, for compatibility.
+    esac
+done
+
+if fgrep -qs '${GRUB_PREFIX}/video.lst' "${grub_mkconfig_dir}/00_header"; then
+  echo "GRUB >= 2.00 has been unpacked but not yet configured." >&2
+  echo "grub-mkconfig will not work until the upgrade is complete." >&2
+  echo "It should run later as part of configuring the new GRUB packages." >&2
+  exit 0
+fi
+
+if [ "x$EUID" = "x" ] ; then
+  EUID=`id -u`
+fi
+
+if [ "$EUID" != 0 ] ; then
+  root=f
+  case "`uname 2>/dev/null`" in
+    CYGWIN*)
+      # Cygwin: Assume root if member of admin group
+      for g in `id -G 2>/dev/null` ; do
+	case $g in
+	  0|544) root=t ;;
+	esac
+      done ;;
+  esac
+  if [ $root != t ] ; then
+    gettext_printf "%s: You must run this as root\n" "$self" >&2
+    exit 1
+  fi
+fi
+
+set $grub_probe dummy
+if test -f "$1"; then
+    :
+else
+    gettext_print "%s: Not found.\n" "$1" 1>&2
+    exit 1
+fi
+
+# Device containing our userland.  Typically used for root= parameter.
+GRUB_DEVICE="`${grub_probe} --target=device /`"
+GRUB_DEVICE_UUID="`${grub_probe} --device ${GRUB_DEVICE} --target=fs_uuid 2> /dev/null`" || true
+
+# Device containing our /boot partition.  Usually the same as GRUB_DEVICE.
+GRUB_DEVICE_BOOT="`${grub_probe} --target=device /boot`"
+GRUB_DEVICE_BOOT_UUID="`${grub_probe} --device ${GRUB_DEVICE_BOOT} --target=fs_uuid 2> /dev/null`" || true
+
+# Filesystem for the device containing our userland.  Used for stuff like
+# choosing Hurd filesystem module.
+GRUB_FS="`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2> /dev/null || echo unknown`"
+
+if [ x"$GRUB_FS" = xunknown ]; then
+    GRUB_FS="$(stat -f --printf=%T / || echo unknown)"
+fi
+
+if test -f ${sysconfdir}/default/grub ; then
+  . ${sysconfdir}/default/grub
+fi
+
+# XXX: should this be deprecated at some point?
+if [ "x${GRUB_TERMINAL}" != "x" ] ; then
+  GRUB_TERMINAL_INPUT="${GRUB_TERMINAL}"
+  GRUB_TERMINAL_OUTPUT="${GRUB_TERMINAL}"
+fi
+
+termoutdefault=0
+if [ "x${GRUB_TERMINAL_OUTPUT}" = "x" ]; then
+    GRUB_TERMINAL_OUTPUT=gfxterm;
+    termoutdefault=1;
+fi
+
+for x in ${GRUB_TERMINAL_OUTPUT}; do
+    case "x${x}" in
+	xgfxterm) ;;
+	xconsole | xserial | xofconsole | xvga_text)
+            # make sure all our children behave in conformance with ascii..
+	    export LANG=C;;
+	*) echo "Invalid output terminal \"${GRUB_TERMINAL_OUTPUT}\"" >&2 ; exit 1 ;;
+    esac
+done
+
+GRUB_ACTUAL_DEFAULT="$GRUB_DEFAULT"
+
+if [ "x${GRUB_ACTUAL_DEFAULT}" = "xsaved" ] ; then GRUB_ACTUAL_DEFAULT="`"${grub_editenv}" - list | sed -n '/^saved_entry=/ s,^saved_entry=,,p'`" ; fi
+
+
+# These are defined in this script, export them here so that user can
+# override them.
+export GRUB_DEVICE \
+  GRUB_DEVICE_UUID \
+  GRUB_DEVICE_BOOT \
+  GRUB_DEVICE_BOOT_UUID \
+  GRUB_FS \
+  GRUB_FONT \
+  GRUB_PRELOAD_MODULES \
+  GRUB_ACTUAL_DEFAULT
+
+# These are optional, user-defined variables.
+export GRUB_DEFAULT \
+  GRUB_HIDDEN_TIMEOUT \
+  GRUB_HIDDEN_TIMEOUT_QUIET \
+  GRUB_TIMEOUT \
+  GRUB_TIMEOUT_STYLE \
+  GRUB_DEFAULT_BUTTON \
+  GRUB_HIDDEN_TIMEOUT_BUTTON \
+  GRUB_TIMEOUT_BUTTON \
+  GRUB_TIMEOUT_STYLE_BUTTON \
+  GRUB_BUTTON_CMOS_ADDRESS \
+  GRUB_BUTTON_CMOS_CLEAN \
+  GRUB_DISTRIBUTOR \
+  GRUB_CMDLINE_LINUX \
+  GRUB_CMDLINE_LINUX_DEFAULT \
+  GRUB_CMDLINE_XEN \
+  GRUB_CMDLINE_XEN_DEFAULT \
+  GRUB_CMDLINE_LINUX_XEN_REPLACE \
+  GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT \
+  GRUB_CMDLINE_NETBSD \
+  GRUB_CMDLINE_NETBSD_DEFAULT \
+  GRUB_CMDLINE_GNUMACH \
+  GRUB_TERMINAL_INPUT \
+  GRUB_TERMINAL_OUTPUT \
+  GRUB_SERIAL_COMMAND \
+  GRUB_DISABLE_LINUX_UUID \
+  GRUB_DISABLE_RECOVERY \
+  GRUB_VIDEO_BACKEND \
+  GRUB_GFXMODE \
+  GRUB_BACKGROUND \
+  GRUB_THEME \
+  GRUB_GFXPAYLOAD_LINUX \
+  GRUB_DISABLE_OS_PROBER \
+  GRUB_INIT_TUNE \
+  GRUB_SAVEDEFAULT \
+  GRUB_ENABLE_CRYPTODISK \
+  GRUB_BADRAM \
+  GRUB_OS_PROBER_SKIP_LIST \
+  GRUB_DISABLE_SUBMENU
+
+if test "x${grub_cfg}" != "x"; then
+  rm -f "${grub_cfg}.new"
+  oldumask=$(umask); umask 077
+  exec > "${grub_cfg}.new"
+  umask $oldumask
+fi
+gettext "Generating grub configuration file ..." >&2
+echo >&2
+
+cat << EOF
+#
+# DO NOT EDIT THIS FILE
+#
+# It is automatically generated by $self using templates
+# from ${grub_mkconfig_dir} and settings from ${sysconfdir}/default/grub
+#
+EOF
+
+
+for i in "${grub_mkconfig_dir}"/* ; do
+  case "$i" in
+    # emacsen backup files. FIXME: support other editors
+    *~) ;;
+    # emacsen autosave files. FIXME: support other editors
+    */\#*\#) ;;
+    *)
+      if grub_file_is_not_garbage "$i" && test -x "$i" ; then
+        echo
+        echo "### BEGIN $i ###"
+        "$i"
+        echo "### END $i ###"
+      fi
+    ;;
+  esac
+done
+
+if [ "x${grub_cfg}" != "x" ] && ! grep "^password" ${grub_cfg}.new >/dev/null; then
+  chmod 444 ${grub_cfg}.new || true
+fi
+
+if test "x${grub_cfg}" != "x" ; then
+  if ! ${grub_script_check} ${grub_cfg}.new; then
+    # TRANSLATORS: %s is replaced by filename
+    gettext_printf "Syntax errors are detected in generated GRUB config file.
+Ensure that there are no errors in /etc/default/grub
+and /etc/grub.d/* files or please file a bug report with
+%s file attached." "${grub_cfg}.new" >&2
+    echo >&2
+  else
+    # none of the children aborted with error, install the new grub.cfg
+    mv -f ${grub_cfg}.new ${grub_cfg}
+  fi
+fi
+
+gettext "done" >&2
+echo >&2

=== added directory '.pc/disable_floppies.patch'
=== added directory '.pc/disable_floppies.patch/grub-core'
=== added directory '.pc/disable_floppies.patch/grub-core/kern'
=== added directory '.pc/disable_floppies.patch/grub-core/kern/emu'
=== added file '.pc/disable_floppies.patch/grub-core/kern/emu/hostdisk.c'
--- .pc/disable_floppies.patch/grub-core/kern/emu/hostdisk.c	1970-01-01 00:00:00 +0000
+++ .pc/disable_floppies.patch/grub-core/kern/emu/hostdisk.c	2014-08-24 23:28:48 +0000
@@ -0,0 +1,686 @@
+/* hostdisk.c - emulate biosdisk */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2004,2006,2007,2008,2009,2010  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config-util.h>
+
+#include <grub/disk.h>
+#include <grub/partition.h>
+#include <grub/msdos_partition.h>
+#include <grub/types.h>
+#include <grub/err.h>
+#include <grub/emu/misc.h>
+#include <grub/emu/hostdisk.h>
+#include <grub/emu/getroot.h>
+#include <grub/misc.h>
+#include <grub/i18n.h>
+#include <grub/list.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <limits.h>
+
+#ifdef __linux__
+# include <sys/ioctl.h>         /* ioctl */
+# include <sys/mount.h>
+# ifndef BLKFLSBUF
+#  define BLKFLSBUF     _IO (0x12,97)   /* flush buffer cache */
+# endif /* ! BLKFLSBUF */
+#endif /* __linux__ */
+
+static struct
+{
+  char *drive;
+  char *device;
+  int device_map;
+} map[256];
+
+static int
+unescape_cmp (const char *a, const char *b_escaped)
+{
+  while (*a || *b_escaped)
+    {
+      if (*b_escaped == '\\' && b_escaped[1] != 0)
+	b_escaped++;
+      if (*a < *b_escaped)
+	return -1;
+      if (*a > *b_escaped)
+	return +1;
+      a++;
+      b_escaped++;
+    }
+  if (*a)
+    return +1;
+  if (*b_escaped)
+    return -1;
+  return 0;
+}
+
+static int
+find_grub_drive (const char *name)
+{
+  unsigned int i;
+
+  if (name)
+    {
+      for (i = 0; i < ARRAY_SIZE (map); i++)
+	if (map[i].drive && unescape_cmp (map[i].drive, name) == 0)
+	  return i;
+    }
+
+  return -1;
+}
+
+static int
+find_free_slot (void)
+{
+  unsigned int i;
+
+  for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
+    if (! map[i].drive)
+      return i;
+
+  return -1;
+}
+
+static int
+grub_util_biosdisk_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data,
+			    grub_disk_pull_t pull)
+{
+  unsigned i;
+
+  if (pull != GRUB_DISK_PULL_NONE)
+    return 0;
+
+  for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
+    if (map[i].drive && hook (map[i].drive, hook_data))
+      return 1;
+
+  return 0;
+}
+
+static grub_err_t
+grub_util_biosdisk_open (const char *name, grub_disk_t disk)
+{
+  int drive;
+  struct grub_util_hostdisk_data *data;
+
+  drive = find_grub_drive (name);
+  grub_util_info ("drive = %d", drive);
+  if (drive < 0)
+    return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
+		       "no mapping exists for `%s'", name);
+
+  disk->id = drive;
+  disk->data = data = xmalloc (sizeof (struct grub_util_hostdisk_data));
+  data->dev = NULL;
+  data->access_mode = 0;
+  data->fd = GRUB_UTIL_FD_INVALID;
+  data->is_disk = 0;
+  data->device_map = map[drive].device_map;
+
+  /* Get the size.  */
+  {
+    grub_util_fd_t fd;
+
+    fd = grub_util_fd_open (map[drive].device, GRUB_UTIL_FD_O_RDONLY);
+
+    if (!GRUB_UTIL_FD_IS_VALID(fd))
+      return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("cannot open `%s': %s"),
+			 map[drive].device, grub_util_fd_strerror ());
+
+    disk->total_sectors = grub_util_get_fd_size (fd, map[drive].device,
+						 &disk->log_sector_size);
+    disk->total_sectors >>= disk->log_sector_size;
+    disk->max_agglomerate = GRUB_DISK_MAX_MAX_AGGLOMERATE;
+
+#if GRUB_UTIL_FD_STAT_IS_FUNCTIONAL
+    {
+      struct stat st;
+# if GRUB_DISK_DEVS_ARE_CHAR
+      if (fstat (fd, &st) < 0 || ! S_ISCHR (st.st_mode))
+# else
+      if (fstat (fd, &st) < 0 || ! S_ISBLK (st.st_mode))
+# endif
+	data->is_disk = 1;
+    }
+#endif
+
+    grub_util_fd_close (fd);
+
+    grub_util_info ("the size of %s is %" GRUB_HOST_PRIuLONG_LONG,
+		    name, (unsigned long long) disk->total_sectors);
+
+    return GRUB_ERR_NONE;
+  }
+}
+
+const char *
+grub_hostdisk_os_dev_to_grub_drive (const char *os_disk, int add)
+{
+  unsigned int i;
+  char *canon;
+
+  canon = canonicalize_file_name (os_disk);
+  if (!canon)
+    canon = xstrdup (os_disk);
+
+  for (i = 0; i < ARRAY_SIZE (map); i++)
+    if (! map[i].device)
+      break;
+    else if (strcmp (map[i].device, canon) == 0)
+      {
+	free (canon);
+	return map[i].drive;
+      }
+
+  if (!add)
+    {
+      free (canon);
+      return NULL;
+    }
+
+  if (i == ARRAY_SIZE (map))
+    /* TRANSLATORS: it refers to the lack of free slots.  */
+    grub_util_error ("%s", _("device count exceeds limit"));
+
+  map[i].device = canon;
+  map[i].drive = xmalloc (sizeof ("hostdisk/") + strlen (os_disk));
+  strcpy (map[i].drive, "hostdisk/");
+  strcpy (map[i].drive + sizeof ("hostdisk/") - 1, os_disk);
+  map[i].device_map = 0;
+
+  grub_hostdisk_flush_initial_buffer (os_disk);
+
+  return map[i].drive;
+}
+
+#ifndef __linux__
+grub_util_fd_t
+grub_util_fd_open_device (const grub_disk_t disk, grub_disk_addr_t sector, int flags,
+			  grub_disk_addr_t *max)
+{
+  grub_util_fd_t fd;
+  struct grub_util_hostdisk_data *data = disk->data;
+
+  *max = ~0ULL;
+
+  flags |= GRUB_UTIL_FD_O_SYNC;
+
+  if (data->dev && strcmp (data->dev, map[disk->id].device) == 0 &&
+      data->access_mode == (flags & O_ACCMODE))
+    {
+      grub_dprintf ("hostdisk", "reusing open device `%s'\n", data->dev);
+      fd = data->fd;
+    }
+  else
+    {
+      free (data->dev);
+      data->dev = 0;
+      if (GRUB_UTIL_FD_IS_VALID(data->fd))
+	{
+	    if (data->access_mode == O_RDWR || data->access_mode == O_WRONLY)
+	      grub_util_fd_sync (data->fd);
+	    grub_util_fd_close (data->fd);
+	    data->fd = GRUB_UTIL_FD_INVALID;
+	}
+
+      fd = grub_util_fd_open (map[disk->id].device, flags);
+      if (GRUB_UTIL_FD_IS_VALID(fd))
+	{
+	  data->dev = xstrdup (map[disk->id].device);
+	  data->access_mode = (flags & O_ACCMODE);
+	  data->fd = fd;
+	}
+    }
+
+  if (!GRUB_UTIL_FD_IS_VALID(data->fd))
+    {
+      grub_error (GRUB_ERR_BAD_DEVICE, N_("cannot open `%s': %s"),
+		  map[disk->id].device, grub_util_fd_strerror ());
+      return GRUB_UTIL_FD_INVALID;
+    }
+
+  if (grub_util_fd_seek (fd, sector << disk->log_sector_size))
+    {
+      grub_util_fd_close (fd);
+      grub_error (GRUB_ERR_BAD_DEVICE, N_("cannot seek `%s': %s"),
+		  map[disk->id].device, grub_util_fd_strerror ());
+
+      return GRUB_UTIL_FD_INVALID;
+    }
+
+  return fd;
+}
+#endif
+
+
+static grub_err_t
+grub_util_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
+			 grub_size_t size, char *buf)
+{
+  while (size)
+    {
+      grub_util_fd_t fd;
+      grub_disk_addr_t max = ~0ULL;
+      fd = grub_util_fd_open_device (disk, sector, GRUB_UTIL_FD_O_RDONLY, &max);
+      if (!GRUB_UTIL_FD_IS_VALID (fd))
+	return grub_errno;
+
+#ifdef __linux__
+      if (sector == 0)
+	/* Work around a bug in Linux ez remapping.  Linux remaps all
+	   sectors that are read together with the MBR in one read.  It
+	   should only remap the MBR, so we split the read in two
+	   parts. -jochen  */
+	max = 1;
+#endif /* __linux__ */
+
+      if (max > size)
+	max = size;
+
+      if (grub_util_fd_read (fd, buf, max << disk->log_sector_size)
+	  != (ssize_t) (max << disk->log_sector_size))
+	return grub_error (GRUB_ERR_READ_ERROR, N_("cannot read `%s': %s"),
+			   map[disk->id].device, grub_util_fd_strerror ());
+      size -= max;
+      buf += (max << disk->log_sector_size);
+      sector += max;
+    }
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_util_biosdisk_write (grub_disk_t disk, grub_disk_addr_t sector,
+			  grub_size_t size, const char *buf)
+{
+  while (size)
+    {
+      grub_util_fd_t fd;
+      grub_disk_addr_t max = ~0ULL;
+      fd = grub_util_fd_open_device (disk, sector, GRUB_UTIL_FD_O_WRONLY, &max);
+      if (!GRUB_UTIL_FD_IS_VALID (fd))
+	return grub_errno;
+
+#ifdef __linux__
+      if (sector == 0)
+	/* Work around a bug in Linux ez remapping.  Linux remaps all
+	   sectors that are write together with the MBR in one write.  It
+	   should only remap the MBR, so we split the write in two
+	   parts. -jochen  */
+	max = 1;
+#endif /* __linux__ */
+
+      if (max > size)
+	max = size;
+
+      if (grub_util_fd_write (fd, buf, max << disk->log_sector_size)
+	  != (ssize_t) (max << disk->log_sector_size))
+	return grub_error (GRUB_ERR_WRITE_ERROR, N_("cannot write to `%s': %s"),
+			   map[disk->id].device, grub_util_fd_strerror ());
+      size -= max;
+      buf += (max << disk->log_sector_size);
+    }
+  return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_util_biosdisk_flush (struct grub_disk *disk)
+{
+  struct grub_util_hostdisk_data *data = disk->data;
+
+  if (disk->dev->id != GRUB_DISK_DEVICE_BIOSDISK_ID)
+    return GRUB_ERR_NONE;
+  if (!GRUB_UTIL_FD_IS_VALID (data->fd))
+    {
+      grub_disk_addr_t max;
+      data->fd = grub_util_fd_open_device (disk, 0, GRUB_UTIL_FD_O_RDONLY, &max);
+      if (!GRUB_UTIL_FD_IS_VALID (data->fd))
+	return grub_errno;
+    }
+  grub_util_fd_sync (data->fd);
+#ifdef __linux__
+  if (data->is_disk)
+    ioctl (data->fd, BLKFLSBUF, 0);
+#endif
+  return GRUB_ERR_NONE;
+}
+
+static void
+grub_util_biosdisk_close (struct grub_disk *disk)
+{
+  struct grub_util_hostdisk_data *data = disk->data;
+
+  free (data->dev);
+  if (GRUB_UTIL_FD_IS_VALID (data->fd))
+    {
+      if (data->access_mode == O_RDWR || data->access_mode == O_WRONLY)
+	grub_util_biosdisk_flush (disk);
+      grub_util_fd_close (data->fd);
+    }
+  free (data);
+}
+
+static struct grub_disk_dev grub_util_biosdisk_dev =
+  {
+    .name = "hostdisk",
+    .id = GRUB_DISK_DEVICE_HOSTDISK_ID,
+    .iterate = grub_util_biosdisk_iterate,
+    .open = grub_util_biosdisk_open,
+    .close = grub_util_biosdisk_close,
+    .read = grub_util_biosdisk_read,
+    .write = grub_util_biosdisk_write,
+    .next = 0
+  };
+
+static int
+grub_util_check_file_presence (const char *p)
+{
+#if !GRUB_UTIL_FD_STAT_IS_FUNCTIONAL
+  grub_util_fd_t h;
+  h = grub_util_fd_open (p, GRUB_UTIL_FD_O_RDONLY);
+  if (!GRUB_UTIL_FD_IS_VALID(h))
+    return 0;
+  grub_util_fd_close (h);
+  return 1;
+#else
+  struct stat st;
+
+  if (stat (p, &st) == -1)
+    return 0;
+  return 1;
+#endif
+}
+
+static void
+read_device_map (const char *dev_map)
+{
+  FILE *fp;
+  char buf[1024];	/* XXX */
+  int lineno = 0;
+
+  if (dev_map[0] == '\0')
+    {
+      grub_util_info ("no device.map");
+      return;
+    }
+
+  fp = grub_util_fopen (dev_map, "r");
+  if (! fp)
+    {
+      grub_util_info (_("cannot open `%s': %s"), dev_map, strerror (errno));
+      return;
+    }
+
+  while (fgets (buf, sizeof (buf), fp))
+    {
+      char *p = buf;
+      char *e;
+      char *drive_e, *drive_p;
+      int drive;
+
+      lineno++;
+
+      /* Skip leading spaces.  */
+      while (*p && grub_isspace (*p))
+	p++;
+
+      /* If the first character is `#' or NUL, skip this line.  */
+      if (*p == '\0' || *p == '#')
+	continue;
+
+      if (*p != '(')
+	{
+	  char *tmp;
+	  tmp = xasprintf (_("missing `%c' symbol"), '(');
+	  grub_util_error ("%s:%d: %s", dev_map, lineno, tmp);
+	}
+
+      p++;
+      /* Find a free slot.  */
+      drive = find_free_slot ();
+      if (drive < 0)
+	grub_util_error ("%s:%d: %s", dev_map, lineno, _("device count exceeds limit"));
+
+      e = p;
+      p = strchr (p, ')');
+      if (! p)
+	{
+	  char *tmp;
+	  tmp = xasprintf (_("missing `%c' symbol"), ')');
+	  grub_util_error ("%s:%d: %s", dev_map, lineno, tmp);
+	}
+
+      map[drive].drive = 0;
+      if ((e[0] == 'f' || e[0] == 'h' || e[0] == 'c') && e[1] == 'd')
+	{
+	  char *ptr;
+	  for (ptr = e + 2; ptr < p; ptr++)
+	    if (!grub_isdigit (*ptr))
+	      break;
+	  if (ptr == p)
+	    {
+	      map[drive].drive = xmalloc (p - e + sizeof ('\0'));
+	      strncpy (map[drive].drive, e, p - e + sizeof ('\0'));
+	      map[drive].drive[p - e] = '\0';
+	    }
+	  if (*ptr == ',')
+	    {
+	      *p = 0;
+
+	      /* TRANSLATORS: Only one entry is ignored. However the suggestion
+		 is to correct/delete the whole file.
+		 device.map is a file indicating which
+		 devices are available at boot time. Fedora populated it with
+		 entries like (hd0,1) /dev/sda1 which would mean that every
+		 partition is a separate disk for BIOS. Such entries were
+		 inactive in GRUB due to its bug which is now gone. Without
+		 this additional check these entries would be harmful now.
+	      */
+	      grub_util_warn (_("the device.map entry `%s' is invalid. "
+				"Ignoring it. Please correct or "
+				"delete your device.map"), e);
+	      continue;
+	    }
+	}
+      drive_e = e;
+      drive_p = p;
+      map[drive].device_map = 1;
+
+      p++;
+      /* Skip leading spaces.  */
+      while (*p && grub_isspace (*p))
+	p++;
+
+      if (*p == '\0')
+	grub_util_error ("%s:%d: %s", dev_map, lineno, _("filename expected"));
+
+      /* NUL-terminate the filename.  */
+      e = p;
+      while (*e && ! grub_isspace (*e))
+	e++;
+      *e = '\0';
+
+      if (!grub_util_check_file_presence (p))
+	{
+	  free (map[drive].drive);
+	  map[drive].drive = NULL;
+	  grub_util_info ("Cannot stat `%s', skipping", p);
+	  continue;
+	}
+
+      /* On Linux, the devfs uses symbolic links horribly, and that
+	 confuses the interface very much, so use realpath to expand
+	 symbolic links.  */
+      map[drive].device = canonicalize_file_name (p);
+      if (! map[drive].device)
+	map[drive].device = xstrdup (p);
+      
+      if (!map[drive].drive)
+	{
+	  char c;
+	  map[drive].drive = xmalloc (sizeof ("hostdisk/") + strlen (p));
+	  memcpy (map[drive].drive, "hostdisk/", sizeof ("hostdisk/") - 1);
+	  strcpy (map[drive].drive + sizeof ("hostdisk/") - 1, p);
+	  c = *drive_p;
+	  *drive_p = 0;
+	  /* TRANSLATORS: device.map is a filename. Not to be translated.
+	     device.map specifies disk correspondance overrides. Previously
+	     one could create any kind of device name with this. Due to
+	     some problems we decided to limit it to just a handful
+	     possibilities.  */
+	  grub_util_warn (_("the drive name `%s' in device.map is incorrect. "
+			    "Using %s instead. "
+			    "Please use the form [hfc]d[0-9]* "
+			    "(E.g. `hd0' or `cd')"),
+			  drive_e, map[drive].drive);
+	  *drive_p = c;
+	}
+
+      grub_util_info ("adding `%s' -> `%s' from device.map", map[drive].drive,
+		      map[drive].device);
+
+      grub_hostdisk_flush_initial_buffer (map[drive].device);
+    }
+
+  fclose (fp);
+}
+
+void
+grub_util_biosdisk_init (const char *dev_map)
+{
+  read_device_map (dev_map);
+  grub_disk_dev_register (&grub_util_biosdisk_dev);
+}
+
+void
+grub_util_biosdisk_fini (void)
+{
+  unsigned i;
+
+  for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
+    {
+      if (map[i].drive)
+	free (map[i].drive);
+      if (map[i].device)
+	free (map[i].device);
+      map[i].drive = map[i].device = NULL;
+    }
+
+  grub_disk_dev_unregister (&grub_util_biosdisk_dev);
+}
+
+const char *
+grub_util_biosdisk_get_compatibility_hint (grub_disk_t disk)
+{
+  if (disk->dev != &grub_util_biosdisk_dev || map[disk->id].device_map)
+    return disk->name;
+  return 0;
+}
+
+const char *
+grub_util_biosdisk_get_osdev (grub_disk_t disk)
+{
+  if (disk->dev != &grub_util_biosdisk_dev)
+    return 0;
+
+  return map[disk->id].device;
+}
+
+
+static char *
+grub_util_path_concat_real (size_t n, int ext, va_list ap)
+{
+  size_t totlen = 0;
+  char **l = xmalloc ((n + ext) * sizeof (l[0]));
+  char *r, *p, *pi;
+  size_t i;
+  int first = 1;
+
+  for (i = 0; i < n + ext; i++)
+    {
+      l[i] = va_arg (ap, char *);
+      if (l[i])
+	totlen += strlen (l[i]) + 1;
+    }
+
+  r = xmalloc (totlen + 10);
+
+  p = r;
+  for (i = 0; i < n; i++)
+    {
+      pi = l[i];
+      if (!pi)
+	continue;
+      while (*pi == '/')
+	pi++;
+      if ((p != r || (pi != l[i] && first)) && (p == r || *(p - 1) != '/'))
+	*p++ = '/';
+      first = 0;
+      p = grub_stpcpy (p, pi);
+      while (p != r && p != r + 1 && *(p - 1) == '/')
+	p--;
+    }
+
+  if (ext && l[i])
+    p = grub_stpcpy (p, l[i]);
+
+  *p = '\0';
+