xref: /onnv-gate/usr/src/uts/common/fs/mntfs/mntvnops.c (revision 13096:b02331b7b26d)

/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/file.h>
#include <sys/stat.h>
#include <sys/atomic.h>
#include <sys/mntio.h>
#include <sys/mnttab.h>
#include <sys/mount.h>
#include <sys/sunddi.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/vfs.h>
#include <sys/vfs_opreg.h>
#include <sys/fs/mntdata.h>
#include <fs/fs_subr.h>
#include <sys/vmsystm.h>
#include <vm/seg_vn.h>
#include <sys/time.h>
#include <sys/ksynch.h>
#include <sys/sdt.h>

#define	MNTROOTINO	2

static mntnode_t *mntgetnode(vnode_t *);

vnodeops_t *mntvnodeops;
extern void vfs_mnttab_readop(void);

/*
 * Design of kernel mnttab accounting.
 *
 * mntfs provides two methods of reading the in-kernel mnttab, i.e. the state of
 * the mounted resources: the read-only file /etc/mnttab, and a collection of
 * ioctl() commands. Most of these interfaces are public and are described in
 * mnttab(4). Three private ioctl() commands, MNTIOC_GETMNTENT,
 * MNTIOC_GETEXTMNTENT and MNTIOC_GETMNTANY, provide for the getmntent(3C)
 * family of functions, allowing them to support white space in mount names.
 *
 * A significant feature of mntfs is that it provides a file descriptor with a
 * snapshot once it begins to consume mnttab data. Thus, as the process
 * continues to consume data, its view of the in-kernel mnttab does not change
 * even if resources are mounted or unmounted. The intent is to ensure that
 * processes are guaranteed to read self-consistent data even as the system
 * changes.
 *
 * The snapshot is implemented by a "database", unique to each zone, that
 * comprises a linked list of mntelem_ts. The database is identified by
 * zone_mntfs_db and is protected by zone_mntfs_db_lock. Each element contains
 * the text entry in /etc/mnttab for a mounted resource, i.e. a vfs_t, and is
 * marked with its time of "birth", i.e. creation. An element is "killed", and
 * marked with its time of death, when it is found to be out of date, e.g. when
 * the corresponding resource has been unmounted.
 *
 * When a process performs the first read() or ioctl() for a file descriptor for
 * /etc/mnttab, the database is updated by a call to mntfs_snapshot() to ensure
 * that an element exists for each currently mounted resource. Following this,
 * the current time is written into a snapshot structure, a mntsnap_t, embedded
 * in the descriptor's mntnode_t.
 *
 * mntfs is able to enumerate the /etc/mnttab entries corresponding to a
 * particular file descriptor by searching the database for entries that were
 * born before the appropriate snapshot and that either are still alive or died
 * after the snapshot was created. Consumers use the iterator function
 * mntfs_get_next_elem() to identify the next suitable element in the database.
 *
 * Each snapshot has a hold on its corresponding database elements, effected by
 * a per-element reference count. At last close(), a snapshot is destroyed in
 * mntfs_freesnap() by releasing all of its holds; an element is destroyed if
 * its reference count becomes zero. Therefore the database never exists unless
 * there is at least one active consumer of /etc/mnttab.
 *
 * getmntent(3C) et al. "do not open, close or rewind the file." This implies
 * that getmntent() and read() must be able to operate without interaction on
 * the same file descriptor; this is accomplished by the use of separate
 * mntsnap_ts for both read() and ioctl().
 *
 * mntfs observes the following lock-ordering:
 *
 *	mnp->mnt_contents -> vfslist -> zonep->zone_mntfs_db_lock
 *
 * NOTE: The following variable enables the generation of the "dev=xxx"
 * in the option string for a mounted file system.  Really this should
 * be gotten rid of altogether, but for the sake of backwards compatibility
 * we had to leave it in.  It is defined as a 32-bit device number.  This
 * means that when 64-bit device numbers are in use, if either the major or
 * minor part of the device number will not fit in a 16 bit quantity, the
 * "dev=" will be set to NODEV (0x7fffffff).  See PSARC 1999/566 and
 * 1999/131 for details.  The cmpldev() function used to generate the 32-bit
 * device number handles this check and assigns the proper value.
 */
int mntfs_enabledev = 1;	/* enable old "dev=xxx" option */

extern void vfs_mono_time(timespec_t *);
enum { MNTFS_FIRST, MNTFS_SECOND, MNTFS_NEITHER };

/*
 * Determine whether a field within a line from /etc/mnttab contains actual
 * content or simply the marker string "-". This never applies to the time,
 * therefore the delimiter must be a tab.
 */
#define	MNTFS_REAL_FIELD(x)	(*(x) != '-' || *((x) + 1) != '\t')

static int
mntfs_devsize(struct vfs *vfsp)
{
	dev32_t odev;

	(void) cmpldev(&odev, vfsp->vfs_dev);
	return (snprintf(NULL, 0, "dev=%x", odev));
}

static int
mntfs_devprint(struct vfs *vfsp, char *buf)
{
	dev32_t odev;

	(void) cmpldev(&odev, vfsp->vfs_dev);
	return (snprintf(buf, MAX_MNTOPT_STR, "dev=%x", odev));
}

/* Identify which, if either, of two supplied timespec structs is newer. */
static int
mntfs_newest(timespec_t *a, timespec_t *b)
{
	if (a->tv_sec == b->tv_sec &&
	    a->tv_nsec == b->tv_nsec) {
		return (MNTFS_NEITHER);
	} else if (b->tv_sec > a->tv_sec ||
	    (b->tv_sec == a->tv_sec &&
	    b->tv_nsec > a->tv_nsec)) {
		return (MNTFS_SECOND);
	} else {
		return (MNTFS_FIRST);
	}
}

static int
mntfs_optsize(struct vfs *vfsp)
{
	int i, size = 0;
	mntopt_t *mop;

	for (i = 0; i < vfsp->vfs_mntopts.mo_count; i++) {
		mop = &vfsp->vfs_mntopts.mo_list[i];
		if (mop->mo_flags & MO_NODISPLAY)
			continue;
		if (mop->mo_flags & MO_SET) {
			if (size)
				size++; /* space for comma */
			size += strlen(mop->mo_name);
			/*
			 * count option value if there is one
			 */
			if (mop->mo_arg != NULL) {
				size += strlen(mop->mo_arg) + 1;
			}
		}
	}
	if (vfsp->vfs_zone != NULL && vfsp->vfs_zone != global_zone) {
		/*
		 * Add space for "zone=<zone_name>" if required.
		 */
		if (size)
			size++;	/* space for comma */
		size += sizeof ("zone=") - 1;
		size += strlen(vfsp->vfs_zone->zone_name);
	}
	if (mntfs_enabledev) {
		if (size != 0)
			size++; /* space for comma */
		size += mntfs_devsize(vfsp);
	}
	if (size == 0)
		size = strlen("-");
	return (size);
}

static int
mntfs_optprint(struct vfs *vfsp, char *buf)
{
	int i, optinbuf = 0;
	mntopt_t *mop;
	char *origbuf = buf;

	for (i = 0; i < vfsp->vfs_mntopts.mo_count; i++) {
		mop = &vfsp->vfs_mntopts.mo_list[i];
		if (mop->mo_flags & MO_NODISPLAY)
			continue;
		if (mop->mo_flags & MO_SET) {
			if (optinbuf)
				*buf++ = ',';
			else
				optinbuf = 1;
			buf += snprintf(buf, MAX_MNTOPT_STR,
			    "%s", mop->mo_name);
			/*
			 * print option value if there is one
			 */
			if (mop->mo_arg != NULL) {
				buf += snprintf(buf, MAX_MNTOPT_STR, "=%s",
				    mop->mo_arg);
			}
		}
	}
	if (vfsp->vfs_zone != NULL && vfsp->vfs_zone != global_zone) {
		if (optinbuf)
			*buf++ = ',';
		else
			optinbuf = 1;
		buf += snprintf(buf, MAX_MNTOPT_STR, "zone=%s",
		    vfsp->vfs_zone->zone_name);
	}
	if (mntfs_enabledev) {
		if (optinbuf++)
			*buf++ = ',';
		buf += mntfs_devprint(vfsp, buf);
	}
	if (!optinbuf) {
		buf += snprintf(buf, MAX_MNTOPT_STR, "-");
	}
	return (buf - origbuf);
}

