[illumos-gate merge]

commit ce87906fe0d027df0327d283b3423eaf1d3cdda5
    13125 libc: unchecked function return 'nvfree'
commit 64f188a3e276245cf34a8f6ef0189e1cc568b840
    13160 loader: Remove NAND and NANDFS support
commit 08a72deac9aaea53335ce22bdbc25eb85de27652
    13159 loader: remove common/ufsread.c
commit 7e63fc6f405ee1e58ef05d46f92cb5e1c441e8d7
    13176 gptzfsboot: rework stage3 loading
commit d83a2486bd7b53e4a9741736a076e098071b5cbd
    13126 libc: variable dereferenced before check 'found'

13 files changed, 44 insertions, 1479 deletions

diff --git a/usr/src/boot/Makefile.version b/usr/src/boot/Makefile.version
index 5c3e29449d..1df520dd7d 100644
--- a/usr/src/boot/Makefile.version
+++ b/usr/src/boot/Makefile.version
@@ -33,4 +33,4 @@ LOADER_VERSION = 1.1
 # Use date like formatting here, YYYY.MM.DD.XX, without leading zeroes.
 # The version is processed from left to right, the version number can only
 # be increased.
-BOOT_VERSION = $(LOADER_VERSION)-2020.08.25.1
+BOOT_VERSION = $(LOADER_VERSION)-2020.09.17.1
diff --git a/usr/src/boot/lib/libstand/nandfs.c b/usr/src/boot/lib/libstand/nandfs.c
deleted file mode 100644
index b8c51e3b5a..0000000000
--- a/usr/src/boot/lib/libstand/nandfs.c
+++ /dev/null
@@ -1,1061 +0,0 @@
-/*-
- * Copyright (c) 2010-2012 Semihalf.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * 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.
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/queue.h>
-#include <sys/stdint.h>
-#include <ufs/ufs/dinode.h>
-#include <fs/nandfs/nandfs_fs.h>
-#include "stand.h"
-#include "string.h"
-#include "zlib.h"
-
-#define DEBUG
-#undef DEBUG
-#ifdef DEBUG
-#define NANDFS_DEBUG(fmt, args...) do { \
-    printf("NANDFS_DEBUG:" fmt "\n", ##args); } while (0)
-#else
-#define NANDFS_DEBUG(fmt, args...)
-#endif
-
-struct nandfs_mdt {
-	uint32_t	entries_per_block;
-	uint32_t	entries_per_group;
-	uint32_t	blocks_per_group;
-	uint32_t	groups_per_desc_block;	/* desc is super group */
-	uint32_t	blocks_per_desc_block;	/* desc is super group */
-};
-
-struct bmap_buf {
-	LIST_ENTRY(bmap_buf)	list;
-	nandfs_daddr_t		blknr;
-	uint64_t		*map;
-};
-
-struct nandfs_node {
-	struct nandfs_inode	*inode;
-	LIST_HEAD(, bmap_buf)	bmap_bufs;
-};
-struct nandfs {
-	int	nf_blocksize;
-	int	nf_sectorsize;
-	int	nf_cpno;
-
-	struct open_file	*nf_file;
-	struct nandfs_node	*nf_opened_node;
-	u_int			nf_offset;
-	uint8_t			*nf_buf;
-	int64_t			nf_buf_blknr;
-
-	struct nandfs_fsdata		*nf_fsdata;
-	struct nandfs_super_block	*nf_sb;
-	struct nandfs_segment_summary	nf_segsum;
-	struct nandfs_checkpoint	nf_checkpoint;
-	struct nandfs_super_root	nf_sroot;
-	struct nandfs_node		nf_ifile;
-	struct nandfs_node		nf_datfile;
-	struct nandfs_node		nf_cpfile;
-	struct nandfs_mdt		nf_datfile_mdt;
-	struct nandfs_mdt		nf_ifile_mdt;
-
-	int nf_nindir[NIADDR];
-};
-
-static int nandfs_open(const char *, struct open_file *);
-static int nandfs_close(struct open_file *);
-static int nandfs_read(struct open_file *, void *, size_t, size_t *);
-static off_t nandfs_seek(struct open_file *, off_t, int);
-static int nandfs_stat(struct open_file *, struct stat *);
-static int nandfs_readdir(struct open_file *, struct dirent *);
-
-static int nandfs_buf_read(struct nandfs *, void **, size_t *);
-static struct nandfs_node *nandfs_lookup_path(struct nandfs *, const char *);
-static int nandfs_read_inode(struct nandfs *, struct nandfs_node *,
-    nandfs_lbn_t, u_int, void *, int);
-static int nandfs_read_blk(struct nandfs *, nandfs_daddr_t, void *, int);
-static int nandfs_bmap_lookup(struct nandfs *, struct nandfs_node *,
-    nandfs_lbn_t, nandfs_daddr_t *, int);
-static int nandfs_get_checkpoint(struct nandfs *, uint64_t,
-    struct nandfs_checkpoint *);
-static nandfs_daddr_t nandfs_vtop(struct nandfs *, nandfs_daddr_t);
-static void nandfs_calc_mdt_consts(int, struct nandfs_mdt *, int);
-static void nandfs_mdt_trans(struct nandfs_mdt *, uint64_t,
-    nandfs_daddr_t *, uint32_t *);
-static int ioread(struct open_file *, off_t, void *, u_int);
-static int nandfs_probe_sectorsize(struct open_file *);
-
-struct fs_ops nandfs_fsops = {
-	"nandfs",
-	nandfs_open,
-	nandfs_close,
-	nandfs_read,
-	null_write,
-	nandfs_seek,
-	nandfs_stat,
-	nandfs_readdir
-};
-
-#define	NINDIR(fs)	((fs)->nf_blocksize / sizeof(nandfs_daddr_t))
-
-/* from NetBSD's src/sys/net/if_ethersubr.c */
-static uint32_t
-nandfs_crc32(uint32_t crc, const uint8_t *buf, size_t len)
-{
-	static const uint32_t crctab[] = {
-		0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
-		0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
-		0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
-		0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
-	};
-	size_t i;
-
-	crc = crc ^ ~0U;
-	for (i = 0; i < len; i++) {
-		crc ^= buf[i];
-		crc = (crc >> 4) ^ crctab[crc & 0xf];
-		crc = (crc >> 4) ^ crctab[crc & 0xf];
-	}
-	return (crc ^ ~0U);
-}
-
-static int
-nandfs_check_fsdata_crc(struct nandfs_fsdata *fsdata)
-{
-	uint32_t fsdata_crc, comp_crc;
-
-	if (fsdata->f_magic != NANDFS_FSDATA_MAGIC)
-		return (0);
-
-	/* Preserve crc */
-	fsdata_crc = fsdata->f_sum;
-
-	/* Calculate */
-	fsdata->f_sum = (0);
-	comp_crc = nandfs_crc32(0, (uint8_t *)fsdata, fsdata->f_bytes);
-
-	/* Restore */
-	fsdata->f_sum = fsdata_crc;
-
-	/* Check CRC */
-	return (fsdata_crc == comp_crc);
-}
-
-static int
-nandfs_check_superblock_crc(struct nandfs_fsdata *fsdata,
-    struct nandfs_super_block *super)
-{
-	uint32_t super_crc, comp_crc;
-
-	/* Check super block magic */
-	if (super->s_magic != NANDFS_SUPER_MAGIC)
-		return (0);
-
-	/* Preserve CRC */
-	super_crc = super->s_sum;
-
-	/* Calculate */
-	super->s_sum = (0);
-	comp_crc = nandfs_crc32(0, (uint8_t *)super, fsdata->f_sbbytes);
-
-	/* Restore */
-	super->s_sum = super_crc;
-
-	/* Check CRC */
-	return (super_crc == comp_crc);
-}
-
-static int
-nandfs_find_super_block(struct nandfs *fs, struct open_file *f)
-{
-	struct nandfs_super_block *sb;
-	int i, j, n, s;
-	int sectors_to_read, error;
-
-	sb = malloc(fs->nf_sectorsize);
-	if (sb == NULL)
-		return (ENOMEM);
-
-	memset(fs->nf_sb, 0, sizeof(*fs->nf_sb));
-
-	sectors_to_read = (NANDFS_NFSAREAS * fs->nf_fsdata->f_erasesize) /
-	    fs->nf_sectorsize;
-	for (i = 0; i < sectors_to_read; i++) {
-		NANDFS_DEBUG("reading i %d offset %d\n", i,
-		    i * fs->nf_sectorsize);
-		error = ioread(f, i * fs->nf_sectorsize, (char *)sb,
-		    fs->nf_sectorsize);
-		if (error) {
-			NANDFS_DEBUG("error %d\n", error);
-			continue;
-		}
-		n = fs->nf_sectorsize / sizeof(struct nandfs_super_block);
-		s = 0;
-		if ((i * fs->nf_sectorsize) % fs->nf_fsdata->f_erasesize == 0) {
-			if (fs->nf_sectorsize == sizeof(struct nandfs_fsdata))
-				continue;
-			else {
-				s += (sizeof(struct nandfs_fsdata) /
-				    sizeof(struct nandfs_super_block));
-			}
-		}
-
-		for (j = s; j < n; j++) {
-			if (!nandfs_check_superblock_crc(fs->nf_fsdata, &sb[j]))
-				continue;
-			NANDFS_DEBUG("magic %x wtime %jd, lastcp 0x%jx\n",
-			    sb[j].s_magic, sb[j].s_wtime, sb[j].s_last_cno);
-			if (sb[j].s_last_cno > fs->nf_sb->s_last_cno)
-				memcpy(fs->nf_sb, &sb[j], sizeof(*fs->nf_sb));
-		}
-	}
-
-	free(sb);
-
-	return (fs->nf_sb->s_magic != 0 ? 0 : EINVAL);
-}
-
-static int
-nandfs_find_fsdata(struct nandfs *fs, struct open_file *f)
-{
-	int offset, error, i;
-
-	NANDFS_DEBUG("starting\n");
-
-	offset = 0;
-	for (i = 0; i < 64 * NANDFS_NFSAREAS; i++) {
-		error = ioread(f, offset, (char *)fs->nf_fsdata,
-		    sizeof(struct nandfs_fsdata));
-		if (error)
-			return (error);
-		if (fs->nf_fsdata->f_magic == NANDFS_FSDATA_MAGIC) {
-			NANDFS_DEBUG("found at %x, volume %s\n", offset,
-			    fs->nf_fsdata->f_volume_name);
-			if (nandfs_check_fsdata_crc(fs->nf_fsdata))
-				break;
-		}
-		offset += fs->nf_sectorsize;
-	}
-
-	return (error);
-}
-
-static int
-nandfs_read_structures(struct nandfs *fs, struct open_file *f)
-{
-	int error;
-
-	error = nandfs_find_fsdata(fs, f);
-	if (error)
-		return (error);
-
-	error = nandfs_find_super_block(fs, f);
-
-	if (error == 0)
-		NANDFS_DEBUG("selected sb with w_time %jd last_pseg %jx\n",
-		    fs->nf_sb->s_wtime, fs->nf_sb->s_last_pseg);
-
-	return (error);
-}
-
-static int
-nandfs_mount(struct nandfs *fs, struct open_file *f)
-{
-	int err = 0, level;
-	uint64_t last_pseg;
-
-	fs->nf_fsdata = malloc(sizeof(struct nandfs_fsdata));
-	fs->nf_sb = malloc(sizeof(struct nandfs_super_block));
-
-	err = nandfs_read_structures(fs, f);
-	if (err) {
-		free(fs->nf_fsdata);
-		free(fs->nf_sb);
-		return (err);
-	}
-
-	fs->nf_blocksize = 1 << (fs->nf_fsdata->f_log_block_size + 10);
-
-	NANDFS_DEBUG("using superblock with wtime %jd\n", fs->nf_sb->s_wtime);
-
-	fs->nf_cpno = fs->nf_sb->s_last_cno;
-	last_pseg = fs->nf_sb->s_last_pseg;
-
-	/*
-	 * Calculate indirect block levels.
-	 */
-	nandfs_daddr_t mult;
-
-	mult = 1;
-	for (level = 0; level < NIADDR; level++) {
-		mult *= NINDIR(fs);
-		fs->nf_nindir[level] = mult;
-	}
-
-	nandfs_calc_mdt_consts(fs->nf_blocksize, &fs->nf_datfile_mdt,
-	    fs->nf_fsdata->f_dat_entry_size);
-
-	nandfs_calc_mdt_consts(fs->nf_blocksize, &fs->nf_ifile_mdt,
-	    fs->nf_fsdata->f_inode_size);
-
-	err = ioread(f, last_pseg * fs->nf_blocksize, &fs->nf_segsum,
-	    sizeof(struct nandfs_segment_summary));
-	if (err) {
-		free(fs->nf_sb);
-		free(fs->nf_fsdata);
-		return (err);
-	}
-
-	err = ioread(f, (last_pseg + fs->nf_segsum.ss_nblocks - 1) *
-	    fs->nf_blocksize, &fs->nf_sroot, sizeof(struct nandfs_super_root));
-	if (err) {
-		free(fs->nf_sb);
-		free(fs->nf_fsdata);
-		return (err);
-	}
-
-	fs->nf_datfile.inode = &fs->nf_sroot.sr_dat;
-	LIST_INIT(&fs->nf_datfile.bmap_bufs);
-	fs->nf_cpfile.inode = &fs->nf_sroot.sr_cpfile;
-	LIST_INIT(&fs->nf_cpfile.bmap_bufs);
-
-	err = nandfs_get_checkpoint(fs, fs->nf_cpno, &fs->nf_checkpoint);
-	if (err) {
-		free(fs->nf_sb);
-		free(fs->nf_fsdata);
-		return (err);
-	}
-
-	NANDFS_DEBUG("checkpoint cp_cno=%lld\n", fs->nf_checkpoint.cp_cno);
-	NANDFS_DEBUG("checkpoint cp_inodes_count=%lld\n",
-	    fs->nf_checkpoint.cp_inodes_count);
-	NANDFS_DEBUG("checkpoint cp_ifile_inode.i_blocks=%lld\n",
-	    fs->nf_checkpoint.cp_ifile_inode.i_blocks);
-
-	fs->nf_ifile.inode = &fs->nf_checkpoint.cp_ifile_inode;
-	LIST_INIT(&fs->nf_ifile.bmap_bufs);
-	return (0);
-}
-
-#define NINDIR(fs)	((fs)->nf_blocksize / sizeof(nandfs_daddr_t))
-
-static int
-nandfs_open(const char *path, struct open_file *f)
-{
-	struct nandfs *fs;
-	struct nandfs_node *node;
-	int err, bsize, level;
-
-	NANDFS_DEBUG("nandfs_open('%s', %p)\n", path, f);
-
-	fs = malloc(sizeof(struct nandfs));
-	f->f_fsdata = fs;
-	fs->nf_file = f;
-
-	bsize = nandfs_probe_sectorsize(f);
-	if (bsize < 0) {
-		printf("Cannot probe medium sector size\n");
-		return (EINVAL);
-	}
-
-	fs->nf_sectorsize = bsize;
-
-	/*
-	 * Calculate indirect block levels.
-	 */
-	nandfs_daddr_t mult;
-
-	mult = 1;
-	for (level = 0; level < NIADDR; level++) {
-		mult *= NINDIR(fs);
-		fs->nf_nindir[level] = mult;
-	}
-
-	NANDFS_DEBUG("fs %p nf_sectorsize=%x\n", fs, fs->nf_sectorsize);
-
-	err = nandfs_mount(fs, f);
-	if (err) {
-		NANDFS_DEBUG("Cannot mount nandfs: %s\n", strerror(err));
-		return (err);
-	}
-
-	node = nandfs_lookup_path(fs, path);
-	if (node == NULL)
-		return (EINVAL);
-
-	fs->nf_offset = 0;
-	fs->nf_buf = NULL;
-	fs->nf_buf_blknr = -1;
-	fs->nf_opened_node = node;
-	LIST_INIT(&fs->nf_opened_node->bmap_bufs);
-	return (0);
-}
-
-static void
-nandfs_free_node(struct nandfs_node *node)
-{
-	struct bmap_buf *bmap, *tmp;
-
-	free(node->inode);
-	LIST_FOREACH_SAFE(bmap, &node->bmap_bufs, list, tmp) {
-		LIST_REMOVE(bmap, list);
-		free(bmap->map);
-		free(bmap);
-	}
-	free(node);
-}
-
-static int
-nandfs_close(struct open_file *f)
-{
-	struct nandfs *fs = f->f_fsdata;
-
-	NANDFS_DEBUG("nandfs_close(%p)\n", f);
-
-	if (fs->nf_buf != NULL)
-		free(fs->nf_buf);
-
-	nandfs_free_node(fs->nf_opened_node);
-	free(fs->nf_sb);
-	free(fs);
-	return (0);
-}
-
-static int
-nandfs_read(struct open_file *f, void *addr, size_t size, size_t *resid)
-{
-	struct nandfs *fs = (struct nandfs *)f->f_fsdata;
-	size_t csize, buf_size;
-	void *buf;
-	int error = 0;
-
-	NANDFS_DEBUG("nandfs_read(file=%p, addr=%p, size=%d)\n", f, addr, size);
-
-	while (size != 0) {
-		if (fs->nf_offset >= fs->nf_opened_node->inode->i_size)
-			break;
-
-		error = nandfs_buf_read(fs, &buf, &buf_size);
-		if (error)
-			break;
-
-		csize = size;
-		if (csize > buf_size)
-			csize = buf_size;
-
-		bcopy(buf, addr, csize);
-
-		fs->nf_offset += csize;
-		addr = (char *)addr + csize;
-		size -= csize;
-	}
-
-	if (resid)
-		*resid = size;
-	return (error);
-}
-
-static off_t
-nandfs_seek(struct open_file *f, off_t offset, int where)
-{
-	struct nandfs *fs = f->f_fsdata;
-	off_t off;
-	u_int size;
-
-	NANDFS_DEBUG("nandfs_seek(file=%p, offset=%lld, where=%d)\n", f,
-	    offset, where);
-
-	size = fs->nf_opened_node->inode->i_size;
-
-	switch (where) {
-	case SEEK_SET:
-		off = 0;
-		break;
-	case SEEK_CUR:
-		off = fs->nf_offset;
-		break;
-	case SEEK_END:
-		off = size;
-		break;
-	default:
-		errno = EINVAL;
-		return (-1);
-	}
-
-	off += offset;
-	if (off < 0 || off > size) {
-		errno = EINVAL;
-		return(-1);
-	}
-
-	fs->nf_offset = (u_int)off;
-
-	return (off);
-}
-
-static int
-nandfs_stat(struct open_file *f, struct stat *sb)
-{
-	struct nandfs *fs = f->f_fsdata;
-
-	NANDFS_DEBUG("nandfs_stat(file=%p, stat=%p)\n", f, sb);
-
-	sb->st_size = fs->nf_opened_node->inode->i_size;
-	sb->st_mode = fs->nf_opened_node->inode->i_mode;
-	sb->st_uid = fs->nf_opened_node->inode->i_uid;
-	sb->st_gid = fs->nf_opened_node->inode->i_gid;
-	return (0);
-}
-
-static int
-nandfs_readdir(struct open_file *f, struct dirent *d)
-{
-	struct nandfs *fs = f->f_fsdata;
-	struct nandfs_dir_entry *dirent;
-	void *buf;
-	size_t buf_size;
-
-	NANDFS_DEBUG("nandfs_readdir(file=%p, dirent=%p)\n", f, d);
-
-	if (fs->nf_offset >= fs->nf_opened_node->inode->i_size) {
-		NANDFS_DEBUG("nandfs_readdir(file=%p, dirent=%p) ENOENT\n",
-		    f, d);
-		return (ENOENT);
-	}
-
-	if (nandfs_buf_read(fs, &buf, &buf_size)) {
-		NANDFS_DEBUG("nandfs_readdir(file=%p, dirent=%p)"
-		    "buf_read failed\n", f, d);
-		return (EIO);
-	}
-
-	NANDFS_DEBUG("nandfs_readdir(file=%p, dirent=%p) moving forward\n",
-	    f, d);
-
-	dirent = (struct nandfs_dir_entry *)buf;
-	fs->nf_offset += dirent->rec_len;
-	strncpy(d->d_name, dirent->name, dirent->name_len);
-	d->d_name[dirent->name_len] = '\0';
-	d->d_type = dirent->file_type;
-	return (0);
-}
-
-static int
-nandfs_buf_read(struct nandfs *fs, void **buf_p, size_t *size_p)
-{
-	nandfs_daddr_t blknr, blkoff;
-
-	blknr = fs->nf_offset / fs->nf_blocksize;
-	blkoff = fs->nf_offset % fs->nf_blocksize;
-
-	if (blknr != fs->nf_buf_blknr) {
-		if (fs->nf_buf == NULL)
-			fs->nf_buf = malloc(fs->nf_blocksize);
-
-		if (nandfs_read_inode(fs, fs->nf_opened_node, blknr, 1,
-		    fs->nf_buf, 0))
-			return (EIO);
-
-		fs->nf_buf_blknr = blknr;
-	}
-
-	*buf_p = fs->nf_buf + blkoff;
-	*size_p = fs->nf_blocksize - blkoff;
-
-	NANDFS_DEBUG("nandfs_buf_read buf_p=%p size_p=%d\n", *buf_p, *size_p);
-
-	if (*size_p > fs->nf_opened_node->inode->i_size - fs->nf_offset)
-		*size_p = fs->nf_opened_node->inode->i_size - fs->nf_offset;
-
-	return (0);
-}
-
-static struct nandfs_node *
-nandfs_lookup_node(struct nandfs *fs, uint64_t ino)
-{
-	uint64_t blocknr;
-	int entrynr;
-	struct nandfs_inode *buffer;
-	struct nandfs_node *node;
-	struct nandfs_inode *inode;
-
-	NANDFS_DEBUG("nandfs_lookup_node ino=%lld\n", ino);
-
-	if (ino == 0) {
-		printf("nandfs_lookup_node: invalid inode requested\n");
-		return (NULL);
-	}
-
-	buffer = malloc(fs->nf_blocksize);
-	inode = malloc(sizeof(struct nandfs_inode));
-	node = malloc(sizeof(struct nandfs_node));
-
-	nandfs_mdt_trans(&fs->nf_ifile_mdt, ino, &blocknr, &entrynr);
-
-	if (nandfs_read_inode(fs, &fs->nf_ifile, blocknr, 1, buffer, 0))
-		return (NULL);
-
-	memcpy(inode, &buffer[entrynr], sizeof(struct nandfs_inode));
-	node->inode = inode;
-	free(buffer);
-	return (node);
-}
-
-static struct nandfs_node *
-nandfs_lookup_path(struct nandfs *fs, const char *path)
-{
-	struct nandfs_node *node;
-	struct nandfs_dir_entry *dirent;
-	char *namebuf;
-	uint64_t i, done, pinode, inode;
-	int nlinks = 0, counter, len, link_len, nameidx;
-	uint8_t *buffer, *orig;
-	char *strp, *lpath;
-
-	buffer = malloc(fs->nf_blocksize);
-	orig = buffer;
-
-	namebuf = malloc(2 * MAXPATHLEN + 2);
-	strncpy(namebuf, path, MAXPATHLEN);
-	namebuf[MAXPATHLEN] = '\0';
-	done = nameidx = 0;
-	lpath = namebuf;
-
-	/* Get the root inode */
-	node = nandfs_lookup_node(fs, NANDFS_ROOT_INO);
-	inode = NANDFS_ROOT_INO;
-
-	while ((strp = strsep(&lpath, "/")) != NULL) {
-		if (*strp == '\0')
-			continue;
-		if ((node->inode->i_mode & IFMT) != IFDIR) {
-			nandfs_free_node(node);
-			node = NULL;
-			goto out;
-		}
-
-		len = strlen(strp);
-		NANDFS_DEBUG("%s: looking for %s\n", __func__, strp);
-		for (i = 0; i < node->inode->i_blocks; i++) {
-			if (nandfs_read_inode(fs, node, i, 1, orig, 0)) {
-				node = NULL;
-				goto out;
-			}
-
-			buffer = orig;
-			done = counter = 0;
-			while (1) {
-				dirent = 
-				    (struct nandfs_dir_entry *)(void *)buffer;
-				NANDFS_DEBUG("%s: dirent.name = %s\n",
-				    __func__, dirent->name);
-				NANDFS_DEBUG("%s: dirent.rec_len = %d\n",
-				    __func__, dirent->rec_len);
-				NANDFS_DEBUG("%s: dirent.inode = %lld\n",
-				    __func__, dirent->inode);
-				if (len == dirent->name_len &&
-				    (strncmp(strp, dirent->name, len) == 0) &&
-				    dirent->inode != 0) {
-					nandfs_free_node(node);
-					node = nandfs_lookup_node(fs,
-					    dirent->inode);
-					pinode = inode;
-					inode = dirent->inode;
-					done = 1;
-					break;
-				}
-
-				counter += dirent->rec_len;
-				buffer += dirent->rec_len;
-
-				if (counter == fs->nf_blocksize)
-					break;
-			}
-
-			if (done)
-				break;
-		}
-
-		if (!done) {
-			node = NULL;
-			goto out;
-		}
-
-		NANDFS_DEBUG("%s: %.*s has mode %o\n", __func__,
-		    dirent->name_len, dirent->name, node->inode->i_mode);
-
-		if ((node->inode->i_mode & IFMT) == IFLNK) {
-			NANDFS_DEBUG("%s: %.*s is symlink\n",
-			    __func__, dirent->name_len, dirent->name);
-			link_len = node->inode->i_size;
-
-			if (++nlinks > MAXSYMLINKS) {
-				nandfs_free_node(node);
-				node = NULL;
-				goto out;
-			}
-
-			if (nandfs_read_inode(fs, node, 0, 1, orig, 0)) {
-				nandfs_free_node(node);
-				node = NULL;
-				goto out;
-			}
-
-			NANDFS_DEBUG("%s: symlink is  %.*s\n",
-			    __func__, link_len, (char *)orig);
-
-			nameidx = (nameidx == 0) ? MAXPATHLEN + 1 : 0;
-			bcopy((char *)orig, namebuf + nameidx,
-			    (unsigned)link_len);
-			if (lpath != NULL) {
-				namebuf[nameidx + link_len++] = '/';
-				strncpy(namebuf + nameidx + link_len, lpath,
-				    MAXPATHLEN - link_len);
-				namebuf[nameidx + MAXPATHLEN] = '\0';
-			} else
-				namebuf[nameidx + link_len] = '\0';
-
-			NANDFS_DEBUG("%s: strp=%s, lpath=%s, namebuf0=%s, "
-			    "namebuf1=%s, idx=%d\n", __func__, strp, lpath,
-			    namebuf + 0, namebuf + MAXPATHLEN + 1, nameidx);
-
-			lpath = namebuf + nameidx;
-
-			nandfs_free_node(node);
-
-			/*
-			 * If absolute pathname, restart at root. Otherwise
-			 * continue with out parent inode.
-			 */
-			inode = (orig[0] == '/') ? NANDFS_ROOT_INO : pinode;
-			node = nandfs_lookup_node(fs, inode);
-		}
-	}
-
-out:
-	free(namebuf);
-	free(orig);
-	return (node);
-}
-
-static int
-nandfs_read_inode(struct nandfs *fs, struct nandfs_node *node,
-    nandfs_daddr_t blknr, u_int nblks, void *buf, int raw)
-{
-	uint64_t *pblks;
-	uint64_t *vblks;
-	u_int i;
-	int error;
-
-	pblks = malloc(nblks * sizeof(uint64_t));
-	vblks = malloc(nblks * sizeof(uint64_t));
-
-	NANDFS_DEBUG("nandfs_read_inode fs=%p node=%p blknr=%lld nblks=%d\n",
-	    fs, node, blknr, nblks);
-	for (i = 0; i < nblks; i++) {
-		error = nandfs_bmap_lookup(fs, node, blknr + i, &vblks[i], raw);
-		if (error) {
-			free(pblks);
-			free(vblks);
-			return (error);
-		}
-		if (raw == 0)
-			pblks[i] = nandfs_vtop(fs, vblks[i]);
-		else
-			pblks[i] = vblks[i];
-	}
-
-	for (i = 0; i < nblks; i++) {
-		if (ioread(fs->nf_file, pblks[i] * fs->nf_blocksize, buf,
-		    fs->nf_blocksize)) {
-			free(pblks);
-			free(vblks);
-			return (EIO);
-		}
-
-		buf = (void *)((uintptr_t)buf + fs->nf_blocksize);
-	}
-
-	free(pblks);
-	free(vblks);
-	return (0);
-}
-
-static int
-nandfs_read_blk(struct nandfs *fs, nandfs_daddr_t blknr, void *buf, int phys)
-{
-	uint64_t pblknr;
-
-	pblknr = (phys ? blknr : nandfs_vtop(fs, blknr));
-
-	return (ioread(fs->nf_file, pblknr * fs->nf_blocksize, buf,
-	    fs->nf_blocksize));
-}
-
-static int
-nandfs_get_checkpoint(struct nandfs *fs, uint64_t cpno,
-    struct nandfs_checkpoint *cp)
-{
-	uint64_t blocknr;
-	int blockoff, cp_per_block, dlen;
-	uint8_t *buf;
-
-	NANDFS_DEBUG("nandfs_get_checkpoint(fs=%p cpno=%lld)\n", fs, cpno);
-
-	buf = malloc(fs->nf_blocksize);
-
-	cpno += NANDFS_CPFILE_FIRST_CHECKPOINT_OFFSET - 1;
-	dlen = fs->nf_fsdata->f_checkpoint_size;
-	cp_per_block = fs->nf_blocksize / dlen;
-	blocknr = cpno / cp_per_block;
-	blockoff = (cpno % cp_per_block) * dlen;
-
-	if (nandfs_read_inode(fs, &fs->nf_cpfile, blocknr, 1, buf, 0)) {
-		free(buf);
-		return (EINVAL);
-	}
-
-	memcpy(cp, buf + blockoff, sizeof(struct nandfs_checkpoint));
-	free(buf);
-
-	return (0);
-}
-
-static uint64_t *
-nandfs_get_map(struct nandfs *fs, struct nandfs_node *node, nandfs_daddr_t blknr,
-    int phys)
-{
-	struct bmap_buf *bmap;
-	uint64_t *map;
-
-	LIST_FOREACH(bmap, &node->bmap_bufs, list) {
-		if (bmap->blknr == blknr)
-			return (bmap->map);
-	}
-
-	map = malloc(fs->nf_blocksize);
-	if (nandfs_read_blk(fs, blknr, map, phys)) {
-		free(map);
-		return (NULL);
-	}
-
-	bmap = malloc(sizeof(struct bmap_buf));
-	bmap->blknr = blknr;
-	bmap->map = map;
-
-	LIST_INSERT_HEAD(&node->bmap_bufs, bmap, list);
-
-	NANDFS_DEBUG("%s:(node=%p, map=%p)\n", __func__, node, map);
-	return (map);
-}
-
-static int
-nandfs_bmap_lookup(struct nandfs *fs, struct nandfs_node *node,
-    nandfs_lbn_t lblknr, nandfs_daddr_t *vblknr, int phys)
-{
-	struct nandfs_inode *ino;
-	nandfs_daddr_t ind_block_num;
-	uint64_t *map;
-	int idx;
-	int level;
-
-	ino = node->inode;
-
-	if (lblknr < NDADDR) {
-		*vblknr = ino->i_db[lblknr];
-		return (0);
-	}
-
-	lblknr -= NDADDR;
-
-	/*
-	 * nindir[0] = NINDIR
-	 * nindir[1] = NINDIR**2
-	 * nindir[2] = NINDIR**3
-	 *	etc
-	 */
-	for (level = 0; level < NIADDR; level++) {
-		NANDFS_DEBUG("lblknr=%jx fs->nf_nindir[%d]=%d\n", lblknr, level, fs->nf_nindir[level]);
-		if (lblknr < fs->nf_nindir[level])
-			break;
-		lblknr -= fs->nf_nindir[level];
-	}
-
-	if (level == NIADDR) {
-		/* Block number too high */
-		NANDFS_DEBUG("lblknr %jx too high\n", lblknr);
-		return (EFBIG);
-	}
-
-	ind_block_num = ino->i_ib[level];
-
-	for (; level >= 0; level--) {
-		if (ind_block_num == 0) {
-			*vblknr = 0;	/* missing */
-			return (0);
-		}
-
-		twiddle(1);
-		NANDFS_DEBUG("calling get_map with %jx\n", ind_block_num);
-		map = nandfs_get_map(fs, node, ind_block_num, phys);
-		if (map == NULL)
-			return (EIO);
-
-		if (level > 0) {
-			idx = lblknr / fs->nf_nindir[level - 1];
-			lblknr %= fs->nf_nindir[level - 1];
-		} else
-			idx = lblknr;
-
-		ind_block_num = ((nandfs_daddr_t *)map)[idx];
-	}
-
-	*vblknr = ind_block_num;
-
-	return (0);
-}
-
-static nandfs_daddr_t
-nandfs_vtop(struct nandfs *fs, nandfs_daddr_t vblocknr)
-{
-	nandfs_lbn_t blocknr;
-	nandfs_daddr_t pblocknr;
-	int entrynr;
-	struct nandfs_dat_entry *dat;
-
-	dat = malloc(fs->nf_blocksize);
-	nandfs_mdt_trans(&fs->nf_datfile_mdt, vblocknr, &blocknr, &entrynr);
-
-	if (nandfs_read_inode(fs, &fs->nf_datfile, blocknr, 1, dat, 1)) {
-		free(dat);
-		return (0);
-	}
-
-	NANDFS_DEBUG("nandfs_vtop entrynr=%d vblocknr=%lld pblocknr=%lld\n",
-	    entrynr, vblocknr, dat[entrynr].de_blocknr);
-
-	pblocknr = dat[entrynr].de_blocknr;
-	free(dat);
-	return (pblocknr);
-}
-
-static void
-nandfs_calc_mdt_consts(int blocksize, struct nandfs_mdt *mdt, int entry_size)
-{
-
-	mdt->entries_per_group = blocksize * 8;	   /* bits in sector */
-	mdt->entries_per_block = blocksize / entry_size;
-	mdt->blocks_per_group  =
-	    (mdt->entries_per_group -1) / mdt->entries_per_block + 1 + 1;
-	mdt->groups_per_desc_block =
-	    blocksize / sizeof(struct nandfs_block_group_desc);
-	mdt->blocks_per_desc_block =
-	    mdt->groups_per_desc_block * mdt->blocks_per_group + 1;
-}
-
-static void
-nandfs_mdt_trans(struct nandfs_mdt *mdt, uint64_t index,
-    nandfs_daddr_t *blocknr, uint32_t *entry_in_block)
-{
-	nandfs_daddr_t blknr;
-	uint64_t group, group_offset, blocknr_in_group;
-	uint64_t desc_block, desc_offset;
-
-	/* Calculate our offset in the file */
-	group = index / mdt->entries_per_group;
-	group_offset = index % mdt->entries_per_group;
-	desc_block = group / mdt->groups_per_desc_block;
-	desc_offset = group % mdt->groups_per_desc_block;
-	blocknr_in_group = group_offset / mdt->entries_per_block;
-
-	/* To descgroup offset */
-	blknr = 1 + desc_block * mdt->blocks_per_desc_block;
-
-	/* To group offset */
-	blknr += desc_offset * mdt->blocks_per_group;
-
-	/* To actual file block */
-	blknr += 1 + blocknr_in_group;
-
-	*blocknr        = blknr;
-	*entry_in_block = group_offset % mdt->entries_per_block;
-}
-
-static int
-ioread(struct open_file *f, off_t pos, void *buf, u_int length)
-{
-	void *buffer;
-	int err;
-	int bsize = ((struct nandfs *)f->f_fsdata)->nf_sectorsize;
-	u_int off, nsec;
-
-	off = pos % bsize;
-	pos /= bsize;
-	nsec = (length + (bsize - 1)) / bsize;
-
-	NANDFS_DEBUG("pos=%lld length=%d off=%d nsec=%d\n", pos, length,
-	    off, nsec);
-
-	buffer = malloc(nsec * bsize);
-
-	err = (f->f_dev->dv_strategy)(f->f_devdata, F_READ, pos,
-	    nsec * bsize, buffer, NULL);
-
-	memcpy(buf, (void *)((uintptr_t)buffer + off), length);
-	free(buffer);
-
-	return (err);
-}
-
-static int
-nandfs_probe_sectorsize(struct open_file *f)
-{
-	void *buffer;
-	int i, err;
-
-	buffer = malloc(16 * 1024);
-
-	NANDFS_DEBUG("probing for sector size: ");
-
-	for (i = 512; i < (16 * 1024); i <<= 1) {
-		NANDFS_DEBUG("%d ", i);
-		err = (f->f_dev->dv_strategy)(f->f_devdata, F_READ, 0, i,
-		    buffer, NULL);
-
-		if (err == 0) {
-			NANDFS_DEBUG("found");
-			free(buffer);
-			return (i);
-		}
-	}
-
-	free(buffer);
-	NANDFS_DEBUG("not found\n");
-	return (-1);
-}
diff --git a/usr/src/boot/lib/libstand/stand.h b/usr/src/boot/lib/libstand/stand.h
index 63595f2956..6526eb6d76 100644
--- a/usr/src/boot/lib/libstand/stand.h
+++ b/usr/src/boot/lib/libstand/stand.h
@@ -121,7 +121,6 @@ extern struct fs_ops ufs_fsops;
 extern struct fs_ops tftp_fsops;
 extern struct fs_ops nfs_fsops;
 extern struct fs_ops cd9660_fsops;
