Index: head/lib/libstand/stand.h
===================================================================
--- head/lib/libstand/stand.h
+++ head/lib/libstand/stand.h
@@ -168,6 +168,7 @@
 #define DEVT_NET	2
 #define DEVT_CD		3
 #define DEVT_ZFS	4
+#define DEVT_FD		5
     int			d_unit;
     void		*d_opendata;
 };
Index: head/sys/boot/efi/include/efilib.h
===================================================================
--- head/sys/boot/efi/include/efilib.h
+++ head/sys/boot/efi/include/efilib.h
@@ -31,16 +31,37 @@
 #define	_LOADER_EFILIB_H
 
 #include <stand.h>
+#include <sys/queue.h>
 
 extern EFI_HANDLE		IH;
 extern EFI_SYSTEM_TABLE		*ST;
 extern EFI_BOOT_SERVICES	*BS;
 extern EFI_RUNTIME_SERVICES	*RS;
 
-extern struct devsw efipart_dev;
+extern struct devsw efipart_fddev;
+extern struct devsw efipart_cddev;
+extern struct devsw efipart_hddev;
 extern struct devsw efinet_dev;
 extern struct netif_driver efinetif;
 
+/* EFI block device data, included here to help efi_zfs_probe() */
+typedef STAILQ_HEAD(pdinfo_list, pdinfo) pdinfo_list_t;
+
+typedef struct pdinfo
+{
+	STAILQ_ENTRY(pdinfo)	pd_link;	/* link in device list */
+	pdinfo_list_t		pd_part;	/* link of partitions */
+	EFI_HANDLE		pd_handle;
+	EFI_HANDLE		pd_alias;
+	EFI_DEVICE_PATH		*pd_devpath;
+	EFI_BLOCK_IO		*pd_blkio;
+	int			pd_unit;	/* unit number */
+	int			pd_open;	/* reference counter */
+	void			*pd_bcache;	/* buffer cache data */
+} pdinfo_t;
+
+pdinfo_list_t *efiblk_get_pdinfo_list(struct devsw *dev);
+
 void *efi_get_table(EFI_GUID *tbl);
 
 int efi_register_handles(struct devsw *, EFI_HANDLE *, EFI_HANDLE *, int);
@@ -53,6 +74,7 @@
 EFI_HANDLE efi_devpath_handle(EFI_DEVICE_PATH *);
 EFI_DEVICE_PATH *efi_devpath_last_node(EFI_DEVICE_PATH *);
 EFI_DEVICE_PATH *efi_devpath_trim(EFI_DEVICE_PATH *);
+int efi_devpath_match(EFI_DEVICE_PATH *, EFI_DEVICE_PATH *);
 CHAR16 *efi_devpath_name(EFI_DEVICE_PATH *);
 void efi_free_devpath_name(CHAR16 *);
 
Index: head/sys/boot/efi/libefi/devpath.c
===================================================================
--- head/sys/boot/efi/libefi/devpath.c
+++ head/sys/boot/efi/libefi/devpath.c
@@ -138,3 +138,31 @@
 		return (NULL);
 	return (h);
 }
+
+int
+efi_devpath_match(EFI_DEVICE_PATH *devpath1, EFI_DEVICE_PATH *devpath2)
+{
+	int len;
+
+	if (devpath1 == NULL || devpath2 == NULL)
+		return (0);
+
+	while (1) {
+		if (DevicePathType(devpath1) != DevicePathType(devpath2) ||
+		    DevicePathSubType(devpath1) != DevicePathSubType(devpath2))
+			return (0);
+
+		len = DevicePathNodeLength(devpath1);
+		if (len != DevicePathNodeLength(devpath2))
+			return (0);
+
+		if (memcmp(devpath1, devpath2, (size_t)len) != 0)
+			return (0);
+
+		if (IsDevicePathEnd(devpath1))
+			break;
+		devpath1 = NextDevicePathNode(devpath1);
+		devpath2 = NextDevicePathNode(devpath2);
+	}
+	return (1);
+}
Index: head/sys/boot/efi/libefi/efipart.c
===================================================================
--- head/sys/boot/efi/libefi/efipart.c
+++ head/sys/boot/efi/libefi/efipart.c
@@ -27,8 +27,10 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
+#include <sys/disk.h>
 #include <sys/param.h>
 #include <sys/time.h>
+#include <sys/queue.h>
 #include <stddef.h>
 #include <stdarg.h>
 
@@ -37,57 +39,110 @@
 #include <efi.h>
 #include <efilib.h>
 #include <efiprot.h>
+#include <disk.h>
 
 static EFI_GUID blkio_guid = BLOCK_IO_PROTOCOL;
 
-static int efipart_init(void);
+static int efipart_initfd(void);
+static int efipart_initcd(void);
+static int efipart_inithd(void);
+
 static int efipart_strategy(void *, int, daddr_t, size_t, char *, size_t *);
 static int efipart_realstrategy(void *, int, daddr_t, size_t, char *, size_t *);
+
 static int efipart_open(struct open_file *, ...);
 static int efipart_close(struct open_file *);
-static int efipart_print(int);
+static int efipart_ioctl(struct open_file *, u_long, void *);
 