void
mntfs_populate_text(vfs_t *vfsp, zone_t *zonep, mntelem_t *elemp)
{
	struct extmnttab *tabp = &elemp->mnte_tab;
	const char *resource, *mntpt;
	char *cp = elemp->mnte_text;
	mntpt = refstr_value(vfsp->vfs_mntpt);
	resource = refstr_value(vfsp->vfs_resource);

	tabp->mnt_special = 0;
	if (resource != NULL && resource[0] != '\0') {
		if (resource[0] != '/') {
			cp += snprintf(cp, MAXPATHLEN, "%s\t", resource);
		} else if (!ZONE_PATH_VISIBLE(resource, zonep)) {
			/*
			 * Use the mount point as the resource.
			 */
			cp += snprintf(cp, MAXPATHLEN, "%s\t",
			    ZONE_PATH_TRANSLATE(mntpt, zonep));
		} else {
			cp += snprintf(cp, MAXPATHLEN, "%s\t",
			    ZONE_PATH_TRANSLATE(resource, zonep));
		}
	} else {
		cp += snprintf(cp, MAXPATHLEN, "-\t");
	}

	tabp->mnt_mountp = (char *)(cp - elemp->mnte_text);
	if (mntpt != NULL && mntpt[0] != '\0') {
		/*
		 * We know the mount point is visible from within the zone,
		 * otherwise it wouldn't be on the zone's vfs list.
		 */
		cp += snprintf(cp, MAXPATHLEN, "%s\t",
		    ZONE_PATH_TRANSLATE(mntpt, zonep));
	} else {
		cp += snprintf(cp, MAXPATHLEN, "-\t");
	}

	tabp->mnt_fstype = (char *)(cp - elemp->mnte_text);
	cp += snprintf(cp, MAXPATHLEN, "%s\t",
	    vfssw[vfsp->vfs_fstype].vsw_name);

	tabp->mnt_mntopts = (char *)(cp - elemp->mnte_text);
	cp += mntfs_optprint(vfsp, cp);
	*cp++ = '\t';

	tabp->mnt_time = (char *)(cp - elemp->mnte_text);
	cp += snprintf(cp, MAX_MNTOPT_STR, "%ld", vfsp->vfs_mtime);
	*cp++ = '\n'; /* over-write snprintf's trailing null-byte */

	tabp->mnt_major = getmajor(vfsp->vfs_dev);
	tabp->mnt_minor = getminor(vfsp->vfs_dev);

	elemp->mnte_text_size = cp - elemp->mnte_text;
	elemp->mnte_vfs_ctime = vfsp->vfs_hrctime;
	elemp->mnte_hidden = vfsp->vfs_flag & VFS_NOMNTTAB;
}

/* Determine the length of the /etc/mnttab entry for this vfs_t. */
static size_t
mntfs_text_len(vfs_t *vfsp, zone_t *zone)
{
	size_t size = 0;
	const char *resource, *mntpt;
	size_t mntsize;

	mntpt = refstr_value(vfsp->vfs_mntpt);
	if (mntpt != NULL && mntpt[0] != '\0') {
		mntsize = strlen(ZONE_PATH_TRANSLATE(mntpt, zone)) + 1;
	} else {
		mntsize = 2;	/* "-\t" */
	}
	size += mntsize;

	resource = refstr_value(vfsp->vfs_resource);
	if (resource != NULL && resource[0] != '\0') {
		if (resource[0] != '/') {
			size += strlen(resource) + 1;
		} else if (!ZONE_PATH_VISIBLE(resource, zone)) {
			/*
			 * Same as the zone's view of the mount point.
			 */
			size += mntsize;
		} else {
			size += strlen(ZONE_PATH_TRANSLATE(resource, zone)) + 1;
		}
	} else {
		size += 2;	/* "-\t" */
	}
	size += strlen(vfssw[vfsp->vfs_fstype].vsw_name) + 1;
	size += mntfs_optsize(vfsp);
	size += snprintf(NULL, 0, "\t%ld\n", vfsp->vfs_mtime);
	return (size);
}

/* Destroy the resources associated with a snapshot element. */
static void
mntfs_destroy_elem(mntelem_t *elemp)
{
	kmem_free(elemp->mnte_text, elemp->mnte_text_size);
	kmem_free(elemp, sizeof (mntelem_t));
}

/*
 * Return 1 if the given snapshot is in the range of the given element; return
 * 0 otherwise.
 */
static int
mntfs_elem_in_range(mntsnap_t *snapp, mntelem_t *elemp)
{
	timespec_t	*stimep = &snapp->mnts_time;
	timespec_t	*btimep = &elemp->mnte_birth;
	timespec_t	*dtimep = &elemp->mnte_death;

	/*
	 * If a snapshot is in range of an element then the snapshot must have
	 * been created after the birth of the element, and either the element
	 * is still alive or it died after the snapshot was created.
	 */
	if (mntfs_newest(btimep, stimep) == MNTFS_SECOND &&
	    (MNTFS_ELEM_IS_ALIVE(elemp) ||
	    mntfs_newest(stimep, dtimep) == MNTFS_SECOND))
		return (1);
	else
		return (0);
}

/*
 * Return the next valid database element, after the one provided, for a given
 * snapshot; return NULL if none exists. The caller must hold the zone's
 * database lock as a reader before calling this function.
 */
static mntelem_t *
mntfs_get_next_elem(mntsnap_t *snapp, mntelem_t *elemp)
{
	int show_hidden = snapp->mnts_flags & MNTS_SHOWHIDDEN;

	do {
		elemp = elemp->mnte_next;
	} while (elemp &&
	    (!mntfs_elem_in_range(snapp, elemp) ||
	    (!show_hidden && elemp->mnte_hidden)));
	return (elemp);
}

/*
 * This function frees the resources associated with a mntsnap_t. It walks
 * through the database, decrementing the reference count of any element that
 * satisfies the snapshot. If the reference count of an element becomes zero
 * then it is removed from the database.
 */
static void
mntfs_freesnap(mntnode_t *mnp, mntsnap_t *snapp)
{
	zone_t *zonep = MTOD(mnp)->mnt_zone_ref.zref_zone;
	krwlock_t *dblockp = &zonep->zone_mntfs_db_lock;
	mntelem_t **elempp = &zonep->zone_mntfs_db;
	mntelem_t *elemp;
	int show_hidden = snapp->mnts_flags & MNTS_SHOWHIDDEN;
	size_t number_decremented = 0;

	ASSERT(RW_WRITE_HELD(&mnp->mnt_contents));

	/* Ignore an uninitialised snapshot. */
	if (snapp->mnts_nmnts == 0)
		return;

	/* Drop the holds on any matching database elements. */
	rw_enter(dblockp, RW_WRITER);
	while ((elemp = *elempp) != NULL) {
		if (mntfs_elem_in_range(snapp, elemp) &&
		    (!elemp->mnte_hidden || show_hidden) &&
		    ++number_decremented && --elemp->mnte_refcnt == 0) {
			if ((*elempp = elemp->mnte_next) != NULL)
				(*elempp)->mnte_prev = elemp->mnte_prev;
			mntfs_destroy_elem(elemp);
		} else {
			elempp = &elemp->mnte_next;
		}
	}
	rw_exit(dblockp);
	ASSERT(number_decremented == snapp->mnts_nmnts);

	/* Clear the snapshot data. */
	bzero(snapp, sizeof (mntsnap_t));
}

/* Insert the new database element newp after the existing element prevp. */
static void
mntfs_insert_after(mntelem_t *newp, mntelem_t *prevp)
{
	newp->mnte_prev = prevp;
	newp->mnte_next = prevp->mnte_next;
	prevp->mnte_next = newp;
	if (newp->mnte_next != NULL)
		newp->mnte_next->mnte_prev = newp;
}

/* Create and return a copy of a given database element. */
static mntelem_t *
mntfs_copy(mntelem_t *origp)
{
	mntelem_t *copyp;

	copyp = kmem_zalloc(sizeof (mntelem_t), KM_SLEEP);
	copyp->mnte_vfs_ctime = origp->mnte_vfs_ctime;
	copyp->mnte_text_size = origp->mnte_text_size;
	copyp->mnte_text = kmem_alloc(copyp->mnte_text_size, KM_SLEEP);
	bcopy(origp->mnte_text, copyp->mnte_text, copyp->mnte_text_size);
	copyp->mnte_tab = origp->mnte_tab;
	copyp->mnte_hidden = origp->mnte_hidden;

	return (copyp);
}

/*
 * Compare two database elements and determine whether or not the vfs_t payload
 * data of each are the same. Return 1 if so and 0 otherwise.
 */
static int
mntfs_is_same_element(mntelem_t *a, mntelem_t *b)
{
	if (a->mnte_hidden == b->mnte_hidden &&
	    a->mnte_text_size == b->mnte_text_size &&
	    bcmp(a->mnte_text, b->mnte_text, a->mnte_text_size) == 0 &&
	    bcmp(&a->mnte_tab, &b->mnte_tab, sizeof (struct extmnttab)) == 0)
		return (1);
	else
		return (0);
}