-extern struct fs_ops nandfs_fsops;
 extern struct fs_ops gzipfs_fsops;
 extern struct fs_ops bzipfs_fsops;
 extern struct fs_ops dosfs_fsops;
diff --git a/usr/src/boot/sys/boot/common/part.c b/usr/src/boot/sys/boot/common/part.c
index bcc792dcd4..084eb38f80 100644
--- a/usr/src/boot/sys/boot/common/part.c
+++ b/usr/src/boot/sys/boot/common/part.c
@@ -56,7 +56,6 @@ static const uuid_t gpt_uuid_freebsd_ufs = GPT_ENT_TYPE_FREEBSD_UFS;
 static const uuid_t gpt_uuid_efi = GPT_ENT_TYPE_EFI;
 static const uuid_t gpt_uuid_freebsd = GPT_ENT_TYPE_FREEBSD;
 static const uuid_t gpt_uuid_freebsd_boot = GPT_ENT_TYPE_FREEBSD_BOOT;
-static const uuid_t gpt_uuid_freebsd_nandfs = GPT_ENT_TYPE_FREEBSD_NANDFS;
 static const uuid_t gpt_uuid_freebsd_swap = GPT_ENT_TYPE_FREEBSD_SWAP;
 static const uuid_t gpt_uuid_freebsd_zfs = GPT_ENT_TYPE_FREEBSD_ZFS;
 static const uuid_t gpt_uuid_freebsd_vinum = GPT_ENT_TYPE_FREEBSD_VINUM;
