diff --git a/ChangeLog b/ChangeLog
index 084131202..1abd5daa2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,45 @@
+2011-10-26  Vladimir Serbinenko  <phcoder@gmail.com>
+
+	ZFS multi-device and version 33 support.
+
+	* Makefile.util.def (libgrubkern): Add grub-core/fs/zfs/zfsinfo.c.
+	* grub-core/fs/zfs/zfs.c (grub_zfs_device_desc): New struct.
+	(grub_zfs_data): Add multidev-ice-related fields.
+	(zio_checksum_verify): Zero-pad printed values. Print checksum name.
+	(dva_get_offset): Make dva const.
+	(zfs_fetch_nvlist): New function.
+	(fill_vdev_info_real): Likewise.
+	(fill_vdev_info): Likewise.
+	(check_pool_label): Likewise.
+	(scan_disk): Likewise.
+	(scan_devices): Likewise.
+	(read_device): Likewise.
+	(read_dva): Likewise.
+	(zio_read_gang): Use read_dva.
+	(zio_read_data): Likewise.
+	(zap_leaf_lookup): Add missing endian conversion.
+	(zap_verify): Add missing endian conversion. All users updated.
+	(fzap_lookup): Likewise.
+	(fzap_iterate): Likewise.
+	(dnode_get_path): Handle SA bonus.
+	(nvlist_find_value): Make input const. All users updated.
+	(unmount_device): New function.
+	(zfs_unmount): Use unmount_device.
+	(zfs_mount): Use scan_disk.
+	(zfs_mtime): New function.
+	(grub_zfs_open): Handle system attributes.
+	(fill_fs_info): Likewise.
+	(grub_zfs_dir): Likewise.
+	(grub_zfs_fs): Add mtime.
+	* grub-core/fs/zfs/zfsinfo.c (print_vdev_info): Add missing return.
+	* include/grub/zfs/sa_impl.h (SA_TYPE_OFFSET): New definition.
+	(SA_MTIME_OFFSET): Likewise.
+	(SA_SYMLINK_OFFSET): Likewise.
+	* include/grub/zfs/zfs.h (SPA_VERSION): Increase to 33.
+	* util/grub-fstest.c (CMD_ZFSINFO): New enum value.
+	(fstest): Support zfsinfo.
+	(argp_parser): Likewise.
+
 2011-10-26  Vladimir Serbinenko  <phcoder@gmail.com>
 
 	* include/grub/datetime.h (grub_datetime2unixtime): Fix off-by-one
diff --git a/Makefile.util.def b/Makefile.util.def
index 759e164d2..e1040c24f 100644
--- a/Makefile.util.def
+++ b/Makefile.util.def
@@ -84,6 +84,7 @@ library = {
   common = grub-core/fs/ufs.c;
   common = grub-core/fs/xfs.c;
   common = grub-core/fs/zfs/zfs.c;
+  common = grub-core/fs/zfs/zfsinfo.c;
   common = grub-core/fs/zfs/zfs_lzjb.c;
   common = grub-core/fs/zfs/zfs_sha256.c;
   common = grub-core/fs/zfs/zfs_fletcher.c;
diff --git a/grub-core/fs/zfs/zfs.c b/grub-core/fs/zfs/zfs.c
index 6721cddc1..3253457c7 100644
--- a/grub-core/fs/zfs/zfs.c
+++ b/grub-core/fs/zfs/zfs.c
@@ -140,6 +140,26 @@ typedef struct dnode_end
   grub_zfs_endian_t endian;
 } dnode_end_t;
 
+struct grub_zfs_device_desc
+{
+  enum { DEVICE_LEAF, DEVICE_MIRROR, DEVICE_RAIDZ } type;
+  grub_uint64_t id;
+  grub_uint64_t guid;
+
+  /* Valid only for non-leafs.  */
+  unsigned n_children;
+  struct grub_zfs_device_desc *children;
+
+  /* Valid only for RAIDZ.  */
+  unsigned nparity;
+
+  /* Valid only for leaf devices.  */
+  grub_device_t dev;
+  grub_disk_addr_t vdev_phys_sector;
+  uberblock_t current_uberblock;
+  int original;
+};
+
 struct grub_zfs_data
 {
   /* cache for a file block of the currently zfs_open()-ed file */
@@ -154,14 +174,19 @@ struct grub_zfs_data
   grub_uint64_t dnode_end;
   grub_zfs_endian_t dnode_endian;
 
-  uberblock_t current_uberblock;
-  grub_disk_t disk;
-
   dnode_end_t mos;
   dnode_end_t mdn;
   dnode_end_t dnode;
 
-  grub_disk_addr_t vdev_phys_sector;
+  struct grub_zfs_device_desc *devices_attached;
+  unsigned n_devices_attached;
+  unsigned n_devices_allocated;
+  struct grub_zfs_device_desc *device_original;
+
+  uberblock_t current_uberblock;
+
+  int mounted;
+  grub_uint64_t guid;
 };
 
 static grub_err_t 