/*
 * mntfs_snapshot() updates the database, creating it if necessary, so that it
 * accurately reflects the state of the in-kernel mnttab. It also increments
 * the reference count on all database elements that correspond to currently-
 * mounted resources. Finally, it initialises the appropriate snapshot
 * structure.
 *
 * Each vfs_t is given a high-resolution time stamp, for the benefit of mntfs,
 * when it is inserted into the in-kernel mnttab. This time stamp is copied into
 * the corresponding database element when it is created, allowing the element
 * and the vfs_t to be identified as a pair. It is possible that some file
 * systems may make unadvertised changes to, for example, a resource's mount
 * options. Therefore, in order to determine whether a database element is an
 * up-to-date representation of a given vfs_t, it is compared with a temporary
 * element generated for this purpose. Although less efficient, this is safer
 * than implementing an mtime for a vfs_t.
 *
 * Some mounted resources are marked as "hidden" with a VFS_NOMNTTAB flag. These
 * are considered invisible unless the user has already set the MNT_SHOWHIDDEN
 * flag in the vnode using the MNTIOC_SHOWHIDDEN ioctl.
 */
static void
mntfs_snapshot(mntnode_t *mnp, mntsnap_t *snapp)
{
	mntdata_t	*mnd = MTOD(mnp);
	zone_t		*zonep = mnd->mnt_zone_ref.zref_zone;
	int		is_global_zone = (zonep == global_zone);
	int		show_hidden = mnp->mnt_flags & MNT_SHOWHIDDEN;
	vfs_t		*vfsp, *firstvfsp, *lastvfsp;
	vfs_t		dummyvfs;
	vfs_t		*dummyvfsp = NULL;
	krwlock_t	*dblockp = &zonep->zone_mntfs_db_lock;
	mntelem_t	**headpp = &zonep->zone_mntfs_db;
	mntelem_t	*elemp;
	mntelem_t	*prevp = NULL;
	int		order;
	mntelem_t	*tempelemp;
	mntelem_t	*newp;
	mntelem_t	*firstp = NULL;
	size_t		nmnts = 0;
	size_t		total_text_size = 0;
	size_t		normal_text_size = 0;
	int		insert_before;
	timespec_t	last_mtime;
	size_t		entry_length, new_entry_length;


	ASSERT(RW_WRITE_HELD(&mnp->mnt_contents));
	vfs_list_read_lock();
	vfs_mnttab_modtime(&last_mtime);

	/*
	 * If this snapshot already exists then we must have been asked to
	 * rewind the file, i.e. discard the snapshot and create a new one in
	 * its place. In this case we first see if the in-kernel mnttab has
	 * advertised a change; if not then we simply reinitialise the metadata.
	 */
	if (snapp->mnts_nmnts) {
		if (mntfs_newest(&last_mtime, &snapp->mnts_last_mtime) ==
		    MNTFS_NEITHER) {
			/*
			 * An unchanged mtime is no guarantee that the
			 * in-kernel mnttab is unchanged; for example, a
			 * concurrent remount may be between calls to
			 * vfs_setmntopt_nolock() and vfs_mnttab_modtimeupd().
			 * It follows that the database may have changed, and
			 * in particular that some elements in this snapshot
			 * may have been killed by another call to
			 * mntfs_snapshot(). It is therefore not merely
			 * unnecessary to update the snapshot's time but in
			 * fact dangerous; it needs to be left alone.
			 */
			snapp->mnts_next = snapp->mnts_first;
			snapp->mnts_flags &= ~MNTS_REWIND;
			snapp->mnts_foffset = snapp->mnts_ieoffset = 0;
			vfs_list_unlock();
			return;
		} else {
			mntfs_freesnap(mnp, snapp);
		}
	}

	/*
	 * Create a temporary database element. For each vfs_t, the temporary
	 * element will be populated with the corresponding text. If the vfs_t
	 * does not have a corresponding element within the database, or if
	 * there is such an element but it is stale, a copy of the temporary
	 * element is inserted into the database at the appropriate location.
	 */
	tempelemp = kmem_alloc(sizeof (mntelem_t), KM_SLEEP);
	entry_length = MNT_LINE_MAX;
	tempelemp->mnte_text = kmem_alloc(entry_length, KM_SLEEP);

	/* Find the first and last vfs_t for the given zone. */
	if (is_global_zone) {
		firstvfsp = rootvfs;
		lastvfsp = firstvfsp->vfs_prev;
	} else {
		firstvfsp = zonep->zone_vfslist;
		/*
		 * If there isn't already a vfs_t for root then we create a
		 * dummy which will be used as the head of the list (which will
		 * therefore no longer be circular).
		 */
		if (firstvfsp == NULL ||
		    strcmp(refstr_value(firstvfsp->vfs_mntpt),
		    zonep->zone_rootpath) != 0) {
			/*
			 * The zone's vfs_ts will have mount points relative to
			 * the zone's root path. The vfs_t for the zone's
			 * root file system would therefore have a mount point
			 * equal to the zone's root path. Since the zone's root
			 * path isn't a mount point, we copy the vfs_t of the
			 * zone's root vnode, and provide it with a fake mount
			 * and resource. However, if the zone's root is a
			 * zfs dataset, use the dataset name as the resource.
			 *
			 * Note that by cloning another vfs_t we also acquire
			 * its high-resolution ctime. This might appear to
			 * violate the requirement that the ctimes in the list
			 * of vfs_ts are unique and monotonically increasing;
			 * this is not the case. The dummy vfs_t appears in only
			 * a non-global zone's vfs_t list, where the cloned
			 * vfs_t would not ordinarily be visible; the ctimes are
			 * therefore unique. The zone's root path must be
			 * available before the zone boots, and so its root
			 * vnode's vfs_t's ctime must be lower than those of any
			 * resources subsequently mounted by the zone. The
			 * ctimes are therefore monotonically increasing.
			 */
			dummyvfs = *zonep->zone_rootvp->v_vfsp;
			dummyvfs.vfs_mntpt = refstr_alloc(zonep->zone_rootpath);
			if (strcmp(vfssw[dummyvfs.vfs_fstype].vsw_name, "zfs")
			    != 0)
				dummyvfs.vfs_resource = dummyvfs.vfs_mntpt;
			dummyvfsp = &dummyvfs;
			if (firstvfsp == NULL) {
				lastvfsp = dummyvfsp;
			} else {
				lastvfsp = firstvfsp->vfs_zone_prev;
				dummyvfsp->vfs_zone_next = firstvfsp;
			}
			firstvfsp = dummyvfsp;
		} else {
			lastvfsp = firstvfsp->vfs_zone_prev;
		}
	}

	/*
	 * Now walk through all the vfs_ts for this zone. For each one, find the
	 * corresponding database element, creating it first if necessary, and
	 * increment its reference count.
	 */
	rw_enter(dblockp, RW_WRITER);
	elemp = zonep->zone_mntfs_db;
	/* CSTYLED */
	for (vfsp = firstvfsp;;
	    vfsp = is_global_zone ? vfsp->vfs_next : vfsp->vfs_zone_next) {
		DTRACE_PROBE1(new__vfs, vfs_t *, vfsp);
		/* Consider only visible entries. */
		if ((vfsp->vfs_flag & VFS_NOMNTTAB) == 0 || show_hidden) {
			/*
			 * Walk through the existing database looking for either
			 * an element that matches the current vfs_t, or for the
			 * correct place in which to insert a new element.
			 */
			insert_before = 0;
			for (; elemp; prevp = elemp, elemp = elemp->mnte_next) {
				DTRACE_PROBE1(considering__elem, mntelem_t *,
				    elemp);

				/* Compare the vfs_t with the element. */
				order = mntfs_newest(&elemp->mnte_vfs_ctime,
				    &vfsp->vfs_hrctime);

				/*
				 * If we encounter a database element newer than
				 * this vfs_t then we've stepped over a gap
				 * where the element for this vfs_t must be
				 * inserted.
				 */
				if (order == MNTFS_FIRST) {
					insert_before = 1;
					break;
				}

				/* Dead elements no longer interest us. */
				if (MNTFS_ELEM_IS_DEAD(elemp))
					continue;

				/*
				 * If the time stamps are the same then the
				 * element is potential match for the vfs_t,
				 * although it may later prove to be stale.
				 */
				if (order == MNTFS_NEITHER)
					break;

				/*
				 * This element must be older than the vfs_t.
				 * It must, therefore, correspond to a vfs_t
				 * that has been unmounted. Since the element is
				 * still alive, we kill it if it is visible.
				 */
				if (!elemp->mnte_hidden || show_hidden)
					vfs_mono_time(&elemp->mnte_death);
			}
			DTRACE_PROBE2(possible__match, vfs_t *, vfsp,
			    mntelem_t *, elemp);

			/* Create a new database element if required. */
			new_entry_length = mntfs_text_len(vfsp, zonep);
			if (new_entry_length > entry_length) {
				kmem_free(tempelemp->mnte_text, entry_length);
				tempelemp->mnte_text =
				    kmem_alloc(new_entry_length, KM_SLEEP);
				entry_length = new_entry_length;
			}
			mntfs_populate_text(vfsp, zonep, tempelemp);
			ASSERT(tempelemp->mnte_text_size == new_entry_length);
			if (elemp == NULL) {
				/*
				 * We ran off the end of the database. Insert a
				 * new element at the end.
				 */
				newp = mntfs_copy(tempelemp);
				vfs_mono_time(&newp->mnte_birth);
				if (prevp) {
					mntfs_insert_after(newp, prevp);
				} else {
					newp->mnte_next = NULL;
					newp->mnte_prev = NULL;
					ASSERT(*headpp == NULL);
					*headpp = newp;
				}
				elemp = newp;
			} else if (insert_before) {
				/*
				 * Insert a new element before the current one.
				 */
				newp = mntfs_copy(tempelemp);
				vfs_mono_time(&newp->mnte_birth);
				if (prevp) {
					mntfs_insert_after(newp, prevp);
				} else {
					newp->mnte_next = elemp;
					newp->mnte_prev = NULL;
					elemp->mnte_prev = newp;
					ASSERT(*headpp == elemp);
					*headpp = newp;
				}
				elemp = newp;
			} else if (!mntfs_is_same_element(elemp, tempelemp)) {
				/*
				 * The element corresponds to the vfs_t, but the
				 * vfs_t has changed; it must have been
				 * remounted. Kill the old element and insert a
				 * new one after it.
				 */
				vfs_mono_time(&elemp->mnte_death);
				newp = mntfs_copy(tempelemp);
				vfs_mono_time(&newp->mnte_birth);
				mntfs_insert_after(newp, elemp);
				elemp = newp;
			}

			/* We've found the corresponding element. Hold it. */
			DTRACE_PROBE1(incrementing, mntelem_t *, elemp);
			elemp->mnte_refcnt++;

			/*
			 * Update the parameters used to initialise the
			 * snapshot.
			 */
			nmnts++;
			total_text_size += elemp->mnte_text_size;
			if (!elemp->mnte_hidden)
				normal_text_size += elemp->mnte_text_size;
			if (!firstp)
				firstp = elemp;

			prevp = elemp;
			elemp = elemp->mnte_next;
		}

		if (vfsp == lastvfsp)
			break;
	}

	/*
	 * Any remaining visible database elements that are still alive must be
	 * killed now, because their corresponding vfs_ts must have been
	 * unmounted.
	 */
	for (; elemp; elemp = elemp->mnte_next) {
		if (MNTFS_ELEM_IS_ALIVE(elemp) &&
		    (!elemp->mnte_hidden || show_hidden))
			vfs_mono_time(&elemp->mnte_death);
	}

	/* Initialise the snapshot. */
	vfs_mono_time(&snapp->mnts_time);
	snapp->mnts_last_mtime = last_mtime;
	snapp->mnts_first = snapp->mnts_next = firstp;
	snapp->mnts_flags = show_hidden ? MNTS_SHOWHIDDEN : 0;
	snapp->mnts_nmnts = nmnts;
	snapp->mnts_text_size = total_text_size;
	snapp->mnts_foffset = snapp->mnts_ieoffset = 0;

	/*
	 * Record /etc/mnttab's current size and mtime for possible future use
	 * by mntgetattr().
	 */
	mnd->mnt_size = normal_text_size;
	mnd->mnt_mtime = last_mtime;
	if (show_hidden) {
		mnd->mnt_hidden_size = total_text_size;
		mnd->mnt_hidden_mtime = last_mtime;
	}

	/* Clean up. */
	rw_exit(dblockp);
	vfs_list_unlock();
	if (dummyvfsp != NULL)
		refstr_rele(dummyvfsp->vfs_mntpt);
	kmem_free(tempelemp->mnte_text, entry_length);
	kmem_free(tempelemp, sizeof (mntelem_t));
}