-struct devsw efipart_dev = {
-	.dv_name = "part",
-	.dv_type = DEVT_DISK,
-	.dv_init = efipart_init,
+static int efipart_printfd(int);
+static int efipart_printcd(int);
+static int efipart_printhd(int);
+
+struct devsw efipart_fddev = {
+	.dv_name = "fd",
+	.dv_type = DEVT_FD,
+	.dv_init = efipart_initfd,
 	.dv_strategy = efipart_strategy,
 	.dv_open = efipart_open,
 	.dv_close = efipart_close,
-	.dv_ioctl = noioctl,
-	.dv_print = efipart_print,
+	.dv_ioctl = efipart_ioctl,
+	.dv_print = efipart_printfd,
 	.dv_cleanup = NULL
 };
 
-/*
- * info structure to support bcache
- */
-struct pdinfo {
-	int	pd_unit;	/* unit number */
-	int	pd_open;	/* reference counter */
-	void	*pd_bcache;	/* buffer cache data */
+struct devsw efipart_cddev = {
+	.dv_name = "cd",
+	.dv_type = DEVT_CD,
+	.dv_init = efipart_initcd,
+	.dv_strategy = efipart_strategy,
+	.dv_open = efipart_open,
+	.dv_close = efipart_close,
+	.dv_ioctl = efipart_ioctl,
+	.dv_print = efipart_printcd,
+	.dv_cleanup = NULL
 };
-static struct pdinfo *pdinfo;
-static int npdinfo = 0;
 
-#define PD(dev)         (pdinfo[(dev)->d_unit])
+struct devsw efipart_hddev = {
+	.dv_name = "disk",
+	.dv_type = DEVT_DISK,
+	.dv_init = efipart_inithd,
+	.dv_strategy = efipart_strategy,
+	.dv_open = efipart_open,
+	.dv_close = efipart_close,
+	.dv_ioctl = efipart_ioctl,
+	.dv_print = efipart_printhd,
+	.dv_cleanup = NULL
+};
+
+static pdinfo_list_t fdinfo;
+static pdinfo_list_t cdinfo;
+static pdinfo_list_t hdinfo;
+
+static EFI_HANDLE *efipart_handles = NULL;
+static UINTN efipart_nhandles = 0;
+
+static pdinfo_t *
+efiblk_get_pdinfo(pdinfo_list_t *pdi, int unit)
+{
+	pdinfo_t *pd;
+
+	STAILQ_FOREACH(pd, pdi, pd_link) {
+		if (pd->pd_unit == unit)
+			return (pd);
+	}
+	return (NULL);
+}
 
 static int
-efipart_init(void) 
+efiblk_pdinfo_count(pdinfo_list_t *pdi)
+{
+	pdinfo_t *pd;
+	int i = 0;
+
+	STAILQ_FOREACH(pd, pdi, pd_link) {
+		i++;
+	}
+	return (i);
+}
+
+static int
+efipart_inithandles(void)
 {
-	EFI_BLOCK_IO *blkio;
-	EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
-	EFI_HANDLE *hin, *hout, *aliases, handle;
-	EFI_STATUS status;
 	UINTN sz;
-	u_int n, nin, nout, nrdisk;
-	int err;
+	EFI_HANDLE *hin;
+	EFI_STATUS status;
+
+	if (efipart_nhandles != 0) {
+		free(efipart_handles);
+		efipart_handles = NULL;
+		efipart_nhandles = 0;
+	}
 
 	sz = 0;
 	hin = NULL;
-	status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, 0);
+	status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
 	if (status == EFI_BUFFER_TOO_SMALL) {
-		hin = (EFI_HANDLE *)malloc(sz * 3);
+		hin = malloc(sz);
 		status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
 		    hin);
 		if (EFI_ERROR(status))
@@ -96,33 +151,150 @@
 	if (EFI_ERROR(status))
 		return (efi_status_to_errno(status));
 
-	/* Filter handles to only include FreeBSD partitions. */
-	nin = sz / sizeof(EFI_HANDLE);
-	hout = hin + nin;
-	aliases = hout + nin;
-	nout = 0;
-	nrdisk = 0;
-
-	bzero(aliases, nin * sizeof(EFI_HANDLE));
-	pdinfo = malloc(nin * sizeof(*pdinfo));
-	if (pdinfo == NULL)
-		return (ENOMEM);
+	efipart_handles = hin;
+	efipart_nhandles = sz;
+	return (0);
+}
 
-	for (n = 0; n < nin; n++) {
-		devpath = efi_lookup_devpath(hin[n]);
-		if (devpath == NULL) {
-			continue;
+static ACPI_HID_DEVICE_PATH *
+efipart_floppy(EFI_DEVICE_PATH *node)
+{
+	ACPI_HID_DEVICE_PATH *acpi = NULL;
+
+	if (DevicePathType(node) == ACPI_DEVICE_PATH &&
+	    DevicePathSubType(node) == ACPI_DP) {
+		acpi = (ACPI_HID_DEVICE_PATH *) node;
+		if (acpi->HID == EISA_PNP_ID(0x604) ||
+		    acpi->HID == EISA_PNP_ID(0x700) ||
+		    acpi->HID == EISA_ID(0x41d1, 0x701)) {
+			return (acpi);
 		}
+	}
+	return (acpi);
+}
 
-		status = BS->HandleProtocol(hin[n], &blkio_guid,
-		    (void**)&blkio);
-		if (EFI_ERROR(status))
+/*
+ * Add or update entries with new handle data.
+ */
+static int
+efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
+{
+	pdinfo_t *fd;
+
+	fd = malloc(sizeof(pdinfo_t));
+	if (fd == NULL) {
+		printf("Failed to register floppy %d, out of memory\n", uid);
+		return (ENOMEM);
+	}
+	memset(fd, 0, sizeof(pdinfo_t));
+	STAILQ_INIT(&fd->pd_part);
+
+	fd->pd_unit = uid;
+	fd->pd_handle = handle;
+	fd->pd_devpath = devpath;
+	STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
+	return (0);
+}
+
+static void
+efipart_updatefd(void)
+{
+	EFI_DEVICE_PATH *devpath, *node;
+	ACPI_HID_DEVICE_PATH *acpi;
+	int i, nin;
+
+	nin = efipart_nhandles / sizeof (*efipart_handles);
+	for (i = 0; i < nin; i++) {
+		devpath = efi_lookup_devpath(efipart_handles[i]);
+		if (devpath == NULL)
 			continue;
-		if (!blkio->Media->LogicalPartition) {
-			nrdisk++;
+
+		if ((node = efi_devpath_last_node(devpath)) == NULL)
 			continue;
+		if ((acpi = efipart_floppy(node)) != NULL) {
+			efipart_fdinfo_add(efipart_handles[i], acpi->UID,
+			    devpath);
+		}
+	}
+}
+
+static int
+efipart_initfd(void)
+{
+	int rv;
+
+	rv = efipart_inithandles();
+	if (rv != 0)
+		return (rv);
+	STAILQ_INIT(&fdinfo);
+
+	efipart_updatefd();
+
+	bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
+	return (0);
+}
+
+/*
+ * Add or update entries with new handle data.
+ */
+static int
+efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias,
+    EFI_DEVICE_PATH *devpath)
+{
+	int unit;
+	pdinfo_t *cd;
+	pdinfo_t *pd;
+
+	unit = 0;
+	STAILQ_FOREACH(pd, &cdinfo, pd_link) {
+		if (efi_devpath_match(pd->pd_devpath, devpath) != 0) {
+			pd->pd_handle = handle;
+			pd->pd_alias = alias;
+			return (0);
 		}
+		unit++;
+	}
+ 
+	cd = malloc(sizeof(pdinfo_t));
+	if (cd == NULL) {
+		printf("Failed to add cd %d, out of memory\n", unit);
+		return (ENOMEM);
+	}
+	memset(cd, 0, sizeof(pdinfo_t));
+	STAILQ_INIT(&cd->pd_part);
+
+	cd->pd_handle = handle;
+	cd->pd_unit = unit;
+	cd->pd_alias = alias;
+	cd->pd_devpath = devpath;
+	STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
+	return (0);
+}
+
+static void
+efipart_updatecd(void)
+{
+	int i, nin;
+	EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
+	EFI_HANDLE handle;
+	EFI_BLOCK_IO *blkio;
+	EFI_STATUS status;
 
+	nin = efipart_nhandles / sizeof (*efipart_handles);
+	for (i = 0; i < nin; i++) {
+		devpath = efi_lookup_devpath(efipart_handles[i]);
+		if (devpath == NULL)
+			continue;
+
+		if ((node = efi_devpath_last_node(devpath)) == NULL)
+			continue;
+		if (efipart_floppy(node) != NULL)
+			continue;
+ 
+		status = BS->HandleProtocol(efipart_handles[i],
+		    &blkio_guid, (void **)&blkio);
+		if (EFI_ERROR(status))
+			continue;
 		/*
 		 * If we come across a logical partition of subtype CDROM
 		 * it doesn't refer to the CD filesystem itself, but rather
@@ -130,8 +302,6 @@
 		 * we try to find the parent device and add that instead as
 		 * that will be the CD filesystem.
 		 */
-		if ((node = efi_devpath_last_node(devpath)) == NULL)
-			continue;
 		if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
 		    DevicePathSubType(node) == MEDIA_CDROM_DP) {
 			devpathcpy = efi_devpath_trim(devpath);
@@ -143,109 +313,400 @@
 			free(devpathcpy);
 			if (EFI_ERROR(status))
 				continue;
-			hout[nout] = handle;
-			aliases[nout] = hin[n];
-		} else
-			hout[nout] = hin[n];
-		nout++;
-		pdinfo[npdinfo].pd_open = 0;
-		pdinfo[npdinfo].pd_bcache = NULL;
-		pdinfo[npdinfo].pd_unit = npdinfo;
-		npdinfo++;
+			devpath = efi_lookup_devpath(handle);
+			efipart_cdinfo_add(handle, efipart_handles[i],
+			    devpath);
+			continue;
+		}
+
+		if (DevicePathType(node) == MESSAGING_DEVICE_PATH &&
+		    DevicePathSubType(node) == MSG_ATAPI_DP) {
+			efipart_cdinfo_add(efipart_handles[i], NULL,
+			    devpath);
+			continue;
+		}
+
+		/* USB or SATA cd without the media. */
+		if (blkio->Media->RemovableMedia &&
+		    !blkio->Media->MediaPresent) {
+			efipart_cdinfo_add(efipart_handles[i], NULL,
+			    devpath);
+		}
 	}
+}
 
-	bcache_add_dev(npdinfo);
-	err = efi_register_handles(&efipart_dev, hout, aliases, nout);
-	free(hin);
+static int
+efipart_initcd(void)
+{
+	int rv;
+
+	rv = efipart_inithandles();
+	if (rv != 0)
+		return (rv);
+	STAILQ_INIT(&cdinfo);
 
-	if (nout == 0 && nrdisk > 0)
-		printf("Found %d disk(s) but no logical partition\n", nrdisk);
-	return (err);
+	efipart_updatecd();
+
+	bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
+	return (0);
 }
 
 static int
-efipart_print(int verbose)
+efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle)
 {
-	char line[80];
+	EFI_DEVICE_PATH *disk_devpath, *part_devpath;
+	HARDDRIVE_DEVICE_PATH *node;
+	int unit;
+	pdinfo_t *hd, *pd, *last;
+
+	disk_devpath = efi_lookup_devpath(disk_handle);
+	part_devpath = efi_lookup_devpath(part_handle);
+	if (disk_devpath == NULL || part_devpath == NULL) {
+		return (ENOENT);
+	}
+
+	pd = malloc(sizeof(pdinfo_t));
+	if (pd == NULL) {
+		printf("Failed to add disk, out of memory\n");
+		return (ENOMEM);
+	}
+	memset(pd, 0, sizeof(pdinfo_t));
+	STAILQ_INIT(&pd->pd_part);
+	node = (HARDDRIVE_DEVICE_PATH *)efi_devpath_last_node(part_devpath);
+
+	STAILQ_FOREACH(hd, &hdinfo, pd_link) {
+		if (efi_devpath_match(hd->pd_devpath, disk_devpath) != 0) {
+			/* Add the partition. */
+			pd->pd_handle = part_handle;
+			pd->pd_unit = node->PartitionNumber;
+			pd->pd_devpath = part_devpath;
+			STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
+			return (0);
+		}
+	}
+
+	last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
+	if (last != NULL)
+		unit = last->pd_unit + 1;
+	else
+		unit = 0;
+
+	/* Add the disk. */
+	hd = pd;
+	hd->pd_handle = disk_handle;
+	hd->pd_unit = unit;
+	hd->pd_devpath = disk_devpath;
+	STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
+
+	pd = malloc(sizeof(pdinfo_t));
+	if (pd == NULL) {
+		printf("Failed to add partition, out of memory\n");
+		return (ENOMEM);
+	}
+	memset(pd, 0, sizeof(pdinfo_t));
+	STAILQ_INIT(&pd->pd_part);
+
+	/* Add the partition. */
+	pd->pd_handle = part_handle;
+	pd->pd_unit = node->PartitionNumber;
+	pd->pd_devpath = part_devpath;
+	STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
+
+	return (0);
+}
+
+static void
+efipart_updatehd(void)
+{
+	int i, nin;
+	EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
+	EFI_HANDLE handle;
 	EFI_BLOCK_IO *blkio;
-	EFI_HANDLE h;
 	EFI_STATUS status;
-	u_int unit;
+
+	nin = efipart_nhandles / sizeof (*efipart_handles);
+	for (i = 0; i < nin; i++) {
+		devpath = efi_lookup_devpath(efipart_handles[i]);
+		if (devpath == NULL)
+			continue;
+
+		if ((node = efi_devpath_last_node(devpath)) == NULL)
+			continue;
+		if (efipart_floppy(node) != NULL)
+			continue;
+
+		status = BS->HandleProtocol(efipart_handles[i],
+		    &blkio_guid, (void **)&blkio);
+		if (EFI_ERROR(status))
+			continue;
+
+		if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
+		    DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) {
+			devpathcpy = efi_devpath_trim(devpath);
+			if (devpathcpy == NULL)
+				continue;
+			tmpdevpath = devpathcpy;
+			status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath,
+			    &handle);
+			free(devpathcpy);
+			if (EFI_ERROR(status))
+				continue;
+			/*
+			 * We do not support nested partitions.
+			 */
+			devpathcpy = efi_lookup_devpath(handle);
+			if (devpathcpy == NULL)
+				continue;
+			if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
+				continue;
+			if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
+			    DevicePathSubType(node) == MEDIA_HARDDRIVE_DP)
+				continue;
+			efipart_hdinfo_add(handle, efipart_handles[i]);
+			continue;
+		}
+	}
+}
+
+static int
+efipart_inithd(void)
+{
+	int rv;
+
+	rv = efipart_inithandles();
+	if (rv != 0)
+		return (rv);
+	STAILQ_INIT(&hdinfo);
+
+	efipart_updatehd();
+
+	bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
+	return (0);
+}
+
+static int
+efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
+{
 	int ret = 0;
+	EFI_BLOCK_IO *blkio;
+	EFI_STATUS status;
+	EFI_HANDLE h;
+	pdinfo_t *pd;
+	CHAR16 *text;
+	struct disk_devdesc pd_dev;
+	char line[80];
 
-	printf("%s devices:", efipart_dev.dv_name);
+	if (STAILQ_EMPTY(pdlist))
+		return (0);
+ 
+	printf("%s devices:", dev->dv_name);
 	if ((ret = pager_output("\n")) != 0)
 		return (ret);
 
-	for (unit = 0, h = efi_find_handle(&efipart_dev, 0);
-	    h != NULL; h = efi_find_handle(&efipart_dev, ++unit)) {
-		snprintf(line, sizeof(line), "    %s%d:",
-		    efipart_dev.dv_name, unit);
-		if ((ret = pager_output(line)) != 0)
-			break;
-
+	STAILQ_FOREACH(pd, pdlist, pd_link) {
+		h = pd->pd_handle;
+		if (verbose) {  /* Output the device path. */
+			text = efi_devpath_name(efi_lookup_devpath(h));
+			if (text != NULL) {
+				printf("  %S", text);
+				efi_free_devpath_name(text);
+				if ((ret = pager_output("\n")) != 0)
+					break;
+			}
+		}
+		snprintf(line, sizeof(line),
+		    "    %s%d", dev->dv_name, pd->pd_unit);
+		printf("%s:", line);
 		status = BS->HandleProtocol(h, &blkio_guid, (void **)&blkio);
 		if (!EFI_ERROR(status)) {
-			snprintf(line, sizeof(line), "    %llu blocks",
-			    (unsigned long long)(blkio->Media->LastBlock + 1));
-			if ((ret = pager_output(line)) != 0)
+			printf("    %llu",
+			    blkio->Media->LastBlock == 0? 0:
+			    (unsigned long long) (blkio->Media->LastBlock + 1));
+			if (blkio->Media->LastBlock != 0) {
+				printf(" X %u", blkio->Media->BlockSize);
+			}
+			printf(" blocks");
+			if (blkio->Media->MediaPresent) {
+				if (blkio->Media->RemovableMedia)
+					printf(" (removable)");
+			} else
+				printf(" (no media)");
+			if ((ret = pager_output("\n")) != 0)
+				break;
+			if (!blkio->Media->MediaPresent)
+				continue;
+
+			pd->pd_blkio = blkio;
+			pd_dev.d_dev = dev;
+			pd_dev.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,
+			    blkio->Media->RemovableMedia? DISK_F_NOCACHE: 0);
+			if (ret == 0) {
+				ret = disk_print(&pd_dev, line, verbose);
+				disk_close(&pd_dev);
+				if (ret != 0)
+					return (ret);
+			} else {
+				/* Do not fail from disk_open() */
+				ret = 0;
+			}
+		} else {
+			if ((ret = pager_output("\n")) != 0)
 				break;
-			if (blkio->Media->RemovableMedia)
-				if ((ret = pager_output(" (removable)")) != 0)
-					break;
 		}
-		if ((ret = pager_output("\n")) != 0)
-			break;
 	}
 	return (ret);
 }
 
 static int
