This patch adds a ZFS implementation of the fs_envblk_* functions. These functions will be used to load the grubenv block from a padding area in the label of ZFS. This padding area is protected by an embedded checksum, and multiple copies are stored on each disk. This should provide sufficient reliability for most use cases. Since this area is not part of the block tree, it can be easily modified at boot time with a simple recalculation of the embedded checksum, enabling save_env to work for ZFS boot filesystems.
Note that the open() function is doing the read; this is because the ZFS envblk logic doesn't store the file size, so the only way to retrieve it is to determine the length of the file using strlen. If this is considered too poor of an approach to be acceptable, format changes can still be made to the structure of the padding area. Signed-off-by: Paul Dagnelie <p...@delphix.com> --- grub-core/fs/zfs/zfs.c | 134 ++++++++++++++++++++++++++++++++--- include/grub/zfs/vdev_impl.h | 33 +++++---- 2 files changed, 139 insertions(+), 28 deletions(-) diff --git a/grub-core/fs/zfs/zfs.c b/grub-core/fs/zfs/zfs.c index 2f72e42bf..d741426cd 100644 --- a/grub-core/fs/zfs/zfs.c +++ b/grub-core/fs/zfs/zfs.c @@ -30,6 +30,7 @@ * */ +#include <stddef.h> #include <grub/err.h> #include <grub/file.h> #include <grub/mm.h> @@ -1146,7 +1147,6 @@ scan_disk (grub_device_t dev, struct grub_zfs_data *data, { 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; @@ -1155,13 +1155,6 @@ scan_disk (grub_device_t dev, struct grub_zfs_data *data, 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; @@ -1175,7 +1168,7 @@ scan_disk (grub_device_t dev, struct grub_zfs_data *data, { desc.vdev_phys_sector = label * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT) - + ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SPA_MINBLOCKSHIFT) + + ((VDEV_PAD_SIZE * 2) >> SPA_MINBLOCKSHIFT) + (label < VDEV_LABELS / 2 ? 0 : ALIGN_DOWN (grub_disk_get_size (dev->disk), sizeof (vdev_label_t)) - VDEV_LABELS * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT)); @@ -1184,6 +1177,7 @@ scan_disk (grub_device_t dev, struct grub_zfs_data *data, 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; @@ -1219,12 +1213,10 @@ scan_disk (grub_device_t dev, struct grub_zfs_data *data, 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"); } @@ -3765,6 +3757,60 @@ zfs_mtime (grub_device_t device, grub_int32_t *mt) return GRUB_ERR_NONE; } +static grub_err_t +zfs_devs_read_zbt (struct grub_zfs_data *data, grub_uint64_t offset, char *buf, grub_size_t len) +{ + grub_err_t err = GRUB_ERR_NONE; + zio_cksum_t zc; + unsigned int i; + ZIO_SET_CHECKSUM(&zc, offset, 0, 0, 0); + + for (i = 0; i < data->n_devices_attached; i++) + { + err = grub_disk_read (data->devices_attached[i].dev->disk, + offset >> SPA_MINBLOCKSHIFT, + offset & ((1 << SPA_MINBLOCKSHIFT) - 1), + len, buf); + if (err) + continue; + ZIO_SET_CHECKSUM(&zc, offset, 0, 0, 0); + err = zio_checksum_verify (zc, ZIO_CHECKSUM_LABEL, GRUB_ZFS_LITTLE_ENDIAN, + buf, len); + if (!err) + return GRUB_ERR_NONE; + } + return err; +} + +static grub_err_t +grub_zfs_envblk_open (struct grub_file *file) +{ + grub_err_t err; + struct grub_zfs_data *data; + vdev_boot_envblock_t *vbe; + int l; + + file->offset = 0; + data = zfs_mount (file->device); + file->data = data; + data->file_buf = grub_malloc (sizeof (vdev_boot_envblock_t)); + for (l = 0; l < VDEV_LABELS / 2; l++) + { + grub_uint64_t offset = l * sizeof (vdev_label_t) + offsetof (vdev_label_t, vl_be); + + err = zfs_devs_read_zbt (data, offset, data->file_buf, + sizeof (vdev_boot_envblock_t)); + if (err == GRUB_ERR_NONE) + { + vbe = (vdev_boot_envblock_t *)data->file_buf; + file->size = grub_strlen (vbe->vbe_bootenv); + return err; + } + } + zfs_unmount (data); + return err; +} + /* * zfs_open() locates a file in the rootpool by following the * MOS and places the dnode of the file in the memory address DNODE. @@ -3850,6 +3896,19 @@ grub_zfs_open (struct grub_file *file, const char *fsfilename) return GRUB_ERR_NONE; } +static grub_ssize_t +grub_zfs_envblk_read (grub_file_t file, char *buf, grub_size_t len) +{ + struct grub_zfs_data *data = (struct grub_zfs_data *) file->data; + grub_ssize_t olen = len; + grub_uint64_t offset = file->offset + offsetof (vdev_boot_envblock_t, vbe_bootenv); + + if (len + file->offset > file->size) + olen = file->size - file->offset; + grub_memmove (buf, data->file_buf + offset, olen); + return olen; +} + static grub_ssize_t grub_zfs_read (grub_file_t file, char *buf, grub_size_t len) { @@ -3859,6 +3918,9 @@ grub_zfs_read (grub_file_t file, char *buf, grub_size_t len) grub_size_t read; grub_err_t err; + if (grub_file_envblk (file)) + return grub_zfs_envblk_read (file, buf, len); + /* * If offset is in memory, move it into the buffer provided and return. */ @@ -3924,6 +3986,52 @@ grub_zfs_read (grub_file_t file, char *buf, grub_size_t len) return len; } +static grub_err_t +grub_zfs_envblk_write (struct grub_file *file, char *buf, grub_size_t len) +{ + grub_uint64_t offset = file->offset + offsetof (vdev_boot_envblock_t, vbe_bootenv); + grub_err_t err = GRUB_ERR_NONE; + struct grub_zfs_data *data = file->data; + unsigned int i, l; + zio_cksum_t cksum; + vdev_boot_envblock_t *vbe = (vdev_boot_envblock_t *)data->file_buf; + + if (len + file->offset > file->size) + return GRUB_ERR_OUT_OF_RANGE; + + grub_memmove (data->file_buf + offset, buf, len); + + for (l = 0; l < VDEV_LABELS / 2; l++) + { + offset = l * sizeof (vdev_label_t) + offsetof (vdev_label_t, vl_be); + vbe->vbe_zbt.zec_magic = ZEC_MAGIC; + ZIO_SET_CHECKSUM(&vbe->vbe_zbt.zec_cksum, offset, 0, 0, 0); + vbe->vbe_zbt.zec_magic = ZEC_MAGIC; + zio_checksum_SHA256(vbe, VDEV_PAD_SIZE, GRUB_ZFS_LITTLE_ENDIAN, &cksum); + vbe->vbe_zbt.zec_cksum = cksum; + + for (i = 0; i < data->n_devices_attached; i++) + { + struct grub_zfs_device_desc *desc = &data->devices_attached[i]; + int num_sectors = VDEV_PAD_SIZE >> desc->ashift; + int label_seek = l * sizeof (vdev_label_t) >> desc->ashift; + int j; + + for (j = 0; j < num_sectors; j++) + { + grub_err_t err2; + + err2 = grub_disk_write (desc->dev->disk, label_seek + num_sectors + j, 0, + 1 << desc->ashift, + data->file_buf + (j << desc->ashift)); + if (err2 != GRUB_ERR_NONE) + err = err2; + } + } + } + return err; +} + static grub_err_t grub_zfs_close (grub_file_t file) { @@ -4360,6 +4468,10 @@ static struct grub_fs grub_zfs_fs = { .reserved_first_sector = 1, .blocklist_install = 0, #endif + .fs_envblk_open = grub_zfs_envblk_open, + .fs_envblk_read = grub_zfs_read, + .fs_envblk_write = grub_zfs_envblk_write, + .fs_envblk_close = grub_zfs_close, .next = 0 }; diff --git a/include/grub/zfs/vdev_impl.h b/include/grub/zfs/vdev_impl.h index 9b5f0a7a8..48ec59003 100644 --- a/include/grub/zfs/vdev_impl.h +++ b/include/grub/zfs/vdev_impl.h @@ -23,34 +23,33 @@ #ifndef _SYS_VDEV_IMPL_H #define _SYS_VDEV_IMPL_H -#define VDEV_SKIP_SIZE (8 << 10) -#define VDEV_BOOT_HEADER_SIZE (8 << 10) +#define VDEV_PAD_SIZE (8 << 10) #define VDEV_PHYS_SIZE (112 << 10) #define VDEV_UBERBLOCK_RING (128 << 10) -/* ZFS boot block */ -#define VDEV_BOOT_MAGIC 0x2f5b007b10cULL -#define VDEV_BOOT_VERSION 1 /* version number */ - -typedef struct vdev_boot_header { - grub_uint64_t vb_magic; /* VDEV_BOOT_MAGIC */ - grub_uint64_t vb_version; /* VDEV_BOOT_VERSION */ - grub_uint64_t vb_offset; /* start offset (bytes) */ - grub_uint64_t vb_size; /* size (bytes) */ - char vb_pad[VDEV_BOOT_HEADER_SIZE - 4 * sizeof (grub_uint64_t)]; -} vdev_boot_header_t; - typedef struct vdev_phys { char vp_nvlist[VDEV_PHYS_SIZE - sizeof (zio_eck_t)]; zio_eck_t vp_zbt; } vdev_phys_t; +typedef enum vbe_vers { + VB_RAW, + VB_NVLIST +} vb_evers_t; + +typedef struct vdev_boot_envblock { + grub_uint64_t vbe_version; + char vbe_bootenv[VDEV_PAD_SIZE - sizeof (grub_uint64_t) - + sizeof (zio_eck_t)]; + zio_eck_t vbe_zbt; +} vdev_boot_envblock_t; + typedef struct vdev_label { - char vl_pad[VDEV_SKIP_SIZE]; /* 8K */ - vdev_boot_header_t vl_boot_header; /* 8K */ + char vl_pad1[VDEV_PAD_SIZE]; /* 8K */ + vdev_boot_envblock_t vl_be; /* 8K */ vdev_phys_t vl_vdev_phys; /* 112K */ char vl_uberblock[VDEV_UBERBLOCK_RING]; /* 128K */ -} vdev_label_t; /* 256K total */ +} vdev_label_t; /* 256K total */ /* * Size and offset of embedded boot loader region on each label. -- 2.19.0 _______________________________________________ Grub-devel mailing list Grub-devel@gnu.org https://lists.gnu.org/mailman/listinfo/grub-devel