/*
 * Public function to convert vfs_mntopts into a string.
 * A buffer of sufficient size is allocated, which is returned via bufp,
 * and whose length is returned via lenp.
 */
void
mntfs_getmntopts(struct vfs *vfsp, char **bufp, size_t *lenp)
{
	size_t len;
	char *buf;

	vfs_list_read_lock();

	len = mntfs_optsize(vfsp) + 1;
	buf = kmem_alloc(len, KM_NOSLEEP);
	if (buf == NULL) {
		*bufp = NULL;
		vfs_list_unlock();
		return;
	}
	buf[len - 1] = '\0';
	(void) mntfs_optprint(vfsp, buf);
	ASSERT(buf[len - 1] == '\0');

	vfs_list_unlock();
	*bufp = buf;
	*lenp = len;
}

/* ARGSUSED */
static int
mntopen(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
{
	vnode_t *vp = *vpp;
	mntnode_t *nmnp;

	/*
	 * Not allowed to open for writing, return error.
	 */
	if (flag & FWRITE)
		return (EPERM);
	/*
	 * Create a new mnt/vnode for each open, this will give us a handle to
	 * hang the snapshot on.
	 */
	nmnp = mntgetnode(vp);

	*vpp = MTOV(nmnp);
	atomic_add_32(&MTOD(nmnp)->mnt_nopen, 1);
	VN_RELE(vp);
	return (0);
}

/* ARGSUSED */
static int
mntclose(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
	caller_context_t *ct)
{
	mntnode_t *mnp = VTOM(vp);

	/* Clean up any locks or shares held by the current process */
	cleanlocks(vp, ttoproc(curthread)->p_pid, 0);
	cleanshares(vp, ttoproc(curthread)->p_pid);

	if (count > 1)
		return (0);
	if (vp->v_count == 1) {
		rw_enter(&mnp->mnt_contents, RW_WRITER);
		mntfs_freesnap(mnp, &mnp->mnt_read);
		mntfs_freesnap(mnp, &mnp->mnt_ioctl);
		rw_exit(&mnp->mnt_contents);
		atomic_add_32(&MTOD(mnp)->mnt_nopen, -1);
	}
	return (0);
}

/* ARGSUSED */
static int
mntread(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred, caller_context_t *ct)
{
	mntnode_t *mnp = VTOM(vp);
	zone_t *zonep = MTOD(mnp)->mnt_zone_ref.zref_zone;
	mntsnap_t *snapp = &mnp->mnt_read;
	off_t off = uio->uio_offset;
	size_t len = uio->uio_resid;
	char *bufferp;
	size_t available, copylen;
	size_t written = 0;
	mntelem_t *elemp;
	krwlock_t *dblockp = &zonep->zone_mntfs_db_lock;
	int error = 0;
	off_t	ieoffset;

	rw_enter(&mnp->mnt_contents, RW_WRITER);
	if (snapp->mnts_nmnts == 0 || (off == (off_t)0))
		mntfs_snapshot(mnp, snapp);

	if ((size_t)(off + len) > snapp->mnts_text_size)
		len = snapp->mnts_text_size - off;

	if (off < 0 || len > snapp->mnts_text_size) {
		rw_exit(&mnp->mnt_contents);
		return (EFAULT);
	}

	if (len == 0) {
		rw_exit(&mnp->mnt_contents);
		return (0);
	}

	/*
	 * For the file offset provided, locate the corresponding database
	 * element and calculate the corresponding offset within its text. If
	 * the file offset is the same as that reached during the last read(2)
	 * then use the saved element and intra-element offset.
	 */
	rw_enter(dblockp, RW_READER);
	if (off == 0 || (off == snapp->mnts_foffset)) {
		elemp = snapp->mnts_next;
		ieoffset = snapp->mnts_ieoffset;
	} else {
		off_t total_off;
		/*
		 * Find the element corresponding to the requested file offset
		 * by walking through the database and summing the text sizes
		 * of the individual elements. If the requested file offset is
		 * greater than that reached on the last visit then we can start
		 * at the last seen element; otherwise, we have to start at the
		 * beginning.
		 */
		if (off > snapp->mnts_foffset) {
			elemp = snapp->mnts_next;
			total_off = snapp->mnts_foffset - snapp->mnts_ieoffset;
		} else {
			elemp = snapp->mnts_first;
			total_off = 0;
		}
		while (off > total_off + elemp->mnte_text_size) {
			total_off += elemp->mnte_text_size;
			elemp = mntfs_get_next_elem(snapp, elemp);
			ASSERT(elemp != NULL);
		}
		/* Calculate the intra-element offset. */
		if (off > total_off)
			ieoffset = off - total_off;
		else
			ieoffset = 0;
	}

	/*
	 * Create a buffer and populate it with the text from successive
	 * database elements until it is full.
	 */
	bufferp = kmem_alloc(len, KM_SLEEP);
	while (written < len) {
		available = elemp->mnte_text_size - ieoffset;
		copylen = MIN(len - written, available);
		bcopy(elemp->mnte_text + ieoffset, bufferp + written, copylen);
		written += copylen;
		if (copylen == available) {
			elemp = mntfs_get_next_elem(snapp, elemp);
			ASSERT(elemp != NULL || written == len);
			ieoffset = 0;
		} else {
			ieoffset += copylen;
		}
	}
	rw_exit(dblockp);

	/*
	 * Write the populated buffer, update the snapshot's state if
	 * successful and then advertise our read.
	 */
	error = uiomove(bufferp, len, UIO_READ, uio);
	if (error == 0) {
		snapp->mnts_next = elemp;
		snapp->mnts_foffset = off + len;
		snapp->mnts_ieoffset = ieoffset;
	}
	vfs_mnttab_readop();
	rw_exit(&mnp->mnt_contents);

	/* Clean up. */
	kmem_free(bufferp, len);
	return (error);
}

static int
mntgetattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
	caller_context_t *ct)
{
	int mask = vap->va_mask;
	int error;
	mntnode_t *mnp = VTOM(vp);
	timespec_t mtime, old_mtime;
	size_t size, old_size;
	mntdata_t *mntdata = MTOD(VTOM(vp));
	mntsnap_t *rsnapp, *isnapp;
	extern timespec_t vfs_mnttab_ctime;


	/* AT_MODE, AT_UID and AT_GID are derived from the underlying file. */
	if (mask & AT_MODE|AT_UID|AT_GID) {
		if (error = VOP_GETATTR(mnp->mnt_mountvp, vap, flags, cr, ct))
			return (error);
	}

	/*
	 * There are some minor subtleties in the determination of
	 * /etc/mnttab's size and mtime. We wish to avoid any condition in
	 * which, in the vicinity of a change to the in-kernel mnttab, we
	 * return an old value for one but a new value for the other. We cannot
	 * simply hold vfslist for the entire calculation because we might need
	 * to call mntfs_snapshot(), which calls vfs_list_read_lock().
	 */
	if (mask & AT_SIZE|AT_NBLOCKS) {
		rw_enter(&mnp->mnt_contents, RW_WRITER);

		vfs_list_read_lock();
		vfs_mnttab_modtime(&mtime);
		if (mnp->mnt_flags & MNT_SHOWHIDDEN) {
			old_mtime = mntdata->mnt_hidden_mtime;
			old_size = mntdata->mnt_hidden_size;
		} else {
			old_mtime = mntdata->mnt_mtime;
			old_size = mntdata->mnt_size;
		}
		vfs_list_unlock();

		rsnapp = &mnp->mnt_read;
		isnapp = &mnp->mnt_ioctl;
		if (rsnapp->mnts_nmnts || isnapp->mnts_nmnts) {
			/*
			 * The mntnode already has at least one snapshot from
			 * which to take the size; the user will understand from
			 * mnttab(4) that the current size of the in-kernel
			 * mnttab is irrelevant.
			 */
			size = rsnapp->mnts_nmnts ? rsnapp->mnts_text_size :
			    isnapp->mnts_text_size;
		} else if (mntfs_newest(&mtime, &old_mtime) == MNTFS_NEITHER) {
			/*
			 * There is no existing valid snapshot but the in-kernel
			 * mnttab has not changed since the time that the last
			 * one was generated. Use the old file size; note that
			 * it is guaranteed to be consistent with mtime, which
			 * may be returned to the user later.
			 */
			size = old_size;
		} else {
			/*
			 * There is no snapshot and the in-kernel mnttab has
			 * changed since the last one was created. We generate a
			 * new snapshot which we use for not only the size but
			 * also the mtime, thereby ensuring that the two are
			 * consistent.
			 */
			mntfs_snapshot(mnp, rsnapp);
			size = rsnapp->mnts_text_size;
			mtime = rsnapp->mnts_last_mtime;
			mntfs_freesnap(mnp, rsnapp);
		}

		rw_exit(&mnp->mnt_contents);
	} else if (mask & AT_ATIME|AT_MTIME) {
		vfs_list_read_lock();
		vfs_mnttab_modtime(&mtime);
		vfs_list_unlock();
	}

	/* Always look like a regular file. */
	if (mask & AT_TYPE)
		vap->va_type = VREG;
	/* Mode should basically be read only. */
	if (mask & AT_MODE)
		vap->va_mode &= 07444;
	if (mask & AT_FSID)
		vap->va_fsid = vp->v_vfsp->vfs_dev;
	/* Nodeid is always ROOTINO. */
	if (mask & AT_NODEID)
		vap->va_nodeid = (ino64_t)MNTROOTINO;
	/*
	 * Set nlink to the number of open vnodes for mnttab info
	 * plus one for existing.
	 */
	if (mask & AT_NLINK)
		vap->va_nlink = mntdata->mnt_nopen + 1;
	if (mask & AT_SIZE)
		vap->va_size = size;
	if (mask & AT_ATIME)
		vap->va_atime = mtime;
	if (mask & AT_MTIME)
		vap->va_mtime = mtime;
	if (mask & AT_CTIME)
		vap->va_ctime = vfs_mnttab_ctime;
	if (mask & AT_RDEV)
		vap->va_rdev = 0;
	if (mask & AT_BLKSIZE)
		vap->va_blksize = DEV_BSIZE;
	if (mask & AT_NBLOCKS)
		vap->va_nblocks = btod(size);
	if (mask & AT_SEQ)
		vap->va_seq = 0;

	return (0);
}