+efipart_printfd(int verbose)
+{
+	return (efipart_print_common(&efipart_fddev, &fdinfo, verbose));
+}
+
+static int
+efipart_printcd(int verbose)
+{
+	return (efipart_print_common(&efipart_cddev, &cdinfo, verbose));
+}
+
+static int
+efipart_printhd(int verbose)
+{
+	return (efipart_print_common(&efipart_hddev, &hdinfo, verbose));
+}
+
+pdinfo_list_t *
+efiblk_get_pdinfo_list(struct devsw *dev)
+{
+	if (dev->dv_type == DEVT_DISK)
+		return (&hdinfo);
+	if (dev->dv_type == DEVT_CD)
+		return (&cdinfo);
+	if (dev->dv_type == DEVT_FD)
+		return (&fdinfo);
+	return (NULL);
+}
+
+static int
 efipart_open(struct open_file *f, ...)
 {
 	va_list args;
-	struct devdesc *dev;
+	struct disk_devdesc *dev;
+	pdinfo_list_t *pdi;
+	pdinfo_t *pd;
 	EFI_BLOCK_IO *blkio;
-	EFI_HANDLE h;
 	EFI_STATUS status;
 
 	va_start(args, f);
-	dev = va_arg(args, struct devdesc*);
+	dev = va_arg(args, struct disk_devdesc*);
 	va_end(args);
+	if (dev == NULL)
+		return (EINVAL);
 
-	h = efi_find_handle(&efipart_dev, dev->d_unit);
-	if (h == NULL)
+	pdi = efiblk_get_pdinfo_list(dev->d_dev);
+	if (pdi == NULL)
 		return (EINVAL);
 
-	status = BS->HandleProtocol(h, &blkio_guid, (void **)&blkio);
-	if (EFI_ERROR(status))
-		return (efi_status_to_errno(status));
+	pd = efiblk_get_pdinfo(pdi, dev->d_unit);
+	if (pd == NULL)
+		return (EIO);
+ 
+	if (pd->pd_blkio == NULL) {
+		status = BS->HandleProtocol(pd->pd_handle, &blkio_guid,
+		    (void **)&pd->pd_blkio);
+		if (EFI_ERROR(status))
+			return (efi_status_to_errno(status));
+	}
 
+	blkio = pd->pd_blkio;
 	if (!blkio->Media->MediaPresent)
 		return (EAGAIN);
 
-	dev->d_opendata = blkio;
-	PD(dev).pd_open++;
-	if (PD(dev).pd_bcache == NULL)
-		PD(dev).pd_bcache = bcache_allocate();
+	pd->pd_open++;
+	if (pd->pd_bcache == NULL)
+		pd->pd_bcache = bcache_allocate();
+
+	if (dev->d_dev->dv_type == DEVT_DISK) {
+		return (disk_open(dev,
+		    blkio->Media->BlockSize * (blkio->Media->LastBlock + 1),
+		    blkio->Media->BlockSize,
+		    blkio->Media->RemovableMedia? DISK_F_NOCACHE: 0));
+	}
 	return (0);
 }
 
 static int
 efipart_close(struct open_file *f)
 {
-	struct devdesc *dev;
+	struct disk_devdesc *dev;
+	pdinfo_list_t *pdi;
+	pdinfo_t *pd;
 
-	dev = (struct devdesc *)(f->f_devdata);
-	if (dev->d_opendata == NULL)
+	dev = (struct disk_devdesc *)(f->f_devdata);
+	if (dev == NULL)
+		return (EINVAL);
+	pdi = efiblk_get_pdinfo_list(dev->d_dev);
+	if (pdi == NULL)
 		return (EINVAL);
 
-	dev->d_opendata = NULL;
-	PD(dev).pd_open--;
-	if (PD(dev).pd_open == 0) {
-		bcache_free(PD(dev).pd_bcache);
-		PD(dev).pd_bcache = NULL;
+	pd = efiblk_get_pdinfo(pdi, dev->d_unit);
+	if (pd == NULL)
+		return (EINVAL);
+
+	pd->pd_open--;
+	if (pd->pd_open == 0) {
+		pd->pd_blkio = NULL;
+		bcache_free(pd->pd_bcache);
+		pd->pd_bcache = NULL;
 	}
+	if (dev->d_dev->dv_type == DEVT_DISK)
+		return (disk_close(dev));
+	return (0);
+}
+
+static int
+efipart_ioctl(struct open_file *f, u_long cmd, void *data)
+{
+	struct disk_devdesc *dev;
+	pdinfo_list_t *pdi;
+	pdinfo_t *pd;
+	int rc;
+
+	dev = (struct disk_devdesc *)(f->f_devdata);
+	if (dev == NULL)
+		return (EINVAL);
+	pdi = efiblk_get_pdinfo_list(dev->d_dev);
+	if (pdi == NULL)
+		return (EINVAL);
+
+	pd = efiblk_get_pdinfo(pdi, dev->d_unit);
+	if (pd == NULL)
+		return (EINVAL);
+
+	if (dev->d_dev->dv_type == DEVT_DISK) {
+		rc = disk_ioctl(dev, cmd, data);
+		if (rc != ENOTTY)
+			return (rc);
+	}
+
+	switch (cmd) {
+	case DIOCGSECTORSIZE:
+		*(u_int *)data = pd->pd_blkio->Media->BlockSize;
+		break;
+	case DIOCGMEDIASIZE:
+		*(off_t *)data = pd->pd_blkio->Media->BlockSize *
+		    (pd->pd_blkio->Media->LastBlock + 1);
+		break;
+	default:
+		return (ENOTTY);
+	}
+
 	return (0);
 }
 
@@ -294,12 +755,29 @@
     char *buf, size_t *rsize)
 {
 	struct bcache_devdata bcd;
-	struct devdesc *dev;
+	struct disk_devdesc *dev;
+	pdinfo_list_t *pdi;
+	pdinfo_t *pd;
+
+	dev = (struct disk_devdesc *)devdata;
+	if (dev == NULL)
+		return (EINVAL);
+	pdi = efiblk_get_pdinfo_list(dev->d_dev);
+	if (pdi == NULL)
+		return (EINVAL);
+
+	pd = efiblk_get_pdinfo(pdi, dev->d_unit);
+	if (pd == NULL)
+		return (EINVAL);
 
-	dev = (struct devdesc *)devdata;
 	bcd.dv_strategy = efipart_realstrategy;
 	bcd.dv_devdata = devdata;
-	bcd.dv_cache = PD(dev).pd_bcache;
+	bcd.dv_cache = pd->pd_bcache;
+
+	if (dev->d_dev->dv_type == DEVT_DISK) {
+		return (bcache_strategy(&bcd, rw, blk + dev->d_offset,
+		    size, buf, rsize));
+	}
 	return (bcache_strategy(&bcd, rw, blk, size, buf, rsize));
 }
 
