OS-2677 modules should appear in /system/boot

Reviewed by: Keith M Wesolowski <wesolows@foobazco.org>

13 files changed, 1652 insertions, 4 deletions

diff --git a/manifest b/manifest
index 4cc12d50ac..d0a8173195 100644
--- a/manifest
+++ b/manifest
@@ -857,6 +857,7 @@ f kernel/exec/amd64/intpexec 0755 root sys
 d kernel/fs 0755 root sys
 d kernel/fs/amd64 0755 root sys
 f kernel/fs/amd64/autofs 0755 root sys
+f kernel/fs/amd64/bootfs 0755 root sys
 f kernel/fs/amd64/ctfs 0755 root sys
 f kernel/fs/amd64/dcfs 0755 root sys
 f kernel/fs/amd64/dev 0755 root sys
@@ -5365,6 +5366,8 @@ s usr/lib/fs/autofs/libshare_autofs.so=libshare_autofs.so.1
 f usr/lib/fs/autofs/mount 0555 root bin
 f usr/lib/fs/autofs/share 0555 root bin
 f usr/lib/fs/autofs/unshare 0555 root bin
+d usr/lib/fs/bootfs 0755 root sys
+f usr/lib/fs/bootfs/mount 0555 root bin
 d usr/lib/fs/ctfs 0755 root sys
 f usr/lib/fs/ctfs/mount 0555 root bin
 d usr/lib/fs/dev 0755 root sys
@@ -18164,6 +18167,7 @@ f usr/share/man/man7d/yge.7d 0444 root bin
 f usr/share/man/man7d/zcons.7d 0444 root bin
 f usr/share/man/man7d/zero.7d 0444 root bin
 d usr/share/man/man7fs 0755 root bin
+f usr/share/man/man7fs/bootfs.7fs 0444 root bin
 f usr/share/man/man7fs/ctfs.7fs 0444 root bin
 f usr/share/man/man7fs/dcfs.7fs 0444 root bin
 f usr/share/man/man7fs/dev.7fs 0444 root bin
diff --git a/usr/src/cmd/fs.d/bootfs/Makefile b/usr/src/cmd/fs.d/bootfs/Makefile
new file mode 100644
index 0000000000..d0ac4311f4
--- /dev/null
+++ b/usr/src/cmd/fs.d/bootfs/Makefile
@@ -0,0 +1,21 @@
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source.  A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
+
+#
+# Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+#
+
+FSTYPE=		bootfs
+LIBPROG=	mount
+
+include		../Makefile.fstype
+include		../Makefile.mount
+include		../Makefile.mount.targ
diff --git a/usr/src/cmd/fs.d/bootfs/mount.c b/usr/src/cmd/fs.d/bootfs/mount.c
new file mode 100644
index 0000000000..5363a4f872
--- /dev/null
+++ b/usr/src/cmd/fs.d/bootfs/mount.c
@@ -0,0 +1,139 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ * Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libintl.h>
+#include <errno.h>
+#include <sys/fstyp.h>
+#include <sys/fsid.h>
+#include <sys/mntent.h>
+#include <sys/mnttab.h>
+#include <sys/mount.h>
+#include <sys/signal.h>
+#include <sys/stat.h>
+#include <fslib.h>
+
+#define	MNTTYPE_BOOTFS "bootfs"
+
+static char  optbuf[MAX_MNTOPT_STR] = { '\0', };
+static int   optsize = 0;
+
+static void
+usage(void)
+{
+	(void) fprintf(stderr,
+	    "Usage: mount [-Ormq] [-o options] special mountpoint\n");
+	exit(2);
+}
+
+/*
+ * usage: mount [-Ormq] [-o options] special mountp
+ *
+ * This mount program is exec'ed by /usr/sbin/mount if '-F bootfs' is
+ * specified.
+ */
+int
+main(int argc, char *argv[])
+{
+	int c;
+	char *special;		/* Entity being mounted */
+	char *mountp;		/* Entity being mounted on */
+	char *savedoptbuf;
+	char *myname;
+	char typename[64];
+	int flags = 0;
+	int errflag = 0;
+	int qflg = 0;
+
+	myname = strrchr(argv[0], '/');
+	myname = myname ? myname+1 : argv[0];
+	(void) snprintf(typename, sizeof (typename), "%s %s", MNTTYPE_BOOTFS,
+	    myname);
+	argv[0] = typename;
+
+	while ((c = getopt(argc, argv, "o:rmOq")) != EOF) {
+		switch (c) {
+		case '?':
+			errflag++;
+			break;
+
+		case 'o':
+			if (strlcpy(optbuf, optarg, sizeof (optbuf)) >=
+			    sizeof (optbuf)) {
+				(void) fprintf(stderr,
+				    gettext("%s: Invalid argument: %s\n"),
+				    myname, optarg);
+				return (2);
+			}
+			optsize = strlen(optbuf);
+			break;
+		case 'O':
+			flags |= MS_OVERLAY;
+			break;
+		case 'r':
+			flags |= MS_RDONLY;
+			break;
+
+		case 'm':
+			flags |= MS_NOMNTTAB;
+			break;
+
+		case 'q':
+			qflg = 1;
+			break;
+
+		default:
+			usage();
+		}
+	}
+	if ((argc - optind != 2) || errflag) {
+		usage();
+	}
+	special = argv[argc - 2];
+	mountp = argv[argc - 1];
+
+	if ((savedoptbuf = strdup(optbuf)) == NULL) {
+		(void) fprintf(stderr, gettext("%s: out of memory\n"),
+		    myname);
+		exit(2);
+	}
+
+	if (mount(special, mountp, flags | MS_OPTIONSTR, MNTTYPE_BOOTFS, NULL,
+	    0, optbuf, MAX_MNTOPT_STR)) {
+		(void) fprintf(stderr, "mount: ");
+		perror(special);
+		exit(2);
+	}
+	if (optsize && !qflg) {
+		cmp_requested_to_actual_options(savedoptbuf, optbuf,
+		    special, mountp);
+	}
+
+	return (0);
+}
diff --git a/usr/src/man/man7fs/Makefile b/usr/src/man/man7fs/Makefile
index f940a4da13..d985e95410 100644
--- a/usr/src/man/man7fs/Makefile
+++ b/usr/src/man/man7fs/Makefile
@@ -12,14 +12,15 @@
 #
 # Copyright 2011, Richard Lowe
 # Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
-# Copyright 2012 Joyent, Inc. All rights reserved.
+# Copyright 2014 Joyent, Inc. All rights reserved.
 #
 
 include		$(SRC)/Makefile.master
 
 MANSECT= 	7fs
 
-MANFILES= 	ctfs.7fs	\
+MANFILES= 	bootfs.7fs	\
+		ctfs.7fs	\
 	 	dcfs.7fs	\
 	 	dev.7fs		\
 	 	devfs.7fs	\