static int
mntaccess(vnode_t *vp, int mode, int flags, cred_t *cr,
	caller_context_t *ct)
{
	mntnode_t *mnp = VTOM(vp);

	if (mode & (VWRITE|VEXEC))
		return (EROFS);

	/*
	 * Do access check on the underlying directory vnode.
	 */
	return (VOP_ACCESS(mnp->mnt_mountvp, mode, flags, cr, ct));
}


/*
 * New /mntfs vnode required; allocate it and fill in most of the fields.
 */
static mntnode_t *
mntgetnode(vnode_t *dp)
{
	mntnode_t *mnp;
	vnode_t *vp;

	mnp = kmem_zalloc(sizeof (mntnode_t), KM_SLEEP);
	mnp->mnt_vnode = vn_alloc(KM_SLEEP);
	mnp->mnt_mountvp = VTOM(dp)->mnt_mountvp;
	rw_init(&mnp->mnt_contents, NULL, RW_DEFAULT, NULL);
	vp = MTOV(mnp);
	vp->v_flag = VNOCACHE|VNOMAP|VNOSWAP|VNOMOUNT;
	vn_setops(vp, mntvnodeops);
	vp->v_vfsp = dp->v_vfsp;
	vp->v_type = VREG;
	vp->v_data = (caddr_t)mnp;

	return (mnp);
}

/*
 * Free the storage obtained from mntgetnode().
 */
static void
mntfreenode(mntnode_t *mnp)
{
	vnode_t *vp = MTOV(mnp);

	rw_destroy(&mnp->mnt_contents);
	vn_invalid(vp);
	vn_free(vp);
	kmem_free(mnp, sizeof (*mnp));
}


/* ARGSUSED */
static int
mntfsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct)
{
	return (0);
}

/* ARGSUSED */
static void
mntinactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
{
	mntnode_t *mnp = VTOM(vp);

	mntfreenode(mnp);
}

/*
 * lseek(2) is supported only to rewind the file by resetmnttab(3C). Rewinding
 * has a special meaning for /etc/mnttab: it forces mntfs to refresh the
 * snapshot at the next ioctl().
 *
 * mnttab(4) explains that "the snapshot...is taken any time a read(2) is
 * performed at offset 0". We therefore ignore the read snapshot here.
 */
/* ARGSUSED */
static int
mntseek(vnode_t *vp, offset_t ooff, offset_t *noffp, caller_context_t *ct)
{
	mntnode_t *mnp = VTOM(vp);

	if (*noffp == 0) {
		rw_enter(&mnp->mnt_contents, RW_WRITER);
		mnp->mnt_ioctl.mnts_flags |= MNTS_REWIND;
		rw_exit(&mnp->mnt_contents);
	}

	return (0);
}

/*
 * Return the answer requested to poll().
 * POLLRDBAND will return when the mtime of the mnttab
 * information is newer than the latest one read for this open.
 */