@@ -307,7 +785,9 @@
 efipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
     char *buf, size_t *rsize)
 {
-	struct devdesc *dev = (struct devdesc *)devdata;
+	struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
+	pdinfo_list_t *pdi;
+	pdinfo_t *pd;
 	EFI_BLOCK_IO *blkio;
 	off_t off;
 	char *blkbuf;
@@ -317,7 +797,15 @@
 	if (dev == NULL || blk < 0)
 		return (EINVAL);
 
-	blkio = dev->d_opendata;
+	pdi = efiblk_get_pdinfo_list(dev->d_dev);
+	if (pdi == NULL)
+		return (EINVAL);
+
+	pd = efiblk_get_pdinfo(pdi, dev->d_unit);
+	if (pd == NULL)
+		return (EINVAL);
+
+	blkio = pd->pd_blkio;
 	if (blkio == NULL)
 		return (ENXIO);
 
Index: head/sys/boot/efi/loader/conf.c
===================================================================
--- head/sys/boot/efi/loader/conf.c
+++ head/sys/boot/efi/loader/conf.c
@@ -36,7 +36,9 @@
 #endif
 
 struct devsw *devsw[] = {
-	&efipart_dev,
+	&efipart_fddev,
+	&efipart_cddev,
+	&efipart_hddev,
 	&efinet_dev,
 #ifdef EFI_ZFS_BOOT
 	&zfs_dev,
Index: head/sys/boot/efi/loader/devicename.c
===================================================================
--- head/sys/boot/efi/loader/devicename.c
+++ head/sys/boot/efi/loader/devicename.c
@@ -33,6 +33,7 @@
 #include <sys/disklabel.h>
 #include <sys/param.h>
 #include <bootstrap.h>
+#include <disk.h>
 #ifdef EFI_ZFS_BOOT
 #include <libzfs.h>
 #endif
@@ -90,7 +91,7 @@
 	struct devsw *dv;
 	char *cp;
 	const char *np;
-	int i;
+	int i, err;
 
 	/* minimum length check */
 	if (strlen(devspec) < 2)
@@ -106,11 +107,26 @@
 		return (ENOENT);
 
 	np = devspec + strlen(dv->dv_name);
+	err = 0;
 
-#ifdef EFI_ZFS_BOOT
-	if (dv->dv_type == DEVT_ZFS) {
-		int err;
+	switch (dv->dv_type) {
+	case DEVT_NONE:
+		break;
+
+	case DEVT_DISK:
+		idev = malloc(sizeof(struct disk_devdesc));
+		if (idev == NULL)
+			return (ENOMEM);
+
+		err = disk_parsedev((struct disk_devdesc *)idev, np, path);
+		if (err != 0) {
+			free(idev);
+			return (err);
+		}
+		break;
 
+#ifdef EFI_ZFS_BOOT
+	case DEVT_ZFS:
 		idev = malloc(sizeof(struct zfs_devdesc));
 		if (idev == NULL)
 			return (ENOMEM);
@@ -120,34 +136,35 @@
 			free(idev);
 			return (err);
 		}
-		cp = strchr(np + 1, ':');
-	} else
+		break;
 #endif
-	{
+	default:
 		idev = malloc(sizeof(struct devdesc));
 		if (idev == NULL)
 			return (ENOMEM);
 
-		idev->d_dev = dv;
-		idev->d_type = dv->dv_type;
 		idev->d_unit = -1;
+		cp = (char *)np;
 		if (*np != '\0' && *np != ':') {
 			idev->d_unit = strtol(np, &cp, 0);
 			if (cp == np) {
-				idev->d_unit = -1;
 				free(idev);
 				return (EUNIT);
 			}
 		}
-	}
+		if (*cp != '\0' && *cp != ':') {
+			free(idev);
+			return (EINVAL);
+		}
 
-	if (*cp != '\0' && *cp != ':') {
-		free(idev);
-		return (EINVAL);
+		if (path != NULL)
+			*path = (*cp == 0) ? cp : cp + 1;
+		break;
 	}
 
-	if (path != NULL)
-		*path = (*cp == 0) ? cp : cp + 1;
+	idev->d_dev = dv;
+	idev->d_type = dv->dv_type;
+
 	if (dev != NULL)
 		*dev = idev;
 	else
@@ -162,14 +179,17 @@
 	static char buf[SPECNAMELEN + 1];
 
 	switch(dev->d_type) {
-#ifdef EFI_ZFS_BOOT
-	case DEVT_ZFS:
-		return (zfs_fmtdev(dev));
-#endif
 	case DEVT_NONE:
 		strcpy(buf, "(no device)");
 		break;
 
+	case DEVT_DISK:
+		return (disk_fmtdev(vdev));
+
+#ifdef EFI_ZFS_BOOT
+	case DEVT_ZFS:
+		return (zfs_fmtdev(dev));
+#endif
 	default:
 		sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
 		break;
Index: head/sys/boot/efi/loader/main.c
===================================================================
--- head/sys/boot/efi/loader/main.c
+++ head/sys/boot/efi/loader/main.c
@@ -35,6 +35,7 @@
 #include <stand.h>
 #include <string.h>
 #include <setjmp.h>
+#include <disk.h>
 
 #include <efi.h>
 #include <efilib.h>
@@ -70,6 +71,7 @@
 
 #ifdef EFI_ZFS_BOOT
 static void efi_zfs_probe(void);
+static uint64_t pool_guid;
 #endif
 
 static int
@@ -154,12 +156,107 @@
 	return retval;
 }
 
+static void
+set_devdesc_currdev(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;
+	devname = efi_fmtdev(&currdev);
+
+	env_setenv("currdev", EV_VOLATILE, devname, efi_setcurrdev,
+	    env_nounset);
+	env_setenv("loaddev", EV_VOLATILE, devname, env_noset, env_nounset);
+}
+
 static int
-find_currdev(EFI_LOADED_IMAGE *img, struct devsw **dev, int *unit,
-    uint64_t *extra)
+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;
+	struct devsw *dev;
+	int unit;
+	uint64_t extra;
+
+	/* Did efi_zfs_probe() detect the boot pool? */
+	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);
+		return (0);
+	}
+
+	/* 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);
+			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);
+			}
+		}
+	}
+
+	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);
+		}
+	}
+
+	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);
+			return (0);
+		}
+	}
 
 	/*
 	 * Try the device handle from our loaded image first.  If that
@@ -167,8 +264,10 @@
 	 * any of the nodes in that path match one of the enumerated
 	 * handles.
 	 */