diff --git a/usr/src/man/man7fs/bootfs.7fs b/usr/src/man/man7fs/bootfs.7fs
new file mode 100644
index 0000000000..9aea119370
--- /dev/null
+++ b/usr/src/man/man7fs/bootfs.7fs
@@ -0,0 +1,90 @@
+.\"
+.\" This file and its contents are supplied under the terms of the
+.\" Common Development and Distribution License ("CDDL"), version 1.0.
+.\" You may only use this file in accordance with the terms of version
+.\" 1.0 of the CDDL.
+.\"
+.\" A full copy of the text of the CDDL should have accompanied this
+.\" source.  A copy of the CDDL is also available via the Internet at
+.\" http://www.illumos.org/license/CDDL.
+.\"
+.\"
+.\" Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+.\"
+
+.TH BOOTFS 7FS "May 8, 2014"
+.SH NAME
+bootfs \- boot-time module file system
+
+.SH DESCRIPTION
+
+The
+.B bootfs
+file system is a read-only file system that provides access to any
+boot-time modules that were passed in to the system loader which were
+tagged with the type 
+.IR file .
+.B bootfs
+does not display any boot-time modules that were tagged as type
+.I hash
+or type
+.IR rootfs .
+
+If modules with duplicate names and paths are specified, only the first
+such entry will be present in the file system and a counter will be
+incremented to indicate that a duplicate entry was found, but is not
+present into the file system. If a module's name only consists of
+invalid characters, such as '.', '..', or '/', then the module will not
+be present in the file system and a counter will be incremented to
+indicate that this has occurred. In both cases, diagnostic information
+is available through the kstats facility.
+
+.SH FILES
+.sp
+.ne 2
+.na
+.B /system/boot
+.ad
+.RS 8n
+The mount point for the
+.B bootfs
+file system in the global zone.
+
+.SH EXAMPLES
+
+.LP
+Example 1 Determining if collisions or invalid names are present
+.sp
+.LP
+To determine if any boot-time modules were not created due to collisions
+or invalid names, enter the following command:
+
+.sp
+.in +2
+.nf
+# kstat -m bootfs
+module: bootfs                          instance: 1     
+name:   bootfs                          class:    fs
+        crtime                          236063.651324041
+        nbytes                          8749355
+        ndirs                           3
+        ndiscard                        0
+        ndup                            0
+        nfiles                          2
+        snaptime                        236063.651324041
+.fi
+.in -2
+.sp
+.LP
+The field
+.B ndiscard
+lists the number of boot-time modules that were discarded due to naming conflicts. The field 
+.B ndup
+lists the number of duplicate entries that were found and therefore not displayed in the file system.
+.sp
+.LP
+This information is provided for informational purposes only, it is not to be construed as a stable interface.
+
+.SH SEE ALSO
+.BR kstat (1M),
+.BR grub (5)
diff --git a/usr/src/uts/common/Makefile.files b/usr/src/uts/common/Makefile.files
index bd0a9d465a..e00224f248 100644
--- a/usr/src/uts/common/Makefile.files
+++ b/usr/src/uts/common/Makefile.files
@@ -1316,6 +1316,7 @@ SMBFS_OBJS +=	smbfs_vfsops.o	smbfs_vnops.o	smbfs_node.o	\
 		smbfs_rwlock.o	smbfs_xattr.o	\
 		$(SMBFS_COMMON_OBJS)
 
+BOOTFS_OBJS +=	bootfs_construct.o bootfs_vfsops.o bootfs_vnops.o
 
 #
 #			LVM modules
diff --git a/usr/src/uts/common/Makefile.rules b/usr/src/uts/common/Makefile.rules
index e4d94382b2..5f51f83b0e 100644
--- a/usr/src/uts/common/Makefile.rules
+++ b/usr/src/uts/common/Makefile.rules
@@ -215,6 +215,10 @@ $(OBJS_DIR)/%.o:		$(UTSBASE)/common/fs/autofs/%.c
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
 
+$(OBJS_DIR)/%.o:		$(UTSBASE)/common/fs/bootfs/%.c
+	$(COMPILE.c) -o $@ $<
+	$(CTFCONVERT_O)
+
 $(OBJS_DIR)/%.o:		$(UTSBASE)/common/fs/cachefs/%.c
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
@@ -1779,6 +1783,9 @@ $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/fs/%.c
 $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/fs/autofs/%.c
 	@($(LHEAD) $(LINT.c) $< $(LTAIL))
 
+$(LINTS_DIR)/%.ln:		$(UTSBASE)/common/fs/bootfs/%.c
+	@($(LHEAD) $(LINT.c) $< $(LTAIL))
+
 $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/fs/cachefs/%.c
 	@($(LHEAD) $(LINT.c) $< $(LTAIL))
 