/* ARGSUSED */
static int
mntpoll(vnode_t *vp, short ev, int any, short *revp, pollhead_t **phpp,
	caller_context_t *ct)
{
	mntnode_t *mnp = VTOM(vp);
	mntsnap_t *snapp;

	rw_enter(&mnp->mnt_contents, RW_READER);
	if (mntfs_newest(&mnp->mnt_ioctl.mnts_last_mtime,
	    &mnp->mnt_read.mnts_last_mtime) == MNTFS_FIRST)
		snapp = &mnp->mnt_ioctl;
	else
		snapp = &mnp->mnt_read;

	*revp = 0;
	*phpp = (pollhead_t *)NULL;
	if (ev & POLLIN)
		*revp |= POLLIN;

	if (ev & POLLRDNORM)
		*revp |= POLLRDNORM;

	if (ev & POLLRDBAND) {
		vfs_mnttab_poll(&snapp->mnts_last_mtime, phpp);
		if (*phpp == (pollhead_t *)NULL)
			*revp |= POLLRDBAND;
	}
	rw_exit(&mnp->mnt_contents);

	if (*revp || *phpp != NULL || any) {
		return (0);
	}
	/*
	 * If someone is polling an unsupported poll events (e.g.
	 * POLLOUT, POLLPRI, etc.), just return POLLERR revents.
	 * That way we will ensure that we don't return a 0
	 * revents with a NULL pollhead pointer.
	 */
	*revp = POLLERR;
	return (0);
}

/*
 * mntfs_same_word() returns 1 if two words are the same in the context of
 * MNTIOC_GETMNTANY and 0 otherwise.
 *
 * worda is a memory address that lies somewhere in the buffer bufa; it cannot
 * be NULL since this is used to indicate to getmntany(3C) that the user does
 * not wish to match a particular field. The text to which worda points is
 * supplied by the user; if it is not null-terminated then it cannot match.
 *
 * Buffer bufb contains a line from /etc/mnttab, in which the fields are
 * delimited by tab or new-line characters. offb is the offset of the second
 * word within this buffer.
 *
 * mntfs_same_word() returns 1 if the words are the same and 0 otherwise.
 */
int
mntfs_same_word(char *worda, char *bufa, size_t sizea, off_t offb, char *bufb,
    size_t sizeb)
{
	char *wordb = bufb + offb;
	int bytes_remaining;

	ASSERT(worda != NULL);

	bytes_remaining = MIN(((bufa + sizea) - worda),
	    ((bufb + sizeb) - wordb));
	while (bytes_remaining && *worda == *wordb) {
		worda++;
		wordb++;
		bytes_remaining--;
	}
	if (bytes_remaining &&
	    *worda == '\0' && (*wordb == '\t' || *wordb == '\n'))
		return (1);
	else
		return (0);
}

/*
 * mntfs_special_info_string() returns which, if either, of VBLK or VCHR
 * corresponds to a supplied path. If the path is a special device then the
 * function optionally sets the major and minor numbers.
 */
vtype_t
mntfs_special_info_string(char *path, uint_t *major, uint_t *minor, cred_t *cr)
{
	vattr_t vattr;
	vnode_t *vp;
	vtype_t type;
	int error;

	if (path == NULL || *path != '/' ||
	    lookupnameat(path + 1, UIO_SYSSPACE, FOLLOW, NULLVPP, &vp, rootdir))
		return (0);

	vattr.va_mask = AT_TYPE | AT_RDEV;
	error = VOP_GETATTR(vp, &vattr, ATTR_REAL, cr, NULL);
	VN_RELE(vp);

	if (error == 0 && ((type = vattr.va_type) == VBLK || type == VCHR)) {
		if (major && minor) {
			*major = getmajor(vattr.va_rdev);
			*minor = getminor(vattr.va_rdev);
		}
		return (type);
	} else {
		return (0);
	}
}

/*
 * mntfs_special_info_element() extracts the name of the mounted resource
 * for a given element and copies it into a null-terminated string, which it
 * then passes to mntfs_special_info_string().
 */
vtype_t
mntfs_special_info_element(mntelem_t *elemp, cred_t *cr)
{
	char *newpath;
	vtype_t type;

	newpath = kmem_alloc(elemp->mnte_text_size, KM_SLEEP);
	bcopy(elemp->mnte_text, newpath, (off_t)(elemp->mnte_tab.mnt_mountp));
	*(newpath + (off_t)elemp->mnte_tab.mnt_mountp - 1) = '\0';
	type = mntfs_special_info_string(newpath, NULL, NULL, cr);
	kmem_free(newpath, elemp->mnte_text_size);

	return (type);
}

/*
 * Convert an address that points to a byte within a user buffer into an
 * address that points to the corresponding offset within a kernel buffer. If
 * the user address is NULL then make no conversion. If the address does not
 * lie within the buffer then reset it to NULL.
 */
char *
mntfs_import_addr(char *uaddr, char *ubufp, char *kbufp, size_t bufsize)
{
	if (uaddr < ubufp || uaddr >= ubufp + bufsize)
		return (NULL);
	else
		return (kbufp + (uaddr - ubufp));
}

/*
 * These 32-bit versions are to support STRUCT_DECL(9F) etc. in
 * mntfs_copyout_element() and mntioctl().
 */
#ifdef _SYSCALL32_IMPL
typedef struct extmnttab32 {
	uint32_t	mnt_special;
	uint32_t	mnt_mountp;
	uint32_t	mnt_fstype;
	uint32_t	mnt_mntopts;
	uint32_t	mnt_time;
	uint_t		mnt_major;
	uint_t		mnt_minor;
} extmnttab32_t;

typedef struct mnttab32 {
	uint32_t	mnt_special;
	uint32_t	mnt_mountp;
	uint32_t	mnt_fstype;
	uint32_t	mnt_mntopts;
	uint32_t	mnt_time;
} mnttab32_t;

struct mntentbuf32 {
	uint32_t	mbuf_emp;
	uint_t		mbuf_bufsize;
	uint32_t	mbuf_buf;
};
#endif

/*
 * mntfs_copyout_element() is common code for the MNTIOC_GETMNTENT,
 * MNTIOC_GETEXTMNTENT and MNTIOC_GETMNTANY ioctls. Having identifed the
 * database element desired by the user, this function copies out the text and
 * the pointers to the relevant userland addresses. It returns 0 on success
 * and non-zero otherwise.
 */
int
mntfs_copyout_elem(mntelem_t *elemp, struct extmnttab *uemp,
    char *ubufp, int cmd, int datamodel)
{
		STRUCT_DECL(extmnttab, ktab);
		char *dbbufp = elemp->mnte_text;
		size_t dbbufsize = elemp->mnte_text_size;
		struct extmnttab *dbtabp = &elemp->mnte_tab;
		size_t ssize;
		char *kbufp;
		int error = 0;


		/*
		 * We create a struct extmnttab within the kernel of the size
		 * determined by the user's data model. We then populate its
		 * fields by combining the start address of the text buffer
		 * supplied by the user, ubufp, with the offsets stored for
		 * this database element within dbtabp, a pointer to a struct
		 * extmnttab.
		 *
		 * Note that if the corresponding field is "-" this signifies
		 * no real content, and we set the address to NULL. This does
		 * not apply to mnt_time.
		 */
		STRUCT_INIT(ktab, datamodel);
		STRUCT_FSETP(ktab, mnt_special,
		    MNTFS_REAL_FIELD(dbbufp) ? ubufp : NULL);
		STRUCT_FSETP(ktab, mnt_mountp,
		    MNTFS_REAL_FIELD(dbbufp + (off_t)dbtabp->mnt_mountp) ?
		    ubufp + (off_t)dbtabp->mnt_mountp : NULL);
		STRUCT_FSETP(ktab, mnt_fstype,
		    MNTFS_REAL_FIELD(dbbufp + (off_t)dbtabp->mnt_fstype) ?
		    ubufp + (off_t)dbtabp->mnt_fstype : NULL);
		STRUCT_FSETP(ktab, mnt_mntopts,
		    MNTFS_REAL_FIELD(dbbufp + (off_t)dbtabp->mnt_mntopts) ?
		    ubufp + (off_t)dbtabp->mnt_mntopts : NULL);
		STRUCT_FSETP(ktab, mnt_time,
		    ubufp + (off_t)dbtabp->mnt_time);
		if (cmd == MNTIOC_GETEXTMNTENT) {
			STRUCT_FSETP(ktab, mnt_major, dbtabp->mnt_major);
			STRUCT_FSETP(ktab, mnt_minor, dbtabp->mnt_minor);
			ssize = SIZEOF_STRUCT(extmnttab, datamodel);
		} else {
			ssize = SIZEOF_STRUCT(mnttab, datamodel);
		}
		if (copyout(STRUCT_BUF(ktab), uemp, ssize))
			return (EFAULT);

		/*
		 * We create a text buffer in the kernel into which we copy the
		 * /etc/mnttab entry for this element. We change the tab and
		 * new-line delimiters to null bytes before copying out the
		 * buffer.
		 */
		kbufp = kmem_alloc(dbbufsize, KM_SLEEP);
		bcopy(elemp->mnte_text, kbufp, dbbufsize);
		*(kbufp + (off_t)dbtabp->mnt_mountp - 1) =
		    *(kbufp + (off_t)dbtabp->mnt_fstype - 1) =
		    *(kbufp + (off_t)dbtabp->mnt_mntopts - 1) =
		    *(kbufp + (off_t)dbtabp->mnt_time - 1) =
		    *(kbufp + dbbufsize - 1) = '\0';
		if (copyout(kbufp, ubufp, dbbufsize))
			error = EFAULT;

		kmem_free(kbufp, dbbufsize);
		return (error);
}

