D13784.id40122.diff
No OneTemporary
Actions

Size

25 KB

Referenced Files

None

Subscribers

None

D13784.id40122.diff
View Options

	Index: stand/common/disk.h
	===================================================================
	--- stand/common/disk.h
	+++ stand/common/disk.h
	@@ -84,7 +84,6 @@
	struct disk_devdesc
	{
	struct devsw *d_dev;
	- int d_type;
	int d_unit;
	void *d_opendata;
	int d_slice;
	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);

	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/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/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);
	Index: stand/efi/libefi/efizfs.c
	===================================================================
	--- stand/efi/libefi/efizfs.c
	+++ stand/efi/libefi/efizfs.c
	@@ -65,6 +65,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/loader/main.c
	===================================================================
	--- stand/efi/loader/main.c
	+++ stand/efi/loader/main.c
	@@ -40,6 +40,7 @@

	#include <efi.h>
	#include <efilib.h>
	+#include <efichar.h>

	#include <uuid.h>

	@@ -76,8 +77,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 +182,186 @@
	}

	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.d_dev = dp->pd_devsw;
	+ currdev.d_opendata = NULL;
	+ if (dp->pd_parent == NULL) {
	+ currdev.d_unit = dp->pd_unit;
	+ currdev.d_slice = -1;
	+ currdev.d_partition = -1;
	+ } else {
	+ currdev.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.d_dev = &zfs_dev;
	+ currdev.d_unit = 0;
	+ currdev.d_opendata = NULL;
	+ 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 +375,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 +391,69 @@
	return (ENOENT);
	}

	+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);
	+}
	+
	+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 +462,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 +507,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 +595,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 +606,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 +641,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_getenv(&GlobalBootVarGUID, "BootCurrent", &boot_current, &sz);
	+ printf(" BootCurrent: %04x\n", boot_current);
	+
	+ sz = sizeof(boot_order);
	+ efi_getenv(&GlobalBootVarGUID, "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 +683,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 +1049,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/biosdisk.c
	===================================================================
	--- stand/i386/libi386/biosdisk.c
	+++ stand/i386/libi386/biosdisk.c
	@@ -403,7 +403,6 @@
	* 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.d_slice = -1;
	@@ -441,7 +440,7 @@
	int geli_part = 0;

	dskp.drive = bd_unit2bios(dev->d_unit);
	- dskp.type = dev->d_type;
	+ dskp.type = dev->d_dev->dv_type;
	dskp.unit = dev->d_unit;
	dskp.slice = dev->d_slice;
	dskp.part = dev->d_partition;
	@@ -872,7 +871,7 @@
	return (err);

	dskp.drive = bd_unit2bios(dev->d_unit);
	- dskp.type = dev->d_type;
	+ dskp.type = dev->d_dev->dv_type;
	dskp.unit = dev->d_unit;
	dskp.slice = dev->d_slice;
	dskp.part = dev->d_partition;
	@@ -997,7 +996,6 @@
	struct dsk *priv = xpriv;

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

	- switch(rootdev->d_type) {
	+ switch(rootdev->d_dev->dv_type) {
	case DEVT_CD:
	/* Pass in BIOS device number. */
	bi.bi_bios_dev = bc_unit2bios(rootdev->d_unit);
	@@ -199,7 +199,7 @@
	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->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
	@@ -149,7 +149,6 @@
	goto fail;
	}
	idev->d_dev = dv;
	- idev->d_type = dv->dv_type;
	if (dev == NULL) {
	free(idev);
	} else {
	@@ -169,7 +168,7 @@
	struct i386_devdesc dev = (struct i386_devdesc )vdev;
	static char buf[128]; /* XXX device length constant? */

	- switch(dev->d_type) {
	+ switch(dev->d_dev->dv_type) {
	case DEVT_NONE:
	strcpy(buf, "(no device)");
	break;
	Index: stand/i386/libi386/libi386.h
	===================================================================
	--- stand/i386/libi386/libi386.h
	+++ stand/i386/libi386/libi386.h
	@@ -36,7 +36,6 @@
	struct i386_devdesc
	{
	struct devsw *d_dev;
	- int d_type;
	int d_unit;
	union
	{
	Index: stand/i386/loader/main.c
	===================================================================
	--- stand/i386/loader/main.c
	+++ stand/i386/loader/main.c
	@@ -316,13 +316,12 @@
	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) &&
	+ if ((new_currdev.d_dev->dv_type == biosdisk.dv_type) &&
	((new_currdev.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);
	@@ -330,7 +329,7 @@
	}

	#ifdef LOADER_ZFS_SUPPORT
	- if (new_currdev.d_type == DEVT_ZFS)
	+ if (new_currdev.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);
	@@ -163,13 +169,6 @@
	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/ofw/libofw/libofw.h
	===================================================================
	--- stand/ofw/libofw/libofw.h
	+++ stand/ofw/libofw/libofw.h
	@@ -30,7 +30,6 @@
	/* 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;
	union {
	Index: stand/uboot/lib/libuboot.h
	===================================================================
	--- stand/uboot/lib/libuboot.h
	+++ stand/uboot/lib/libuboot.h
	@@ -30,7 +30,6 @@
	struct uboot_devdesc
	{
	struct devsw *d_dev;
	- int d_type;
	int d_unit;
	void *d_opendata;
	union {
	Index: stand/userboot/userboot/devicename.c
	===================================================================
	--- stand/userboot/userboot/devicename.c
	+++ stand/userboot/userboot/devicename.c
	@@ -159,7 +159,6 @@
	goto fail;
	}
	idev->d_dev = dv;
	- idev->d_type = dv->dv_type;
	if (dev == NULL) {
	free(idev);
	} else {
	@@ -179,7 +178,7 @@
	struct disk_devdesc dev = (struct disk_devdesc )vdev;
	static char buf[128]; /* XXX device length constant? */

	- switch(dev->d_type) {
	+ switch(dev->d_dev->dv_type) {
	case DEVT_NONE:
	strcpy(buf, "(no device)");
	break;
	Index: stand/userboot/userboot/main.c
	===================================================================
	--- stand/userboot/userboot/main.c
	+++ stand/userboot/userboot/main.c
	@@ -165,7 +165,6 @@
	/* Leave the pool/root guid's unassigned */
	bzero(&zdev, sizeof(zdev));
	zdev.d_dev = &zfs_dev;
	- zdev.d_type = zdev.d_dev->dv_type;

	dev = (struct disk_devdesc )&zdev;
	init_zfs_bootenv(zfs_fmtdev(&dev));
	@@ -174,7 +173,6 @@

	if (userboot_disk_maxunit > 0) {
	dev.d_dev = &userboot_disk;
	- dev.d_type = dev.d_dev->dv_type;
	dev.d_unit = 0;
	dev.d_slice = 0;
	dev.d_partition = 0;
	@@ -188,7 +186,6 @@
	}
	} else {
	dev.d_dev = &host_dev;
	- dev.d_type = dev.d_dev->dv_type;
	dev.d_unit = 0;
	}

	Index: stand/zfs/libzfs.h
	===================================================================
	--- stand/zfs/libzfs.h
	+++ stand/zfs/libzfs.h
	@@ -40,7 +40,6 @@
	struct zfs_devdesc
	{
	struct devsw *d_dev;
	- int d_type;
	int d_unit;
	void *d_opendata;
	uint64_t pool_guid;
	Index: stand/zfs/zfs.c
	===================================================================
	--- stand/zfs/zfs.c
	+++ stand/zfs/zfs.c
	@@ -688,7 +688,6 @@
	if (path != NULL)
	path = (end == '\0') ? end : end + 1;
	dev->d_dev = &zfs_dev;
	- dev->d_type = zfs_dev.dv_type;
	return (0);
	}

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

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

	if (dev->pool_guid == 0) {

File Metadata

Mime Type: text/plain
Expires: Tue, May 19, 10:14 PM (8 h, 51 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 33328387
Default Alt Text: D13784.id40122.diff (25 KB)

D13784.id40122.diffNo OneTemporaryActions

D13784.id40122.diffView Options

File Metadata

Event Timeline

D13784.id40122.diff
No OneTemporary
Actions

D13784.id40122.diff
View Options