Index: head/sys/boot/common/disk.h
===================================================================
--- head/sys/boot/common/disk.h
+++ head/sys/boot/common/disk.h
@@ -78,6 +78,9 @@
  * the device's strategy method.
  */
 
+#ifndef	_DISK_H
+#define	_DISK_H
+
 struct disk_devdesc
 {
 	struct devsw	*d_dev;
@@ -97,23 +100,18 @@
 /*
  * Parse disk metadata and initialise dev->d_offset.
  */
-extern int disk_open(struct disk_devdesc *dev, uint64_t mediasize,
-    u_int sectorsize, u_int flags);
-#define	DISK_F_NOCACHE	0x0001		/* Do not use metadata caching */
-extern int disk_close(struct disk_devdesc *dev);
-extern void disk_cleanup(const struct devsw *d_dev);
-extern int disk_ioctl(struct disk_devdesc *dev, u_long cmd, void *buf);
-extern int disk_read(struct disk_devdesc *dev, void *buf, uint64_t offset,
-    u_int blocks);
-extern int disk_write(struct disk_devdesc *dev, void *buf, uint64_t offset,
-    u_int blocks);
-extern int ptblread(void *d, void *buf, size_t blocks, uint64_t offset);
+extern int disk_open(struct disk_devdesc *, uint64_t, u_int);
+extern int disk_close(struct disk_devdesc *);
+extern int disk_ioctl(struct disk_devdesc *, u_long, void *);
+extern int disk_read(struct disk_devdesc *, void *, uint64_t, u_int);
+extern int disk_write(struct disk_devdesc *, void *, uint64_t, u_int);
+extern int ptblread(void *, void *, size_t, uint64_t);
 
 /*
  * Print information about slices on a disk.
  */
-extern int disk_print(struct disk_devdesc *dev, char *prefix, int verbose);
-extern char* disk_fmtdev(struct disk_devdesc *dev);
-extern int disk_parsedev(struct disk_devdesc *dev, const char *devspec,
-    const char **path);
+extern int disk_print(struct disk_devdesc *, char *, int);
+extern char* disk_fmtdev(struct disk_devdesc *);
+extern int disk_parsedev(struct disk_devdesc *, const char *, const char **);
 
+#endif	/* _DISK_H */
Index: head/sys/boot/common/disk.c
===================================================================
--- head/sys/boot/common/disk.c
+++ head/sys/boot/common/disk.c
@@ -48,8 +48,6 @@
 	uint64_t		mediasize;
 	uint64_t		entrysize;
 	u_int			sectorsize;
-	u_int			flags;
-	int			rcnt;
 };
 
 struct print_args {
@@ -58,96 +56,6 @@
 	int			verbose;
 };
 
-struct dentry {
-	const struct devsw	*d_dev;
-	int			d_unit;
-	int			d_slice;
-	int			d_partition;
-
-	struct open_disk	*od;
-	uint64_t		d_offset;
-	STAILQ_ENTRY(dentry)	entry;
-#ifdef DISK_DEBUG
-	uint32_t		count;
-#endif
-};
-
-static STAILQ_HEAD(, dentry) opened_disks =
-    STAILQ_HEAD_INITIALIZER(opened_disks);
-
-static int
-disk_lookup(struct disk_devdesc *dev)
-{
-	struct dentry *entry;
-	int rc;
-
-	rc = ENOENT;
-	STAILQ_FOREACH(entry, &opened_disks, entry) {
-		if (entry->d_dev != dev->d_dev ||
-		    entry->d_unit != dev->d_unit)
-			continue;
-		dev->d_opendata = entry->od;
-		if (entry->d_slice == dev->d_slice &&
-		    entry->d_partition == dev->d_partition) {
-			dev->d_offset = entry->d_offset;
-			DEBUG("%s offset %lld", disk_fmtdev(dev),
-			    (long long)dev->d_offset);
-#ifdef DISK_DEBUG
-			entry->count++;
-#endif
-			return (0);
-		}
-		rc = EAGAIN;
-	}
-	return (rc);
-}
-
-static void
-disk_insert(struct disk_devdesc *dev)
-{
-	struct dentry *entry;
-
-	entry = (struct dentry *)malloc(sizeof(struct dentry));
-	if (entry == NULL) {
-		DEBUG("no memory");
-		return;
-	}
-	entry->d_dev = dev->d_dev;
-	entry->d_unit = dev->d_unit;
-	entry->d_slice = dev->d_slice;
-	entry->d_partition = dev->d_partition;
-	entry->od = (struct open_disk *)dev->d_opendata;
-	entry->od->rcnt++;
-	entry->d_offset = dev->d_offset;
-#ifdef DISK_DEBUG
-	entry->count = 1;
-#endif
-	STAILQ_INSERT_TAIL(&opened_disks, entry, entry);
-	DEBUG("%s cached", disk_fmtdev(dev));
-}
-
-#ifdef DISK_DEBUG
-COMMAND_SET(dcachestat, "dcachestat", "get disk cache stats",
-    command_dcachestat);
-
-static int
-command_dcachestat(int argc, char *argv[])
-{
-	struct disk_devdesc dev;
-	struct dentry *entry;
-
-	STAILQ_FOREACH(entry, &opened_disks, entry) {
-		dev.d_dev = (struct devsw *)entry->d_dev;
-		dev.d_unit = entry->d_unit;
-		dev.d_slice = entry->d_slice;
-		dev.d_partition = entry->d_partition;
-		printf("%s %d => %p [%d]\n", disk_fmtdev(&dev), entry->count,
-		    entry->od, entry->od->rcnt);
-	}
-	return (CMD_OK);
-}
-#endif /* DISK_DEBUG */
-
 /* Convert size to a human-readable number. */
 static char *
 display_size(uint64_t size, u_int sectorsize)