diff --git a/usr/src/uts/common/fs/bootfs/bootfs_construct.c b/usr/src/uts/common/fs/bootfs/bootfs_construct.c
new file mode 100644
index 0000000000..87895d21bb
--- /dev/null
+++ b/usr/src/uts/common/fs/bootfs/bootfs_construct.c
@@ -0,0 +1,367 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+ */
+
+/*
+ * This file takes care of reading the boot time modules and constructing them
+ * into the appropriate series of vnodes.
+ */
+
+#include <sys/conf.h>
+#include <sys/ddi.h>
+#include <sys/sunddi.h>
+#include <sys/vfs.h>
+#include <sys/sysmacros.h>
+#include <sys/stat.h>
+
+#include <sys/fs/bootfs_impl.h>
+
+kmem_cache_t *bootfs_node_cache;
+
+static const vattr_t bootfs_vattr_dir = {
+	AT_ALL,					/* va_mask */
+	VDIR,					/* va_type */
+	S_IFDIR | 0555,				/* va_mode */
+	0,					/* va_uid */
+	0,					/* va_gid */
+	0,					/* va_fsid */
+	0,					/* va_nodeid */
+	1,					/* va_nlink */
+	0,					/* va_size */
+	0,					/* va_atime */
+	0,					/* va_mtime */
+	0,					/* va_ctime */
+	0,					/* va_rdev */
+	0,					/* va_blksize */
+	0,					/* va_nblocks */
+	0					/* va_seq */
+};
+
+static const vattr_t bootfs_vattr_reg = {
+	AT_ALL,					/* va_mask */
+	VREG,					/* va_type */
+	S_IFREG | 0555,				/* va_mode */
+	0,					/* va_uid */
+	0,					/* va_gid */
+	0,					/* va_fsid */
+	0,					/* va_nodeid */
+	2,					/* va_nlink */
+	2,					/* va_size */
+	0,					/* va_atime */
+	0,					/* va_mtime */
+	0,					/* va_ctime */
+	0,					/* va_rdev */
+	0,					/* va_blksize */
+	1,					/* va_nblocks */
+	0					/* va_seq */
+};
+
+/*ARGSUSED*/
+int
+bootfs_node_constructor(void *buf, void *arg, int kmflags)
+{
+	bootfs_node_t *bnp = buf;
+
+	bnp->bvn_vnp = vn_alloc(kmflags);
+	if (bnp->bvn_vnp == NULL)
+		return (-1);
+
+	return (0);
+}
+
+/*ARGSUSED*/
+void
+bootfs_node_destructor(void *buf, void *arg)
+{
+	bootfs_node_t *bnp = buf;
+
+	vn_free(bnp->bvn_vnp);
+}
+
+static int
+bootfs_comparator(const void *a, const void *b)
+{
+	const bootfs_node_t *lfs, *rfs;
+	int ret;
+
+	lfs = a;
+	rfs = b;
+
+	ret = strcmp(lfs->bvn_name, rfs->bvn_name);
+	if (ret > 0)
+		ret = 1;
+	if (ret < 0)
+		ret = -1;
+	return (ret);
+}
+
+static void
+bootfs_node_init(bootfs_t *bfs, bootfs_node_t *bnp, const struct vattr *vap,
+    const char *name, size_t namelen)
+{
+	timestruc_t now;
+
+	vn_reinit(bnp->bvn_vnp);
+
+	bnp->bvn_vnp->v_flag |= VNOSWAP;
+	bnp->bvn_vnp->v_type = vap->va_type;
+	bnp->bvn_vnp->v_vfsp = bfs->bfs_vfsp;
+	bnp->bvn_vnp->v_rdev = 0;
+	bnp->bvn_vnp->v_data = (caddr_t)bnp;
+	vn_setops(bnp->bvn_vnp, bootfs_vnodeops);
+
+	bnp->bvn_name = kmem_alloc(namelen + 1, KM_SLEEP);
+	bcopy(name, bnp->bvn_name, namelen);
+	bnp->bvn_name[namelen] = '\0';
+	if (vap->va_type == VDIR) {
+		avl_create(&bnp->bvn_dir, bootfs_comparator,
+		    sizeof (bootfs_node_t),
+		    offsetof(bootfs_node_t, bvn_link));
+	}
+	bzero(&bnp->bvn_link, sizeof (avl_node_t));
+	bcopy(vap, &bnp->bvn_attr, sizeof (vattr_t));
+
+	gethrestime(&now);
+	bnp->bvn_attr.va_atime = now;
+	bnp->bvn_attr.va_ctime = now;
+	bnp->bvn_attr.va_mtime = now;
+	bnp->bvn_attr.va_fsid = makedevice(bootfs_major, bfs->bfs_minor);
+	bnp->bvn_attr.va_nodeid = bfs->bfs_ninode;
+	bnp->bvn_attr.va_blksize = PAGESIZE;
+	bfs->bfs_ninode++;
+	list_insert_tail(&bfs->bfs_nodes, bnp);
+}
+
+static void
+bootfs_mkroot(bootfs_t *bfs)
+{
+	bootfs_node_t *bnp;
+
+	bnp = kmem_cache_alloc(bootfs_node_cache, KM_SLEEP);
+	bootfs_node_init(bfs, bnp, &bootfs_vattr_dir, "/", 1);
+	bnp->bvn_vnp->v_flag |= VROOT;
+	bnp->bvn_parent = bnp;
+	bfs->bfs_rootvn = bnp;
+	bfs->bfs_stat.bfss_ndirs.value.ui32++;
+	vn_exists(bnp->bvn_vnp);
+}
+
+static int
+bootfs_mknode(bootfs_t *bfs, bootfs_node_t *parent, bootfs_node_t **outp,
+    const char *name, size_t namelen, const vattr_t *vap, uintptr_t addr,
+    uint64_t size)
+{
+	bootfs_node_t *bnp;
+	bootfs_node_t sn;
+	avl_index_t where;
+	char *buf;
+
+	ASSERT(parent->bvn_attr.va_type == VDIR);
+	buf = kmem_alloc(namelen + 1, KM_SLEEP);
+	bcopy(name, buf, namelen);
+	buf[namelen] = '\0';
+	sn.bvn_name = buf;
+	if ((bnp = avl_find(&parent->bvn_dir, &sn, &where)) != NULL) {
+		kmem_free(buf, namelen + 1);
+		/* Directories can collide, files cannot */
+		if (vap->va_type == VDIR) {
+			*outp = bnp;
+			return (0);
+		}
+		return (EEXIST);
+	}
+	kmem_free(buf, namelen + 1);
+
+	bnp = kmem_cache_alloc(bootfs_node_cache, KM_SLEEP);
+	bootfs_node_init(bfs, bnp, vap, name, namelen);
+	bnp->bvn_parent = parent;
+	avl_add(&parent->bvn_dir, bnp);
+	*outp = bnp;
+
+	if (vap->va_type == VDIR) {
+		parent->bvn_attr.va_size++;
+		parent->bvn_attr.va_nlink++;
+		bfs->bfs_stat.bfss_ndirs.value.ui32++;
+	} else {
+		bnp->bvn_addr = addr;
+		bnp->bvn_size = size;
+		bfs->bfs_stat.bfss_nfiles.value.ui32++;
+		bfs->bfs_stat.bfss_nbytes.value.ui64 += size;
+		bnp->bvn_attr.va_nblocks = P2ROUNDUP(size, 512) >> 9;
+	}
+
+	vn_exists(bnp->bvn_vnp);
+
+	return (0);
+}
+
+/*
+ * Given the address, size, and path a boot-time module would like, go through
+ * and create all of the directory entries that are required and then the file
+ * itself. If someone has passed in a module that has the same name as another
+ * one, we honor the first one.
+ */
+static int
+bootfs_construct_entry(bootfs_t *bfs, uintptr_t addr, uint64_t size,
+    const char *mname)
+{
+	char *sp;
+	size_t nlen;
+	int ret;
+	bootfs_node_t *nbnp;
+
+	const char *p = mname;
+	bootfs_node_t *bnp = bfs->bfs_rootvn;
+
+	if (*p == '\0')
+		return (EINVAL);
+
+	for (;;) {
+		/* First eliminate all leading / characters. */
+		while (*p == '/')
+			p++;
+
+		/* A name with all slashes or ending in a / */
+		if (*p == '\0')
+			return (EINVAL);
+
+		sp = strchr(p, '/');
+		if (sp == NULL)
+			break;
+		nlen = (ptrdiff_t)sp - (ptrdiff_t)p;
+		if (strncmp(p, ".", nlen) == 0) {
+			p = sp + 1;
+			continue;
+		}
+
+		if (strncmp(p, "..", nlen) == 0) {
+			bnp = bnp->bvn_parent;
+			p = sp + 1;
+			continue;
+		}
+
+		VERIFY(bootfs_mknode(bfs, bnp, &nbnp, p, nlen,
+		    &bootfs_vattr_dir, addr, size) == 0);
+		p = sp + 1;
+		bnp = nbnp;
+	}
+
+	nlen = strlen(p);
+	ret = bootfs_mknode(bfs, bnp, &nbnp, p, nlen, &bootfs_vattr_reg,
+	    addr, size);
+	if (ret != 0)
+		return (ret);
+
+	return (0);
+}
+
+/*
+ * We're going to go through every boot time module and construct the
+ * appropriate vnodes for them now. Because there are very few of these that
+ * exist, generally on the order of a handful, we're going to create them all
+ * when the file system is initialized and then tear them all down when the
+ * module gets unloaded.
+ *
+ * The information about the modules is contained in properties on the root of
+ * the devinfo tree. Specifically there are three properties per module:
+ *
+ *   - module-size-%d	int64_t size, in bytes, of the boot time module.
+ *   - module-addr-%d	The address of the boot time module
+ *   - module-name-%d	The string name of the boot time module
+ *
+ * Note that the module-size and module-addr fields are always 64-bit values
+ * regardless of being on a 32-bit or 64-bit kernel. module-name is a string
+ * property.
+ *
+ * There is no property that indicates the total number of such modules. Modules
+ * start at 0 and work their way up incrementally. The first time we can't find
+ * a module or a property, then we stop.
+ */
+void
+bootfs_construct(bootfs_t *bfs)
+{
+	uint_t id = 0, ndata;
+	char paddr[64], psize[64], pname[64], *mname;
+	dev_info_t *root;
+	uchar_t *datap;
+	uint64_t size = 0, addr = 0;
+	int ret;
+
+	bootfs_mkroot(bfs);
+	root = ddi_root_node();
+
+	for (;;) {
+		if (id == UINT32_MAX)
+			break;
+
+		if (snprintf(paddr, sizeof (paddr), "module-addr-%d", id) >
+		    sizeof (paddr))
+			break;
+
+		if (snprintf(psize, sizeof (paddr), "module-size-%d", id) >
+		    sizeof (paddr))
+			break;
+
+		if (snprintf(pname, sizeof (paddr), "module-name-%d", id) >
+		    sizeof (paddr))
+			break;
+
+		if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, root,
+		    DDI_PROP_DONTPASS, paddr, &datap, &ndata) !=
+		    DDI_PROP_SUCCESS)
+			break;
+
+		if (ndata == 8)
+			bcopy(datap, &addr, sizeof (uint64_t));
+		ddi_prop_free(datap);
+		if (ndata != 8)
+			break;
+
+		if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, root,
+		    DDI_PROP_DONTPASS, psize, &datap, &ndata) !=
+		    DDI_PROP_SUCCESS)
+			break;
+		if (ndata == 8)
+			bcopy(datap, &size, sizeof (uint64_t));
+		ddi_prop_free(datap);
+		if (ndata != 8)
+			break;
+
+		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, root,
+		    DDI_PROP_DONTPASS, pname, &mname) != DDI_PROP_SUCCESS)
+			break;
+
+		ret = bootfs_construct_entry(bfs, addr, size, mname);
+		if (ret == EINVAL)
+			bfs->bfs_stat.bfss_ndiscards.value.ui32++;
+		if (ret == EEXIST)
+			bfs->bfs_stat.bfss_ndups.value.ui32++;
+		ddi_prop_free(mname);
+
+		id++;
+	}
+}
+
+void
+bootfs_destruct(bootfs_t *bfs)
+{
+	bootfs_node_t *bnp;
+
+	while ((bnp = list_remove_head(&bfs->bfs_nodes)) != NULL) {
+		ASSERT(bnp->bvn_vnp->v_count == 1);
+		VN_RELE(bnp->bvn_vnp);
+		kmem_free(bnp->bvn_name, strlen(bnp->bvn_name) + 1);
+		kmem_cache_free(bootfs_node_cache, bnp);
+	}
+}
diff --git a/usr/src/uts/common/fs/bootfs/bootfs_vfsops.c b/usr/src/uts/common/fs/bootfs/bootfs_vfsops.c
new file mode 100644
index 0000000000..b87e4b738e
--- /dev/null
+++ b/usr/src/uts/common/fs/bootfs/bootfs_vfsops.c
@@ -0,0 +1,320 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+ */
+
+#include <sys/errno.h>
+#include <sys/modctl.h>
+#include <sys/types.h>
+#include <sys/mkdev.h>
+#include <sys/ddi.h>
+#include <sys/sunddi.h>
+#include <sys/vfs.h>
+#include <sys/vfs_opreg.h>
+#include <sys/systm.h>
+#include <sys/id_space.h>
+#include <sys/cmn_err.h>
+#include <sys/ksynch.h>
+#include <sys/policy.h>
+#include <sys/mount.h>
+#include <sys/sysmacros.h>
+
+#include <sys/fs/bootfs_impl.h>
+
+/*
+ * While booting, additional types of modules and files can be passed in to the
+ * loader. These include the familiar boot archive, as well as, a module hash
+ * and additional modules that are interpreted as files. As part of the handoff
+ * in early boot, information about these modules are saved as properties on the
+ * root of the devinfo tree, similar to other boot-time properties.
+ *
+ * This file system provides a read-only view of those additional files. Due to
+ * its limited scope, it has a slightly simpler construction than several other
+ * file systems. When mounted, it looks for the corresponding properties and
+ * creates bootfs_node_t's and vnodes for all of the corresponding files and
+ * directories that exist along the way. At this time, there are currently a
+ * rather small number of files passed in this way.
+ *
+ * This does lead to one behavior that folks used to other file systems might
+ * find peculiar. Because we are not always actively creating and destroying the
+ * required vnodes on demand, the count on the root vnode will not be going up
+ * accordingly with the existence of other vnodes. This means that a bootfs file
+ * system that is not in use will have all of its vnodes exist with a v_count of
+ * one.
+ */
+
+major_t bootfs_major;
+static int bootfs_fstype;
+static id_space_t *bootfs_idspace;
+static uint64_t bootfs_nactive;
+static kmutex_t bootfs_lock;
+
+static const char *bootfs_name = "bootfs";
+
+static int
+bootfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
+{
+	int ret;
+	bootfs_t *bfs;
+	struct pathname dpn;
+	dev_t fsdev;
+
+	if ((ret = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
+		return (ret);
+
+	if (mvp->v_type != VDIR)
+		return (ENOTDIR);
+
+	if (uap->flags & MS_REMOUNT)
+		return (EBUSY);
+
+	mutex_enter(&mvp->v_lock);
+	if ((uap->flags & MS_OVERLAY) == 0 &&
+	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
+		mutex_exit(&mvp->v_lock);
+		return (EBUSY);
+	}
+	mutex_exit(&mvp->v_lock);
+
+	/*
+	 * We indicate that the backing store is bootfs. We don't want to use
+	 * swap, because folks might think that this is putting all the data
+	 * into memory ala tmpfs. Rather these modules are always in memory and
+	 * there's nothing to be done about that.
+	 */
+	vfs_setresource(vfsp, bootfs_name, 0);
+	bfs = kmem_zalloc(sizeof (bootfs_t), KM_NOSLEEP | KM_NORMALPRI);
+	if (bfs == NULL)
+		return (ENOMEM);
+
+	ret = pn_get(uap->dir,
+	    (uap->flags & MS_SYSSPACE) ? UIO_SYSSPACE : UIO_USERSPACE, &dpn);
+	if (ret != 0) {
+		kmem_free(bfs, sizeof (bfs));
+		return (ret);
+	}
+
+	bfs->bfs_minor = id_alloc(bootfs_idspace);
+	bfs->bfs_kstat = kstat_create_zone("bootfs", bfs->bfs_minor, "bootfs",
+	    "fs", KSTAT_TYPE_NAMED,
+	    sizeof (bootfs_stat_t) / sizeof (kstat_named_t),
+	    KSTAT_FLAG_VIRTUAL, GLOBAL_ZONEID);
+	if (bfs->bfs_kstat == NULL) {
+		id_free(bootfs_idspace, bfs->bfs_minor);
+		pn_free(&dpn);
+		kmem_free(bfs, sizeof (bfs));
+		return (ENOMEM);
+	}
+	bfs->bfs_kstat->ks_data = &bfs->bfs_stat;
+
+	fsdev = makedevice(bootfs_major, bfs->bfs_minor);
+	bfs->bfs_vfsp = vfsp;
+
+	vfsp->vfs_data = (caddr_t)bfs;
+	vfsp->vfs_fstype = bootfs_fstype;
+	vfsp->vfs_dev = fsdev;
+	vfsp->vfs_bsize = PAGESIZE;
+	vfsp->vfs_flag |= VFS_RDONLY | VFS_NOSETUID | VFS_NOTRUNC |
+	    VFS_UNLINKABLE;
+	vfs_make_fsid(&vfsp->vfs_fsid, fsdev, bootfs_fstype);
+	bfs->bfs_mntpath = kmem_alloc(dpn.pn_pathlen + 1, KM_SLEEP);
+	bcopy(dpn.pn_path, bfs->bfs_mntpath, dpn.pn_pathlen);
+	bfs->bfs_mntpath[dpn.pn_pathlen] = '\0';
+	pn_free(&dpn);
+	list_create(&bfs->bfs_nodes, sizeof (bootfs_node_t),
+	    offsetof(bootfs_node_t, bvn_alink));
+
+	kstat_named_init(&bfs->bfs_stat.bfss_nfiles, "nfiles",
+	    KSTAT_DATA_UINT32);
+	kstat_named_init(&bfs->bfs_stat.bfss_ndirs, "ndirs",
+	    KSTAT_DATA_UINT32);
+	kstat_named_init(&bfs->bfs_stat.bfss_nbytes, "nbytes",
+	    KSTAT_DATA_UINT64);
+	kstat_named_init(&bfs->bfs_stat.bfss_ndups, "ndup",
+	    KSTAT_DATA_UINT32);
+	kstat_named_init(&bfs->bfs_stat.bfss_ndiscards, "ndiscard",
+	    KSTAT_DATA_UINT32);
+
+	bootfs_construct(bfs);
+
+	kstat_install(bfs->bfs_kstat);
+
+	return (0);
+}
+
+static int
+bootfs_unmount(vfs_t *vfsp, int flag, cred_t *cr)
+{
+	int ret;
+	bootfs_t *bfs = vfsp->vfs_data;
+	bootfs_node_t *bnp;
+
+	if ((ret = secpolicy_fs_unmount(cr, vfsp)) != 0)
+		return (ret);
+
+	if (flag & MS_FORCE)
+		return (ENOTSUP);
+
+	for (bnp = list_head(&bfs->bfs_nodes); bnp != NULL;
+	    bnp = list_next(&bfs->bfs_nodes, bnp)) {
+		mutex_enter(&bnp->bvn_vnp->v_lock);
+		if (bnp->bvn_vnp->v_count > 1) {
+			mutex_exit(&bnp->bvn_vnp->v_lock);
+			return (EBUSY);
+		}
+		mutex_exit(&bnp->bvn_vnp->v_lock);
+	}
+
+	kstat_delete(bfs->bfs_kstat);
+	bootfs_destruct(bfs);
+	list_destroy(&bfs->bfs_nodes);
+	kmem_free(bfs->bfs_mntpath, strlen(bfs->bfs_mntpath) + 1);
+	id_free(bootfs_idspace, bfs->bfs_minor);
+	kmem_free(bfs, sizeof (bootfs_t));
+	return (0);
+}
+
+static int
+bootfs_root(vfs_t *vfsp, vnode_t **vpp)
+{
+	bootfs_t *bfs;
+
+	bfs = (bootfs_t *)vfsp->vfs_data;
+	*vpp = bfs->bfs_rootvn->bvn_vnp;
+	VN_HOLD(*vpp)
+
+	return (0);
+}
+
+static int
+bootfs_statvfs(vfs_t *vfsp, struct statvfs64 *sbp)
+{
+	const bootfs_t *bfs = (bootfs_t *)vfsp;
+	dev32_t d32;
+
+	sbp->f_bsize = PAGESIZE;
+	sbp->f_frsize = PAGESIZE;
+
+	sbp->f_blocks = bfs->bfs_stat.bfss_nbytes.value.ui64 >> PAGESHIFT;
+	sbp->f_bfree = 0;
+	sbp->f_bavail = 0;
+
+	sbp->f_files = bfs->bfs_stat.bfss_nfiles.value.ui32 +
+	    bfs->bfs_stat.bfss_ndirs.value.ui32;
+	sbp->f_ffree = 0;
+	sbp->f_favail = 0;
+
+	(void) cmpldev(&d32, vfsp->vfs_dev);
+	sbp->f_fsid = d32;
+	(void) strlcpy(sbp->f_basetype, bootfs_name, FSTYPSZ);
+	bzero(sbp->f_fstr, sizeof (sbp->f_fstr));
+
+	return (0);
+}
+
+static const fs_operation_def_t bootfs_vfsops_tmpl[] = {
+	VFSNAME_MOUNT,		{ .vfs_mount = bootfs_mount },
+	VFSNAME_UNMOUNT,	{ .vfs_unmount = bootfs_unmount },
+	VFSNAME_ROOT,		{ .vfs_root = bootfs_root },
+	VFSNAME_STATVFS,	{ .vfs_statvfs = bootfs_statvfs },
+};
+
+static int
+bootfs_init(int fstype, char *name)
+{
+	int ret;
+
+	bootfs_fstype = fstype;
+	ASSERT(bootfs_fstype != 0);
+
+	ret = vfs_setfsops(fstype, bootfs_vfsops_tmpl, NULL);
+	if (ret != 0)
+		return (ret);
+
+	ret = vn_make_ops(name, bootfs_vnodeops_template, &bootfs_vnodeops);
+	if (ret != 0) {
+		(void) vfs_freevfsops_by_type(bootfs_fstype);
+		return (ret);
+	}
+
+	bootfs_major = getudev();
+	if (bootfs_major == (major_t)-1) {
+		cmn_err(CE_WARN, "bootfs_init: Can't get unique device number");
+		bootfs_major = 0;
+	}
+
+	bootfs_nactive = 0;
+	return (0);
+}
+
+static mntopts_t bootfs_mntopts = {
+	0, NULL
+};
+
+static vfsdef_t bootfs_vfsdef = {
+	VFSDEF_VERSION,
+	"bootfs",
+	bootfs_init,
+	VSW_HASPROTO|VSW_STATS,
+	&bootfs_mntopts
+};
+
+static struct modlfs bootfs_modlfs = {
+	&mod_fsops, "boot-time modules file system", &bootfs_vfsdef
+};
+
+static struct modlinkage bootfs_modlinkage = {
+	MODREV_1, &bootfs_modlfs, NULL
+};
+
+int
+_init(void)
+{
+	bootfs_node_cache = kmem_cache_create("bootfs_node_cache",
+	    sizeof (bootfs_node_t), 0, bootfs_node_constructor,
+	    bootfs_node_destructor, NULL, NULL, NULL, 0);
+	bootfs_idspace = id_space_create("bootfs_minors", 1, INT32_MAX);
+	mutex_init(&bootfs_lock, NULL, MUTEX_DEFAULT, NULL);
+
+	return (mod_install(&bootfs_modlinkage));
+}
+
+int
+_info(struct modinfo *modinfop)
+{
+	return (mod_info(&bootfs_modlinkage, modinfop));
+}
+
+int
+_fini(void)
+{
+	int err;
+
+	mutex_enter(&bootfs_lock);
+	if (bootfs_nactive > 0) {
+		mutex_exit(&bootfs_lock);
+		return (EBUSY);
+	}
+	mutex_exit(&bootfs_lock);
+
+	err = mod_remove(&bootfs_modlinkage);
+	if (err != 0)
+		return (err);
+
+	(void) vfs_freevfsops_by_type(bootfs_fstype);
+	vn_freevnodeops(bootfs_vnodeops);
+	id_space_destroy(bootfs_idspace);
+	mutex_destroy(&bootfs_lock);
+	kmem_cache_destroy(bootfs_node_cache);
+	return (err);
+}
diff --git a/usr/src/uts/common/fs/bootfs/bootfs_vnops.c b/usr/src/uts/common/fs/bootfs/bootfs_vnops.c
new file mode 100644
index 0000000000..f63d0a4f24
--- /dev/null
+++ b/usr/src/uts/common/fs/bootfs/bootfs_vnops.c
@@ -0,0 +1,544 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+ */
+
+/*
+ * bootfs vnode operations
+ */
+
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/sunddi.h>
+#include <sys/errno.h>
+#include <sys/vfs_opreg.h>
+#include <sys/vnode.h>
+#include <sys/mman.h>
+#include <fs/fs_subr.h>
+#include <sys/policy.h>
+#include <sys/sysmacros.h>
+#include <sys/dirent.h>
+#include <sys/uio.h>
+#include <vm/pvn.h>
+#include <vm/hat.h>
+#include <vm/seg_map.h>
+#include <vm/seg_vn.h>
+#include <sys/vmsystm.h>
+
+#include <sys/fs/bootfs_impl.h>
+
+struct vnodeops *bootfs_vnodeops;
+
+/*ARGSUSED*/
+static int
+bootfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
+{
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
+    caller_context_t *ct)
+{
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_read(vnode_t *vp, struct uio *uiop, int ioflag, cred_t *cr,
+    caller_context_t *ct)
+{
+	int err;
+	ssize_t sres = uiop->uio_resid;
+	bootfs_node_t *bnp = vp->v_data;
+
+	if (vp->v_type == VDIR)
+		return (EISDIR);
+
+	if (vp->v_type != VREG)
+		return (EINVAL);
+
+	if (uiop->uio_loffset < 0)
+		return (EINVAL);
+
+	if (uiop->uio_loffset >= bnp->bvn_size)
+		return (0);
+
+	err = 0;
+	while (uiop->uio_resid != 0) {
+		caddr_t base;
+		long offset, frem;
+		ulong_t poff, segoff;
+		size_t bytes;
+		int relerr;
+
+		offset = uiop->uio_loffset;
+		poff = offset & PAGEOFFSET;
+		bytes = MIN(PAGESIZE - poff, uiop->uio_resid);
+
+		frem = bnp->bvn_size - offset;
+		if (frem <= 0) {
+			err = 0;
+			break;
+		}
+
+		/* Don't read past EOF */
+		bytes = MIN(bytes, frem);
+
+		/*
+		 * Segmaps are likely larger than our page size, so make sure we
+		 * have the proper offfset into the resulting segmap data.
+		 */
+		segoff = (offset & PAGEMASK) & MAXBOFFSET;
+
+		base = segmap_getmapflt(segkmap, vp, offset & MAXBMASK, bytes,
+		    1, S_READ);
+
+		err = uiomove(base + segoff + poff, bytes, UIO_READ, uiop);
+		relerr = segmap_release(segkmap, base, 0);
+
+		if (err == 0)
+			err = relerr;
+
+		if (err != 0)
+			break;
+	}
+
+	/* Even if we had an error in a partial read, return success */
+	if (uiop->uio_resid > sres)
+		err = 0;
+
+	gethrestime(&bnp->bvn_attr.va_atime);
+
+	return (err);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_ioctl(vnode_t *vp, int cmd, intptr_t data, int flag,
+    cred_t *cr, int *rvalp, caller_context_t *ct)
+{
+	return (ENOTTY);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
+    caller_context_t *ct)
+{
+	uint32_t mask;
+	bootfs_node_t *bpn = (bootfs_node_t *)vp->v_data;
+
+	mask = vap->va_mask;
+	bcopy(&bpn->bvn_attr, vap, sizeof (vattr_t));
+	vap->va_mask = mask;
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_access(vnode_t *vp, int mode, int flags, cred_t *cr,
+    caller_context_t *ct)
+{
+	int shift = 0;
+	bootfs_node_t *bpn = (bootfs_node_t *)vp->v_data;
+
+	if (crgetuid(cr) != bpn->bvn_attr.va_uid) {
+		shift += 3;
+		if (groupmember(bpn->bvn_attr.va_gid, cr) == 0)
+			shift += 3;
+	}
+
+	return (secpolicy_vnode_access2(cr, vp, bpn->bvn_attr.va_uid,
+	    bpn->bvn_attr.va_mode << shift, mode));
+}
+
+/*ARGSUSED*/
+static int
+bootfs_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, struct pathname *pnp,
+    int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
+    int *direntflags, pathname_t *realpnp)
+{
+	avl_index_t where;
+	bootfs_node_t sn, *bnp;
+	bootfs_node_t *bpp = (bootfs_node_t *)dvp->v_data;
+
+	if (flags & LOOKUP_XATTR)
+		return (EINVAL);
+
+	if (bpp->bvn_attr.va_type != VDIR)
+		return (ENOTDIR);
+
+	if (*nm == '\0' || strcmp(nm, ".") == 0) {
+		VN_HOLD(dvp);
+		*vpp = dvp;
+		return (0);
+	}
+
+	if (strcmp(nm, "..") == 0) {
+		VN_HOLD(bpp->bvn_parent->bvn_vnp);
+		*vpp = bpp->bvn_parent->bvn_vnp;
+		return (0);
+	}
+
+	sn.bvn_name = nm;
+	bnp = avl_find(&bpp->bvn_dir, &sn, &where);
+	if (bnp == NULL)
+		return (ENOENT);
+
+	VN_HOLD(bnp->bvn_vnp);
+	*vpp = bnp->bvn_vnp;
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_readdir(vnode_t *vp, struct uio *uiop, cred_t *cr, int *eofp,
+    caller_context_t *ct, int flags)
+{
+	bootfs_node_t *bnp = (bootfs_node_t *)vp->v_data;
+	dirent64_t *dp;
+	void *buf;
+	ulong_t bsize, brem;
+	offset_t coff, roff;
+	int dlen, ret;
+	bootfs_node_t *dnp;
+	boolean_t first = B_TRUE;
+
+	if (uiop->uio_loffset >= MAXOFF_T) {
+		if (eofp != NULL)
+			*eofp = 1;
+		return (0);
+	}
+
+	if (uiop->uio_iovcnt != 1)
+		return (EINVAL);
+
+	if (!(uiop->uio_iov->iov_len > 0))
+		return (EINVAL);
+
+	if (vp->v_type != VDIR)
+		return (ENOTDIR);
+
+	roff = uiop->uio_loffset;
+	coff = 0;
+	brem = bsize = uiop->uio_iov->iov_len;
+	buf = kmem_alloc(bsize, KM_SLEEP);
+	dp = buf;
+
+	/*
+	 * Recall that offsets here are done based on the name of the dirent
+	 * excluding the null terminator. Therefore `.` is always at 0, `..` is
+	 * always at 1, and then the first real dirent is at 3. This offset is
+	 * what's actually stored when we update the offset in the structure.
+	 */
+	if (roff == 0) {
+		dlen = DIRENT64_RECLEN(1);
+		if (first == B_TRUE) {
+			if (dlen > brem) {
+				kmem_free(buf, bsize);
+				return (EINVAL);
+			}
+			first = B_FALSE;
+		}
+		dp->d_ino = (ino64_t)bnp->bvn_attr.va_nodeid;
+		dp->d_off = 0;
+		dp->d_reclen = (ushort_t)dlen;
+		(void) strncpy(dp->d_name, ".", DIRENT64_NAMELEN(dlen));
+		dp = (struct dirent64 *)((uintptr_t)dp + dp->d_reclen);
+		brem -= dlen;
+	}
+
+	if (roff <= 1) {
+		dlen = DIRENT64_RECLEN(2);
+		if (first == B_TRUE) {
+			if (dlen > brem) {
+				kmem_free(buf, bsize);
+				return (EINVAL);
+			}
+			first = B_FALSE;
+		}
+		dp->d_ino = (ino64_t)bnp->bvn_parent->bvn_attr.va_nodeid;
+		dp->d_off = 1;
+		dp->d_reclen = (ushort_t)dlen;
+		(void) strncpy(dp->d_name, "..", DIRENT64_NAMELEN(dlen));
+		dp = (struct dirent64 *)((uintptr_t)dp + dp->d_reclen);
+		brem -= dlen;
+	}
+
+	coff = 3;
+	for (dnp = avl_first(&bnp->bvn_dir); dnp != NULL;
+	    dnp = AVL_NEXT(&bnp->bvn_dir, dnp)) {
+		size_t nlen = strlen(dnp->bvn_name);
+
+		if (roff > coff) {
+			coff += nlen;
+			continue;
+		}
+
+		dlen = DIRENT64_RECLEN(nlen);
+		if (dlen > brem) {
+			if (first == B_TRUE) {
+				kmem_free(buf, bsize);
+				return (EINVAL);
+			}
+			break;
+		}
+		first = B_FALSE;
+
+		dp->d_ino = (ino64_t)dnp->bvn_attr.va_nodeid;
+		dp->d_off = coff;
+		dp->d_reclen = (ushort_t)dlen;
+		(void) strncpy(dp->d_name, dnp->bvn_name,
+		    DIRENT64_NAMELEN(dlen));
+		dp = (struct dirent64 *)((uintptr_t)dp + dp->d_reclen);
+		brem -= dlen;
+		coff += nlen;
+	}
+
+	ret = uiomove(buf, (bsize - brem), UIO_READ, uiop);
+
+	if (ret == 0) {
+		if (dnp == NULL) {
+			coff++;
+			if (eofp != NULL)
+				*eofp = 1;
+		} else if (eofp != NULL) {
+			*eofp = 0;
+		}
+		uiop->uio_loffset = coff;
+	}
+	gethrestime(&bnp->bvn_attr.va_atime);
+	kmem_free(buf, bsize);
+	return (ret);
+}
+
+/*ARGSUSED*/
+static void
+bootfs_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
+{
+}
+
+/*ARGSUSED*/
+static int
+bootfs_rwlock(vnode_t *vp, int write_lock, caller_context_t *ct)
+{
+	if (write_lock != 0)
+		return (EINVAL);
+	return (0);
+}
+
+/*ARGSUSED*/
+static void
+bootfs_rwunlock(vnode_t *vp, int write_lock, caller_context_t *ct)
+{
+}
+
+/*ARGSUSED*/
+static int
+bootfs_seek(vnode_t *vp, offset_t ooff, offset_t *noffp,
+    caller_context_t *ct)
+{
+	bootfs_node_t *bnp = (bootfs_node_t *)vp->v_data;
+	if (vp->v_type == VDIR)
+		return (0);
+	return ((*noffp < 0 || *noffp > bnp->bvn_size ? EINVAL : 0));
+}
+
+/*
+ * We need to fill in a single page of a vnode's memory based on the actual data
+ * from the kernel. We'll use this node's sliding window into physical memory
+ * and update one page at a time.
+ */
+/*ARGSUSED*/
+static int
+bootfs_getapage(vnode_t *vp, u_offset_t off, size_t len, uint_t *protp,
+    page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr, enum seg_rw rw,
+    cred_t *cr)
+{
+	bootfs_node_t *bnp = vp->v_data;
+	page_t *pp, *fpp;
+	pfn_t pfn;
+
+	for (;;) {
+		/* Easy case where the page exists */
+		pp = page_lookup(vp, off, rw == S_CREATE ? SE_EXCL : SE_SHARED);
+		if (pp != NULL) {
+			if (pl != NULL) {
+				pl[0] = pp;
+				pl[1] = NULL;
+			} else {
+				page_unlock(pp);
+			}
+			return (0);
+		}
+
+		pp = page_create_va(vp, off, PAGESIZE, PG_EXCL | PG_WAIT, seg,
+		    addr);
+
+		/*
+		 * If we didn't get the page, that means someone else beat us to
+		 * creating this so we need to try again.
+		 */
+		if (pp != NULL)
+			break;
+	}
+
+	pfn = btop((bnp->bvn_addr + off) & PAGEMASK);
+	fpp = page_numtopp_nolock(pfn);
+
+	if (ppcopy(fpp, pp) == 0) {
+		pvn_read_done(pp, B_ERROR);
+		return (EIO);
+	}
+
+	if (pl != NULL) {
+		pvn_plist_init(pp, pl, plsz, off, PAGESIZE, rw);
+	} else {
+		pvn_io_done(pp);
+	}
+
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp,
+    page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr, enum seg_rw rw,
+    cred_t *cr, caller_context_t *ct)
+{
+	int err;
+	bootfs_node_t *bnp = vp->v_data;
+
+	if (off + len > bnp->bvn_size + PAGEOFFSET)
+		return (EFAULT);
+
+	if (len <= PAGESIZE)
+		err = bootfs_getapage(vp, (u_offset_t)off, len, protp, pl,
+		    plsz, seg, addr, rw, cr);
+	else
+		err = pvn_getpages(bootfs_getapage, vp, (u_offset_t)off, len,
+		    protp, pl, plsz, seg, addr, rw, cr);
+
+	return (err);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp,
+    size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
+    caller_context_t *ct)
+{
+	int ret;
+	segvn_crargs_t vn_a;
+
+#ifdef	_ILP32
+	if (len > MAXOFF_T)
+		return (ENOMEM);
+#endif
+
+	if (vp->v_flag & VNOMAP)
+		return (ENOSYS);
+
+	if (off < 0 || off > MAXOFFSET_T - off)
+		return (ENXIO);
+
+	if (vp->v_type != VREG)
+		return (ENODEV);
+
+	if (prot & PROT_WRITE)
+		return (ENOTSUP);
+
+	as_rangelock(as);
+	ret = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
+	if (ret != 0) {
+		as_rangeunlock(as);
+		return (ret);
+	}
+
+	vn_a.vp = vp;
+	vn_a.offset = (u_offset_t)off;
+	vn_a.type = flags & MAP_TYPE;
+	vn_a.prot = prot;
+	vn_a.maxprot = maxprot;
+	vn_a.cred = cr;
+	vn_a.amp = NULL;
+	vn_a.flags = flags & ~MAP_TYPE;
+	vn_a.szc = 0;
+	vn_a.lgrp_mem_policy_flags = 0;
+
+	ret = as_map(as, *addrp, len, segvn_create, &vn_a);
+
+	as_rangeunlock(as);
+	return (ret);
+
+}
+
+/*ARGSUSED*/
+static int
+bootfs_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
+    size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
+    caller_context_t *ct)
+{
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+bootfs_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
+    size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr,
+    caller_context_t *ct)
+{
+	return (0);
+}
+
+static int
+bootfs_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,
+    caller_context_t *ct)
+{
+	int ret;
+
+	switch (cmd) {
+	case _PC_TIMESTAMP_RESOLUTION:
+		*valp = 1L;
+		ret = 0;
+		break;
+	default:
+		ret = fs_pathconf(vp, cmd, valp, cr, ct);
+	}
+
+	return (ret);
+}
+
+const fs_operation_def_t bootfs_vnodeops_template[] = {
+	VOPNAME_OPEN,		{ .vop_open = bootfs_open },
+	VOPNAME_CLOSE,		{ .vop_close = bootfs_close },
+	VOPNAME_READ,		{ .vop_read = bootfs_read },
+	VOPNAME_IOCTL,		{ .vop_ioctl = bootfs_ioctl },
+	VOPNAME_GETATTR,	{ .vop_getattr = bootfs_getattr },
+	VOPNAME_ACCESS,		{ .vop_access = bootfs_access },
+	VOPNAME_LOOKUP,		{ .vop_lookup = bootfs_lookup },
+	VOPNAME_READDIR,	{ .vop_readdir = bootfs_readdir },
+	VOPNAME_INACTIVE,	{ .vop_inactive = bootfs_inactive },
+	VOPNAME_RWLOCK,		{ .vop_rwlock = bootfs_rwlock },
+	VOPNAME_RWUNLOCK,	{ .vop_rwunlock = bootfs_rwunlock },
+	VOPNAME_SEEK,		{ .vop_seek = bootfs_seek },
+	VOPNAME_GETPAGE,	{ .vop_getpage = bootfs_getpage },
+	VOPNAME_MAP,		{ .vop_map = bootfs_map },
+	VOPNAME_ADDMAP,		{ .vop_addmap = bootfs_addmap },
+	VOPNAME_DELMAP,		{ .vop_delmap = bootfs_delmap },
+	VOPNAME_PATHCONF,	{ .vop_pathconf = bootfs_pathconf },
+	VOPNAME_VNEVENT,	{ .vop_vnevent = fs_vnevent_nosupport },
+	NULL,			NULL
+};
diff --git a/usr/src/uts/common/fs/vfs.c b/usr/src/uts/common/fs/vfs.c
index bea80bd609..8044a3deaa 100644
--- a/usr/src/uts/common/fs/vfs.c
+++ b/usr/src/uts/common/fs/vfs.c
@@ -20,7 +20,7 @@
  */
 /*
  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2013, Joyent, Inc. All rights reserved.
+ * Copyright (c) 2014, Joyent, Inc. All rights reserved.
  */
 
 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
@@ -905,6 +905,7 @@ vfs_mountroot(void)
 	vfs_mountfs("mntfs", "/etc/mnttab", "/etc/mnttab");
 	vfs_mountfs("tmpfs", "/etc/svc/volatile", "/etc/svc/volatile");
 	vfs_mountfs("objfs", "objfs", OBJFS_ROOT);
+	vfs_mountfs("bootfs", "bootfs", "/system/boot");
 
 	if (getzoneid() == GLOBAL_ZONEID) {
 		vfs_mountfs("sharefs", "sharefs", "/etc/dfs/sharetab");
@@ -1594,7 +1595,7 @@ domount(char *fsname, struct mounta *uap, vnode_t *vp, struct cred *credp,
 	/*
 	 * Serialize with zone state transitions.
 	 * See vfs_list_add; zone mounted into is:
-	 *     zone_find_by_path(refstr_value(vfsp->vfs_mntpt))
+	 * 	zone_find_by_path(refstr_value(vfsp->vfs_mntpt))
 	 * not the zone doing the mount (curproc->p_zone), but if we're already
 	 * inside a NGZ, then we know what zone we are.
 	 */
diff --git a/usr/src/uts/common/sys/fs/bootfs_impl.h b/usr/src/uts/common/sys/fs/bootfs_impl.h
new file mode 100644
index 0000000000..5726f1428a
--- /dev/null
+++ b/usr/src/uts/common/sys/fs/bootfs_impl.h
@@ -0,0 +1,81 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+ */
+
+#ifndef _SYS_FS_BOOTFS_IMPL_H
+#define	_SYS_FS_BOOTFS_IMPL_H
+
+#include <sys/types.h>
+#include <sys/list.h>
+#include <sys/avl.h>
+#include <sys/vnode.h>
+#include <sys/vfs_opreg.h>
+#include <sys/kstat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The bootfs node is the file system specific version of the vnode for the
+ * bootfs file system. Because the bootfs file system is entirely a read-only
+ * file system, this structure requires no locking as the contents are
+ * immutable.
+ */
+typedef struct bootfs_node {
+	char			*bvn_name;	/* entry name */
+	struct vnode		*bvn_vnp;	/* Corresponding vnode */
+	avl_tree_t		bvn_dir;	/* directory entries, if VDIR */
+	avl_node_t		bvn_link;	/* dirent link */
+	list_node_t		bvn_alink;	/* link for all nodes */
+	uint64_t		bvn_addr;	/* Address in pmem */
+	uint64_t		bvn_size;	/* Size of the file */
+	struct bootfs_node	*bvn_parent;	/* .. */
+	vattr_t			bvn_attr;	/* attributes for the node */
+} bootfs_node_t;
+
+typedef struct bootfs_stat {
+	kstat_named_t	bfss_nfiles;
+	kstat_named_t	bfss_ndirs;
+	kstat_named_t	bfss_nbytes;
+	kstat_named_t	bfss_ndups;
+	kstat_named_t	bfss_ndiscards;
+} bootfs_stat_t;
+
+typedef struct bootfs {
+	vfs_t			*bfs_vfsp;
+	char			*bfs_mntpath;
+	bootfs_node_t		*bfs_rootvn;
+	kstat_t			*bfs_kstat;
+	list_t			bfs_nodes;
+	minor_t			bfs_minor;
+	uint_t			bfs_ninode;
+	bootfs_stat_t		bfs_stat;
+} bootfs_t;
+
+extern void bootfs_construct(bootfs_t *);
+extern void bootfs_destruct(bootfs_t *);
+extern int bootfs_node_constructor(void *, void *, int);
+extern void bootfs_node_destructor(void *, void *);
+
+extern struct vnodeops *bootfs_vnodeops;
+extern const fs_operation_def_t bootfs_vnodeops_template[];
+extern kmem_cache_t *bootfs_node_cache;
+extern major_t bootfs_major;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_FS_BOOTFS_IMPL_H */
diff --git a/usr/src/uts/intel/bootfs/Makefile b/usr/src/uts/intel/bootfs/Makefile
new file mode 100644
index 0000000000..ca412de439
--- /dev/null
+++ b/usr/src/uts/intel/bootfs/Makefile
@@ -0,0 +1,72 @@
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source.  A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
+
+#
+# Copyright (c) 2014 Joyent, Inc.  All rights reserved.
+#
+
+#
+#	This makefile drives the production of the bootfs file system
+#	kernel module.
+#
+#	intel architecture dependent
+#
+
+#
+#	Path to the base of the uts directory tree (usually /usr/src/uts).
+#
+UTSBASE	= ../..
+
+#
+#	Define the module and object file sets.
+#
+MODULE		= bootfs
+OBJECTS		= $(BOOTFS_OBJS:%=$(OBJS_DIR)/%)
+LINTS		= $(BOOTFS_OBJS:%.o=$(LINTS_DIR)/%.ln)
+ROOTMODULE	= $(ROOT_FS_DIR)/$(MODULE)
+
+#
+#	Include common rules.
+#
+include $(UTSBASE)/intel/Makefile.intel
+
+#
+#	Define targets
+#
+ALL_TARGET	= $(BINARY)
+LINT_TARGET	= $(MODULE).lint
+INSTALL_TARGET	= $(BINARY) $(ROOTMODULE)
+
+#
+#	Default build targets.
+#
+.KEEP_STATE:
+
+def:		$(DEF_DEPS)
+
+all:		$(ALL_DEPS)
+
+clean:		$(CLEAN_DEPS)
+
+clobber:	$(CLOBBER_DEPS)
+
+lint:		$(LINT_DEPS)
+
+modlintlib:	$(MODLINTLIB_DEPS)
+
+clean.lint:	$(CLEAN_LINT_DEPS)
+
+install:	$(INSTALL_DEPS)
+
+#
+#	Include common targets.
+#
+include $(UTSBASE)/intel/Makefile.targ