@@ -271,13 +296,13 @@ zio_checksum_verify (zio_cksum_t zc, grub_uint32_t checksum,
       || (actual_cksum.zc_word[2] != zc.zc_word[2]) 
       || (actual_cksum.zc_word[3] != zc.zc_word[3]))
     {
-      grub_dprintf ("zfs", "checksum %d verification failed\n", checksum);
-      grub_dprintf ("zfs", "actual checksum %16llx %16llx %16llx %16llx\n",
+      grub_dprintf ("zfs", "checksum %s verification failed\n", ci->ci_name);
+      grub_dprintf ("zfs", "actual checksum %016llx %016llx %016llx %016llx\n",
 		    (unsigned long long) actual_cksum.zc_word[0], 
 		    (unsigned long long) actual_cksum.zc_word[1],
 		    (unsigned long long) actual_cksum.zc_word[2], 
 		    (unsigned long long) actual_cksum.zc_word[3]);
-      grub_dprintf ("zfs", "expected checksum %16llx %16llx %16llx %16llx\n",
+      grub_dprintf ("zfs", "expected checksum %016llx %016llx %016llx %016llx\n",
 		    (unsigned long long) zc.zc_word[0], 
 		    (unsigned long long) zc.zc_word[1],
 		    (unsigned long long) zc.zc_word[2], 
@@ -410,7 +435,7 @@ get_psize (blkptr_t * bp, grub_zfs_endian_t endian)
 }
 
 static grub_uint64_t
-dva_get_offset (dva_t * dva, grub_zfs_endian_t endian)
+dva_get_offset (const dva_t *dva, grub_zfs_endian_t endian)
 {
   grub_dprintf ("zfs", "dva=%llx, %llx\n", 
 		(unsigned long long) dva->dva_word[0], 
@@ -419,6 +444,510 @@ dva_get_offset (dva_t * dva, grub_zfs_endian_t endian)
 			    endian) << SPA_MINBLOCKSHIFT;
 }
 
+static grub_err_t
+zfs_fetch_nvlist (struct grub_zfs_device_desc *diskdesc, char **nvlist)
+{
+  grub_err_t err;
+
+  *nvlist = grub_malloc (VDEV_PHYS_SIZE);
+  if (!diskdesc->dev)
+    return grub_error (GRUB_ERR_BAD_FS, "member drive unknown");
+
+  /* Read in the vdev name-value pair list (112K). */
+  err = grub_disk_read (diskdesc->dev->disk, diskdesc->vdev_phys_sector, 0,
+			VDEV_PHYS_SIZE, *nvlist);
+  if (err)
+    {
+      grub_free (*nvlist);
+      *nvlist = 0;
+      return err;
+    }
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+fill_vdev_info_real (struct grub_zfs_data *data,
+		     const char *nvlist,
+		     struct grub_zfs_device_desc *fill,
+		     struct grub_zfs_device_desc *insert)
+{
+  char *type;
+
+  type = grub_zfs_nvlist_lookup_string (nvlist, ZPOOL_CONFIG_TYPE);
+
+  if (!type)
+    return grub_errno;
+
+  if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "id", &(fill->id)))
+    return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id");
+
+  if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "guid", &(fill->guid)))
+    return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id");
+
+  if (grub_strcmp (type, VDEV_TYPE_DISK) == 0
+      || grub_strcmp (type, VDEV_TYPE_FILE) == 0)
+    {
+      fill->type = DEVICE_LEAF;
+
+      if (!fill->dev && fill->guid == insert->guid)
+	{
+	  fill->dev = insert->dev;
+	  fill->vdev_phys_sector = insert->vdev_phys_sector;
+	  fill->current_uberblock = insert->current_uberblock;
+	  fill->original = insert->original;
+	  if (!data->device_original)
+	    data->device_original = fill;
+	}
+
+      return GRUB_ERR_NONE;
+    }
+
+  if (grub_strcmp (type, VDEV_TYPE_MIRROR) == 0
+      || grub_strcmp (type, VDEV_TYPE_RAIDZ) == 0)
+    {
+      int nelm, i;
+
+      if (grub_strcmp (type, VDEV_TYPE_MIRROR) == 0)
+	fill->type = DEVICE_MIRROR;
+      else
+	{
+	  grub_uint64_t par;
+	  fill->type = DEVICE_RAIDZ;
+	  if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "nparity", &par))
+	    return grub_error (GRUB_ERR_BAD_FS, "couldn't find raidz parity");
+	  fill->nparity = par;
+	}
+
+      nelm = grub_zfs_nvlist_lookup_nvlist_array_get_nelm (nvlist, ZPOOL_CONFIG_CHILDREN);
+
+      if (nelm <= 0)
+	return grub_error (GRUB_ERR_BAD_FS, "incorrect mirror VDEV");
+
+      if (!fill->children)
+	{
+	  fill->n_children = nelm;
+	  
+	  fill->children = grub_zalloc (fill->n_children
+					* sizeof (fill->children[0]));
+	}
+
+      for (i = 0; i < nelm; i++)
+	{
+	  char *child;
+	  grub_err_t err;
+
+	  child = grub_zfs_nvlist_lookup_nvlist_array
+	    (nvlist, ZPOOL_CONFIG_CHILDREN, i);
+
+	  err = fill_vdev_info_real (data, child, &fill->children[i], insert);
+
+	  grub_free (child);
+
+	  if (err)
+	    return err;
+	}
+      return GRUB_ERR_NONE;
+    }
+
+  return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "vdev %s isn't supported",
+		     type);
+}
+
+static grub_err_t
+fill_vdev_info (struct grub_zfs_data *data,
+		char *nvlist, struct grub_zfs_device_desc *diskdesc)
+{
+  grub_uint64_t id;
+  unsigned i;
+
+  if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "id", &id))
+    return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id");
+
+  for (i = 0; i < data->n_devices_attached; i++)
+    if (data->devices_attached[i].id == id)
+      return fill_vdev_info_real (data, nvlist, &data->devices_attached[i],
+				  diskdesc);
+
+  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)
+	{
+	  data->devices_attached = tmp;
+	  return grub_errno;
+	}
+    }
+
+  grub_memset (&data->devices_attached[data->n_devices_attached - 1],
+	       0, sizeof (data->devices_attached[data->n_devices_attached - 1]));
+
+  return fill_vdev_info_real (data, nvlist,
+			      &data->devices_attached[data->n_devices_attached - 1],
+			      diskdesc);
+}
+
+/*
+ * Check the disk label information and retrieve needed vdev name-value pairs.
+ *
+ */
+static grub_err_t
+check_pool_label (struct grub_zfs_data *data,
+		  struct grub_zfs_device_desc *diskdesc)
+{
+  grub_uint64_t pool_state, txg = 0;
+  char *nvlist;
+#if 0
+  char *nv;
+#endif
+  grub_uint64_t poolguid;
+  grub_uint64_t version;
+  int found;
+  grub_err_t err;
+
+  err = zfs_fetch_nvlist (diskdesc, &nvlist);
+  if (err)
+    return err;
+
+  grub_dprintf ("zfs", "check 2 passed\n");
+
+  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_STATE,
+					 &pool_state);
+  if (! found)
+    {
+      grub_free (nvlist);
+      if (! grub_errno)
+	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_STATE " not found");
+      return grub_errno;
+    }
+  grub_dprintf ("zfs", "check 3 passed\n");
+
+  if (pool_state == POOL_STATE_DESTROYED)
+    {
+      grub_free (nvlist);
+      return grub_error (GRUB_ERR_BAD_FS, "zpool is marked as destroyed");
+    }
+  grub_dprintf ("zfs", "check 4 passed\n");
+
+  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_TXG, &txg);
+  if (!found)
+    {
+      grub_free (nvlist);
+      if (! grub_errno)
+	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_TXG " not found");
+      return grub_errno;
+    }
+  grub_dprintf ("zfs", "check 6 passed\n");
+
+  /* not an active device */
+  if (txg == 0)
+    {
+      grub_free (nvlist);
+      return grub_error (GRUB_ERR_BAD_FS, "zpool isn't active");
+    }
+  grub_dprintf ("zfs", "check 7 passed\n");
+
+  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_VERSION,
+					 &version);
+  if (! found)
+    {
+      grub_free (nvlist);
+      if (! grub_errno)
+	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_VERSION " not found");
+      return grub_errno;
+    }
+  grub_dprintf ("zfs", "check 8 passed\n");
+
+  if (version > SPA_VERSION)
+    {
+      grub_free (nvlist);
+      return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+			 "too new version %llu > %llu",
+			 (unsigned long long) version,
+			 (unsigned long long) SPA_VERSION);
+    }
+  grub_dprintf ("zfs", "check 9 passed\n");
+
+  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_GUID,
+					 &(diskdesc->guid));
+  if (! found)
+    {
+      grub_free (nvlist);
+      if (! grub_errno)
+	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_GUID " not found");
+      return grub_errno;
+    }
+
+  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_GUID,
+					 &poolguid);
+  if (! found)
+    {
+      grub_free (nvlist);
+      if (! grub_errno)
+	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_GUID " not found");
+      return grub_errno;
+    }
+
+  grub_dprintf ("zfs", "check 11 passed\n");
+
+  if (data->mounted && data->guid != poolguid)
+    return grub_error (GRUB_ERR_BAD_FS, "another zpool");
+  else
+    data->guid = poolguid;
+
+  {
+    char *nv;
+    nv = grub_zfs_nvlist_lookup_nvlist (nvlist, ZPOOL_CONFIG_VDEV_TREE);
+
+    if (!nv)
+      {
+	grub_free (nvlist);
+	return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev tree");
+      }
+    err = fill_vdev_info (data, nv, diskdesc);
+    if (err)
+      {
+	grub_free (nvlist);
+	return err;
+      }
+  }
+  grub_dprintf ("zfs", "check 10 passed\n");
+
+  grub_free (nvlist);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+scan_disk (grub_device_t dev, struct grub_zfs_data *data,
+	   int original)
+{
+  int label = 0;
+  uberblock_phys_t *ub_array, *ubbest = NULL;
+  vdev_boot_header_t *bh;
+  grub_err_t err;
+  int vdevnum;
+  struct grub_zfs_device_desc desc;
+
+  ub_array = grub_malloc (VDEV_UBERBLOCK_RING);
+  if (!ub_array)
+    return grub_errno;
+
+  bh = grub_malloc (VDEV_BOOT_HEADER_SIZE);
+  if (!bh)
+    {
+      grub_free (ub_array);
+      return grub_errno;
+    }
+
+  vdevnum = VDEV_LABELS;
+
+  desc.dev = dev;
+  desc.original = original;
+
+  /* Don't check back labels on CDROM.  */
+  if (grub_disk_get_size (dev->disk) == GRUB_DISK_SIZE_UNKNOWN)
+    vdevnum = VDEV_LABELS / 2;
+
+  for (label = 0; ubbest == NULL && label < vdevnum; label++)
+    {
+      desc.vdev_phys_sector
+	= label * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT)
+	+ ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SPA_MINBLOCKSHIFT)
+	+ (label < VDEV_LABELS / 2 ? 0 : grub_disk_get_size (dev->disk)
+	   - VDEV_LABELS * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT));
+
+      /* Read in the uberblock ring (128K). */
+      err = grub_disk_read (dev->disk, desc.vdev_phys_sector
+			    + (VDEV_PHYS_SIZE >> SPA_MINBLOCKSHIFT),
+			    0, VDEV_UBERBLOCK_RING, (char *) ub_array);
+      if (err)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  continue;
+	}
+      grub_dprintf ("zfs", "label ok %d\n", label);
+
+      ubbest = find_bestub (ub_array, desc.vdev_phys_sector);
+      if (!ubbest)
+	{
+	  grub_dprintf ("zfs", "No uberblock found\n");
+	  grub_errno = GRUB_ERR_NONE;
+	  continue;
+	}
+
+      grub_memmove (&(desc.current_uberblock),
+		    &ubbest->ubp_uberblock, sizeof (uberblock_t));
+      if (original)
+	grub_memmove (&(data->current_uberblock),
+		      &ubbest->ubp_uberblock, sizeof (uberblock_t));
+
+      err = check_pool_label (data, &desc);
+      if (err)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  continue;
+	}
+#if 0
+      if (find_best_root &&
+	  vdev_uberblock_compare (&ubbest->ubp_uberblock,
+				  &(current_uberblock)) <= 0)
+	continue;
+#endif
+      grub_free (ub_array);
+      grub_free (bh);
+      return GRUB_ERR_NONE;
+    }
+  
+  grub_free (ub_array);
+  grub_free (bh);
+
+  return grub_error (GRUB_ERR_BAD_FS, "couldn't find a valid label");
+}
+
+static grub_err_t
+scan_devices (struct grub_zfs_data *data)
+{
+  auto int hook (const char *name);
+  int hook (const char *name)
+  {
+    grub_device_t dev;
+    grub_err_t err;
+    dev = grub_device_open (name);
+    if (!dev)
+      return 0;
+    if (!dev->disk)
+      {
+	grub_device_close (dev);
+	return 0;
+      }
+    err = scan_disk (dev, data, 0);
+    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;
+      }
+    
+    return 0;
+  }
+  grub_device_iterate (hook);
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+read_device (grub_uint64_t offset, struct grub_zfs_device_desc *desc,
+	     grub_uint32_t asize, grub_size_t len, void *buf)
+{
+  switch (desc->type)
+    {
+    case DEVICE_LEAF:
+      {
+	grub_uint64_t sector;
+	sector = DVA_OFFSET_TO_PHYS_SECTOR (offset);
+	if (!desc->dev)
+	  {
+	    return grub_error (GRUB_ERR_BAD_FS, "member drive unknown");
+	  }
+	/* read in a data block */
+	return grub_disk_read (desc->dev->disk, sector, 0, len, buf);
+      }
+    case DEVICE_MIRROR:
+      {
+	grub_err_t err;
+	unsigned i;
+	if (desc->n_children <= 0)
+	  return grub_error (GRUB_ERR_BAD_FS,
+			     "non-positive number of mirror children");
+	for (i = 0; i < desc->n_children; i++)
+	  {
+	    err = read_device (offset, &desc->children[i], asize,
+			       len, buf);
+	    if (!err)
+	      break;
+	    grub_errno = GRUB_ERR_NONE;
+	  }
+	return (grub_errno = err);
+      }
+    case DEVICE_RAIDZ:
+      {
+	grub_uint64_t sector;
+	grub_uint32_t bsize;
+	unsigned c = 0;
+
+	bsize = (asize + desc->nparity) / desc->n_children;
+	sector = offset >> 9;
+	while (len > 0)
+	  {
+	    grub_size_t csize;
+	    grub_uint64_t high;
+	    grub_uint64_t devn;
+	    grub_err_t err;
+	    high = grub_divmod64 (sector + (asize > 2) + c, desc->n_children,
+				  &devn);
+	    csize = bsize << 9;
+	    if (csize > len)
+	      csize = len;
+	    grub_dprintf ("zfs", "RAIDZ mapping 0x%" PRIxGRUB_UINT64_T
+			  "+%d+%u -> (0x%" PRIxGRUB_UINT64_T ", 0x%"
+			  PRIxGRUB_UINT64_T ")\n",
+			  sector,(asize > 2), c, high, devn);
+	    err = read_device (high << 9, &desc->children[devn],
+			       bsize, csize, buf);
+	    if (err)
+	      return err;
+	    c++;
+	    buf = (char *) buf + csize;
+	    len -= csize;
+	  }
+	return GRUB_ERR_NONE;	    
+      }
+      return GRUB_ERR_NONE;
+    }
+  return grub_error (GRUB_ERR_BAD_FS, "unsupported device type");
+}
+
+static grub_err_t
+read_dva (const dva_t *dva,
+	  grub_zfs_endian_t endian, struct grub_zfs_data *data,
+	  void *buf, grub_size_t len)
+{
+  grub_uint64_t offset;
+  unsigned i;
+  grub_err_t err;
+  int try = 0;
+  offset = dva_get_offset (dva, endian);
+
+  for (try = 0; try < 2; try++)
+    {
+      for (i = 0; i < data->n_devices_attached; i++)
+	if (data->devices_attached[i].id == DVA_GET_VDEV (dva))
+	  {
+	    err = read_device (offset, &data->devices_attached[i],
+			       dva->dva_word[0] & 0xffffff, len, buf);
+	    if (!err)
+	      return GRUB_ERR_NONE;
+	    break;
+	  }
+      if (try == 1)
+	break;
+      err = scan_devices (data);
+      if (err)
+	return err;
+    }
+  return err;
+}
 
 /*
  * Read a block of data based on the gang block address dva,
@@ -430,7 +959,6 @@ zio_read_gang (blkptr_t * bp, grub_zfs_endian_t endian, dva_t * dva, void *buf,
 	       struct grub_zfs_data *data)
 {
   zio_gbh_phys_t *zio_gb;
-  grub_uint64_t offset, sector;
   unsigned i;
   grub_err_t err;
   zio_cksum_t zc;
@@ -442,13 +970,8 @@ zio_read_gang (blkptr_t * bp, grub_zfs_endian_t endian, dva_t * dva, void *buf,
     return grub_errno;
   grub_dprintf ("zfs", endian == LITTLE_ENDIAN ? "little-endian gang\n"
 		:"big-endian gang\n");
-  offset = dva_get_offset (dva, endian);
-  sector = DVA_OFFSET_TO_PHYS_SECTOR (offset);
-  grub_dprintf ("zfs", "offset=%llx\n", (unsigned long long) offset);
 
-  /* read in the gang block header */
-  err = grub_disk_read (data->disk, sector, 0, SPA_GANGBLOCKSIZE,
-			(char *) zio_gb);
+  err = read_dva (dva, endian, data, zio_gb, SPA_GANGBLOCKSIZE);
   if (err)
     {
       grub_free (zio_gb);
@@ -501,20 +1024,13 @@ zio_read_data (blkptr_t * bp, grub_zfs_endian_t endian, void *buf,
   /* pick a good dva from the block pointer */
   for (i = 0; i < SPA_DVAS_PER_BP; i++)
     {
-      grub_uint64_t offset, sector;
-
       if (bp->blk_dva[i].dva_word[0] == 0 && bp->blk_dva[i].dva_word[1] == 0)
 	continue;
 
       if ((grub_zfs_to_cpu64 (bp->blk_dva[i].dva_word[1], endian)>>63) & 1)
 	err = zio_read_gang (bp, endian, &bp->blk_dva[i], buf, data);
       else
-	{
-	  /* read in a data block */
-	  offset = dva_get_offset (&bp->blk_dva[i], endian);
-	  sector = DVA_OFFSET_TO_PHYS_SECTOR (offset);
-	  err = grub_disk_read (data->disk, sector, 0, psize, buf); 
-	}
+	err = read_dva (&bp->blk_dva[i], endian, data, buf, psize);
       if (!err)
 	return GRUB_ERR_NONE;
       grub_errno = GRUB_ERR_NONE;
@@ -835,7 +1351,7 @@ zap_leaf_lookup (zap_leaf_phys_t * l, grub_zfs_endian_t endian,
     return grub_error (GRUB_ERR_BAD_FS, "invalid leaf magic");
 
   for (chunk = grub_zfs_to_cpu16 (l->l_hash[LEAF_HASH (blksft, h)], endian);
-       chunk != CHAIN_END; chunk = le->le_next)
+       chunk != CHAIN_END; chunk = grub_zfs_to_cpu16 (le->le_next, endian))
     {
 
       if (chunk >= ZAP_LEAF_NUMCHUNKS (blksft))
@@ -859,7 +1375,8 @@ zap_leaf_lookup (zap_leaf_phys_t * l, grub_zfs_endian_t endian,
 	{
 	  struct zap_leaf_array *la;
 
-	  if (le->le_int_size != 8 || le->le_value_length != 1)
+	  if (le->le_int_size != 8 || grub_zfs_to_cpu16 (le->le_value_length,
+							 endian) != 1)
 	    return grub_error (GRUB_ERR_BAD_FS, "invalid leaf chunk entry");
 
 	  /* get the uint64_t property value */
@@ -877,9 +1394,9 @@ zap_leaf_lookup (zap_leaf_phys_t * l, grub_zfs_endian_t endian,
 
 /* Verify if this is a fat zap header block */
 static grub_err_t
-zap_verify (zap_phys_t *zap)
+zap_verify (zap_phys_t *zap, grub_zfs_endian_t endian)
 {
-  if (zap->zap_magic != (grub_uint64_t) ZAP_MAGIC)
+  if (grub_zfs_to_cpu64 (zap->zap_magic, endian) != (grub_uint64_t) ZAP_MAGIC)
     return grub_error (GRUB_ERR_BAD_FS, "bad ZAP magic");
 
   if (zap->zap_flags != 0)
@@ -907,7 +1424,7 @@ fzap_lookup (dnode_end_t * zap_dnode, zap_phys_t * zap,
   grub_err_t err;
   grub_zfs_endian_t leafendian;
 
-  err = zap_verify (zap);
+  err = zap_verify (zap, zap_dnode->endian);
   if (err)
     return err;
 
@@ -918,7 +1435,7 @@ fzap_lookup (dnode_end_t * zap_dnode, zap_phys_t * zap,
     return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, 
 		       "external pointer tables not supported");
   idx = ZAP_HASH_IDX (hash, zap->zap_ptrtbl.zt_shift);
-  blkid = ((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
+  blkid = grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))], zap_dnode->endian);
 
   /* Get the leaf block */
   if ((1U << blksft) < sizeof (zap_leaf_phys_t))
@@ -948,7 +1465,7 @@ fzap_iterate (dnode_end_t * zap_dnode, zap_phys_t * zap,
   grub_err_t err;
   grub_zfs_endian_t endian;
 
-  if (zap_verify (zap))
+  if (zap_verify (zap, zap_dnode->endian))
     return 0;
 
   /* get block id from index */
@@ -966,10 +1483,12 @@ fzap_iterate (dnode_end_t * zap_dnode, zap_phys_t * zap,
     }
   for (idx = 0; idx < (1ULL << zap->zap_ptrtbl.zt_shift); idx++)
     {
-      blkid = ((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
+      blkid = grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))],
+					 zap_dnode->endian);
 
       for (idx2 = 0; idx2 < idx; idx2++)
-	if (blkid == ((grub_uint64_t *) zap)[idx2 + (1 << (blksft - 3 - 1))])
+	if (blkid == grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx2 + (1 << (blksft - 3 - 1))],
+					 zap_dnode->endian))
 	  break;
       if (idx2 != idx)
 	continue;
@@ -1008,8 +1527,11 @@ fzap_iterate (dnode_end_t * zap_dnode, zap_phys_t * zap,
 
 	    buf = grub_malloc (grub_zfs_to_cpu16 (le->le_name_length, endian) 
 			       + 1);
-	    if (zap_leaf_array_get (l, endian, blksft, le->le_name_chunk,
-				    le->le_name_length, buf))
+	    if (zap_leaf_array_get (l, endian, blksft,
+				    grub_zfs_to_cpu16 (le->le_name_chunk,
+						       endian),
+				    grub_zfs_to_cpu16 (le->le_name_length,
+						       endian), buf))
 	      {
 		grub_free (buf);
 		continue;
@@ -1021,7 +1543,9 @@ fzap_iterate (dnode_end_t * zap_dnode, zap_phys_t * zap,
 	      continue;
 
 	    /* get the uint64_t property value */
-	    la = &ZAP_LEAF_CHUNK (l, blksft, le->le_value_chunk).l_array;
+	    la = &ZAP_LEAF_CHUNK (l, blksft,
+				  grub_zfs_to_cpu16 (le->le_value_chunk,
+						     endian)).l_array;
 	    val = grub_be_to_cpu64 (la->la_array64);
 	    if (hook (buf, val))
 	      return 1;
@@ -1316,19 +1840,18 @@ dnode_get_path (dnode_end_t * mdn, const char *path_in, dnode_end_t * dn,
 	break;
 
       *path = ch;
-      if (((grub_zfs_to_cpu64(((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_mode, dnode_path->dn.endian) >> 12) & 0xf) == 0xa)
+      if (dnode_path->dn.dn.dn_bonustype == DMU_OT_ZNODE
+	  && ((grub_zfs_to_cpu64(((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_mode, dnode_path->dn.endian) >> 12) & 0xf) == 0xa)
 	{
 	  char *sym_value;
-	  grub_size_t avail_in_dnode;
 	  grub_size_t sym_sz;
 	  int free_symval = 0;
 	  char *oldpath = path, *oldpathbuf = path_buf;
 	  sym_value = ((char *) DN_BONUS (&dnode_path->dn.dn) + sizeof (struct znode_phys));
-	  avail_in_dnode = (char *) (&dnode_path->dn + 1) - sym_value;
 
 	  sym_sz = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_size, dnode_path->dn.endian);
 
-	  if (sym_sz > avail_in_dnode - 8)
+	  if (dnode_path->dn.dn.dn_flags & 1)
 	    {
 	      grub_size_t block;
 	      grub_size_t blksz;
@@ -1382,6 +1905,62 @@ dnode_get_path (dnode_end_t * mdn, const char *path_in, dnode_end_t * dn,
 	      grub_free (dn_new);
 	    }
 	}
+      if (dnode_path->dn.dn.dn_bonustype == DMU_OT_SA)
+	{
+	  void *sahdrp;
+	  int hdrsize;
+	  
+	  if (dnode_path->dn.dn.dn_bonuslen != 0)
+	    {
+	      sahdrp = DN_BONUS (&dnode_path->dn.dn);
+	    }
+	  else if (dnode_path->dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR)
+	    {
+	      blkptr_t *bp = &dnode_path->dn.dn.dn_spill;
+	      
+	      err = zio_read (bp, dnode_path->dn.endian, &sahdrp, NULL, data);
+	      if (err)
+		return err;
+	    }
+	  else
+	    {
+	      return grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt");
+	    }
+
+	  hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
+
+	  if (((grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_TYPE_OFFSET), dnode_path->dn.endian) >> 12) & 0xf) == 0xa)
+	    {
+	      char *sym_value = (char *) sahdrp + hdrsize + SA_SYMLINK_OFFSET;
+	      grub_size_t sym_sz = 
+		grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET), dnode_path->dn.endian);
+	      char *oldpath = path, *oldpathbuf = path_buf;
+	      path = path_buf = grub_malloc (sym_sz + grub_strlen (oldpath) + 1);
+	      if (!path_buf)
+		{
+		  grub_free (oldpathbuf);
+		  return grub_errno;
+		}
+	      grub_memcpy (path, sym_value, sym_sz);
+	      path [sym_sz] = 0;
+	      grub_memcpy (path + grub_strlen (path), oldpath, 
+			   grub_strlen (oldpath) + 1);
+	      
+	      grub_free (oldpathbuf);
+	      if (path[0] != '/')
+		{
+		  dn_new = dnode_path;
+		  dnode_path = dn_new->next;
+		  grub_free (dn_new);
+		}
+	      else while (dnode_path != root)
+		{
+		  dn_new = dnode_path;
+		  dnode_path = dn_new->next;
+		  grub_free (dn_new);
+		}
+	    }
+	}
     }
 
   if (!err)
@@ -1682,11 +2261,12 @@ dnode_get_fullpath (const char *fullpath, dnode_end_t * mdn,
  */
 
 static int
-nvlist_find_value (char *nvlist, char *name, int valtype, char **val,
+nvlist_find_value (const char *nvlist, const char *name,
+		   int valtype, char **val,
 		   grub_size_t *size_out, grub_size_t *nelm_out)
 {
   int name_len, type, encode_size;
-  char *nvpair, *nvp_name;
+  const char *nvpair, *nvp_name;
 
   /* Verify if the 1st and 2nd byte in the nvlist are valid. */
   /* NOTE: independently of what endianness header announces all 
@@ -1728,7 +2308,7 @@ nvlist_find_value (char *nvlist, char *name, int valtype, char **val,
 
       if ((grub_strncmp (nvp_name, name, name_len) == 0) && type == valtype)
 	{
-	  *val = nvpair;
+	  *val = (char *) nvpair;
 	  *size_out = encode_size;
 	  if (nelm_out)
 	    *nelm_out = nelm;
@@ -1741,7 +2321,8 @@ nvlist_find_value (char *nvlist, char *name, int valtype, char **val,
 }
 
 int
-grub_zfs_nvlist_lookup_uint64 (char *nvlist, char *name, grub_uint64_t * out)
+grub_zfs_nvlist_lookup_uint64 (const char *nvlist, const char *name,
+			       grub_uint64_t * out)
 {
   char *nvpair;
   grub_size_t size;
@@ -1761,7 +2342,7 @@ grub_zfs_nvlist_lookup_uint64 (char *nvlist, char *name, grub_uint64_t * out)
 }
 
 char *
-grub_zfs_nvlist_lookup_string (char *nvlist, char *name)
+grub_zfs_nvlist_lookup_string (const char *nvlist, const char *name)
 {
   char *nvpair;
   char *ret;
@@ -1789,7 +2370,7 @@ grub_zfs_nvlist_lookup_string (char *nvlist, char *name)
 }
 
 char *
-grub_zfs_nvlist_lookup_nvlist (char *nvlist, char *name)
+grub_zfs_nvlist_lookup_nvlist (const char *nvlist, const char *name)
 {
   char *nvpair;
   char *ret;
@@ -1810,21 +2391,37 @@ grub_zfs_nvlist_lookup_nvlist (char *nvlist, char *name)
 }
 
 int
-grub_zfs_nvlist_lookup_nvlist_array_get_nelm (char *nvlist, char *name)
+grub_zfs_nvlist_lookup_nvlist_array_get_nelm (const char *nvlist,
+					      const char *name)
 {
   char *nvpair;
   grub_size_t nelm, size;
   int found;
 
-  found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair,
+  found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST_ARRAY, &nvpair,
 			     &size, &nelm);
   if (! found)
     return -1;
   return nelm;
 }
 
+static int
+get_nvlist_size (const char *beg, const char *limit)
+{
+  const char *ptr;
+  grub_uint32_t encode_size;
+  
+  ptr = beg + 8;
+
+  while (ptr < limit
+	 && (encode_size = grub_be_to_cpu32 (*(grub_uint32_t *) ptr)))
+    ptr += encode_size;	/* goto the next nvpair */
+  ptr += 8;      
+  return (ptr > limit) ? -1 : (ptr - beg);
+}
+
 char *
-grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name,
+grub_zfs_nvlist_lookup_nvlist_array (const char *nvlist, const char *name,
 				     grub_size_t index)
 {
   char *nvpair, *nvpairptr;
@@ -1833,8 +2430,9 @@ grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name,
   grub_size_t size;
   unsigned i;
   grub_size_t nelm;
+  int elemsize = 0;
 
-  found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair,
+  found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST_ARRAY, &nvpair,
 			     &size, &nelm);
   if (!found)
     return 0;
@@ -1848,161 +2446,58 @@ grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name,
 
   for (i = 0; i < index; i++)
     {
-      grub_uint32_t encode_size;
+      int r;
+      r = get_nvlist_size (nvpairptr, nvpair + size);
 
-      /* skip the header, nvl_version, and nvl_nvflag */
-      nvpairptr = nvpairptr + 4 * 2;
-
-      while (nvpairptr < nvpair + size
-	     && (encode_size = grub_be_to_cpu32 (*(grub_uint32_t *) nvpairptr)))
-	nvlist += encode_size;	/* goto the next nvpair */
-
-      nvlist = nvlist + 4 * 2;	/* skip the ending 2 zeros - 8 bytes */
+      if (r < 0)
+	{
+	  grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array");
+	  return NULL;
+	}
+      nvpairptr += r;
     }
 
-  if (nvpairptr >= nvpair + size
-      || nvpairptr + grub_be_to_cpu32 (*(grub_uint32_t *) (nvpairptr + 4 * 2))
-      >= nvpair + size)
+  elemsize = get_nvlist_size (nvpairptr, nvpair + size);
+
+  if (elemsize < 0)
     {
       grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array");
       return 0;
     }
 
-  ret = grub_zalloc (grub_be_to_cpu32 (*(grub_uint32_t *) (nvpairptr + 4 * 2))
-		     + 3 * sizeof (grub_uint32_t));
+  ret = grub_zalloc (elemsize + sizeof (grub_uint32_t));
   if (!ret)
     return 0;
   grub_memcpy (ret, nvlist, sizeof (grub_uint32_t));
 
-  grub_memcpy (ret + sizeof (grub_uint32_t), nvpairptr, size);
+  grub_memcpy (ret + sizeof (grub_uint32_t), nvpairptr, elemsize);
   return ret;
 }
 
-static grub_err_t
-zfs_fetch_nvlist (struct grub_zfs_data * data, char **nvlist)
+static void
+unmount_device (struct grub_zfs_device_desc *desc)
 {
-  grub_err_t err;
-
-  *nvlist = grub_malloc (VDEV_PHYS_SIZE);
-  /* Read in the vdev name-value pair list (112K). */
-  err = grub_disk_read (data->disk, data->vdev_phys_sector, 0,
-			VDEV_PHYS_SIZE, *nvlist);
-  if (err)
+  unsigned i;
+  switch (desc->type)
     {
-      grub_free (*nvlist);
-      *nvlist = 0;
-      return err;
+    case DEVICE_LEAF:
+      if (!desc->original && desc->dev)
+	grub_device_close (desc->dev);
+      return;
+    case DEVICE_RAIDZ:
+    case DEVICE_MIRROR:
+      for (i = 0; i < desc->n_children; i++)
+	unmount_device (&desc->children[i]);
+      return;
     }
-  return GRUB_ERR_NONE;
-}
-
-/*
- * Check the disk label information and retrieve needed vdev name-value pairs.
- *
- */
-static grub_err_t
-check_pool_label (struct grub_zfs_data *data)
-{
-  grub_uint64_t pool_state, txg = 0;
-  char *nvlist;
-#if 0
-  char *nv;
-#endif
-  grub_uint64_t diskguid;
-  grub_uint64_t version;
-  int found;
-  grub_err_t err;
-
-  err = zfs_fetch_nvlist (data, &nvlist);
-  if (err)
-    return err;
-
-  grub_dprintf ("zfs", "check 2 passed\n");
-
-  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_STATE,
-					 &pool_state);
-  if (! found)
-    {
-      grub_free (nvlist);
-      if (! grub_errno)
-	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_STATE " not found");
-      return grub_errno;
-    }
-  grub_dprintf ("zfs", "check 3 passed\n");
-
-  if (pool_state == POOL_STATE_DESTROYED)
-    {
-      grub_free (nvlist);
-      return grub_error (GRUB_ERR_BAD_FS, "zpool is marked as destroyed");
-    }
-  grub_dprintf ("zfs", "check 4 passed\n");
-
-  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_TXG, &txg);
-  if (!found)
-    {
-      grub_free (nvlist);
-      if (! grub_errno)
-	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_TXG " not found");
-      return grub_errno;
-    }
-  grub_dprintf ("zfs", "check 6 passed\n");
-
-  /* not an active device */
-  if (txg == 0)
-    {
-      grub_free (nvlist);
-      return grub_error (GRUB_ERR_BAD_FS, "zpool isn't active");
-    }
-  grub_dprintf ("zfs", "check 7 passed\n");
-
-  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_VERSION,
-					 &version);
-  if (! found)
-    {
-      grub_free (nvlist);
-      if (! grub_errno)
-	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_VERSION " not found");
-      return grub_errno;
-    }
-  grub_dprintf ("zfs", "check 8 passed\n");
-
-  if (version > SPA_VERSION)
-    {
-      grub_free (nvlist);
-      return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
-			 "too new version %llu > %llu",
-			 (unsigned long long) version,
-			 (unsigned long long) SPA_VERSION);
-    }
-  grub_dprintf ("zfs", "check 9 passed\n");
-#if 0
-  if (nvlist_lookup_value (nvlist, ZPOOL_CONFIG_VDEV_TREE, &nv,
-			   DATA_TYPE_NVLIST, NULL))
-    {
-      grub_free (vdev);
-      return (GRUB_ERR_BAD_FS);
-    }
-  grub_dprintf ("zfs", "check 10 passed\n");
-#endif
-
-  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_GUID, &diskguid);
-  if (! found)
-    {
-      grub_free (nvlist);
-      if (! grub_errno)
-	grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_GUID " not found");
-      return grub_errno;
-    }
-  grub_dprintf ("zfs", "check 11 passed\n");
-
-  grub_free (nvlist);
-
-  return GRUB_ERR_NONE;
 }
 
 static void
 zfs_unmount (struct grub_zfs_data *data)
 {
+  unsigned i;
+  for (i = 0; i < data->n_devices_attached; i++)
+    unmount_device (&data->devices_attached[i]);
   grub_free (data->dnode_buf);
   grub_free (data->dnode_mdn);
   grub_free (data->file_buf);
@@ -2018,13 +2513,11 @@ static struct grub_zfs_data *
 zfs_mount (grub_device_t dev)
 {
   struct grub_zfs_data *data = 0;
-  int label = 0;
-  uberblock_phys_t *ub_array, *ubbest = NULL;
-  vdev_boot_header_t *bh;
-  void *osp = 0;
-  grub_size_t ospsize;
   grub_err_t err;
-  int vdevnum;
+  objset_phys_t *osp = 0;
+  grub_size_t ospsize;
+  grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN;
+  uberblock_t *ub;
 
   if (! dev->disk)
     {
@@ -2032,119 +2525,56 @@ zfs_mount (grub_device_t dev)
       return 0;
     }
 
-  data = grub_malloc (sizeof (*data));
+  data = grub_zalloc (sizeof (*data));
   if (!data)
     return 0;
-  grub_memset (data, 0, sizeof (*data));
 #if 0
   /* if it's our first time here, zero the best uberblock out */
   if (data->best_drive == 0 && data->best_part == 0 && find_best_root)
     grub_memset (&current_uberblock, 0, sizeof (uberblock_t));
 #endif
 
-  data->disk = dev->disk;
-
-  ub_array = grub_malloc (VDEV_UBERBLOCK_RING);
-  if (!ub_array)
+  data->n_devices_allocated = 16;
+  data->devices_attached = grub_malloc (sizeof (data->devices_attached[0])
+					* data->n_devices_allocated);
+  data->n_devices_attached = 0;
+  err = scan_disk (dev, data, 1);
+  if (err)
     {
       zfs_unmount (data);
-      return 0;
+      return NULL;
     }
 
-  bh = grub_malloc (VDEV_BOOT_HEADER_SIZE);
-  if (!bh)
+  ub = &(data->current_uberblock);
+  ub_endian = (grub_zfs_to_cpu64 (ub->ub_magic, 
+				  LITTLE_ENDIAN) == UBERBLOCK_MAGIC 
+	       ? LITTLE_ENDIAN : BIG_ENDIAN);
+
+  err = zio_read (&ub->ub_rootbp, ub_endian,
+		  (void **) &osp, &ospsize, data);
+  if (err)
     {
       zfs_unmount (data);
-      grub_free (ub_array);
-      return 0;
+      return NULL;
     }
 
-  vdevnum = VDEV_LABELS;
-
-  /* Don't check back labels on CDROM.  */
-  if (grub_disk_get_size (dev->disk) == GRUB_DISK_SIZE_UNKNOWN)
-    vdevnum = VDEV_LABELS / 2;
-
-  for (label = 0; ubbest == NULL && label < vdevnum; label++)
+  if (ospsize < OBJSET_PHYS_SIZE_V14)
     {
-      grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN;
-      grub_dprintf ("zfs", "label %d\n", label);
-
-      data->vdev_phys_sector
-	= label * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT)
-	+ ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SPA_MINBLOCKSHIFT)
-	+ (label < VDEV_LABELS / 2 ? 0 : grub_disk_get_size (dev->disk)
-	   - VDEV_LABELS * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT));
-
-      /* Read in the uberblock ring (128K). */
-      err = grub_disk_read (data->disk, data->vdev_phys_sector
-			    + (VDEV_PHYS_SIZE >> SPA_MINBLOCKSHIFT),
-			    0, VDEV_UBERBLOCK_RING, (char *) ub_array);
-      if (err)
-	{
-	  grub_errno = GRUB_ERR_NONE;
-	  continue;
-	}
-      grub_dprintf ("zfs", "label ok %d\n", label);
-
-      ubbest = find_bestub (ub_array, data->vdev_phys_sector);
-      if (!ubbest)
-	{
-	  grub_dprintf ("zfs", "No uberblock found\n");
-	  grub_errno = GRUB_ERR_NONE;
-	  continue;
-	}
-      ub_endian = (grub_zfs_to_cpu64 (ubbest->ubp_uberblock.ub_magic, 
-				     LITTLE_ENDIAN) == UBERBLOCK_MAGIC 
-		   ? LITTLE_ENDIAN : BIG_ENDIAN);
-      err = zio_read (&ubbest->ubp_uberblock.ub_rootbp, 
-		      ub_endian,
-		      &osp, &ospsize, data);
-      if (err)
-	{
-	  grub_dprintf ("zfs", "couldn't zio_read\n"); 
-	  grub_errno = GRUB_ERR_NONE;
-	  continue;
-	}
-
-      if (ospsize < OBJSET_PHYS_SIZE_V14)
-	{
-	  grub_dprintf ("zfs", "osp too small\n"); 
-	  grub_free (osp);
-	  continue;
-	}
-      grub_dprintf ("zfs", "ubbest %p\n", ubbest);
-
-      err = check_pool_label (data);
-      if (err)
-	{
-	  grub_errno = GRUB_ERR_NONE;
-	  continue;
-	}
-#if 0
-      if (find_best_root &&
-	  vdev_uberblock_compare (&ubbest->ubp_uberblock,
-				  &(current_uberblock)) <= 0)
-	continue;
-#endif
-      /* Got the MOS. Save it at the memory addr MOS. */
-      grub_memmove (&(data->mos.dn), &((objset_phys_t *) osp)->os_meta_dnode,
-		    DNODE_SIZE);
-      data->mos.endian = (grub_zfs_to_cpu64 (ubbest->ubp_uberblock.ub_rootbp.blk_prop, ub_endian) >> 63) & 1;
-      grub_memmove (&(data->current_uberblock),
-		    &ubbest->ubp_uberblock, sizeof (uberblock_t));
-      grub_free (ub_array);
-      grub_free (bh);
+      grub_error (GRUB_ERR_BAD_FS, "OSP too small");
       grub_free (osp);