@@ -187,6 +95,7 @@
 static int
 ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
 {
+	struct disk_devdesc dev;
 	struct print_args *pa, bsd;
 	struct open_disk *od;
 	struct ptable *table;
@@ -207,17 +116,24 @@
 	res = 0;
 	if (part->type == PART_FREEBSD) {
 		/* Open slice with BSD label */
-		pa->dev->d_offset = part->start;
-		table = ptable_open(pa->dev, part->end - part->start + 1,
-		    od->sectorsize, ptblread);
-		if (table == NULL)
-			return 0;
-		sprintf(line, "  %s%s", pa->prefix, pname);
-		bsd.dev = pa->dev;
-		bsd.prefix = line;
-		bsd.verbose = pa->verbose;
-		res = ptable_iterate(table, &bsd, ptable_print);
-		ptable_close(table);
+		dev.d_dev = pa->dev->d_dev;
+		dev.d_unit = pa->dev->d_unit;
+		dev.d_slice = part->index;
+		dev.d_partition = -1;
+		if (disk_open(&dev, part->end - part->start + 1,
+		    od->sectorsize) == 0) {
+			table = ptable_open(&dev, part->end - part->start + 1,
+			    od->sectorsize, ptblread);
+			if (table != NULL) {
+				sprintf(line, "  %s%s", pa->prefix, pname);
+				bsd.dev = pa->dev;
+				bsd.prefix = line;
+				bsd.verbose = pa->verbose;
+				res = ptable_iterate(table, &bsd, ptable_print);
+				ptable_close(table);
+			}
+			disk_close(&dev);
+		}
 	}
 
 	return (res);
@@ -290,8 +206,7 @@
 }
 
 int