/* ARGSUSED */
static int
mntioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, cred_t *cr,
    int *rvalp, caller_context_t *ct)
{
	uint_t *up = (uint_t *)arg;
	mntnode_t *mnp = VTOM(vp);
	mntsnap_t *snapp = &mnp->mnt_ioctl;
	int error = 0;
	zone_t *zonep = MTOD(mnp)->mnt_zone_ref.zref_zone;
	krwlock_t *dblockp = &zonep->zone_mntfs_db_lock;
	model_t datamodel = flag & DATAMODEL_MASK;

	switch (cmd) {

	case MNTIOC_NMNTS:  		/* get no. of mounted resources */
	{
		rw_enter(&mnp->mnt_contents, RW_READER);
		if (snapp->mnts_nmnts == 0 ||
		    (snapp->mnts_flags & MNTS_REWIND)) {
			if (!rw_tryupgrade(&mnp->mnt_contents)) {
				rw_exit(&mnp->mnt_contents);
				rw_enter(&mnp->mnt_contents, RW_WRITER);
			}
			if (snapp->mnts_nmnts == 0 ||
			    (snapp->mnts_flags & MNTS_REWIND))
				mntfs_snapshot(mnp, snapp);
		}
		rw_exit(&mnp->mnt_contents);

		if (suword32(up, snapp->mnts_nmnts) != 0)
			error = EFAULT;
		break;
	}

	case MNTIOC_GETDEVLIST:  	/* get mounted device major/minor nos */
	{
		size_t len;
		uint_t *devlist;
		mntelem_t *elemp;
		int i = 0;

		rw_enter(&mnp->mnt_contents, RW_READER);
		if (snapp->mnts_nmnts == 0 ||
		    (snapp->mnts_flags & MNTS_REWIND)) {
			if (!rw_tryupgrade(&mnp->mnt_contents)) {
				rw_exit(&mnp->mnt_contents);
				rw_enter(&mnp->mnt_contents, RW_WRITER);
			}
			if (snapp->mnts_nmnts == 0 ||
			    (snapp->mnts_flags & MNTS_REWIND))
				mntfs_snapshot(mnp, snapp);
			rw_downgrade(&mnp->mnt_contents);
		}

		/* Create a local buffer to hold the device numbers. */
		len = 2 * snapp->mnts_nmnts * sizeof (uint_t);
		devlist = kmem_alloc(len, KM_SLEEP);

		/*
		 * Walk the database elements for this snapshot and add their
		 * major and minor numbers.
		 */
		rw_enter(dblockp, RW_READER);
		for (elemp = snapp->mnts_first; elemp;
		    elemp = mntfs_get_next_elem(snapp, elemp)) {
				devlist[2 * i] = elemp->mnte_tab.mnt_major;
				devlist[2 * i + 1] = elemp->mnte_tab.mnt_minor;
				i++;
		}
		rw_exit(dblockp);
		ASSERT(i == snapp->mnts_nmnts);
		rw_exit(&mnp->mnt_contents);

		error = xcopyout(devlist, up, len);
		kmem_free(devlist, len);
		break;
	}

	case MNTIOC_SETTAG:		/* set tag on mounted file system */
	case MNTIOC_CLRTAG:		/* clear tag on mounted file system */
	{
		struct mnttagdesc *dp = (struct mnttagdesc *)arg;
		STRUCT_DECL(mnttagdesc, tagdesc);
		char *cptr;
		uint32_t major, minor;
		char tagbuf[MAX_MNTOPT_TAG];
		char *pbuf;
		size_t len;
		uint_t start = 0;
		mntdata_t *mntdata = MTOD(mnp);
		zone_t *zone = mntdata->mnt_zone_ref.zref_zone;

		STRUCT_INIT(tagdesc, flag & DATAMODEL_MASK);
		if (copyin(dp, STRUCT_BUF(tagdesc), STRUCT_SIZE(tagdesc))) {
			error = EFAULT;
			break;
		}
		pbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
		if (zone != global_zone) {
			(void) strcpy(pbuf, zone->zone_rootpath);
			/* truncate "/" and nul */
			start = zone->zone_rootpathlen - 2;
			ASSERT(pbuf[start] == '/');
		}
		cptr = STRUCT_FGETP(tagdesc, mtd_mntpt);
		error = copyinstr(cptr, pbuf + start, MAXPATHLEN - start, &len);
		if (error) {
			kmem_free(pbuf, MAXPATHLEN);
			break;
		}
		if (start != 0 && pbuf[start] != '/') {
			kmem_free(pbuf, MAXPATHLEN);
			error = EINVAL;
			break;
		}
		cptr = STRUCT_FGETP(tagdesc, mtd_tag);
		if ((error = copyinstr(cptr, tagbuf, MAX_MNTOPT_TAG, &len))) {
			kmem_free(pbuf, MAXPATHLEN);
			break;
		}
		major = STRUCT_FGET(tagdesc, mtd_major);
		minor = STRUCT_FGET(tagdesc, mtd_minor);
		if (cmd == MNTIOC_SETTAG)
			error = vfs_settag(major, minor, pbuf, tagbuf, cr);
		else
			error = vfs_clrtag(major, minor, pbuf, tagbuf, cr);
		kmem_free(pbuf, MAXPATHLEN);
		break;
	}

	case MNTIOC_SHOWHIDDEN:
	{
		rw_enter(&mnp->mnt_contents, RW_WRITER);
		mnp->mnt_flags |= MNT_SHOWHIDDEN;
		rw_exit(&mnp->mnt_contents);
		break;
	}

	case MNTIOC_GETMNTANY:
	{
		STRUCT_DECL(mntentbuf, embuf);	/* Our copy of user's embuf */
		STRUCT_DECL(extmnttab, ktab);	/* Out copy of user's emp */
		struct extmnttab *uemp;		/* uaddr of user's emp */
		char *ubufp;			/* uaddr of user's text buf */
		size_t ubufsize;		/* size of the above */
		struct extmnttab preftab;	/* our version of user's emp */
		char *prefbuf;			/* our copy of user's text */
		mntelem_t *elemp;		/* a database element */
		struct extmnttab *dbtabp;	/* element's extmnttab */
		char *dbbufp;			/* element's text buf */
		size_t dbbufsize;		/* size of the above */
		vtype_t type;			/* type, if any, of special */


		/*
		 * embuf is a struct embuf within the kernel. We copy into it
		 * the struct embuf supplied by the user.
		 */
		STRUCT_INIT(embuf, datamodel);
		if (copyin((void *) arg, STRUCT_BUF(embuf),
		    STRUCT_SIZE(embuf))) {
			error = EFAULT;
			break;
		}
		uemp = STRUCT_FGETP(embuf, mbuf_emp);
		ubufp = STRUCT_FGETP(embuf, mbuf_buf);
		ubufsize = STRUCT_FGET(embuf, mbuf_bufsize);

		/*
		 * Check that the text buffer offered by the user is the
		 * agreed size.
		 */
		if (ubufsize != MNT_LINE_MAX) {
			error = EINVAL;
			break;
		}

		/* Copy the user-supplied entry into a local buffer. */
		prefbuf = kmem_alloc(MNT_LINE_MAX, KM_SLEEP);
		if (copyin(ubufp, prefbuf, MNT_LINE_MAX)) {
			kmem_free(prefbuf, MNT_LINE_MAX);
			error = EFAULT;
			break;
		}

		/* Ensure that any string within it is null-terminated. */
		*(prefbuf + MNT_LINE_MAX - 1) = 0;

		/* Copy in the user-supplied mpref */
		STRUCT_INIT(ktab, datamodel);
		if (copyin(uemp, STRUCT_BUF(ktab),
		    SIZEOF_STRUCT(mnttab, datamodel))) {
			kmem_free(prefbuf, MNT_LINE_MAX);
			error = EFAULT;
			break;
		}

		/*
		 * Copy the members of the user's pref struct into a local
		 * struct. The pointers need to be offset and verified to
		 * ensure that they lie within the bounds of the buffer.
		 */
		preftab.mnt_special = mntfs_import_addr(STRUCT_FGETP(ktab,
		    mnt_special), ubufp, prefbuf, MNT_LINE_MAX);
		preftab.mnt_mountp = mntfs_import_addr(STRUCT_FGETP(ktab,
		    mnt_mountp), ubufp, prefbuf, MNT_LINE_MAX);
		preftab.mnt_fstype = mntfs_import_addr(STRUCT_FGETP(ktab,
		    mnt_fstype), ubufp, prefbuf, MNT_LINE_MAX);
		preftab.mnt_mntopts = mntfs_import_addr(STRUCT_FGETP(ktab,
		    mnt_mntopts), ubufp, prefbuf, MNT_LINE_MAX);
		preftab.mnt_time = mntfs_import_addr(STRUCT_FGETP(ktab,
		    mnt_time), ubufp, prefbuf, MNT_LINE_MAX);

		/*
		 * If the user specifies a mounted resource that is a special
		 * device then we capture its mode and major and minor numbers;
		 * cf. the block comment below.
		 */
		type = mntfs_special_info_string(preftab.mnt_special,
		    &preftab.mnt_major, &preftab.mnt_minor, cr);

		rw_enter(&mnp->mnt_contents, RW_WRITER);
		if (snapp->mnts_nmnts == 0 ||
		    (snapp->mnts_flags & MNTS_REWIND))
			mntfs_snapshot(mnp, snapp);

		/*
		 * This is the core functionality that implements getmntany().
		 * We walk through the mntfs database until we find an element
		 * matching the user's preferences that are contained in
		 * preftab. Typically, this means checking that the text
		 * matches. However, the mounted resource is special: if the
		 * user is looking for a special device then we must find a
		 * database element with the same major and minor numbers and
		 * the same type, i.e. VBLK or VCHR. The type is not recorded
		 * in the element because it cannot be inferred from the vfs_t.
		 * We therefore check the type of suitable candidates via
		 * mntfs_special_info_element(); since this calls into the
		 * underlying file system we make sure to drop the database lock
		 * first.
		 */
		elemp = snapp->mnts_next;
		rw_enter(dblockp, RW_READER);
		for (;;) {
			for (; elemp; elemp = mntfs_get_next_elem(snapp,
			    elemp)) {
				dbtabp = &elemp->mnte_tab;
				dbbufp = elemp->mnte_text;
				dbbufsize = elemp->mnte_text_size;

				if (((type &&
				    dbtabp->mnt_major == preftab.mnt_major &&
				    dbtabp->mnt_minor == preftab.mnt_minor &&
				    MNTFS_REAL_FIELD(dbbufp)) ||
				    (!type && (!preftab.mnt_special ||
				    mntfs_same_word(preftab.mnt_special,
				    prefbuf, MNT_LINE_MAX, (off_t)0, dbbufp,
				    dbbufsize)))) &&

				    (!preftab.mnt_mountp || mntfs_same_word(
				    preftab.mnt_mountp, prefbuf, MNT_LINE_MAX,
				    (off_t)dbtabp->mnt_mountp, dbbufp,
				    dbbufsize)) &&

				    (!preftab.mnt_fstype || mntfs_same_word(
				    preftab.mnt_fstype, prefbuf, MNT_LINE_MAX,
				    (off_t)dbtabp->mnt_fstype, dbbufp,
				    dbbufsize)) &&

				    (!preftab.mnt_mntopts || mntfs_same_word(
				    preftab.mnt_mntopts, prefbuf, MNT_LINE_MAX,
				    (off_t)dbtabp->mnt_mntopts, dbbufp,
				    dbbufsize)) &&

				    (!preftab.mnt_time || mntfs_same_word(
				    preftab.mnt_time, prefbuf, MNT_LINE_MAX,
				    (off_t)dbtabp->mnt_time, dbbufp,
				    dbbufsize)))
					break;
			}
			rw_exit(dblockp);

			if (elemp == NULL || type == 0 ||
			    type == mntfs_special_info_element(elemp, cr))
				break;

			rw_enter(dblockp, RW_READER);
			elemp = mntfs_get_next_elem(snapp, elemp);
		}

		kmem_free(prefbuf, MNT_LINE_MAX);

		/* If we failed to find a match then return EOF. */
		if (elemp == NULL) {
			rw_exit(&mnp->mnt_contents);
			*rvalp = MNTFS_EOF;
			break;
		}

		/*
		 * Check that the text buffer offered by the user will be large
		 * enough to accommodate the text for this entry.
		 */
		if (elemp->mnte_text_size > MNT_LINE_MAX) {
			rw_exit(&mnp->mnt_contents);
			*rvalp = MNTFS_TOOLONG;
			break;
		}

		/*
		 * Populate the user's struct mnttab and text buffer using the
		 * element's contents.
		 */
		if (mntfs_copyout_elem(elemp, uemp, ubufp, cmd, datamodel)) {
			error = EFAULT;
		} else {
			rw_enter(dblockp, RW_READER);
			elemp = mntfs_get_next_elem(snapp, elemp);
			rw_exit(dblockp);
			snapp->mnts_next = elemp;
		}
		rw_exit(&mnp->mnt_contents);
		break;
	}

	case MNTIOC_GETMNTENT:
	case MNTIOC_GETEXTMNTENT:
	{
		STRUCT_DECL(mntentbuf, embuf);	/* Our copy of user's embuf */
		struct extmnttab *uemp;		/* uaddr of user's emp */
		char *ubufp;			/* uaddr of user's text buf */
		size_t ubufsize;		/* size of the above */
		mntelem_t *elemp;		/* a database element */


		rw_enter(&mnp->mnt_contents, RW_WRITER);
		if (snapp->mnts_nmnts == 0 ||
		    (snapp->mnts_flags & MNTS_REWIND))
			mntfs_snapshot(mnp, snapp);
		if ((elemp = snapp->mnts_next) == NULL) {
			rw_exit(&mnp->mnt_contents);
			*rvalp = MNTFS_EOF;
			break;
		}

		/*
		 * embuf is a struct embuf within the kernel. We copy into it
		 * the struct embuf supplied by the user.
		 */
		STRUCT_INIT(embuf, datamodel);
		if (copyin((void *) arg, STRUCT_BUF(embuf),
		    STRUCT_SIZE(embuf))) {
			rw_exit(&mnp->mnt_contents);
			error = EFAULT;
			break;
		}
		uemp = STRUCT_FGETP(embuf, mbuf_emp);
		ubufp = STRUCT_FGETP(embuf, mbuf_buf);
		ubufsize = STRUCT_FGET(embuf, mbuf_bufsize);

		/*
		 * Check that the text buffer offered by the user will be large
		 * enough to accommodate the text for this entry.
		 */
		if (elemp->mnte_text_size > ubufsize) {
			rw_exit(&mnp->mnt_contents);
			*rvalp = MNTFS_TOOLONG;
			break;
		}

		/*
		 * Populate the user's struct mnttab and text buffer using the
		 * element's contents.
		 */
		if (mntfs_copyout_elem(elemp, uemp, ubufp, cmd, datamodel)) {
			error = EFAULT;
		} else {
			rw_enter(dblockp, RW_READER);
			elemp = mntfs_get_next_elem(snapp, elemp);
			rw_exit(dblockp);
			snapp->mnts_next = elemp;
		}
		rw_exit(&mnp->mnt_contents);
		break;
	}

	default:
		error = EINVAL;
		break;
	}

	return (error);
}