-	if (efi_handle_lookup(img->DeviceHandle, dev, unit, extra) == 0)
+	if (efi_handle_lookup(img->DeviceHandle, &dev, &unit, &extra) == 0) {
+		set_devdesc_currdev(dev, unit);
 		return (0);
+	}
 
 	copy = NULL;
 	devpath = efi_lookup_image_devpath(IH);
@@ -180,8 +279,10 @@
 		free(copy);
 		copy = NULL;
 
-		if (efi_handle_lookup(h, dev, unit, extra) == 0)
+		if (efi_handle_lookup(h, &dev, &unit, &extra) == 0) {
+			set_devdesc_currdev(dev, unit);
 			return (0);
+		}
 
 		devpath = efi_lookup_devpath(h);
 		if (devpath != NULL) {
@@ -191,11 +292,6 @@
 	}
 	free(copy);
 
-	/* Try to fallback on first device */
-	if (devsw[0] != NULL) {
-		*dev = devsw[0];
-		return (0);
-	}
 	return (ENOENT);
 }
 
@@ -205,9 +301,7 @@
 	char var[128];
 	EFI_LOADED_IMAGE *img;
 	EFI_GUID *guid;
-	int i, j, vargood, unit, howto;
-	struct devsw *dev;
-	uint64_t pool_guid;
+	int i, j, vargood, howto;
 	UINTN k;
 	int has_kbd;
 	char buf[40];
