D13784.id40220.diff
No OneTemporary
Actions

Size

57 KB

Referenced Files

None

Subscribers

None

D13784.id40220.diff
View Options

	Index: stand/common/disk.h
	===================================================================
	--- stand/common/disk.h
	+++ stand/common/disk.h
	@@ -81,12 +81,9 @@
	#ifndef _DISK_H
	#define _DISK_H

	-struct disk_devdesc
	-{
	- struct devsw *d_dev;
	- int d_type;
	- int d_unit;
	- void *d_opendata;
	+/* Note: Must match the 'struct devdesc' in stand.h */
	+struct disk_devdesc {
	+ struct devdesc dd;
	int d_slice;
	int d_partition;
	uint64_t d_offset;
	Index: stand/common/disk.c
	===================================================================
	--- stand/common/disk.c
	+++ stand/common/disk.c
	@@ -86,7 +86,7 @@
	struct open_disk *od;

	dev = (struct disk_devdesc *)d;
	- od = (struct open_disk *)dev->d_opendata;
	+ od = (struct open_disk *)dev->dd.d_opendata;

	/*
	* The strategy function assumes the offset is in units of 512 byte
	@@ -98,7 +98,7 @@
	* As the GPT backup partition is located at the end of the disk,
	* to avoid reading past disk end, flag bcache not to use RA.
	*/
	- return (dev->d_dev->dv_strategy(dev, F_READ \| F_NORA, offset,
	+ return (dev->dd.d_dev->dv_strategy(dev, F_READ \| F_NORA, offset,
	blocks * od->sectorsize, (char *)buf, NULL));
	}

	@@ -114,7 +114,7 @@
	int res;

	pa = (struct print_args *)arg;
	- od = (struct open_disk *)pa->dev->d_opendata;
	+ od = (struct open_disk *)pa->dev->dd.d_opendata;
	sprintf(line, " %s%s: %s", pa->prefix, pname,
	parttype2str(part->type));
	if (pa->verbose)
	@@ -127,8 +127,8 @@
	res = 0;
	if (part->type == PART_FREEBSD) {
	/* Open slice with BSD label */
	- dev.d_dev = pa->dev->d_dev;
	- dev.d_unit = pa->dev->d_unit;
	+ dev.dd.d_dev = pa->dev->dd.d_dev;
	+ dev.dd.d_unit = pa->dev->dd.d_unit;
	dev.d_slice = part->index;
	dev.d_partition = -1;
	if (disk_open(&dev, part->end - part->start + 1,
	@@ -158,7 +158,7 @@
	struct print_args pa;

	/* Disk should be opened */
	- od = (struct open_disk *)dev->d_opendata;
	+ od = (struct open_disk *)dev->dd.d_opendata;
	pa.dev = dev;
	pa.prefix = prefix;
	pa.verbose = verbose;
	@@ -171,8 +171,8 @@
	struct open_disk *od;
	int ret;

	- od = (struct open_disk *)dev->d_opendata;
	- ret = dev->d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
	+ od = (struct open_disk *)dev->dd.d_opendata;
	+ ret = dev->dd.d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
	blocks * od->sectorsize, buf, NULL);

	return (ret);
	@@ -184,8 +184,8 @@
	struct open_disk *od;
	int ret;

	- od = (struct open_disk *)dev->d_opendata;
	- ret = dev->d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
	+ od = (struct open_disk *)dev->dd.d_opendata;
	+ ret = dev->dd.d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
	blocks * od->sectorsize, buf, NULL);

	return (ret);
	@@ -194,7 +194,7 @@
	int
	disk_ioctl(struct disk_devdesc dev, u_long cmd, void data)
	{
	- struct open_disk *od = dev->d_opendata;
	+ struct open_disk *od = dev->dd.d_opendata;

	if (od == NULL)
	return (ENOTTY);
	@@ -238,7 +238,7 @@
	DEBUG("no memory");
	return (ENOMEM);
	}
	- dev->d_opendata = od;
	+ dev->dd.d_opendata = od;
	od->entrysize = 0;
	od->mediasize = mediasize;
	od->sectorsize = sectorsize;
	@@ -348,7 +348,7 @@
	{
	struct open_disk *od;

	- od = (struct open_disk *)dev->d_opendata;
	+ od = (struct open_disk *)dev->dd.d_opendata;
	DEBUG("%s closed => %p", disk_fmtdev(dev), od);
	ptable_close(od->table);
	free(od);
	@@ -361,7 +361,7 @@
	static char buf[128];
	char *cp;

	- cp = buf + sprintf(buf, "%s%d", dev->d_dev->dv_name, dev->d_unit);
	+ cp = buf + sprintf(buf, "%s%d", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	if (dev->d_slice >= 0) {
	#ifdef LOADER_GPT_SUPPORT
	if (dev->d_partition == 255) {
	@@ -423,7 +423,7 @@

	if (cp != '\0' && cp != ':')
	return (EINVAL);
	- dev->d_unit = unit;
	+ dev->dd.d_unit = unit;
	dev->d_slice = slice;
	dev->d_partition = partition;
	if (path != NULL)
	Index: stand/efi/boot1/boot1.c
	===================================================================
	--- stand/efi/boot1/boot1.c
	+++ stand/efi/boot1/boot1.c
	@@ -54,8 +54,6 @@
	static EFI_GUID DevicePathGUID = DEVICE_PATH_PROTOCOL;
	static EFI_GUID LoadedImageGUID = LOADED_IMAGE_PROTOCOL;
	static EFI_GUID ConsoleControlGUID = EFI_CONSOLE_CONTROL_PROTOCOL_GUID;
	-static EFI_GUID FreeBSDBootVarGUID = FREEBSD_BOOT_VAR_GUID;
	-static EFI_GUID GlobalBootVarGUID = UEFI_BOOT_VAR_GUID;

	/*
	* Provide Malloc / Free backed by EFIs AllocatePool / FreePool which ensures
	@@ -80,42 +78,6 @@
	(void)BS->FreePool(buf);
	}

	-static EFI_STATUS
	-efi_getenv(EFI_GUID g, const char v, void data, size_t len)
	-{
	- size_t ul;
	- CHAR16 *uv;
	- UINT32 attr;
	- UINTN dl;
	- EFI_STATUS rv;
	-
	- uv = NULL;
	- if (utf8_to_ucs2(v, &uv, &ul) != 0)
	- return (EFI_OUT_OF_RESOURCES);
	- dl = *len;
	- rv = RS->GetVariable(uv, g, &attr, &dl, data);
	- if (rv == EFI_SUCCESS)
	- *len = dl;
	- free(uv);
	- return (rv);
	-}
	-
	-static EFI_STATUS
	-efi_setenv_freebsd_wcs(const char varname, CHAR16 valstr)
	-{
	- CHAR16 *var = NULL;
	- size_t len;
	- EFI_STATUS rv;
	-
	- if (utf8_to_ucs2(varname, &var, &len) != 0)
	- return (EFI_OUT_OF_RESOURCES);
	- rv = RS->SetVariable(var, &FreeBSDBootVarGUID,
	- EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,
	- (ucs2len(valstr) + 1) * sizeof(efi_char), valstr);
	- free(var);
	- return (rv);
	-}
	-
	/*
	* nodes_match returns TRUE if the imgpath isn't NULL and the nodes match,
	* FALSE otherwise.
	@@ -505,14 +467,15 @@

	boot_current = 0;
	sz = sizeof(boot_current);
	- efi_getenv(&GlobalBootVarGUID, "BootCurrent", &boot_current, &sz);
	+ efi_global_getenv("BootCurrent", &boot_current, &sz);
	printf(" BootCurrent: %04x\n", boot_current);

	sz = sizeof(boot_order);
	- efi_getenv(&GlobalBootVarGUID, "BootOrder", &boot_order, &sz);
	+ efi_global_getenv("BootOrder", &boot_order, &sz);
	printf(" BootOrder:");
	for (i = 0; i < sz / sizeof(boot_order[0]); i++)
	- printf(" %04x", boot_order[i]);
	+ printf(" %04x%s", boot_order[i],
	+ boot_order[i] == boot_current ? "[*]" : "");
	printf("\n");

	#ifdef TEST_FAILURE
	Index: stand/efi/include/efilib.h
	===================================================================
	--- stand/efi/include/efilib.h
	+++ stand/efi/include/efilib.h
	@@ -59,10 +59,13 @@
	uint32_t pd_unit; /* unit number */
	uint32_t pd_open; /* reference counter */
	void pd_bcache; / buffer cache data */
	+ struct pdinfo pd_parent; / Linked items (eg partitions) */
	+ struct devsw pd_devsw; / Back pointer to devsw */
	} pdinfo_t;

	pdinfo_list_t efiblk_get_pdinfo_list(struct devsw dev);
	pdinfo_t efiblk_get_pdinfo(struct devdesc dev);
	+pdinfo_t *efiblk_get_pdinfo_by_handle(EFI_HANDLE h);

	void efi_get_table(EFI_GUID tbl);

	@@ -106,6 +109,17 @@
	void cpy8to16(const char , CHAR16 , size_t);
	void cpy16to8(const CHAR16 , char , size_t);

	+/*
	+ * Routines for interacting with EFI's env vars in a more unix-like
	+ * way than the standard APIs. In addition, convenience routines for
	+ * the loader setting / getting FreeBSD specific variables.
	+ */
	+
	+EFI_STATUS efi_freebsd_getenv(const char v, void data, __size_t *len);
	+EFI_STATUS efi_getenv(EFI_GUID g, const char v, void data, __size_t len);
	+EFI_STATUS efi_global_getenv(const char v, void data, __size_t *len);
	+EFI_STATUS efi_setenv_freebsd_wcs(const char varname, CHAR16 valstr);
	+
	/* efipart.c */
	int efipart_inithandles(void);

	Index: stand/efi/include/efizfs.h
	===================================================================
	--- stand/efi/include/efizfs.h
	+++ stand/efi/include/efizfs.h
	@@ -48,6 +48,7 @@
	extern zfsinfo_list_t *efizfs_get_zfsinfo_list(void);
	extern bool efi_zfs_is_preferred(EFI_HANDLE *h);
	extern EFI_HANDLE efizfs_get_handle_by_guid(uint64_t);
	+extern bool efizfs_get_guid_by_handle(EFI_HANDLE, uint64_t *);

	#endif

	Index: stand/efi/libefi/Makefile
	===================================================================
	--- stand/efi/libefi/Makefile
	+++ stand/efi/libefi/Makefile
	@@ -5,8 +5,21 @@
	LIB= efi
	WARNS?= 2

	-SRCS= delay.c devpath.c efi_console.c efichar.c efinet.c efipart.c env.c errno.c \
	- handles.c wchar.c libefi.c efi_driver_utils.c efizfs.c devicename.c
	+SRCS= delay.c \
	+ devicename.c \
	+ devpath.c \
	+ efi_console.c \
	+ efi_driver_utils.c \
	+ efichar.c \
	+ efienv.c \
	+ efinet.c \
	+ efipart.c \
	+ efizfs.c \
	+ env.c \
	+ errno.c \
	+ handles.c \
	+ libefi.c \
	+ wchar.c

	.if ${MACHINE_CPUARCH} == "amd64" \|\| ${MACHINE_CPUARCH} == "i386"
	SRCS+= time.c
	Index: stand/efi/libefi/devicename.c
	===================================================================
	--- stand/efi/libefi/devicename.c
	+++ stand/efi/libefi/devicename.c
	@@ -161,7 +161,6 @@
	}

	idev->d_dev = dv;
	- idev->d_type = dv->dv_type;

	if (dev != NULL)
	*dev = idev;
	@@ -180,7 +179,7 @@
	struct devdesc dev = (struct devdesc )vdev;
	static char buf[SPECNAMELEN + 1];

	- switch(dev->d_type) {
	+ switch(dev->d_dev->dv_type) {
	case DEVT_NONE:
	strcpy(buf, "(no device)");
	break;
	Index: stand/efi/libefi/efienv.c
	===================================================================
	--- stand/efi/libefi/efienv.c
	+++ stand/efi/libefi/efienv.c
	@@ -1,5 +1,5 @@
	/*-
	- * Copyright (c) 2016 Eric McCorkle
	+ * Copyright (c) 2018 Netflix, Inc.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	@@ -22,33 +22,66 @@
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	- *
	- * $FreeBSD$
	*/

	-#include <stdint.h>
	-#include <stdbool.h>
	+#include <sys/cdefs.h>
	+__FBSDID("$FreeBSD$");
	+
	+#include <stand.h>
	+#include <efi.h>
	+#include <efichar.h>
	+#include <efilib.h>
	+
	+static EFI_GUID FreeBSDBootVarGUID = FREEBSD_BOOT_VAR_GUID;
	+static EFI_GUID GlobalBootVarGUID = UEFI_BOOT_VAR_GUID;
	+
	+EFI_STATUS
	+efi_getenv(EFI_GUID g, const char v, void data, size_t len)
	+{
	+ size_t ul;
	+ CHAR16 *uv;
	+ UINT32 attr;
	+ UINTN dl;
	+ EFI_STATUS rv;
	+
	+ uv = NULL;
	+ if (utf8_to_ucs2(v, &uv, &ul) != 0)
	+ return (EFI_OUT_OF_RESOURCES);
	+ dl = *len;
	+ rv = RS->GetVariable(uv, g, &attr, &dl, data);
	+ if (rv == EFI_SUCCESS)
	+ *len = dl;
	+ free(uv);
	+ return (rv);
	+}

	-#ifndef _EFIZFS_H_
	-#define _EFIZFS_H_
	+EFI_STATUS
	+efi_global_getenv(const char v, void data, size_t *len)
	+{

	-#ifdef EFI_ZFS_BOOT
	-typedef STAILQ_HEAD(zfsinfo_list, zfsinfo) zfsinfo_list_t;
	+ return (efi_getenv(&GlobalBootVarGUID, v, data, len));
	+}

	-typedef struct zfsinfo
	+EFI_STATUS
	+efi_freebsd_getenv(const char v, void data, size_t *len)
	{
	- STAILQ_ENTRY(zfsinfo) zi_link;
	- EFI_HANDLE zi_handle;
	- uint64_t zi_pool_guid;
	-} zfsinfo_t;

	-extern uint64_t pool_guid;
	+ return (efi_getenv(&FreeBSDBootVarGUID, v, data, len));
	+}

	-extern void efi_zfs_probe(void);
	-extern zfsinfo_list_t *efizfs_get_zfsinfo_list(void);
	-extern bool efi_zfs_is_preferred(EFI_HANDLE *h);
	-extern EFI_HANDLE efizfs_get_handle_by_guid(uint64_t);
	+EFI_STATUS
	+efi_setenv_freebsd_wcs(const char varname, CHAR16 valstr)
	+{
	+ CHAR16 *var = NULL;
	+ size_t len;
	+ EFI_STATUS rv;

	-#endif
	+ if (utf8_to_ucs2(varname, &var, &len) != 0)
	+ return (EFI_OUT_OF_RESOURCES);
	+ rv = RS->SetVariable(var, &FreeBSDBootVarGUID,
	+ EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,
	+ (ucs2len(valstr) + 1) * sizeof(efi_char), valstr);
	+ free(var);
	+ return (rv);
	+}

	-#endif
	Index: stand/efi/libefi/efipart.c
	===================================================================
	--- stand/efi/libefi/efipart.c
	+++ stand/efi/libefi/efipart.c
	@@ -119,6 +119,7 @@
	return (NULL);
	}

	+/* XXX this gets called way way too often, investigate */
	pdinfo_t *
	efiblk_get_pdinfo(struct devdesc *dev)
	{
	@@ -136,6 +137,40 @@
	return (pd);
	}

	+static bool
	+same_handle(pdinfo_t *pd, EFI_HANDLE h)
	+{
	+
	+ return (pd->pd_handle == h \|\| pd->pd_alias == h);
	+}
	+
	+pdinfo_t *
	+efiblk_get_pdinfo_by_handle(EFI_HANDLE h)
	+{
	+ pdinfo_t dp, pp;
	+
	+ /*
	+ * Check hard disks, then cd, then floppy
	+ */
	+ STAILQ_FOREACH(dp, &hdinfo, pd_link) {
	+ if (same_handle(dp, h))
	+ return (dp);
	+ STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
	+ if (same_handle(pp, h))
	+ return (pp);
	+ }
	+ }
	+ STAILQ_FOREACH(dp, &cdinfo, pd_link) {
	+ if (same_handle(dp, h))
	+ return (dp);
	+ }
	+ STAILQ_FOREACH(dp, &fdinfo, pd_link) {
	+ if (same_handle(dp, h))
	+ return (dp);
	+ }
	+ return (NULL);
	+}
	+
	static int
	efiblk_pdinfo_count(pdinfo_list_t *pdi)
	{
	@@ -294,6 +329,8 @@
	fd->pd_unit = uid;
	fd->pd_handle = handle;
	fd->pd_devpath = devpath;
	+ fd->pd_parent = NULL;
	+ fd->pd_devsw = &efipart_fddev;
	STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
	return (0);
	}
	@@ -364,6 +401,8 @@
	cd->pd_unit = unit;
	cd->pd_alias = alias;
	cd->pd_devpath = devpath;
	+ cd->pd_parent = NULL;
	+ cd->pd_devsw = &efipart_cddev;
	STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
	return (0);
	}
	@@ -489,6 +528,8 @@
	pd->pd_handle = part_handle;
	pd->pd_unit = node->PartitionNumber;
	pd->pd_devpath = part_devpath;
	+ pd->pd_parent = hd;
	+ pd->pd_devsw = &efipart_hddev;
	STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
	return (0);
	}
	@@ -505,6 +546,8 @@
	hd->pd_handle = disk_handle;
	hd->pd_unit = unit;
	hd->pd_devpath = disk_devpath;
	+ hd->pd_parent = NULL;
	+ hd->pd_devsw = &efipart_hddev;
	STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);

	if (part_devpath == NULL)
	@@ -521,6 +564,8 @@
	pd->pd_handle = part_handle;
	pd->pd_unit = node->PartitionNumber;
	pd->pd_devpath = part_devpath;
	+ pd->pd_parent = hd;
	+ pd->pd_devsw = &efipart_hddev;
	STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);

	return (0);
	@@ -579,6 +624,8 @@
	pd->pd_handle = disk_handle;
	pd->pd_unit = unit;
	pd->pd_devpath = devpath;
	+ pd->pd_parent = NULL;
	+ pd->pd_devsw = &efipart_hddev;
	STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
	free(pathname);
	return (0);
	@@ -609,6 +656,8 @@
	pd->pd_handle = disk_handle;
	pd->pd_unit = unit;
	pd->pd_devpath = devpath;
	+ pd->pd_parent = last;
	+ pd->pd_devsw = &efipart_hddev;
	STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
	free(pathname);
	return (0);
	@@ -744,11 +793,10 @@
	continue;

	pd->pd_blkio = blkio;
	- pd_dev.d_dev = dev;
	- pd_dev.d_unit = pd->pd_unit;
	+ pd_dev.dd.d_dev = dev;
	+ pd_dev.dd.d_unit = pd->pd_unit;
	pd_dev.d_slice = -1;
	pd_dev.d_partition = -1;
	- pd_dev.d_opendata = blkio;
	ret = disk_open(&pd_dev, blkio->Media->BlockSize *
	(blkio->Media->LastBlock + 1),
	blkio->Media->BlockSize);
	@@ -821,7 +869,7 @@
	if (pd->pd_bcache == NULL)
	pd->pd_bcache = bcache_allocate();

	- if (dev->d_dev->dv_type == DEVT_DISK) {
	+ if (dev->dd.d_dev->dv_type == DEVT_DISK) {
	int rc;

	rc = disk_open(dev,
	@@ -860,7 +908,7 @@
	bcache_free(pd->pd_bcache);
	pd->pd_bcache = NULL;
	}
	- if (dev->d_dev->dv_type == DEVT_DISK)
	+ if (dev->dd.d_dev->dv_type == DEVT_DISK)
	return (disk_close(dev));
	return (0);
	}
	@@ -880,7 +928,7 @@
	if (pd == NULL)
	return (EINVAL);

	- if (dev->d_dev->dv_type == DEVT_DISK) {
	+ if (dev->dd.d_dev->dv_type == DEVT_DISK) {
	rc = disk_ioctl(dev, cmd, data);
	if (rc != ENOTTY)
	return (rc);
	@@ -967,7 +1015,7 @@
	bcd.dv_devdata = devdata;
	bcd.dv_cache = pd->pd_bcache;

	- if (dev->d_dev->dv_type == DEVT_DISK) {
	+ if (dev->dd.d_dev->dv_type == DEVT_DISK) {
	daddr_t offset;

	offset = dev->d_offset * pd->pd_blkio->Media->BlockSize;
	@@ -1011,7 +1059,7 @@
	* partition.
	*/
	disk_blocks = 0;
	- if (dev->d_dev->dv_type == DEVT_DISK) {
	+ if (dev->dd.d_dev->dv_type == DEVT_DISK) {
	if (disk_ioctl(dev, DIOCGMEDIASIZE, &disk_blocks) == 0) {
	/* DIOCGMEDIASIZE does return bytes. */
	disk_blocks /= blkio->Media->BlockSize;
	Index: stand/efi/libefi/efizfs.c
	===================================================================
	--- stand/efi/libefi/efizfs.c
	+++ stand/efi/libefi/efizfs.c
	@@ -29,8 +29,7 @@
	__FBSDID("$FreeBSD$");

	#include <sys/param.h>
	-#include <sys/disk.h>
	-#include <stdint.h>
	+#include <stand.h>

	#ifdef EFI_ZFS_BOOT
	#include <libzfs.h>
	@@ -65,6 +64,22 @@
	return (NULL);
	}

	+bool
	+efizfs_get_guid_by_handle(EFI_HANDLE handle, uint64_t *guid)
	+{
	+ zfsinfo_t *zi;
	+
	+ if (guid == NULL)
	+ return (1);
	+ STAILQ_FOREACH(zi, &zfsinfo, zi_link) {
	+ if (zi->zi_handle == handle) {
	+ *guid = zi->zi_pool_guid;
	+ return (true);
	+ }
	+ }
	+ return (false);
	+}
	+
	static void
	insert_zfs(EFI_HANDLE handle, uint64_t guid)
	{
	Index: stand/efi/libefi/env.c
	===================================================================
	--- stand/efi/libefi/env.c
	+++ stand/efi/libefi/env.c
	@@ -35,35 +35,6 @@
	#include <stdbool.h>
	#include "bootstrap.h"

	-/*
	- * Simple wrappers to the underlying UEFI functions.
	- * See http://wiki.phoenix.com/wiki/index.php/EFI_RUNTIME_SERVICES
	- * for details.
	- */
	-EFI_STATUS
	-efi_get_next_variable_name(UINTN variable_name_size, CHAR16 variable_name,
	- EFI_GUID *vendor_guid)
	-{
	- return (RS->GetNextVariableName(variable_name_size, variable_name,
	- vendor_guid));
	-}
	-
	-EFI_STATUS
	-efi_get_variable(CHAR16 variable_name, EFI_GUID vendor_guid,
	- UINT32 attributes, UINTN data_size, void *data)
	-{
	- return (RS->GetVariable(variable_name, vendor_guid, attributes,
	- data_size, data));
	-}
	-
	-EFI_STATUS
	-efi_set_variable(CHAR16 variable_name, EFI_GUID vendor_guid,
	- UINT32 attributes, UINTN data_size, void *data)
	-{
	- return (RS->SetVariable(variable_name, vendor_guid, attributes,
	- data_size, data));
	-}
	-
	void
	efi_init_environment(void)
	{
	Index: stand/efi/loader/main.c
	===================================================================
	--- stand/efi/loader/main.c
	+++ stand/efi/loader/main.c
	@@ -76,8 +76,20 @@
	EFI_GUID fdtdtb = FDT_TABLE_GUID;
	EFI_GUID inputid = SIMPLE_TEXT_INPUT_PROTOCOL;

	+static EFI_GUID FreeBSDBootVarGUID = FREEBSD_BOOT_VAR_GUID;
	+static EFI_GUID GlobalBootVarGUID = UEFI_BOOT_VAR_GUID;
	+
	static EFI_LOADED_IMAGE *img;

	+/*
	+ * Number of seconds to wait for a keystroke before exiting with failure
	+ * in the event no currdev is found. -2 means always break, -1 means
	+ * never break, 0 means poll once and then reboot, > 0 means wait for
	+ * that many seconds. "fail_timeout" can be set in the environment as
	+ * well.
	+ */
	+static int fail_timeout = 5;
	+
	#ifdef EFI_ZFS_BOOT
	bool
	efi_zfs_is_preferred(EFI_HANDLE *h)
	@@ -169,119 +181,183 @@
	}

	static void
	-set_devdesc_currdev(struct devsw *dev, int unit)
	+set_currdev_devdesc(struct devdesc *currdev)
	+{
	+ const char *devname;
	+
	+ devname = efi_fmtdev(currdev);
	+
	+ printf("Setting currdev to %s\n", devname);
	+
	+ env_setenv("currdev", EV_VOLATILE, devname, efi_setcurrdev, env_nounset);
	+ env_setenv("loaddev", EV_VOLATILE, devname, env_noset, env_nounset);
	+}
	+
	+static void
	+set_currdev_devsw(struct devsw *dev, int unit)
	{
	struct devdesc currdev;
	- char *devname;

	currdev.d_dev = dev;
	- currdev.d_type = currdev.d_dev->dv_type;
	currdev.d_unit = unit;
	- currdev.d_opendata = NULL;
	+
	+ set_currdev_devdesc(&currdev);
	+}
	+
	+static void
	+set_currdev_pdinfo(pdinfo_t *dp)
	+{
	+
	+ /*
	+ * Disks are special: they have partitions. if the parent
	+ * pointer is non-null, we're a partition not a full disk
	+ * and we need to adjust currdev appropriately.
	+ */
	+ if (dp->pd_devsw->dv_type == DEVT_DISK) {
	+ struct disk_devdesc currdev;
	+
	+ currdev.dd.d_dev = dp->pd_devsw;
	+ if (dp->pd_parent == NULL) {
	+ currdev.dd.d_unit = dp->pd_unit;
	+ currdev.d_slice = -1;
	+ currdev.d_partition = -1;
	+ } else {
	+ currdev.dd.d_unit = dp->pd_parent->pd_unit;
	+ currdev.d_slice = dp->pd_unit;
	+ currdev.d_partition = 255; /* Assumes GPT */
	+ }
	+ set_currdev_devdesc((struct devdesc *)&currdev);
	+ } else {
	+ set_currdev_devsw(dp->pd_devsw, dp->pd_unit);
	+ }
	+}
	+
	+static bool
	+sanity_check_currdev(void)
	+{
	+ struct stat st;
	+
	+ return (stat("/boot/defaults/loader.conf", &st) == 0);
	+}
	+
	+#ifdef EFI_ZFS_BOOT
	+static bool
	+probe_zfs_currdev(uint64_t guid)
	+{
	+ char *devname;
	+ struct zfs_devdesc currdev;
	+
	+ currdev.dd.d_dev = &zfs_dev;
	+ currdev.dd.d_unit = 0;
	+ currdev.pool_guid = guid;
	+ currdev.root_guid = 0;
	+ set_currdev_devdesc((struct devdesc *)&currdev);
	devname = efi_fmtdev(&currdev);
	+ init_zfs_bootenv(devname);

	- env_setenv("currdev", EV_VOLATILE, devname, efi_setcurrdev,
	- env_nounset);
	- env_setenv("loaddev", EV_VOLATILE, devname, env_noset, env_nounset);
	+ return (sanity_check_currdev());
	+}
	+#endif
	+
	+static bool
	+try_as_currdev(pdinfo_t hd, pdinfo_t pp)
	+{
	+ uint64_t guid;
	+
	+#ifdef EFI_ZFS_BOOT
	+ /*
	+ * If there's a zpool on this device, try it as a ZFS
	+ * filesystem, which has somewhat different setup than all
	+ * other types of fs due to imperfect loader integration.
	+ * This all stems from ZFS being both a device (zpool) and
	+ * a filesystem, plus the boot env feature.
	+ */
	+ if (efizfs_get_guid_by_handle(pp->pd_handle, &guid))
	+ return (probe_zfs_currdev(guid));
	+#endif
	+ /*
	+ * All other filesystems just need the pdinfo
	+ * initialized in the standard way.
	+ */
	+ set_currdev_pdinfo(pp);
	+ return (sanity_check_currdev());
	}

	static int
	find_currdev(EFI_LOADED_IMAGE *img)
	{
	- pdinfo_list_t *pdi_list;
	pdinfo_t dp, pp;
	EFI_DEVICE_PATH devpath, copy;
	EFI_HANDLE h;
	- char *devname;
	+ CHAR16 *text;
	struct devsw *dev;
	int unit;
	uint64_t extra;

	#ifdef EFI_ZFS_BOOT
	- /* Did efi_zfs_probe() detect the boot pool? */
	+ /*
	+ * Did efi_zfs_probe() detect the boot pool? If so, use the zpool
	+ * it found, if it's sane. ZFS is the only thing that looks for
	+ * disks and pools to boot. This may change in the future, however,
	+ * if we allow specifying which pool to boot from via UEFI variables
	+ * rather than the bootenv stuff that FreeBSD uses today.
	+ */
	if (pool_guid != 0) {
	- struct zfs_devdesc currdev;
	-
	- currdev.d_dev = &zfs_dev;
	- currdev.d_unit = 0;
	- currdev.d_type = currdev.d_dev->dv_type;
	- currdev.d_opendata = NULL;
	- currdev.pool_guid = pool_guid;
	- currdev.root_guid = 0;
	- devname = efi_fmtdev(&currdev);
	-
	- env_setenv("currdev", EV_VOLATILE, devname, efi_setcurrdev,
	- env_nounset);
	- env_setenv("loaddev", EV_VOLATILE, devname, env_noset,
	- env_nounset);
	- init_zfs_bootenv(devname);
	- return (0);
	- }
	-#endif /* EFI_ZFS_BOOT */
	-
	- /* We have device lists for hd, cd, fd, walk them all. */
	- pdi_list = efiblk_get_pdinfo_list(&efipart_hddev);
	- STAILQ_FOREACH(dp, pdi_list, pd_link) {
	- struct disk_devdesc currdev;
	-
	- currdev.d_dev = &efipart_hddev;
	- currdev.d_type = currdev.d_dev->dv_type;
	- currdev.d_unit = dp->pd_unit;
	- currdev.d_opendata = NULL;
	- currdev.d_slice = -1;
	- currdev.d_partition = -1;
	-
	- if (dp->pd_handle == img->DeviceHandle) {
	- devname = efi_fmtdev(&currdev);
	-
	- env_setenv("currdev", EV_VOLATILE, devname,
	- efi_setcurrdev, env_nounset);
	- env_setenv("loaddev", EV_VOLATILE, devname,
	- env_noset, env_nounset);
	+ printf("Trying ZFS pool\n");
	+ if (probe_zfs_currdev(pool_guid))
	return (0);
	- }
	- /* Assuming GPT partitioning. */
	- STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
	- if (pp->pd_handle == img->DeviceHandle) {
	- currdev.d_slice = pp->pd_unit;
	- currdev.d_partition = 255;
	- devname = efi_fmtdev(&currdev);
	-
	- env_setenv("currdev", EV_VOLATILE, devname,
	- efi_setcurrdev, env_nounset);
	- env_setenv("loaddev", EV_VOLATILE, devname,
	- env_noset, env_nounset);
	- return (0);
	- }
	- }
	}
	+#endif /* EFI_ZFS_BOOT */

	- pdi_list = efiblk_get_pdinfo_list(&efipart_cddev);
	- STAILQ_FOREACH(dp, pdi_list, pd_link) {
	- if (dp->pd_handle == img->DeviceHandle \|\|
	- dp->pd_alias == img->DeviceHandle) {
	- set_devdesc_currdev(&efipart_cddev, dp->pd_unit);
	- return (0);
	+ /*
	+ * Try to find the block device by its handle based on the
	+ * image we're booting. If we can't find a sane partition,
	+ * search all the other partitions of the disk. We do not
	+ * search other disks because it's a violation of the UEFI
	+ * boot protocol to do so. We fail and let UEFI go on to
	+ * the next candidate.
	+ */
	+ dp = efiblk_get_pdinfo_by_handle(img->DeviceHandle);
	+ if (dp != NULL) {
	+ text = efi_devpath_name(dp->pd_devpath);
	+ if (text != NULL) {
	+ printf("Trying ESP: %S\n", text);
	+ efi_free_devpath_name(text);
	}
	- }
	-
	- pdi_list = efiblk_get_pdinfo_list(&efipart_fddev);
	- STAILQ_FOREACH(dp, pdi_list, pd_link) {
	- if (dp->pd_handle == img->DeviceHandle) {
	- set_devdesc_currdev(&efipart_fddev, dp->pd_unit);
	+ set_currdev_pdinfo(dp);
	+ if (sanity_check_currdev())
	return (0);
	+ if (dp->pd_parent != NULL) {
	+ dp = dp->pd_parent;
	+ STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
	+ text = efi_devpath_name(pp->pd_devpath);
	+ if (text != NULL) {
	+ printf("And now the part: %S\n", text);
	+ efi_free_devpath_name(text);
	+ }
	+ /*
	+ * Roll up the ZFS special case
	+ * for those partitions that have
	+ * zpools on them
	+ */
	+ if (try_as_currdev(dp, pp))
	+ return (0);
	+ }
	}
	+ } else {
	+ printf("Can't find device by handle\n");
	}

	/*
	* Try the device handle from our loaded image first. If that
	* fails, use the device path from the loaded image and see if
	* any of the nodes in that path match one of the enumerated
	- * handles.
	+ * handles. Currently, this handle list is only for netboot.
	*/
	if (efi_handle_lookup(img->DeviceHandle, &dev, &unit, &extra) == 0) {
	- set_devdesc_currdev(dev, unit);
	- return (0);
	+ set_currdev_devsw(dev, unit);
	+ if (sanity_check_currdev())
	+ return (0);
	}

	copy = NULL;
	@@ -295,8 +371,9 @@
	copy = NULL;

	if (efi_handle_lookup(h, &dev, &unit, &extra) == 0) {
	- set_devdesc_currdev(dev, unit);
	- return (0);
	+ set_currdev_devsw(dev, unit);
	+ if (sanity_check_currdev())
	+ return (0);
	}

	devpath = efi_lookup_devpath(h);
	@@ -310,6 +387,33 @@
	return (ENOENT);
	}

	+static bool
	+interactive_interrupt(const char *msg)
	+{
	+ time_t now, then, last;
	+
	+ last = 0;
	+ now = then = getsecs();
	+ printf("%s\n", msg);
	+ if (fail_timeout == -2) /* Always break to OK */
	+ return (true);
	+ if (fail_timeout == -1) /* Never break to OK */
	+ return (false);
	+ do {
	+ if (last != now) {
	+ printf("press any key to interrupt reboot in %d seconds\r",
	+ fail_timeout - (int)(now - then));
	+ last = now;
	+ }
	+
	+ /* XXX no pause or timeout wait for char */
	+ if (ischar())
	+ return (true);
	+ now = getsecs();
	+ } while (now - then < fail_timeout);
	+ return (false);
	+}
	+
	EFI_STATUS
	main(int argc, CHAR16 *argv[])
	{
	@@ -318,6 +422,13 @@
	int i, j, vargood, howto;
	UINTN k;
	int has_kbd;
	+ char *s;
	+ EFI_DEVICE_PATH *imgpath;
	+ CHAR16 *text;
	+ EFI_STATUS status;
	+ UINT16 boot_current;
	+ size_t sz;
	+ UINT16 boot_order[100];
	#if !defined(__arm__)
	char buf[40];
	#endif
	@@ -356,12 +467,15 @@
	/*
	* Parse the args to set the console settings, etc
	* boot1.efi passes these in, if it can read /boot.config or /boot/config
	- * or iPXE may be setup to pass these in.
	+ * or iPXE may be setup to pass these in. Or the optional argument in the
	+ * boot environment was used to pass these arguments in (in which case
	+ * neither /boot.config nor /boot/config are consulted).
	*
	* Loop through the args, and for each one that contains an '=' that is
	* not the first character, add it to the environment. This allows
	* loader and kernel env vars to be passed on the command line. Convert
	- * args from UCS-2 to ASCII (16 to 8 bit) as they are copied.
	+ * args from UCS-2 to ASCII (16 to 8 bit) as they are copied (though this
	+ * method is flawed for non-ASCII characters).
	*/
	howto = 0;
	for (i = 1; i < argc; i++) {
	@@ -441,6 +555,10 @@
	for (i = 0; howto_names[i].ev != NULL; i++)
	if (howto & howto_names[i].mask)
	setenv(howto_names[i].ev, "YES", 1);
	+
	+ /*
	+ * XXX we need fallback to this stuff after looking at the ConIn, ConOut and ConErr variables
	+ */
	if (howto & RB_MULTIPLE) {
	if (howto & RB_SERIAL)
	setenv("console", "comconsole efi" , 1);
	@@ -448,13 +566,17 @@
	setenv("console", "efi comconsole" , 1);
	} else if (howto & RB_SERIAL) {
	setenv("console", "comconsole" , 1);
	- }
	+ } else
	+ setenv("console", "efi", 1);

	if (efi_copy_init()) {
	printf("failed to allocate staging area\n");
	return (EFI_BUFFER_TOO_SMALL);
	}

	+ if ((s = getenv("fail_timeout")) != NULL)
	+ fail_timeout = strtol(s, NULL, 10);
	+
	/*
	* Scan the BLOCK IO MEDIA handles then
	* march through the device switch probing for things.
	@@ -479,6 +601,37 @@

	printf("\n%s", bootprog_info);

	+ /* Determine the devpath of our image so we can prefer it. */
	+ text = efi_devpath_name(img->FilePath);
	+ if (text != NULL) {
	+ printf(" Load Path: %S\n", text);
	+ efi_setenv_freebsd_wcs("LoaderPath", text);
	+ efi_free_devpath_name(text);
	+ }
	+
	+ status = BS->HandleProtocol(img->DeviceHandle, &devid, (void **)&imgpath);
	+ if (status == EFI_SUCCESS) {
	+ text = efi_devpath_name(imgpath);
	+ if (text != NULL) {
	+ printf(" Load Device: %S\n", text);
	+ efi_setenv_freebsd_wcs("LoaderDev", text);
	+ efi_free_devpath_name(text);
	+ }
	+ }
	+
	+ boot_current = 0;
	+ sz = sizeof(boot_current);
	+ efi_global_getenv("BootCurrent", &boot_current, &sz);
	+ printf(" BootCurrent: %04x\n", boot_current);
	+
	+ sz = sizeof(boot_order);
	+ efi_global_getenv("BootOrder", &boot_order, &sz);
	+ printf(" BootOrder:");
	+ for (i = 0; i < sz / sizeof(boot_order[0]); i++)
	+ printf(" %04x%s", boot_order[i],
	+ boot_order[i] == boot_current ? "[*]" : "");
	+ printf("\n");
	+
	/*
	* Disable the watchdog timer. By default the boot manager sets
	* the timer to 5 minutes before invoking a boot option. If we
	@@ -490,11 +643,19 @@
	*/
	BS->SetWatchdogTimer(0, 0, 0, NULL);

	+ /*
	+ * Try and find a good currdev based on the image that was booted.
	+ * It might be desirable here to have a short pause to allow falling
	+ * through to the boot loader instead of returning instantly to follow
	+ * the boot protocol and also allow an escape hatch for users wishing
	+ * to try something different.
	+ */
	if (find_currdev(img) != 0)
	- return (EFI_NOT_FOUND);
	+ if (!interactive_interrupt("Failed to find bootable partition"))
	+ return (EFI_NOT_FOUND);

	efi_init_environment();
	- setenv("LINES", "24", 1); /* optional */
	+ setenv("LINES", "48", 1); /* optional */

	for (k = 0; k < ST->NumberOfTableEntries; k++) {
	guid = &ST->ConfigurationTable[k].VendorGuid;
	@@ -848,7 +1009,7 @@
	struct disk_devdesc *d_dev;
	pdinfo_t hd, pd;

	- switch (dev->d_type) {
	+ switch (dev->d_dev->dv_type) {
	#ifdef EFI_ZFS_BOOT
	case DEVT_ZFS:
	z_dev = (struct zfs_devdesc *)dev;
	Index: stand/i386/libi386/bioscd.c
	===================================================================
	--- stand/i386/libi386/bioscd.c
	+++ stand/i386/libi386/bioscd.c
	@@ -90,7 +90,7 @@
	} bcinfo [MAXBCDEV];
	static int nbcinfo = 0;

	-#define BC(dev) (bcinfo[(dev)->d_unit])
	+#define BC(dev) (bcinfo[(dev)->dd.d_unit])

	static int bc_read(int unit, daddr_t dblk, int blks, caddr_t dest);
	static int bc_init(void);
	@@ -211,7 +211,7 @@
	va_start(ap, f);
	dev = va_arg(ap, struct i386_devdesc *);
	va_end(ap);
	- if (dev->d_unit >= nbcinfo) {
	+ if (dev->dd.d_unit >= nbcinfo) {
	DEBUG("attempt to open nonexistent disk");
	return(ENXIO);
	}
	@@ -271,7 +271,7 @@
	if ((rw & F_MASK) != F_READ)
	return(EROFS);
	dev = (struct i386_devdesc *)devdata;
	- unit = dev->d_unit;
	+ unit = dev->dd.d_unit;
	blks = size / BIOSCD_SECSIZE;
	if (dblk % (BIOSCD_SECSIZE / DEV_BSIZE) != 0)
	return (EINVAL);
	@@ -427,7 +427,7 @@
	int major;
	int rootdev;

	- unit = dev->d_unit;
	+ unit = dev->dd.d_unit;
	biosdev = bc_unit2bios(unit);
	DEBUG("unit %d BIOS device %d", unit, biosdev);
	if (biosdev == -1) /* not a BIOS device */
	Index: stand/i386/libi386/biosdisk.c
	===================================================================
	--- stand/i386/libi386/biosdisk.c
	+++ stand/i386/libi386/biosdisk.c
	@@ -120,7 +120,7 @@
	} bdinfo [MAXBDDEV];
	static int nbdinfo = 0;

	-#define BD(dev) (bdinfo[(dev)->d_unit])
	+#define BD(dev) (bdinfo[(dev)->dd.d_unit])

	static int bd_read(struct disk_devdesc *dev, daddr_t dblk, int blks,
	caddr_t dest);
	@@ -349,8 +349,8 @@
	bdinfo[i].bd_sectorsize);
	if ((ret = pager_output(line)) != 0)
	break;
	- dev.d_dev = &biosdisk;
	- dev.d_unit = i;
	+ dev.dd.d_dev = &biosdisk;
	+ dev.dd.d_unit = i;
	dev.d_slice = -1;
	dev.d_partition = -1;
	if (disk_open(&dev,
	@@ -389,7 +389,7 @@
	dev = va_arg(ap, struct disk_devdesc *);
	va_end(ap);

	- if (dev->d_unit < 0 \|\| dev->d_unit >= nbdinfo)
	+ if (dev->dd.d_unit < 0 \|\| dev->dd.d_unit >= nbdinfo)
	return (EIO);
	BD(dev).bd_open++;
	if (BD(dev).bd_bcache == NULL)
	@@ -402,10 +402,9 @@
	* During bd_probe() we tested if the mulitplication of bd_sectors
	* would overflow so it should be safe to perform here.
	*/
	- disk.d_dev = dev->d_dev;
	- disk.d_type = dev->d_type;
	- disk.d_unit = dev->d_unit;
	- disk.d_opendata = NULL;
	+ disk.dd.d_dev = dev->dd.d_dev;
	+ disk.dd.d_unit = dev->dd.d_unit;
	+ disk.dd.d_opendata = NULL;
	disk.d_slice = -1;
	disk.d_partition = -1;
	disk.d_offset = 0;
	@@ -431,7 +430,7 @@
	return (err);

	/* if we already know there is no GELI, skip the rest */
	- if (geli_status[dev->d_unit][dev->d_slice] != ISGELI_UNKNOWN)
	+ if (geli_status[dev->dd.d_unit][dev->d_slice] != ISGELI_UNKNOWN)
	return (err);

	struct dsk dskp;
	@@ -440,9 +439,9 @@
	struct pentry *entry;
	int geli_part = 0;

	- dskp.drive = bd_unit2bios(dev->d_unit);
	- dskp.type = dev->d_type;
	- dskp.unit = dev->d_unit;
	+ dskp.drive = bd_unit2bios(dev->dd.d_unit);
	+ dskp.type = dev->dd.d_dev->dv_type;
	+ dskp.unit = dev->dd.d_unit;
	dskp.slice = dev->d_slice;
	dskp.part = dev->d_partition;
	dskp.start = dev->d_offset;
	@@ -466,13 +465,13 @@
	dskp.slice = entry->part.index;
	dskp.start = entry->part.start;
	if (is_geli(&dskp) == 0) {
	- geli_status[dev->d_unit][dskp.slice] = ISGELI_YES;
	+ geli_status[dev->dd.d_unit][dskp.slice] = ISGELI_YES;
	return (0);
	}
	if (geli_taste(bios_read, &dskp,
	entry->part.end - entry->part.start) == 0) {
	if (geli_havekey(&dskp) == 0) {
	- geli_status[dev->d_unit][dskp.slice] = ISGELI_YES;
	+ geli_status[dev->dd.d_unit][dskp.slice] = ISGELI_YES;
	geli_part++;
	continue;
	}
	@@ -486,18 +485,18 @@
	&dskp) == 0) {
	setenv("kern.geom.eli.passphrase", gelipw, 1);
	bzero(gelipw, sizeof(gelipw));
	- geli_status[dev->d_unit][dskp.slice] = ISGELI_YES;
	+ geli_status[dev->dd.d_unit][dskp.slice] = ISGELI_YES;
	geli_part++;
	continue;
	}
	} else
	- geli_status[dev->d_unit][dskp.slice] = ISGELI_NO;
	+ geli_status[dev->dd.d_unit][dskp.slice] = ISGELI_NO;
	}

	/* none of the partitions on this disk have GELI */
	if (geli_part == 0) {
	/* found no GELI */
	- geli_status[dev->d_unit][dev->d_slice] = ISGELI_NO;
	+ geli_status[dev->dd.d_unit][dev->d_slice] = ISGELI_NO;
	}
	#endif /* LOADER_GELI_SUPPORT */

	@@ -834,10 +833,10 @@
	char *tmpbuf;

	/* if we already know there is no GELI, skip the rest */
	- if (geli_status[dev->d_unit][dev->d_slice] != ISGELI_YES)
	+ if (geli_status[dev->dd.d_unit][dev->d_slice] != ISGELI_YES)
	return (bd_io(dev, dblk, blks, dest, 0));

	- if (geli_status[dev->d_unit][dev->d_slice] == ISGELI_YES) {
	+ if (geli_status[dev->dd.d_unit][dev->d_slice] == ISGELI_YES) {
	/*
	* Align reads to DEV_GELIBOOT_BSIZE bytes because partial
	* sectors cannot be decrypted. Round the requested LBA down to
	@@ -871,9 +870,9 @@
	if (err)
	return (err);

	- dskp.drive = bd_unit2bios(dev->d_unit);
	- dskp.type = dev->d_type;
	- dskp.unit = dev->d_unit;
	+ dskp.drive = bd_unit2bios(dev->dd.d_unit);
	+ dskp.type = dev->dd.d_dev->dv_type;
	+ dskp.unit = dev->dd.d_unit;
	dskp.slice = dev->d_slice;
	dskp.part = dev->d_partition;
	dskp.start = dev->d_offset;
	@@ -950,8 +949,8 @@
	int i, unit;

	dev = (struct disk_devdesc *)d;
	- biosdev = bd_unit2bios(dev->d_unit);
	- DEBUG("unit %d BIOS device %d", dev->d_unit, biosdev);
	+ biosdev = bd_unit2bios(dev->dd.d_unit);
	+ DEBUG("unit %d BIOS device %d", dev->dd.d_unit, biosdev);
	if (biosdev == -1) /* not a BIOS device */
	return(-1);
	if (disk_open(dev, BD(dev).bd_sectors * BD(dev).bd_sectorsize,
	@@ -962,7 +961,7 @@

	if (biosdev < 0x80) {
	/* floppy (or emulated floppy) or ATAPI device */
	- if (bdinfo[dev->d_unit].bd_type == DT_ATAPI) {
	+ if (bdinfo[dev->dd.d_unit].bd_type == DT_ATAPI) {
	/* is an ATAPI disk */
	major = WFDMAJOR;
	} else {
	@@ -996,9 +995,8 @@
	struct disk_devdesc dev;
	struct dsk *priv = xpriv;

	- dev.d_dev = &biosdisk;
	- dev.d_type = priv->type;
	- dev.d_unit = priv->unit;
	+ dev.dd.d_dev = &biosdisk;
	+ dev.dd.d_unit = priv->unit;
	dev.d_slice = priv->slice;
	dev.d_partition = priv->part;
	dev.d_offset = priv->start;
	Index: stand/i386/libi386/bootinfo32.c
	===================================================================
	--- stand/i386/libi386/bootinfo32.c
	+++ stand/i386/libi386/bootinfo32.c
	@@ -181,16 +181,16 @@
	/* XXX - use a default bootdev of 0. Is this ok??? */
	bootdevnr = 0;

	- switch(rootdev->d_type) {
	+ switch(rootdev->dd.d_dev->dv_type) {
	case DEVT_CD:
	/* Pass in BIOS device number. */
	- bi.bi_bios_dev = bc_unit2bios(rootdev->d_unit);
	+ bi.bi_bios_dev = bc_unit2bios(rootdev->dd.d_unit);
	bootdevnr = bc_getdev(rootdev);
	break;

	case DEVT_DISK:
	/* pass in the BIOS device number of the current disk */
	- bi.bi_bios_dev = bd_unit2bios(rootdev->d_unit);
	+ bi.bi_bios_dev = bd_unit2bios(rootdev->dd.d_unit);
	bootdevnr = bd_getdev(rootdev);
	break;

	@@ -199,7 +199,8 @@
	break;

	default:
	- printf("WARNING - don't know how to boot from device type %d\n", rootdev->d_type);
	+ printf("WARNING - don't know how to boot from device type %d\n",
	+ rootdev->dd.d_dev->dv_type);
	}
	if (bootdevnr == -1) {
	printf("root device %s invalid\n", i386_fmtdev(rootdev));
	Index: stand/i386/libi386/devicename.c
	===================================================================
	--- stand/i386/libi386/devicename.c
	+++ stand/i386/libi386/devicename.c
	@@ -135,7 +135,7 @@
	goto fail;
	}

	- idev->d_unit = unit;
	+ idev->dd.d_unit = unit;
	if (path != NULL)
	path = (cp == 0) ? cp : cp + 1;
	break;
	@@ -148,8 +148,7 @@
	err = EINVAL;
	goto fail;
	}
	- idev->d_dev = dv;
	- idev->d_type = dv->dv_type;
	+ idev->dd.d_dev = dv;
	if (dev == NULL) {
	free(idev);
	} else {
	@@ -169,14 +168,14 @@
	struct i386_devdesc dev = (struct i386_devdesc )vdev;
	static char buf[128]; /* XXX device length constant? */

	- switch(dev->d_type) {
	+ switch(dev->dd.d_dev->dv_type) {
	case DEVT_NONE:
	strcpy(buf, "(no device)");
	break;

	case DEVT_CD:
	case DEVT_NET:
	- sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
	+ sprintf(buf, "%s%d:", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	break;

	case DEVT_DISK:
	Index: stand/i386/libi386/libi386.h
	===================================================================
	--- stand/i386/libi386/libi386.h
	+++ stand/i386/libi386/libi386.h
	@@ -29,31 +29,21 @@

	/*
	* i386 fully-qualified device descriptor.
	- * Note, this must match the 'struct devdesc' declaration
	- * in bootstrap.h and also with struct zfs_devdesc for zfs
	- * support.
	+ * Note, this must match struct zfs_devdesc for zfs support.
	*/
	-struct i386_devdesc
	-{
	- struct devsw *d_dev;
	- int d_type;
	- int d_unit;
	+/* Note: Must match the 'struct devdesc' in stand.h */
	+struct i386_devdesc {
	+ struct devdesc dd;
	union
	{
	struct
	{
	- void *data;
	int slice;
	int partition;
	off_t offset;
	} biosdisk;
	struct
	{
	- void *data;
	- } bioscd;
	- struct
	- {
	- void *data;
	uint64_t pool_guid;
	uint64_t root_guid;
	} zfs;
	Index: stand/i386/loader/chain.c
	===================================================================
	--- stand/i386/loader/chain.c
	+++ stand/i386/loader/chain.c
	@@ -111,7 +111,7 @@
	relocater_data[0].dest = 0x7C00;
	relocater_data[0].size = SECTOR_SIZE;

	- relocator_edx = bd_unit2bios(rootdev->d_unit);
	+ relocator_edx = bd_unit2bios(rootdev->dd.d_unit);
	relocator_esi = relocater_size;
	relocator_ds = 0;
	relocator_es = 0;
	Index: stand/i386/loader/main.c
	===================================================================
	--- stand/i386/loader/main.c
	+++ stand/i386/loader/main.c
	@@ -254,18 +254,18 @@
	int biosdev = -1;

	/* Assume we are booting from a BIOS disk by default */
	- new_currdev.d_dev = &biosdisk;
	+ new_currdev.dd.d_dev = &biosdisk;

	/* new-style boot loaders such as pxeldr and cdldr */
	if (kargs->bootinfo == 0) {
	if ((kargs->bootflags & KARGS_FLAGS_CD) != 0) {
	/* we are booting from a CD with cdboot */
	- new_currdev.d_dev = &bioscd;
	- new_currdev.d_unit = bc_bios2unit(initial_bootdev);
	+ new_currdev.dd.d_dev = &bioscd;
	+ new_currdev.dd.d_unit = bc_bios2unit(initial_bootdev);
	} else if ((kargs->bootflags & KARGS_FLAGS_PXE) != 0) {
	/* we are booting from pxeldr */
	- new_currdev.d_dev = &pxedisk;
	- new_currdev.d_unit = 0;
	+ new_currdev.dd.d_dev = &pxedisk;
	+ new_currdev.dd.d_unit = 0;
	} else {
	/* we don't know what our boot device is */
	new_currdev.d_kind.biosdisk.slice = -1;
	@@ -295,7 +295,7 @@
	new_currdev.d_kind.zfs.pool_guid = kargs->zfspool;
	new_currdev.d_kind.zfs.root_guid = 0;
	}
	- new_currdev.d_dev = &zfs_dev;
	+ new_currdev.dd.d_dev = &zfs_dev;
	#endif
	} else if ((initial_bootdev & B_MAGICMASK) != B_DEVMAGIC) {
	/* The passed-in boot device is bad */
	@@ -316,21 +316,20 @@
	if ((biosdev == 0) && (B_TYPE(initial_bootdev) != 2)) /* biosdev doesn't match major */
	biosdev = 0x80 + B_UNIT(initial_bootdev); /* assume harddisk */
	}
	- new_currdev.d_type = new_currdev.d_dev->dv_type;

	/*
	* If we are booting off of a BIOS disk and we didn't succeed in determining
	* which one we booted off of, just use disk0: as a reasonable default.
	*/
	- if ((new_currdev.d_type == biosdisk.dv_type) &&
	- ((new_currdev.d_unit = bd_bios2unit(biosdev)) == -1)) {
	+ if ((new_currdev.dd.d_dev->dv_type == biosdisk.dv_type) &&
	+ ((new_currdev.dd.d_unit = bd_bios2unit(biosdev)) == -1)) {
	printf("Can't work out which disk we are booting from.\n"
	"Guessed BIOS device 0x%x not found by probes, defaulting to disk0:\n", biosdev);
	- new_currdev.d_unit = 0;
	+ new_currdev.dd.d_unit = 0;
	}

	#ifdef LOADER_ZFS_SUPPORT
	- if (new_currdev.d_type == DEVT_ZFS)
	+ if (new_currdev.dd.d_dev->dv_type == DEVT_ZFS)
	init_zfs_bootenv(zfs_fmtdev(&new_currdev));
	#endif

	Index: stand/libsa/stand.h
	===================================================================
	--- stand/libsa/stand.h
	+++ stand/libsa/stand.h
	@@ -138,6 +138,12 @@
	struct devsw {
	const char dv_name[8];
	int dv_type; /* opaque type constant, arch-dependant */
	+#define DEVT_NONE 0
	+#define DEVT_DISK 1
	+#define DEVT_NET 2
	+#define DEVT_CD 3
	+#define DEVT_ZFS 4
	+#define DEVT_FD 5
	int (dv_init)(void); / early probe call */
	int (dv_strategy)(void devdata, int rw, daddr_t blk,
	size_t size, char buf, size_t rsize);
	@@ -160,16 +166,8 @@
	* versions may be larger, but should be allowed to
	* overlap.
	*/
	-struct devdesc
	-{
	+struct devdesc {
	struct devsw *d_dev;
	- int d_type;
	-#define DEVT_NONE 0
	-#define DEVT_DISK 1
	-#define DEVT_NET 2
	-#define DEVT_CD 3
	-#define DEVT_ZFS 4
	-#define DEVT_FD 5
	int d_unit;
	void *d_opendata;
	};
	Index: stand/mips/beri/loader/beri_disk_cfi.c
	===================================================================
	--- stand/mips/beri/loader/beri_disk_cfi.c
	+++ stand/mips/beri/loader/beri_disk_cfi.c
	@@ -98,7 +98,7 @@
	dev = va_arg(ap, struct disk_devdesc *);
	va_end(ap);

	- if (dev->d_unit != 0)
	+ if (dev->dd.d_unit != 0)
	return (EIO);
	return (disk_open(dev, cfi_get_mediasize(), cfi_get_sectorsize()));
	}
	@@ -127,8 +127,8 @@
	ret = pager_output(line);
	if (ret != 0)
	return (ret);
	- dev.d_dev = &beri_cfi_disk;
	- dev.d_unit = 0;
	+ dev.dd.d_dev = &beri_cfi_disk;
	+ dev.dd.d_unit = 0;
	dev.d_slice = -1;
	dev.d_partition = -1;
	if (disk_open(&dev, cfi_get_mediasize(), cfi_get_sectorsize()) == 0) {
	Index: stand/mips/beri/loader/beri_disk_sdcard.c
	===================================================================
	--- stand/mips/beri/loader/beri_disk_sdcard.c
	+++ stand/mips/beri/loader/beri_disk_sdcard.c
	@@ -103,7 +103,7 @@
	return (ENXIO);
	}

	- if (dev->d_unit != 0)
	+ if (dev->dd.d_unit != 0)
	return (EIO);
	return (disk_open(dev, altera_sdcard_get_mediasize(),
	altera_sdcard_get_sectorsize()));
	@@ -133,8 +133,8 @@
	ret = pager_output(line);
	if (ret != 0)
	return (ret);
	- dev.d_dev = &beri_sdcard_disk;
	- dev.d_unit = 0;
	+ dev.dd.d_dev = &beri_sdcard_disk;
	+ dev.dd.d_unit = 0;
	dev.d_slice = -1;
	dev.d_partition = -1;
	if (disk_open(&dev, altera_sdcard_get_mediasize(),
	Index: stand/mips/beri/loader/devicename.c
	===================================================================
	--- stand/mips/beri/loader/devicename.c
	+++ stand/mips/beri/loader/devicename.c
	@@ -139,7 +139,7 @@
	goto fail;
	}

	- idev->d_unit = unit;
	+ idev->dd.d_unit = unit;
	if (path != NULL)
	path = (cp == 0) ? cp : cp + 1;
	break;
	@@ -148,8 +148,7 @@
	err = EINVAL;
	goto fail;
	}
	- idev->d_dev = dv;
	- idev->d_type = dv->dv_type;
	+ idev->dd.d_dev = dv;
	if (dev == NULL) {
	free(idev);
	} else {
	@@ -169,13 +168,13 @@
	struct disk_devdesc dev = (struct disk_devdesc )vdev;
	static char buf[128]; /* XXX device length constant? */

	- switch(dev->d_type) {
	+ switch(dev->dd.d_dev->dv_type) {
	case DEVT_NONE:
	strcpy(buf, "(no device)");
	break;

	case DEVT_CD:
	- sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
	+ sprintf(buf, "%s%d:", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	break;

	case DEVT_DISK:
	@@ -183,7 +182,7 @@

	case DEVT_NET:
	case DEVT_ZFS:
	- sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
	+ sprintf(buf, "%s%d:", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	break;
	}
	return(buf);
	Index: stand/ofw/libofw/devicename.c
	===================================================================
	--- stand/ofw/libofw/devicename.c
	+++ stand/ofw/libofw/devicename.c
	@@ -113,9 +113,8 @@
	return ENOMEM;
	}
	strcpy(idev->d_path, name);
	- idev->d_dev = dv;
	- idev->d_type = dv->dv_type;
	- if (idev->d_type == DEVT_ZFS) {
	+ idev->dd.d_dev = dv;
	+ if (dv->dv_type == DEVT_ZFS) {
	p = devspec + strlen(dv->dv_name);
	err = zfs_parsedev((struct zfs_devdesc *)idev, p, path);
	if (err != 0) {
	Index: stand/ofw/libofw/libofw.h
	===================================================================
	--- stand/ofw/libofw/libofw.h
	+++ stand/ofw/libofw/libofw.h
	@@ -27,14 +27,13 @@

	#include "openfirm.h"

	-/* Note: Must match the 'struct devdesc' in bootstrap.h */
	struct ofw_devdesc {
	- struct devsw *d_dev;
	- int d_type;
	- int d_unit;
	- ihandle_t d_handle;
	+ struct devdesc dd;
	union {
	- char d_path[256];
	+ struct {
	+ ihandle_t d_handle;
	+ char d_path[256];
	+ };
	struct {
	uint64_t pool_guid;
	uint64_t root_guid;
	Index: stand/sparc64/loader/main.c
	===================================================================
	--- stand/sparc64/loader/main.c
	+++ stand/sparc64/loader/main.c
	@@ -806,8 +806,7 @@
	if (guid != 0) {
	zfs_currdev.pool_guid = guid;
	zfs_currdev.root_guid = 0;
	- zfs_currdev.d_dev = &zfs_dev;
	- zfs_currdev.d_type = zfs_currdev.d_dev->dv_type;
	+ zfs_currdev.dd.d_dev = &zfs_dev;
	}
	}
	#endif /* LOADER_ZFS_SUPPORT */
	Index: stand/uboot/common/main.c
	===================================================================
	--- stand/uboot/common/main.c
	+++ stand/uboot/common/main.c
	@@ -318,7 +318,7 @@
	strcpy(partition, "<auto>");

	printf(" Checking unit=%d slice=%s partition=%s...",
	- currdev.d_unit, slice, partition);
	+ currdev.dd.d_unit, slice, partition);

	}

	@@ -338,8 +338,8 @@
	if (load_type == -1) {
	printf(" Probing all disk devices...\n");
	/* Try each disk in succession until one works. */
	- for (currdev.d_unit = 0; currdev.d_unit < UB_MAX_DEV;
	- currdev.d_unit++) {
	+ for (currdev.dd.d_unit = 0; currdev.dd.d_unit < UB_MAX_DEV;
	+ currdev.dd.d_unit++) {
	print_disk_probe_info();
	open_result = devsw[devidx]->dv_open(&f, &currdev);
	if (open_result == 0) {
	@@ -355,8 +355,8 @@
	printf(" Probing all %s devices...\n", device_typename(load_type));
	/* Try each disk of given type in succession until one works. */
	for (unit = 0; unit < UB_MAX_DEV; unit++) {
	- currdev.d_unit = uboot_diskgetunit(load_type, unit);
	- if (currdev.d_unit == -1)
	+ currdev.dd.d_unit = uboot_diskgetunit(load_type, unit);
	+ if (currdev.dd.d_unit == -1)
	break;
	print_disk_probe_info();
	open_result = devsw[devidx]->dv_open(&f, &currdev);
	@@ -369,7 +369,7 @@
	return (-1);
	}

	- if ((currdev.d_unit = uboot_diskgetunit(load_type, load_unit)) != -1) {
	+ if ((currdev.dd.d_unit = uboot_diskgetunit(load_type, load_unit)) != -1) {
	print_disk_probe_info();
	open_result = devsw[devidx]->dv_open(&f,&currdev);
	if (open_result == 0) {
	@@ -459,9 +459,8 @@

	printf("Found U-Boot device: %s\n", devsw[i]->dv_name);

	- currdev.d_dev = devsw[i];
	- currdev.d_type = currdev.d_dev->dv_type;
	- currdev.d_unit = 0;
	+ currdev.dd.d_dev = devsw[i];
	+ currdev.dd.d_unit = 0;

	if ((load_type == -1 \|\| (load_type & DEV_TYP_STOR)) &&
	strcmp(devsw[i]->dv_name, "disk") == 0) {
	Index: stand/uboot/lib/devicename.c
	===================================================================
	--- stand/uboot/lib/devicename.c
	+++ stand/uboot/lib/devicename.c
	@@ -136,7 +136,7 @@
	err = EINVAL;
	goto fail;
	}
	- idev->d_unit = unit;
	+ idev->dd.d_unit = unit;

	if (path != NULL)
	path = (cp == 0) ? cp : cp + 1;
	@@ -146,8 +146,7 @@
	err = EINVAL;
	goto fail;
	}
	- idev->d_dev = dv;
	- idev->d_type = dv->dv_type;
	+ idev->dd.d_dev = dv;
	if (dev == NULL) {
	free(idev);
	} else {
	@@ -167,7 +166,7 @@
	struct uboot_devdesc dev = (struct uboot_devdesc )vdev;
	static char buf[128];

	- switch(dev->d_type) {
	+ switch(dev->dd.d_dev->dv_type) {
	case DEVT_NONE:
	strcpy(buf, "(no device)");
	break;
	@@ -178,7 +177,7 @@
	#endif

	case DEVT_NET:
	- sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
	+ sprintf(buf, "%s%d:", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	break;
	}
	return(buf);
	Index: stand/uboot/lib/disk.c
	===================================================================
	--- stand/uboot/lib/disk.c
	+++ stand/uboot/lib/disk.c
	@@ -46,7 +46,7 @@
	#include "libuboot.h"

	#define stor_printf(fmt, args...) do { \
	- printf("%s%d: ", dev->d_dev->dv_name, dev->d_unit); \
	+ printf("%s%d: ", dev->dd.d_dev->dv_name, dev->dd.d_unit); \
	printf(fmt, ##args); \
	} while (0)

	@@ -65,7 +65,7 @@
	u_int bsize; /* block size */
	} stor_info[UB_MAX_DEV];

	-#define SI(dev) (stor_info[(dev)->d_unit])
	+#define SI(dev) (stor_info[(dev)->dd.d_unit])

	static int stor_info_no = 0;
	static int stor_opendev(struct disk_devdesc *);
	@@ -190,7 +190,7 @@
	{
	int err;

	- if (dev->d_unit < 0 \|\| dev->d_unit >= stor_info_no)
	+ if (dev->dd.d_unit < 0 \|\| dev->dd.d_unit >= stor_info_no)
	return (EIO);

	if (SI(dev).opened == 0) {
	@@ -252,8 +252,8 @@
	return (ret);

	for (i = 0; i < stor_info_no; i++) {
	- dev.d_dev = &uboot_storage;
	- dev.d_unit = i;
	+ dev.dd.d_dev = &uboot_storage;
	+ dev.dd.d_unit = i;
	dev.d_slice = -1;
	dev.d_partition = -1;
	snprintf(line, sizeof(line), "\tdisk%d (%s)\n", i,
	Index: stand/uboot/lib/libuboot.h
	===================================================================
	--- stand/uboot/lib/libuboot.h
	+++ stand/uboot/lib/libuboot.h
	@@ -27,12 +27,9 @@
	* $FreeBSD$
	*/

	-struct uboot_devdesc
	-{
	- struct devsw *d_dev;
	- int d_type;
	- int d_unit;
	- void *d_opendata;
	+/* Note: Must match the 'struct devdesc' in stand.h */
	+struct uboot_devdesc {
	+ struct devdesc dd;
	union {
	struct {
	int slice;
	Index: stand/userboot/userboot/devicename.c
	===================================================================
	--- stand/userboot/userboot/devicename.c
	+++ stand/userboot/userboot/devicename.c
	@@ -139,7 +139,7 @@
	goto fail;
	}

	- idev->d_unit = unit;
	+ idev->dd.d_unit = unit;
	if (path != NULL)
	path = (cp == 0) ? cp : cp + 1;
	break;
	@@ -158,8 +158,7 @@
	err = EINVAL;
	goto fail;
	}
	- idev->d_dev = dv;
	- idev->d_type = dv->dv_type;
	+ idev->dd.d_dev = dv;
	if (dev == NULL) {
	free(idev);
	} else {
	@@ -179,27 +178,27 @@
	struct disk_devdesc dev = (struct disk_devdesc )vdev;
	static char buf[128]; /* XXX device length constant? */

	- switch(dev->d_type) {
	+ switch(dev->dd.d_dev->dv_type) {
	case DEVT_NONE:
	strcpy(buf, "(no device)");
	break;

	case DEVT_CD:
	- sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
	+ sprintf(buf, "%s%d:", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	break;

	case DEVT_DISK:
	return (disk_fmtdev(vdev));

	case DEVT_NET:
	- sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
	+ sprintf(buf, "%s%d:", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	break;

	case DEVT_ZFS:
	#if defined(USERBOOT_ZFS_SUPPORT)
	return (zfs_fmtdev(vdev));
	#else
	- sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
	+ sprintf(buf, "%s%d:", dev->dd.d_dev->dv_name, dev->dd.d_unit);
	#endif
	break;
	}
	Index: stand/userboot/userboot/main.c
	===================================================================
	--- stand/userboot/userboot/main.c
	+++ stand/userboot/userboot/main.c
	@@ -159,13 +159,13 @@
	//bzero(&dev, sizeof(dev));

	#if defined(USERBOOT_ZFS_SUPPORT)
	+ CT_ASSERT(sizeof(struct disk_devdesc) >= sizeof(struct zfs_devdesc));
	if (userboot_zfs_found) {
	struct zfs_devdesc zdev;

	/* Leave the pool/root guid's unassigned */
	bzero(&zdev, sizeof(zdev));
	- zdev.d_dev = &zfs_dev;
	- zdev.d_type = zdev.d_dev->dv_type;
	+ zdev.dd.d_dev = &zfs_dev;

	dev = (struct disk_devdesc )&zdev;
	init_zfs_bootenv(zfs_fmtdev(&dev));
	@@ -173,23 +173,21 @@
	#endif

	if (userboot_disk_maxunit > 0) {
	- dev.d_dev = &userboot_disk;
	- dev.d_type = dev.d_dev->dv_type;
	- dev.d_unit = 0;
	+ dev.dd.d_dev = &userboot_disk;
	+ dev.dd.d_unit = 0;
	dev.d_slice = 0;
	dev.d_partition = 0;
	/*
	* If we cannot auto-detect the partition type then
	* access the disk as a raw device.
	*/
	- if (dev.d_dev->dv_open(NULL, &dev)) {
	+ if (dev.dd.d_dev->dv_open(NULL, &dev)) {
	dev.d_slice = -1;
	dev.d_partition = -1;
	}
	} else {
	- dev.d_dev = &host_dev;
	- dev.d_type = dev.d_dev->dv_type;
	- dev.d_unit = 0;
	+ dev.dd.d_dev = &host_dev;
	+ dev.dd.d_unit = 0;
	}

	env_setenv("currdev", EV_VOLATILE, userboot_fmtdev(&dev),
	Index: stand/userboot/userboot/userboot_disk.c
	===================================================================
	--- stand/userboot/userboot/userboot_disk.c
	+++ stand/userboot/userboot/userboot_disk.c
	@@ -135,8 +135,8 @@
	ret = pager_output(line);
	if (ret != 0)
	break;
	- dev.d_dev = &userboot_disk;
	- dev.d_unit = i;
	+ dev.dd.d_dev = &userboot_disk;
	+ dev.dd.d_unit = i;
	dev.d_slice = -1;
	dev.d_partition = -1;
	if (disk_open(&dev, ud_info[i].mediasize,
	@@ -164,13 +164,13 @@
	dev = va_arg(ap, struct disk_devdesc *);
	va_end(ap);

	- if (dev->d_unit < 0 \|\| dev->d_unit >= userdisk_maxunit)
	+ if (dev->dd.d_unit < 0 \|\| dev->dd.d_unit >= userdisk_maxunit)
	return (EIO);
	- ud_info[dev->d_unit].ud_open++;
	- if (ud_info[dev->d_unit].ud_bcache == NULL)
	- ud_info[dev->d_unit].ud_bcache = bcache_allocate();
	- return (disk_open(dev, ud_info[dev->d_unit].mediasize,
	- ud_info[dev->d_unit].sectorsize));
	+ ud_info[dev->dd.d_unit].ud_open++;
	+ if (ud_info[dev->dd.d_unit].ud_bcache == NULL)
	+ ud_info[dev->dd.d_unit].ud_bcache = bcache_allocate();
	+ return (disk_open(dev, ud_info[dev->dd.d_unit].mediasize,
	+ ud_info[dev->dd.d_unit].sectorsize));
	}

	static int
	@@ -179,10 +179,10 @@
	struct disk_devdesc *dev;

	dev = (struct disk_devdesc *)f->f_devdata;
	- ud_info[dev->d_unit].ud_open--;
	- if (ud_info[dev->d_unit].ud_open == 0) {
	- bcache_free(ud_info[dev->d_unit].ud_bcache);
	- ud_info[dev->d_unit].ud_bcache = NULL;
	+ ud_info[dev->dd.d_unit].ud_open--;
	+ if (ud_info[dev->dd.d_unit].ud_open == 0) {
	+ bcache_free(ud_info[dev->dd.d_unit].ud_bcache);
	+ ud_info[dev->dd.d_unit].ud_bcache = NULL;
	}
	return (disk_close(dev));
	}
	@@ -197,7 +197,7 @@
	dev = (struct disk_devdesc *)devdata;
	bcd.dv_strategy = userdisk_realstrategy;
	bcd.dv_devdata = devdata;
	- bcd.dv_cache = ud_info[dev->d_unit].ud_bcache;
	+ bcd.dv_cache = ud_info[dev->dd.d_unit].ud_bcache;
	return (bcache_strategy(&bcd, rw, dblk + dev->d_offset,
	size, buf, rsize));
	}
	@@ -218,8 +218,8 @@
	return (EINVAL);
	if (rsize)
	*rsize = 0;
	- off = dblk * ud_info[dev->d_unit].sectorsize;
	- rc = CALLBACK(diskread, dev->d_unit, off, buf, size, &resid);
	+ off = dblk * ud_info[dev->dd.d_unit].sectorsize;
	+ rc = CALLBACK(diskread, dev->dd.d_unit, off, buf, size, &resid);
	if (rc)
	return (rc);
	if (rsize)
	@@ -238,5 +238,5 @@
	if (rc != ENOTTY)
	return (rc);

	- return (CALLBACK(diskioctl, dev->d_unit, cmd, data));
	+ return (CALLBACK(diskioctl, dev->dd.d_unit, cmd, data));
	}
	Index: stand/zfs/libzfs.h
	===================================================================
	--- stand/zfs/libzfs.h
	+++ stand/zfs/libzfs.h
	@@ -33,18 +33,14 @@

	/*
	* ZFS fully-qualified device descriptor.
	- * Note, this must match the 'struct devdesc' declaration in bootstrap.h.
	* Arch-specific device descriptors should be binary compatible with this
	* structure if they are to support ZFS.
	*/
	-struct zfs_devdesc
	-{
	- struct devsw *d_dev;
	- int d_type;
	- int d_unit;
	- void *d_opendata;
	- uint64_t pool_guid;
	- uint64_t root_guid;
	+/* Note: Must match the 'struct devdesc' in stand.h */
	+struct zfs_devdesc {
	+ struct devdesc dd;
	+ uint64_t pool_guid;
	+ uint64_t root_guid;
	};

	#ifdef LOADER_GELI_SUPPORT
	Index: stand/zfs/zfs.c
	===================================================================
	--- stand/zfs/zfs.c
	+++ stand/zfs/zfs.c
	@@ -687,8 +687,7 @@
	return (rv);
	if (path != NULL)
	path = (end == '\0') ? end : end + 1;
	- dev->d_dev = &zfs_dev;
	- dev->d_type = zfs_dev.dv_type;
	+ dev->dd.d_dev = &zfs_dev;
	return (0);
	}

	@@ -701,7 +700,7 @@
	spa_t *spa;

	buf[0] = '\0';
	- if (dev->d_type != DEVT_ZFS)
	+ if (dev->dd.d_dev->dv_type != DEVT_ZFS)
	return (buf);

	if (dev->pool_guid == 0) {
	@@ -723,9 +722,9 @@
	}

	if (rootname[0] == '\0')
	- sprintf(buf, "%s:%s:", dev->d_dev->dv_name, spa->spa_name);
	+ sprintf(buf, "%s:%s:", dev->dd.d_dev->dv_name, spa->spa_name);
	else
	- sprintf(buf, "%s:%s/%s:", dev->d_dev->dv_name, spa->spa_name,
	+ sprintf(buf, "%s:%s/%s:", dev->dd.d_dev->dv_name, spa->spa_name,
	rootname);
	return (buf);
	}

File Metadata

Mime Type: text/plain
Expires: Thu, Mar 19, 11:34 PM (2 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 29985200
Default Alt Text: D13784.id40220.diff (57 KB)

D13784.id40220.diffNo OneTemporaryActions

D13784.id40220.diffView Options

File Metadata

Event Timeline

D13784.id40220.diff
No OneTemporary
Actions

D13784.id40220.diff
View Options