-      return data;  
+      zfs_unmount (data);
+      return NULL;
     }
-  grub_error (GRUB_ERR_BAD_FS, "couldn't find a valid label");
-  zfs_unmount (data);
-  grub_free (ub_array);
-  grub_free (bh);
+
+  /* Got the MOS. Save it at the memory addr MOS. */
+  grub_memmove (&(data->mos.dn), &osp->os_meta_dnode, DNODE_SIZE);
+  data->mos.endian = (grub_zfs_to_cpu64 (ub->ub_rootbp.blk_prop,
+					 ub_endian) >> 63) & 1;
   grub_free (osp);
 
-  return 0;
+  data->mounted = 1;
+
+  return data;
 }
 
 grub_err_t
@@ -2156,7 +2586,7 @@ grub_zfs_fetch_nvlist (grub_device_t dev, char **nvlist)
   zfs = zfs_mount (dev);
   if (!zfs)
     return grub_errno;
-  err = zfs_fetch_nvlist (zfs, nvlist);
+  err = zfs_fetch_nvlist (zfs->device_original, nvlist);
   zfs_unmount (zfs);
   return err;
 }
@@ -2172,7 +2602,7 @@ zfs_label (grub_device_t device, char **label)
   if (! data)
     return grub_errno;
 
-  err = zfs_fetch_nvlist (data, &nvlist);
+  err = zfs_fetch_nvlist (data->device_original, &nvlist);
   if (err)      
     {
       zfs_unmount (data);
@@ -2188,11 +2618,7 @@ zfs_label (grub_device_t device, char **label)
 static grub_err_t 
 zfs_uuid (grub_device_t device, char **uuid)
 {
-  char *nvlist;
-  int found;
   struct grub_zfs_data *data;
-  grub_uint64_t guid;
-  grub_err_t err;
 
   *uuid = 0;
 
@@ -2200,24 +2626,36 @@ zfs_uuid (grub_device_t device, char **uuid)
   if (! data)
     return grub_errno;
 
-  err = zfs_fetch_nvlist (data, &nvlist);
-  if (err)
-    {
-      zfs_unmount (data);
-      return err;
-    }
-
-  found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_GUID, &guid);
-  if (! found)
-    return grub_errno;
-  grub_free (nvlist);
-  *uuid = grub_xasprintf ("%016llx", (long long unsigned) guid);
+  *uuid = grub_xasprintf ("%016llx", (long long unsigned) data->guid);
   zfs_unmount (data);
   if (! *uuid)
     return grub_errno;
   return GRUB_ERR_NONE;
 }
 