-disk_open(struct disk_devdesc *dev, uint64_t mediasize, u_int sectorsize,
-    u_int flags)
+disk_open(struct disk_devdesc *dev, uint64_t mediasize, u_int sectorsize)
 {
 	struct open_disk *od;
 	struct ptable *table;
@@ -299,11 +214,6 @@
 	int rc, slice, partition;
 
 	rc = 0;
-	if ((flags & DISK_F_NOCACHE) == 0) {
-		rc = disk_lookup(dev);
-		if (rc == 0)
-			return (0);
-	}
 	/*
 	 * While we are reading disk metadata, make sure we do it relative
 	 * to the start of the disk
@@ -312,30 +222,15 @@
 	table = NULL;
 	slice = dev->d_slice;
 	partition = dev->d_partition;
-	if (rc == EAGAIN) {
-		/*
-		 * This entire disk was already opened and there is no
-		 * need to allocate new open_disk structure and open the
-		 * main partition table.
-		 */
-		od = (struct open_disk *)dev->d_opendata;
-		DEBUG("%s unit %d, slice %d, partition %d => %p (cached)",
-		    disk_fmtdev(dev), dev->d_unit, dev->d_slice,
-		    dev->d_partition, od);
-		goto opened;
-	} else {
-		od = (struct open_disk *)malloc(sizeof(struct open_disk));
-		if (od == NULL) {
-			DEBUG("no memory");
-			return (ENOMEM);
-		}
-		dev->d_opendata = od;
-		od->rcnt = 0;
-		od->entrysize = 0;
+	od = (struct open_disk *)malloc(sizeof(struct open_disk));
+	if (od == NULL) {
+		DEBUG("no memory");
+		return (ENOMEM);
 	}
+	dev->d_opendata = od;
+	od->entrysize = 0;
 	od->mediasize = mediasize;
 	od->sectorsize = sectorsize;
-	od->flags = flags;
 	DEBUG("%s unit %d, slice %d, partition %d => %p",
 	    disk_fmtdev(dev), dev->d_unit, dev->d_slice, dev->d_partition, od);
 
@@ -355,8 +250,7 @@
 	if (mediasize > od->mediasize) {
 		od->mediasize = mediasize;
 	}
-opened:
-	rc = 0;
+
 	if (ptable_gettype(od->table) == PTABLE_BSD &&
 	    partition >= 0) {
 		/* It doesn't matter what value has d_slice */
@@ -424,15 +318,11 @@
 		ptable_close(table);
 
 	if (rc != 0) {
-		if (od->rcnt < 1) {
-			if (od->table != NULL)
-				ptable_close(od->table);
-			free(od);
-		}
+		if (od->table != NULL)
+			ptable_close(od->table);
+		free(od);
 		DEBUG("%s could not open", disk_fmtdev(dev));
 	} else {
-		if ((flags & DISK_F_NOCACHE) == 0)
-			disk_insert(dev);
 		/* Save the slice and partition number to the dev */
 		dev->d_slice = slice;
 		dev->d_partition = partition;
@@ -448,44 +338,12 @@
 	struct open_disk *od;
 
 	od = (struct open_disk *)dev->d_opendata;
-	DEBUG("%s closed => %p [%d]", disk_fmtdev(dev), od, od->rcnt);
-	if (od->flags & DISK_F_NOCACHE) {
-		ptable_close(od->table);
-		free(od);
-	}
+	DEBUG("%s closed => %p", disk_fmtdev(dev), od);
+	ptable_close(od->table);
+	free(od);
 	return (0);
 }
 
-void
-disk_cleanup(const struct devsw *d_dev)
-{
-#ifdef DISK_DEBUG
-	struct disk_devdesc dev;
-#endif
-	struct dentry *entry, *tmp;
-
-	STAILQ_FOREACH_SAFE(entry, &opened_disks, entry, tmp) {
-		if (entry->d_dev != d_dev)
-			continue;
-		entry->od->rcnt--;
-#ifdef DISK_DEBUG
-		dev.d_dev = (struct devsw *)entry->d_dev;
-		dev.d_unit = entry->d_unit;
-		dev.d_slice = entry->d_slice;
-		dev.d_partition = entry->d_partition;
-		DEBUG("%s was freed => %p [%d]", disk_fmtdev(&dev),
-		    entry->od, entry->od->rcnt);
-#endif
-		STAILQ_REMOVE(&opened_disks, entry, dentry, entry);
-		if (entry->od->rcnt < 1) {
-			if (entry->od->table != NULL)
-				ptable_close(entry->od->table);
-			free(entry->od);
-		}
-		free(entry);
-	}
-}
-
 char*
 disk_fmtdev(struct disk_devdesc *dev)
 {
Index: head/sys/boot/efi/libefi/efipart.c
===================================================================
--- head/sys/boot/efi/libefi/efipart.c
+++ head/sys/boot/efi/libefi/efipart.c
@@ -635,8 +635,7 @@
 			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);
+			    blkio->Media->BlockSize);
 			if (ret == 0) {
 				ret = disk_print(&pd_dev, line, verbose);
 				disk_close(&pd_dev);
@@ -726,8 +725,7 @@
 	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));
+		    blkio->Media->BlockSize));
 	}
 	return (0);
 }
Index: head/sys/boot/i386/libi386/biosdisk.c
===================================================================
--- head/sys/boot/i386/libi386/biosdisk.c
+++ head/sys/boot/i386/libi386/biosdisk.c
@@ -137,7 +137,6 @@
 static int bd_close(struct open_file *f);
 static int bd_ioctl(struct open_file *f, u_long cmd, void *data);
 static int bd_print(int verbose);
-static void bd_cleanup(void);
 
 #ifdef LOADER_GELI_SUPPORT
 static enum isgeli {
@@ -160,7 +159,7 @@
 	bd_close,
 	bd_ioctl,
 	bd_print,
-	bd_cleanup
+	NULL
 };
 
 /*
@@ -231,13 +230,6 @@
 	return(0);
 }
 
-static void
-bd_cleanup(void)
-{
-
-	disk_cleanup(&biosdisk);
-}
-
 /*
  * Try to detect a device supported by the legacy int13 BIOS
  */