@@ -96,7 +95,6 @@ static struct parttypes {
 	{ PART_EFI,		"EFI" },
 	{ PART_FREEBSD,		"FreeBSD" },
 	{ PART_FREEBSD_BOOT,	"FreeBSD boot" },
-	{ PART_FREEBSD_NANDFS,	"FreeBSD nandfs" },
 	{ PART_FREEBSD_UFS,	"FreeBSD UFS" },
 	{ PART_FREEBSD_ZFS,	"FreeBSD ZFS" },
 	{ PART_FREEBSD_SWAP,	"FreeBSD swap" },
@@ -158,8 +156,6 @@ gpt_parttype(uuid_t type)
 		return (PART_FREEBSD_SWAP);
 	else if (uuid_equal(&type, &gpt_uuid_freebsd_vinum, NULL))
 		return (PART_FREEBSD_VINUM);
-	else if (uuid_equal(&type, &gpt_uuid_freebsd_nandfs, NULL))
-		return (PART_FREEBSD_NANDFS);
 	else if (uuid_equal(&type, &gpt_uuid_freebsd, NULL))
 		return (PART_FREEBSD);
 	else if (uuid_equal(&type, &gpt_uuid_illumos_boot, NULL))
@@ -473,8 +469,6 @@ bsd_parttype(uint8_t type)
 {
 
 	switch (type) {
-	case FS_NANDFS:
-		return (PART_FREEBSD_NANDFS);
 	case FS_SWAP:
 		return (PART_FREEBSD_SWAP);
 	case FS_BSDFFS:
@@ -555,8 +549,6 @@ vtoc8_parttype(uint16_t type)
 {
 
 	switch (type) {
-	case VTOC_TAG_FREEBSD_NANDFS:
-		return (PART_FREEBSD_NANDFS);
 	case VTOC_TAG_FREEBSD_SWAP:
 		return (PART_FREEBSD_SWAP);
 	case VTOC_TAG_FREEBSD_UFS:
diff --git a/usr/src/boot/sys/boot/common/part.h b/usr/src/boot/sys/boot/common/part.h
index bed69c4484..bdeddcbd5c 100644
--- a/usr/src/boot/sys/boot/common/part.h
+++ b/usr/src/boot/sys/boot/common/part.h
@@ -44,7 +44,6 @@ enum partition_type {
 	PART_EFI,
 	PART_FREEBSD,
 	PART_FREEBSD_BOOT,
-	PART_FREEBSD_NANDFS,
 	PART_FREEBSD_UFS,
 	PART_FREEBSD_ZFS,
 	PART_FREEBSD_SWAP,
diff --git a/usr/src/boot/sys/boot/common/ufsread.c b/usr/src/boot/sys/boot/common/ufsread.c
deleted file mode 100644
index 3dee081a80..0000000000
--- a/usr/src/boot/sys/boot/common/ufsread.c
+++ /dev/null
@@ -1,363 +0,0 @@
-/*
- * Copyright (c) 2002 McAfee, Inc.
- * All rights reserved.
- *
- * This software was developed for the FreeBSD Project by Marshall
- * Kirk McKusick and McAfee Research,, the Security Research Division of
- * McAfee, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as
- * part of the DARPA CHATS research program
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * 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.
- */
-/*-
- * Copyright (c) 1998 Robert Nordier
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms are freely
- * permitted provided that the above copyright notice and this
- * paragraph and the following disclaimer are duplicated in all
- * such forms.
- *
- * This software is provided "AS IS" and without any express or
- * implied warranties, including, without limitation, the implied
- * warranties of merchantability and fitness for a particular
- * purpose.
- */
-
-#include <sys/cdefs.h>
-
-#include <ufs/ufs/dinode.h>
-#include <ufs/ufs/dir.h>
-#include <ufs/ffs/fs.h>
-
-#ifdef UFS_SMALL_CGBASE
-/* XXX: Revert to old (broken for over 1.5Tb filesystems) version of cgbase
-   (see sys/ufs/ffs/fs.h rev 1.39) so that small boot loaders (e.g. boot2) can
-   support both UFS1 and UFS2. */
-#undef cgbase
-#define cgbase(fs, c)   ((ufs2_daddr_t)((fs)->fs_fpg * (c)))
-#endif
-
-typedef	uint32_t	ufs_ino_t;
-
-/*
- * We use 4k `virtual' blocks for filesystem data, whatever the actual
- * filesystem block size. FFS blocks are always a multiple of 4k.
- */
-#define VBLKSHIFT	12
-#define VBLKSIZE	(1 << VBLKSHIFT)
-#define VBLKMASK	(VBLKSIZE - 1)
-#define DBPERVBLK	(VBLKSIZE / DEV_BSIZE)
-#define INDIRPERVBLK(fs) (NINDIR(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
-#define IPERVBLK(fs)	(INOPB(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
-#define INO_TO_VBA(fs, ipervblk, x) \
-    (fsbtodb(fs, cgimin(fs, ino_to_cg(fs, x))) + \
-    (((x) % (fs)->fs_ipg) / (ipervblk) * DBPERVBLK))
-#define INO_TO_VBO(ipervblk, x) ((x) % ipervblk)
-#define FS_TO_VBA(fs, fsb, off) (fsbtodb(fs, fsb) + \
-    ((off) / VBLKSIZE) * DBPERVBLK)
-#define FS_TO_VBO(fs, fsb, off) ((off) & VBLKMASK)
-
-/* Buffers that must not span a 64k boundary. */
-struct dmadat {
-	char blkbuf[VBLKSIZE];	/* filesystem blocks */
-	char indbuf[VBLKSIZE];	/* indir blocks */
-	char sbbuf[SBLOCKSIZE];	/* superblock */
-	char secbuf[DEV_BSIZE];	/* for MBR/disklabel */
-};
-static struct dmadat *dmadat;
-
-static ufs_ino_t lookup(const char *);
-static ssize_t fsread(ufs_ino_t, void *, size_t);
-static uint8_t inode_type(ufs_ino_t inode);
-
-static uint8_t ls, dsk_meta;
-static uint32_t fs_off;
-
-#ifndef UFS2_ONLY
-static struct ufs1_dinode dp1;
-ufs1_daddr_t addr1;
-#endif
-#ifndef UFS1_ONLY
-static struct ufs2_dinode dp2;
-#endif
-static struct fs fs;
-static ufs_ino_t inomap;
-static ufs2_daddr_t blkmap, indmap;
-
-static __inline uint8_t
-fsfind(const char *name, ufs_ino_t * ino)
-{
-	static char buf[DEV_BSIZE];
-	struct direct *d;
-	char *s;
-	ssize_t n;
-
-	fs_off = 0;
-	while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0)
-		for (s = buf; s < buf + DEV_BSIZE;) {
-			d = (void *)s;
-			if (ls)
-				printf("%s ", d->d_name);
-			else if (!strcmp(name, d->d_name)) {
-				*ino = d->d_ino;
-				return inode_type(*ino);
-			}
-			s += d->d_reclen;
-		}
-	if (n != -1 && ls)
-		printf("\n");
-	return 0;
-}
-
-static ufs_ino_t
-lookup(const char *path)
-{
-	static char name[UFS_MAXNAMLEN + 1];
-	const char *s;
-	ufs_ino_t ino;
-	ssize_t n;
-	uint8_t dt;
-
-	ino = ROOTINO;
-	dt = DT_DIR;
-	for (;;) {
-		if (*path == '/')
-			path++;
-		if (!*path)
-			break;
-		for (s = path; *s && *s != '/'; s++);
-		if ((n = s - path) > UFS_MAXNAMLEN)
-			return 0;
-		ls = *path == '?' && n == 1 && !*s;
-		memcpy(name, path, n);
-		name[n] = 0;
-		if (dt != DT_DIR) {
-			printf("%s: not a directory.\n", name);
-			return (0);
-		}
-		if ((dt = fsfind(name, &ino)) <= 0)
-			break;
-		path = s;
-	}
-	return dt == DT_REG ? ino : 0;
-}
-
-/*
- * Possible superblock locations ordered from most to least likely.
- */
-static int sblock_try[] = SBLOCKSEARCH;
-
-#if defined(UFS2_ONLY)
-#define DIP(field) dp2.field
-#elif defined(UFS1_ONLY)
-#define DIP(field) dp1.field
-#else
-#define DIP(field) fs.fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field
-#endif
-
-static uint8_t
-inode_type(ufs_ino_t inode)
-{
-	char *blkbuf;
-	size_t n;
-
-	blkbuf = dmadat->blkbuf;
-
-	if (!inode)
-		return (0);
-	if (inomap != inode) {
-		n = IPERVBLK(&fs);
-		if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
-			return (-1);
-		n = INO_TO_VBO(n, inode);
-#if defined(UFS1_ONLY)
-		memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
-		    sizeof(struct ufs1_dinode));
-#elif defined(UFS2_ONLY)
-		memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
-		    sizeof(struct ufs2_dinode));
-#else
-		if (fs.fs_magic == FS_UFS1_MAGIC)
-			memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
-			    sizeof(struct ufs1_dinode));
-		else
-			memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
-			    sizeof(struct ufs2_dinode));
-#endif
-		inomap = inode;
-		fs_off = 0;
-		blkmap = indmap = 0;
-	}
-	return (IFTODT(DIP(di_mode)));
-}
-
-static ssize_t
-fsread_size(ufs_ino_t inode, void *buf, size_t nbyte, size_t *fsizep)
-{
-	char *blkbuf;
-	void *indbuf;
-	char *s;
-	size_t n, nb, size, off, vboff;
-	ufs_lbn_t lbn;
-	ufs2_daddr_t addr2, vbaddr;
-	u_int u;
-
-	/* Basic parameter validation. */
-	if ((buf == NULL && nbyte != 0) || dmadat == NULL)
-		return (-1);
-
-	blkbuf = dmadat->blkbuf;
-	indbuf = dmadat->indbuf;
-
-	/*
-	 * Force probe if inode is zero to ensure we have a valid fs, otherwise
-	 * when probing multiple paritions, reads from subsequent parititions
-	 * will incorrectly succeed.
-	 */
-	if (!dsk_meta || inode == 0) {
-		inomap = 0;
-		dsk_meta = 0;
-		for (n = 0; sblock_try[n] != -1; n++) {
-			if (dskread(dmadat->sbbuf, sblock_try[n] / DEV_BSIZE,
-			    SBLOCKSIZE / DEV_BSIZE))
-				return -1;
-			memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
-			if ((
-#if defined(UFS1_ONLY)
-			    fs.fs_magic == FS_UFS1_MAGIC
-#elif defined(UFS2_ONLY)
-			    (fs.fs_magic == FS_UFS2_MAGIC &&
-			    fs.fs_sblockloc == sblock_try[n])
-#else
-			    fs.fs_magic == FS_UFS1_MAGIC ||
-			    (fs.fs_magic == FS_UFS2_MAGIC &&
-			    fs.fs_sblockloc == sblock_try[n])
-#endif
-			    ) &&
-			    fs.fs_bsize <= MAXBSIZE &&
-			    fs.fs_bsize >= (int32_t)sizeof(struct fs))
-				break;
-		}
-		if (sblock_try[n] == -1) {
-			return -1;
-		}
-		dsk_meta++;
-	} else
-		memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
-	if (!inode)
-		return 0;
-	if (inomap != inode) {
-		n = IPERVBLK(&fs);
-		if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
-			return -1;
-		n = INO_TO_VBO(n, inode);
-#if defined(UFS1_ONLY)
-		memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
-		    sizeof(dp1));
-#elif defined(UFS2_ONLY)
-		memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
-		    sizeof(dp2));
-#else
-		if (fs.fs_magic == FS_UFS1_MAGIC)
-			memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
-			    sizeof(dp1));
-		else
-			memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
-			    sizeof(dp2));
-#endif
-		inomap = inode;
-		fs_off = 0;
-		blkmap = indmap = 0;
-	}
-	s = buf;
-	size = DIP(di_size);
-	n = size - fs_off;
-	if (nbyte > n)
-		nbyte = n;
-	nb = nbyte;
-	while (nb) {
-		lbn = lblkno(&fs, fs_off);
-		off = blkoff(&fs, fs_off);
-		if (lbn < NDADDR) {
-			addr2 = DIP(di_db[lbn]);
-		} else if (lbn < NDADDR + NINDIR(&fs)) {
-			n = INDIRPERVBLK(&fs);
-			addr2 = DIP(di_ib[0]);
-			u = (u_int)(lbn - NDADDR) / n * DBPERVBLK;
-			vbaddr = fsbtodb(&fs, addr2) + u;
-			if (indmap != vbaddr) {
-				if (dskread(indbuf, vbaddr, DBPERVBLK))
-					return -1;
-				indmap = vbaddr;
-			}
-			n = (lbn - NDADDR) & (n - 1);
-#if defined(UFS1_ONLY)
-			memcpy(&addr1, (ufs1_daddr_t *)indbuf + n,
-			    sizeof(ufs1_daddr_t));
-			addr2 = addr1;
-#elif defined(UFS2_ONLY)
-			memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
-			    sizeof(ufs2_daddr_t));
-#else
-			if (fs.fs_magic == FS_UFS1_MAGIC) {
-				memcpy(&addr1, (ufs1_daddr_t *)indbuf + n,
-				    sizeof(ufs1_daddr_t));
-				addr2 = addr1;
-			} else
-				memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
-				    sizeof(ufs2_daddr_t));
-#endif
-		} else
-			return -1;
-		vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK;
-		vboff = off & VBLKMASK;
-		n = sblksize(&fs, (off_t)size, lbn) - (off & ~VBLKMASK);
-		if (n > VBLKSIZE)
-			n = VBLKSIZE;
-		if (blkmap != vbaddr) {
-			if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
-				return -1;
-			blkmap = vbaddr;
-		}
-		n -= vboff;
-		if (n > nb)
-			n = nb;
-		memcpy(s, blkbuf + vboff, n);
-		s += n;
-		fs_off += n;
-		nb -= n;
-	}
-
-	if (fsizep != NULL)
-		*fsizep = size;
-
-	return nbyte;
-}
-
-static ssize_t
-fsread(ufs_ino_t inode, void *buf, size_t nbyte)
-{
-
-	return fsread_size(inode, buf, nbyte, NULL);
-}
-
diff --git a/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c b/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c
index 63ba02968a..63086e3cd1 100644
--- a/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c
+++ b/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c
@@ -30,6 +30,7 @@
 #include <machine/pc/bios.h>
 
 #include <stdarg.h>