+static grub_err_t 
+zfs_mtime (grub_device_t device, grub_int32_t *mt)
+{
+  struct grub_zfs_data *data;
+  grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN;
+  uberblock_t *ub;
+
+  *mt = 0;
+
+  data = zfs_mount (device);
+  if (! data)
+    return grub_errno;
+
+  ub = &(data->current_uberblock);
+  ub_endian = (grub_zfs_to_cpu64 (ub->ub_magic, 
+				  LITTLE_ENDIAN) == UBERBLOCK_MAGIC 
+	       ? LITTLE_ENDIAN : BIG_ENDIAN);
+
+  *mt = grub_zfs_to_cpu64 (ub->ub_timestamp, ub_endian);
+  zfs_unmount (data);
+  return GRUB_ERR_NONE;
+}
+
 /*
  * zfs_open() locates a file in the rootpool by following the
  * MOS and places the dnode of the file in the memory address DNODE.
@@ -2284,12 +2722,14 @@ grub_zfs_open (struct grub_file *file, const char *fsfilename)
 	}
 
       hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
-      file->size = *(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET);
+      file->size = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET), data->dnode.endian);
     }
-  else
+  else if (data->dnode.dn.dn_bonustype == DMU_OT_ZNODE)
     {
       file->size = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&data->dnode.dn))->zp_size, data->dnode.endian);
     }
+  else
+    return grub_error (GRUB_ERR_BAD_FS, "bad bonus type");
 
   file->data = data;
   file->offset = 0;
@@ -2448,8 +2888,39 @@ fill_fs_info (struct grub_dirhook_info *info,
       return;
     }
   
-  info->mtimeset = 1;
-  info->mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian);
+  if (dn.dn.dn_bonustype == DMU_OT_SA)
+    {
+      void *sahdrp;
+      int hdrsize;
+
+      if (dn.dn.dn_bonuslen != 0)
+	{
+	  sahdrp = (sa_hdr_phys_t *) DN_BONUS (&dn.dn);
+	}
+      else if (dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR)
+	{
+	  blkptr_t *bp = &dn.dn.dn_spill;
+
+	  err = zio_read (bp, dn.endian, &sahdrp, NULL, data);
+	  if (err)
+	    return;
+	}
+      else
+	{
+	  grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt");
+	  return;
+	}
+
+      hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
+      info->mtimeset = 1;
+      info->mtime = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_MTIME_OFFSET), dn.endian);
+    }
+
+  if (dn.dn.dn_bonustype == DMU_OT_ZNODE)
+    {
+      info->mtimeset = 1;
+      info->mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian);
+    }
   return;
 }
 
@@ -2473,10 +2944,47 @@ grub_zfs_dir (grub_device_t device, const char *path,
     grub_memset (&info, 0, sizeof (info));
 
     dnode_get (&(data->mdn), val, 0, &dn, data);
-    info.mtimeset = 1;
-    info.mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian);
-    info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS);
-    grub_dprintf ("zfs", "type=%d, name=%s\n", 
+
+    if (dn.dn.dn_bonustype == DMU_OT_SA)
+      {
+	void *sahdrp;
+	int hdrsize;
+
+	if (dn.dn.dn_bonuslen != 0)
+	  {
+	    sahdrp = (sa_hdr_phys_t *) DN_BONUS (&data->dnode.dn);
+	  }
+	else if (dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR)
+	  {
+	    blkptr_t *bp = &dn.dn.dn_spill;
+
+	    err = zio_read (bp, dn.endian, &sahdrp, NULL, data);
+	    if (err)
+	      {
+		grub_print_error ();
+		return 0;
+	      }
+	  }
+	else
+	  {
+	    grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt");
+	    grub_print_error ();
+	    return 0;
+	  }
+
+	hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp));
+	info.mtimeset = 1;
+	info.mtime = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_MTIME_OFFSET), dn.endian);
+      }
+    
+    if (dn.dn.dn_bonustype == DMU_OT_ZNODE)
+      {	
+	info.mtimeset = 1;
+	info.mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0],
+					dn.endian);
+      }
+	info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS);
+	grub_dprintf ("zfs", "type=%d, name=%s\n", 
 		  (int)dn.dn.dn_type, (char *)name);
     return hook (name, &info);
   }
@@ -2589,12 +3097,13 @@ static struct grub_fs grub_zfs_fs = {
   .close = grub_zfs_close,
   .label = zfs_label,
   .uuid = zfs_uuid,
-  .mtime = 0,
+  .mtime = zfs_mtime,
   .next = 0
 };
 
 GRUB_MOD_INIT (zfs)
 {
+  COMPILE_TIME_ASSERT (sizeof (zap_leaf_chunk_t) == ZAP_LEAF_CHUNKSIZE);
   grub_fs_register (&grub_zfs_fs);
 #ifndef GRUB_UTIL
   my_mod = mod;
diff --git a/grub-core/fs/zfs/zfsinfo.c b/grub-core/fs/zfs/zfsinfo.c
index 1968ed554..8c073fab5 100644
--- a/grub-core/fs/zfs/zfsinfo.c
+++ b/grub-core/fs/zfs/zfsinfo.c
@@ -141,7 +141,6 @@ print_vdev_info (char *nvlist, int tab)
 	}
       grub_printf ("Mirror VDEV with %d children\n", nelm);
       print_state (nvlist, tab);
-
       for (i = 0; i < nelm; i++)
 	{
 	  char *child;
@@ -161,6 +160,7 @@ print_vdev_info (char *nvlist, int tab)
 
 	  grub_free (child);
 	}
+      return GRUB_ERR_NONE;
     }
 
   print_tabs (tab);
diff --git a/include/grub/zfs/sa_impl.h b/include/grub/zfs/sa_impl.h
index a2b728d37..0845d1290 100644
--- a/include/grub/zfs/sa_impl.h
+++ b/include/grub/zfs/sa_impl.h
@@ -29,6 +29,9 @@ typedef struct sa_hdr_phys {
 } sa_hdr_phys_t;
 
 #define	SA_HDR_SIZE(hdr)	BF32_GET_SB(hdr->sa_layout_info, 10, 16, 3, 0)
+#define	SA_TYPE_OFFSET	0x0
 #define	SA_SIZE_OFFSET	0x8
+#define	SA_MTIME_OFFSET	0x38
+#define SA_SYMLINK_OFFSET 0xa0
 
 #endif	/* _SYS_SA_IMPL_H */