@@ -364,9 +356,7 @@
 		dev.d_partition = -1;
 		if (disk_open(&dev,
 		    bdinfo[i].bd_sectorsize * bdinfo[i].bd_sectors,
-		    bdinfo[i].bd_sectorsize,
-		    (bdinfo[i].bd_flags & BD_FLOPPY) ?
-		    DISK_F_NOCACHE: 0) == 0) {
+		    bdinfo[i].bd_sectorsize) == 0) {
 			snprintf(line, sizeof(line), "    disk%d", i);
 			ret = disk_print(&dev, line, verbose);
 			disk_close(&dev);
@@ -421,8 +411,7 @@
 	disk.d_partition = -1;
 	disk.d_offset = 0;
 	if (disk_open(&disk, BD(dev).bd_sectors * BD(dev).bd_sectorsize,
-	    BD(dev).bd_sectorsize, (BD(dev).bd_flags & BD_FLOPPY) ?
-	    DISK_F_NOCACHE: 0) == 0) {
+	    BD(dev).bd_sectorsize) == 0) {
 
 		if (disk_ioctl(&disk, DIOCGMEDIASIZE, &size) == 0) {
 			size /= BD(dev).bd_sectorsize;
@@ -433,8 +422,7 @@
 	}
 
 	err = disk_open(dev, BD(dev).bd_sectors * BD(dev).bd_sectorsize,
-	    BD(dev).bd_sectorsize, (BD(dev).bd_flags & BD_FLOPPY) ?
-	    DISK_F_NOCACHE: 0);
+	    BD(dev).bd_sectorsize);
 
 #ifdef LOADER_GELI_SUPPORT
 	static char gelipw[GELI_PW_MAXLEN];
@@ -954,8 +942,7 @@
     if (biosdev == -1)				/* not a BIOS device */
 	return(-1);
     if (disk_open(dev, BD(dev).bd_sectors * BD(dev).bd_sectorsize,
-	BD(dev).bd_sectorsize,(BD(dev).bd_flags & BD_FLOPPY) ?
-	DISK_F_NOCACHE: 0) != 0)		/* oops, not a viable device */
+	BD(dev).bd_sectorsize) != 0)		/* oops, not a viable device */
 	    return (-1);
     else
 	disk_close(dev);
Index: head/sys/boot/mips/beri/loader/beri_disk_cfi.c
===================================================================
--- head/sys/boot/mips/beri/loader/beri_disk_cfi.c
+++ head/sys/boot/mips/beri/loader/beri_disk_cfi.c
@@ -44,7 +44,6 @@
 static int	beri_cfi_disk_init(void);
 static int	beri_cfi_disk_open(struct open_file *, ...);
 static int	beri_cfi_disk_close(struct open_file *);
-static void	beri_cfi_disk_cleanup(void);
 static int	beri_cfi_disk_strategy(void *, int, daddr_t, size_t,
 		    char *, size_t *);
 static int	beri_cfi_disk_print(int);
@@ -58,7 +57,7 @@
 	.dv_close = beri_cfi_disk_close,
 	.dv_ioctl = noioctl,
 	.dv_print = beri_cfi_disk_print,
-	.dv_cleanup = beri_cfi_disk_cleanup,
+	.dv_cleanup = NULL,
 };
 
 static int
@@ -100,7 +99,7 @@
 
 	if (dev->d_unit != 0)
 		return (EIO);
-	return (disk_open(dev, cfi_get_mediasize(), cfi_get_sectorsize(), 0));
+	return (disk_open(dev, cfi_get_mediasize(), cfi_get_sectorsize()));
 }
 
 static int
@@ -131,8 +130,7 @@
 	dev.d_unit = 0;
 	dev.d_slice = -1;
 	dev.d_partition = -1;