@@ -376,43 +470,9 @@
 	 */
 	BS->SetWatchdogTimer(0, 0, 0, NULL);
 
-	if (find_currdev(img, &dev, &unit, &pool_guid) != 0)
+	if (find_currdev(img) != 0)
 		return (EFI_NOT_FOUND);
 
-	switch (dev->dv_type) {
-#ifdef EFI_ZFS_BOOT
-	case DEVT_ZFS: {
-		struct zfs_devdesc currdev;
-
-		currdev.d_dev = dev;
-		currdev.d_unit = unit;
-		currdev.d_type = currdev.d_dev->dv_type;
-		currdev.d_opendata = NULL;
-		currdev.pool_guid = pool_guid;
-		currdev.root_guid = 0;
-		env_setenv("currdev", EV_VOLATILE, efi_fmtdev(&currdev),
-			   efi_setcurrdev, env_nounset);
-		env_setenv("loaddev", EV_VOLATILE, efi_fmtdev(&currdev), env_noset,
-			   env_nounset);
-		init_zfs_bootenv(zfs_fmtdev(&currdev));
-		break;
-	}
-#endif
-	default: {
-		struct devdesc currdev;
-
-		currdev.d_dev = dev;
-		currdev.d_unit = unit;
-		currdev.d_opendata = NULL;
-		currdev.d_type = currdev.d_dev->dv_type;
-		env_setenv("currdev", EV_VOLATILE, efi_fmtdev(&currdev),
-			   efi_setcurrdev, env_nounset);
-		env_setenv("loaddev", EV_VOLATILE, efi_fmtdev(&currdev), env_noset,
-			   env_nounset);
-		break;
-	}
-	}
-
 	efi_init_environment();
 	setenv("LINES", "24", 1);	/* optional */
 