/*
 * mntfs provides a new vnode for each open(2). Two vnodes will represent the
 * same instance of /etc/mnttab if they share the same (zone-specific) vfs.
 */
/* ARGSUSED */
int
mntcmp(vnode_t *vp1, vnode_t *vp2, caller_context_t *ct)
{
	return (vp1 != NULL && vp2 != NULL && vp1->v_vfsp == vp2->v_vfsp);
}

/*
 * /mntfs vnode operations vector
 */
const fs_operation_def_t mnt_vnodeops_template[] = {
	VOPNAME_OPEN,		{ .vop_open = mntopen },
	VOPNAME_CLOSE,		{ .vop_close = mntclose },
	VOPNAME_READ,		{ .vop_read = mntread },
	VOPNAME_IOCTL,		{ .vop_ioctl = mntioctl },
	VOPNAME_GETATTR,	{ .vop_getattr = mntgetattr },
	VOPNAME_ACCESS,		{ .vop_access = mntaccess },
	VOPNAME_FSYNC,		{ .vop_fsync = mntfsync },
	VOPNAME_INACTIVE,	{ .vop_inactive = mntinactive },
	VOPNAME_SEEK,		{ .vop_seek = mntseek },
	VOPNAME_POLL,		{ .vop_poll = mntpoll },
	VOPNAME_CMP,		{ .vop_cmp = mntcmp },
	VOPNAME_DISPOSE,	{ .error = fs_error },
	VOPNAME_SHRLOCK,	{ .error = fs_error },
	NULL,			NULL
};