+#include <stdbool.h>
 #include <stddef.h>
 
 #include <a.out.h>
@@ -90,6 +91,18 @@ static const unsigned char flags[NOPT] = {
 };
 uint32_t opts;
 
+/*
+ * Paths to try loading before falling back to the boot2 prompt.
+ */
+#define	PATH_ZFSLOADER "/boot/zfsloader"
+static const struct string {
+	const char *p;
+	size_t len;
+} loadpath[] = {
+	{ PATH_LOADER, sizeof (PATH_LOADER) },
+	{ PATH_ZFSLOADER, sizeof (PATH_ZFSLOADER) }
+};
+
 static const unsigned char dev_maj[NDEV] = {30, 4, 2};
 
 static struct i386_devdesc *bdev;
@@ -130,7 +143,9 @@ struct fs_ops *file_system[] = {
 int
 main(void)
 {
-	int auto_boot, i, fd;
+	unsigned i;
+	int fd;
+	bool auto_boot;
 	struct disk_devdesc devdesc;
 
 	bios_getmem();
@@ -198,7 +213,7 @@ main(void)
 
 	/* Process configuration file */
 	setenv("screen-#rows", "24", 1);
-	auto_boot = 1;
+	auto_boot = true;
 
 	fd = open(PATH_CONFIG, O_RDONLY);
 	if (fd == -1)
@@ -222,37 +237,29 @@ main(void)
 		 */
 		memcpy(cmddup, cmd, sizeof (cmd));
 		if (parse_cmd())
-			auto_boot = 0;
+			auto_boot = false;
 		if (!OPT_CHECK(RBX_QUIET))
 			printf("%s: %s\n", PATH_CONFIG, cmddup);
 		/* Do not process this command twice */
 		*cmd = 0;
 	}
 
-	/*
-	 * Try to exec stage 3 boot loader. If interrupted by a keypress,
-	 * or in case of failure, switch off auto boot.
-	 */
-
 	if (auto_boot && !*kname) {
-		memcpy(kname, PATH_LOADER, sizeof (PATH_LOADER));
-		if (!keyhit(3)) {
-			load();
-			auto_boot = 0;
-			/*
-			 * Try to fall back to /boot/zfsloader.
-			 * This fallback should be eventually removed.
-			 * Created: 08/03/2018
-			 */
-#define	PATH_ZFSLOADER "/boot/zfsloader"
-			memcpy(kname, PATH_ZFSLOADER, sizeof (PATH_ZFSLOADER));
+		/*
+		 * Try to exec stage 3 boot loader. If interrupted by a
+		 * keypress, or in case of failure, drop the user to the
+		 * boot2 prompt..
+		 */
+		auto_boot = false;
+		for (i = 0; i < nitems(loadpath); i++) {
+			memcpy(kname, loadpath[i].p, loadpath[i].len);
+			if (keyhit(3))
+				break;
 			load();
-			/*
-			 * Still there? restore default loader name for prompt.
-			 */
-			memcpy(kname, PATH_LOADER, sizeof (PATH_LOADER));
 		}
 	}
+	/* Reset to default */
+	memcpy(kname, loadpath[0].p, loadpath[0].len);
 
 	/* Present the user with the boot2 prompt. */
 
@@ -267,7 +274,7 @@ main(void)
 			getstr(cmd, sizeof (cmd));
 		else if (!auto_boot || !OPT_CHECK(RBX_QUIET))
 			putchar('\n');
-		auto_boot = 0;
+		auto_boot = false;
 		if (parse_cmd())
 			putchar('\a');
 		else
diff --git a/usr/src/boot/sys/boot/i386/loader/conf.c b/usr/src/boot/sys/boot/i386/loader/conf.c
index 25ce1a8806..d8025b3ef8 100644
--- a/usr/src/boot/sys/boot/i386/loader/conf.c
+++ b/usr/src/boot/sys/boot/i386/loader/conf.c
@@ -72,9 +72,6 @@ struct fs_ops *file_system[] = {
 	&ext2fs_fsops,
 #endif
 	&cd9660_fsops,
-#if defined(LOADER_NANDFS_SUPPORT)
-	&nandfs_fsops,
-#endif
 	&tftp_fsops,
 	&nfs_fsops,
 #ifdef LOADER_BZIP2_SUPPORT
diff --git a/usr/src/boot/sys/sys/disklabel.h b/usr/src/boot/sys/sys/disklabel.h
index 42c757aaf3..7939335673 100644
--- a/usr/src/boot/sys/sys/disklabel.h
+++ b/usr/src/boot/sys/sys/disklabel.h
@@ -234,7 +234,6 @@ static const char *dktypenames[] = {
 #define	FS_UDF		24		/* UDF */
 #define	FS_EFS		26		/* SGI's Extent File system */
 #define	FS_ZFS		27		/* Sun's ZFS */
-#define	FS_NANDFS	30		/* FreeBSD nandfs (NiLFS derived) */
 
 #ifdef	FSTYPENAMES
 static const char *fstypenames[] = {
@@ -268,7 +267,6 @@ static const char *fstypenames[] = {
 	"ZFS",
 	"?",
 	"?",
-	"nandfs",
 	NULL
 };
 #define FSMAXTYPES	(sizeof(fstypenames) / sizeof(fstypenames[0]) - 1)
diff --git a/usr/src/boot/sys/sys/gpt.h b/usr/src/boot/sys/sys/gpt.h
index bb39876e35..f575489a3e 100644
--- a/usr/src/boot/sys/sys/gpt.h
+++ b/usr/src/boot/sys/sys/gpt.h
@@ -79,8 +79,6 @@ struct gpt_ent {
 	{0x516e7cb4,0x6ecf,0x11d6,0x8f,0xf8,{0x00,0x02,0x2d,0x09,0x71,0x2b}}
 #define	GPT_ENT_TYPE_FREEBSD_BOOT	\
 	{0x83bd6b9d,0x7f41,0x11dc,0xbe,0x0b,{0x00,0x15,0x60,0xb8,0x4f,0x0f}}
-#define	GPT_ENT_TYPE_FREEBSD_NANDFS	\
-	{0x74ba7dd9,0xa689,0x11e1,0xbd,0x04,{0x00,0xe0,0x81,0x28,0x6a,0xcf}}
 #define	GPT_ENT_TYPE_FREEBSD_SWAP	\
 	{0x516e7cb5,0x6ecf,0x11d6,0x8f,0xf8,{0x00,0x02,0x2d,0x09,0x71,0x2b}}
 #define	GPT_ENT_TYPE_FREEBSD_UFS	\
diff --git a/usr/src/boot/sys/sys/vtoc.h b/usr/src/boot/sys/sys/vtoc.h
index 10d83499f8..b1d164e3ee 100644
--- a/usr/src/boot/sys/sys/vtoc.h
+++ b/usr/src/boot/sys/sys/vtoc.h
@@ -51,7 +51,6 @@
 #define	VTOC_TAG_FREEBSD_UFS	0x0902
 #define	VTOC_TAG_FREEBSD_VINUM	0x0903
 #define	VTOC_TAG_FREEBSD_ZFS	0x0904
-#define	VTOC_TAG_FREEBSD_NANDFS	0x0905
 
 #define	VTOC_FLAG_UNMNT		0x01	/* unmountable partition */
 #define	VTOC_FLAG_RDONLY	0x10    /* partition is read/only */
diff --git a/usr/src/lib/libc/port/gen/attrat.c b/usr/src/lib/libc/port/gen/attrat.c
index 89163a3909..d7c7949175 100644
--- a/usr/src/lib/libc/port/gen/attrat.c
+++ b/usr/src/lib/libc/port/gen/attrat.c
@@ -310,7 +310,7 @@ setattrat(int basefd, xattr_view_t view, const char *name, nvlist_t *request)
 void
 libc_nvlist_free(nvlist_t *nvp)
 {
-	nvfree(nvp);
+	(void) nvfree(nvp);
 }
 
 int
diff --git a/usr/src/lib/libc/port/gen/crypt.c b/usr/src/lib/libc/port/gen/crypt.c
index 5edc9a1deb..812062644f 100644
--- a/usr/src/lib/libc/port/gen/crypt.c
+++ b/usr/src/lib/libc/port/gen/crypt.c
@@ -208,10 +208,10 @@ cleanup:
  * either still allowed or not deprecated.
  *
  * RETURN VALUES
- * 	Return a pointer to the new salt, the caller is responsible
- * 	for using free(3c) on the return value.
- * 	Returns NULL on error and sets errno to one of:
- * 		EINVAL, ELIBACC, ENOMEM
+ *	Return a pointer to the new salt, the caller is responsible
+ *	for using free(3c) on the return value.
+ *	Returns NULL on error and sets errno to one of:
+ *		EINVAL, ELIBACC, ENOMEM
  */
 char *
 crypt_gensalt(const char *oldsalt, const struct passwd *userinfo)
@@ -570,7 +570,7 @@ getalgbyname(const char *algname, boolean_t *found)
 			*found = B_TRUE;
 		}
 	}
-	if (!found) {
+	if (!(*found)) {
 		errno = EINVAL;
 		goto cleanup;
 	}
@@ -731,7 +731,7 @@ free_crypt_policy(struct crypt_policy_s *policy)
 
 /*
  * isa_path - prepend the default dir or patch up the $ISA in path
- * 	Caller is responsible for calling free(3c) on the result.
+ *	Caller is responsible for calling free(3c) on the result.
  */
 static char *
 isa_path(const char *path)
@@ -778,10 +778,10 @@ isa_path(const char *path)
 /*ARGSUSED*/
 static char *
 _unix_crypt_gensalt(char *gsbuffer,
-	    size_t gsbufflen,
-	    const char *oldpuresalt,
-	    const struct passwd *userinfo,
-	    const char *argv[])
+    size_t gsbufflen,
+    const char *oldpuresalt,
+    const struct passwd *userinfo,
+    const char *argv[])
 {
 	static const char saltchars[] =
 	    "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -807,7 +807,7 @@ _unix_crypt_gensalt(char *gsbuffer,
 
 
 /*	Copyright (c) 1988 AT&T	*/
-/*	  All Rights Reserved  	*/
+/*	  All Rights Reserved	*/