-	if (disk_open(&dev, cfi_get_mediasize(),
-	    cfi_get_sectorsize(), 0) == 0) {
+	if (disk_open(&dev, cfi_get_mediasize(), cfi_get_sectorsize()) == 0) {
 		snprintf(line, sizeof(line), "    cfi%d", 0);
 		ret = disk_print(&dev, line, verbose);
 		disk_close(&dev);
@@ -140,10 +138,3 @@
 
 	return (ret);
 }
-
-static void
-beri_cfi_disk_cleanup(void)
-{
-
-	disk_cleanup(&beri_cfi_disk);
-}
Index: head/sys/boot/mips/beri/loader/beri_disk_sdcard.c
===================================================================
--- head/sys/boot/mips/beri/loader/beri_disk_sdcard.c
+++ head/sys/boot/mips/beri/loader/beri_disk_sdcard.c
@@ -44,7 +44,6 @@
 static int	beri_sdcard_disk_init(void);
 static int	beri_sdcard_disk_open(struct open_file *, ...);
 static int	beri_sdcard_disk_close(struct open_file *);
-static void	beri_sdcard_disk_cleanup(void);
 static int	beri_sdcard_disk_strategy(void *, int, daddr_t, size_t,
 		    char *, size_t *);
 static int	beri_sdcard_disk_print(int);
@@ -58,7 +57,7 @@
 	.dv_close = beri_sdcard_disk_close,
 	.dv_ioctl = noioctl,
 	.dv_print = beri_sdcard_disk_print,
- 	.dv_cleanup = beri_sdcard_disk_cleanup,
+	.dv_cleanup = NULL,
 };
 
 static int
@@ -106,7 +105,7 @@
 	if (dev->d_unit != 0)
 		return (EIO);
 	return (disk_open(dev, altera_sdcard_get_mediasize(),
-	    altera_sdcard_get_sectorsize(), 0));
+	    altera_sdcard_get_sectorsize()));
 }
 
 static int
@@ -138,17 +137,10 @@
 	dev.d_slice = -1;
 	dev.d_partition = -1;
 	if (disk_open(&dev, altera_sdcard_get_mediasize(),
-	    altera_sdcard_get_sectorsize(), 0) == 0) {
+	    altera_sdcard_get_sectorsize()) == 0) {
 		snprintf(line, sizeof(line), "    sdcard%d", 0);
 		ret = disk_print(&dev, line, verbose);
 		disk_close(&dev);
 	}
 	return (ret);
 }
-
-static void
-beri_sdcard_disk_cleanup(void)
-{
-
-	disk_cleanup(&beri_sdcard_disk);
-}
Index: head/sys/boot/uboot/lib/disk.c
===================================================================
--- head/sys/boot/uboot/lib/disk.c
+++ head/sys/boot/uboot/lib/disk.c
@@ -139,7 +139,6 @@
 	for (i = 0; i < stor_info_no; i++)
 		if (stor_info[i].opened > 0)
 			ub_dev_close(stor_info[i].handle);
-	disk_cleanup(&uboot_storage);
 }
 
 static int
@@ -203,7 +202,7 @@
 		SI(dev).opened++;
 	}
 	return (disk_open(dev, SI(dev).blocks * SI(dev).bsize,
-	    SI(dev).bsize, 0));
+	    SI(dev).bsize));
 }
 
 static int
Index: head/sys/boot/usb/storage/umass_loader.c
===================================================================
--- head/sys/boot/usb/storage/umass_loader.c
+++ head/sys/boot/usb/storage/umass_loader.c
@@ -116,7 +116,7 @@
 	if (usb_msc_read_capacity(umass_uaa.device, 0, &nblock, &blocksize) != 0)
 		return (EINVAL);
 
-	return (disk_open(dev, ((uint64_t)nblock + 1) * (uint64_t)blocksize, blocksize, 0));
+	return (disk_open(dev, ((uint64_t)nblock + 1) * (uint64_t)blocksize, blocksize));
 }
 
 static int
@@ -208,7 +208,6 @@
 static void
 umass_disk_cleanup(void)
 {
-	disk_cleanup(&umass_disk);
 
 	usb_uninit();
 }
Index: head/sys/boot/userboot/userboot/userboot_disk.c
===================================================================
--- head/sys/boot/userboot/userboot/userboot_disk.c
+++ head/sys/boot/userboot/userboot/userboot_disk.c
@@ -141,7 +141,7 @@
 		dev.d_slice = -1;
 		dev.d_partition = -1;
 		if (disk_open(&dev, ud_info[i].mediasize,
-		    ud_info[i].sectorsize, 0) == 0) {
+		    ud_info[i].sectorsize) == 0) {
 			snprintf(line, sizeof(line), "    disk%d", i);
 			ret = disk_print(&dev, line, verbose);
 			disk_close(&dev);
@@ -171,7 +171,7 @@
 	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, 0));
+	    ud_info[dev->d_unit].sectorsize));
 }
 
 static int