diff --git a/include/grub/zfs/zfs.h b/include/grub/zfs/zfs.h
index 057692573..d7029903a 100644
--- a/include/grub/zfs/zfs.h
+++ b/include/grub/zfs/zfs.h
@@ -28,7 +28,7 @@
 /*
  * On-disk version number.
  */
-#define	SPA_VERSION			28ULL
+#define	SPA_VERSION			33ULL
 
 /*
  * The following are configuration names used in the nvlist describing a pool's
@@ -112,12 +112,14 @@ grub_err_t grub_zfs_fetch_nvlist (grub_device_t dev, char **nvlist);
 grub_err_t grub_zfs_getmdnobj (grub_device_t dev, const char *fsfilename,
 			       grub_uint64_t *mdnobj);
 
-char *grub_zfs_nvlist_lookup_string (char *nvlist, char *name);
-char *grub_zfs_nvlist_lookup_nvlist (char *nvlist, char *name);
-int grub_zfs_nvlist_lookup_uint64 (char *nvlist, char *name,
+char *grub_zfs_nvlist_lookup_string (const char *nvlist, const char *name);
+char *grub_zfs_nvlist_lookup_nvlist (const char *nvlist, const char *name);
+int grub_zfs_nvlist_lookup_uint64 (const char *nvlist, const char *name,
 				   grub_uint64_t *out);
-char *grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name,
+char *grub_zfs_nvlist_lookup_nvlist_array (const char *nvlist,
+					   const char *name,
 					   grub_size_t index);
-int grub_zfs_nvlist_lookup_nvlist_array_get_nelm (char *nvlist, char *name);
+int grub_zfs_nvlist_lookup_nvlist_array_get_nelm (const char *nvlist,
+						  const char *name);
 
 #endif	/* ! GRUB_ZFS_HEADER */
diff --git a/util/grub-fstest.c b/util/grub-fstest.c
index ad64701a2..b6ed2ef0c 100644
--- a/util/grub-fstest.c
+++ b/util/grub-fstest.c
@@ -62,9 +62,9 @@ enum {
   CMD_HEX,
   CMD_CRC,
   CMD_BLOCKLIST,
-  CMD_TESTLOAD
+  CMD_TESTLOAD,
+  CMD_ZFSINFO
 };
-
 #define BUF_SIZE  32256
 
 static grub_disk_addr_t skip, leng;
@@ -354,6 +354,9 @@ fstest (int n, char **args)
     case CMD_LS:
       execute_command ("ls", n, args);
       break;
+    case CMD_ZFSINFO:
+      execute_command ("zfsinfo", n, args);
+      break;
     case CMD_CP:
       cmd_cp (args[0], args[1]);
       break;
@@ -516,6 +519,10 @@ argp_parser (int key, char *arg, struct argp_state *state)
         {
           cmd = CMD_LS;
         }
+      else if (!grub_strcmp (arg, "zfsinfo"))
+        {
+          cmd = CMD_ZFSINFO;
+        }
       else if (!grub_strcmp (arg, "cp"))
 	{
 	  cmd = CMD_CP;