@@ -734,20 +794,66 @@
 
 #ifdef EFI_ZFS_BOOT
 static void
+efipart_probe_img(pdinfo_list_t *hdi)
+{
+	EFI_GUID imgid = LOADED_IMAGE_PROTOCOL;
+	EFI_LOADED_IMAGE *img;
+	pdinfo_t *hd, *pd = NULL;
+	char devname[SPECNAMELEN + 1];
+
+	BS->HandleProtocol(IH, &imgid, (VOID**)&img);
+
+	/*
+	 * Search for the booted image device handle from hard disk list.
+	 * Note, this does also include usb sticks, and we assume there is no
+	 * ZFS on floppies nor cd.
+	 * However, we might have booted from floppy (unlikely) or CD,
+	 * so we should not surprised if we can not find the handle.
+	 */
+	STAILQ_FOREACH(hd, hdi, pd_link) {
+		if (hd->pd_handle == img->DeviceHandle)
+			break;
+		STAILQ_FOREACH(pd, &hd->pd_part, pd_link) {
+			if (pd->pd_handle == img->DeviceHandle)
+				break;
+		}
+		if (pd != NULL)
+			break;
+	}
+	if (hd != NULL) {
+		if (pd != NULL) {
+			snprintf(devname, sizeof(devname), "%s%dp%d:",
+			    efipart_hddev.dv_name, hd->pd_unit, pd->pd_unit);
+		} else {
+			snprintf(devname, sizeof(devname), "%s%d:",
+			    efipart_hddev.dv_name, hd->pd_unit);
+		}
+		(void) zfs_probe_dev(devname, &pool_guid);
+	}
+}
+
+static void
 efi_zfs_probe(void)
 {
-	EFI_HANDLE h;
-	u_int unit;
-	int i;
-	char dname[SPECNAMELEN + 1];
-	uint64_t guid;
+	pdinfo_list_t *hdi;
+	pdinfo_t *hd;
+	char devname[SPECNAMELEN + 1];
+
+	hdi = efiblk_get_pdinfo_list(&efipart_hddev);
+	/*
+	 * First probe the boot device (from where loader.efi was read),
+	 * and set pool_guid global variable if we are booting from zfs.
+	 * Since loader is running, we do have an access to the device,
+	 * however, it might not be zfs.
+	 */
+
+	if (pool_guid == 0)
+		efipart_probe_img(hdi);
 
-	unit = 0;
-	h = efi_find_handle(&efipart_dev, 0);
-	for (i = 0; h != NULL; h = efi_find_handle(&efipart_dev, ++i)) {
-		snprintf(dname, sizeof(dname), "%s%d:", efipart_dev.dv_name, i);
-		if (zfs_probe_dev(dname, &guid) == 0)
-			(void)efi_handle_update_dev(h, &zfs_dev, unit++, guid);
+	STAILQ_FOREACH(hd, hdi, pd_link) {
+		snprintf(devname, sizeof(devname), "%s%d:",
+		    efipart_hddev.dv_name, hd->pd_unit);
+		(void) zfs_probe_dev(devname, NULL);
 	}
 }
 #endif
Index: head/sys/boot/zfs/zfs.c
===================================================================
--- head/sys/boot/zfs/zfs.c
+++ head/sys/boot/zfs/zfs.c
@@ -486,6 +486,8 @@
 	uint64_t mediasz;
 	int ret;
 
+	if (pool_guid)
+		*pool_guid = 0;
 	pa.fd = open(devname, O_RDONLY);
 	if (pa.fd == -1)
 		return (ENXIO);
@@ -493,6 +495,7 @@
 	ret = zfs_probe(pa.fd, pool_guid);
 	if (ret == 0)
 		return (0);
+
 	/* Probe each partition */
 	ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz);
 	if (ret == 0)
@@ -508,6 +511,8 @@
 		}
 	}
 	close(pa.fd);
+	if (pool_guid && *pool_guid == 0)
+		ret = ENXIO;
 	return (ret);
 }