/*

 * 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 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * University Copyright- Copyright (c) 1982, 1986, 1988

 * The Regents of the University of California

 * All Rights Reserved

 *

 * University Acknowledgment- Portions of this document are derived from

 * software developed by the University of California, Berkeley, and its

 * contributors.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>

#include <sys/t_lock.h>

#include <sys/param.h>

#include <sys/errno.h>

#include <sys/user.h>

#include <sys/fstyp.h>

#include <sys/kmem.h>

#include <sys/systm.h>

#include <sys/proc.h>

#include <sys/mount.h>

#include <sys/vfs.h>

#include <sys/fem.h>

#include <sys/mntent.h>

#include <sys/stat.h>

#include <sys/statvfs.h>

#include <sys/statfs.h>

#include <sys/cred.h>

#include <sys/vnode.h>

#include <sys/rwstlock.h>

#include <sys/dnlc.h>

#include <sys/file.h>

#include <sys/time.h>

#include <sys/atomic.h>

#include <sys/cmn_err.h>

#include <sys/buf.h>

#include <sys/swap.h>

#include <sys/debug.h>

#include <sys/vnode.h>

#include <sys/modctl.h>

#include <sys/ddi.h>

#include <sys/pathname.h>

#include <sys/bootconf.h>

#include <sys/dumphdr.h>

#include <sys/dc_ki.h>

#include <sys/poll.h>

#include <sys/sunddi.h>

#include <sys/sysmacros.h>

#include <sys/zone.h>

#include <sys/policy.h>

#include <sys/ctfs.h>

#include <sys/objfs.h>

#include <sys/console.h>

#include <sys/reboot.h>

#include <vm/page.h>

#include <fs/fs_subr.h>

/* Private interfaces to create vopstats-related data structures */

extern void		initialize_vopstats(vopstats_t *);

extern vopstats_t	*get_fstype_vopstats(struct vfs *, struct vfssw *);

extern vsk_anchor_t	*get_vskstat_anchor(struct vfs *);

static void vfs_clearmntopt_nolock(mntopts_t *, const char *, int);

static void vfs_setmntopt_nolock(mntopts_t *, const char *,

    const char *, int, int);

static int  vfs_optionisset_nolock(const mntopts_t *, const char *, char **);

static void vfs_freemnttab(struct vfs *);

static void vfs_freeopt(mntopt_t *);

static void vfs_swapopttbl_nolock(mntopts_t *, mntopts_t *);

static void vfs_swapopttbl(mntopts_t *, mntopts_t *);

static void vfs_copyopttbl_extend(const mntopts_t *, mntopts_t *, int);

static void vfs_createopttbl_extend(mntopts_t *, const char *,

    const mntopts_t *);

static char **vfs_copycancelopt_extend(char **const, int);

static void vfs_freecancelopt(char **);

static char *getrootfs(void);

static int getmacpath(dev_info_t *, void *);

struct ipmnt {

	struct ipmnt	*mip_next;

	dev_t		mip_dev;

	struct vfs	*mip_vfsp;

};

static kmutex_t		vfs_miplist_mutex;

static struct ipmnt	*vfs_miplist = NULL;

static struct ipmnt	*vfs_miplist_end = NULL;

/*

 * VFS global data.

 */

vnode_t *rootdir;		/* pointer to root inode vnode. */

vnode_t *devicesdir;		/* pointer to inode of devices root */

char *server_rootpath;		/* root path for diskless clients */

char *server_hostname;		/* hostname of diskless server */

static struct vfs root;

static struct vfs devices;

struct vfs *rootvfs = &root;	/* pointer to root vfs; head of VFS list. */

rvfs_t *rvfs_list;		/* array of vfs ptrs for vfs hash list */

int vfshsz = 512;		/* # of heads/locks in vfs hash arrays */

				/* must be power of 2!	*/

timespec_t vfs_mnttab_ctime;	/* mnttab created time */

timespec_t vfs_mnttab_mtime;	/* mnttab last modified time */

char *vfs_dummyfstype = "\0";

struct pollhead vfs_pollhd;	/* for mnttab pollers */

/*

 * Table for generic options recognized in the VFS layer and acted

 * on at this level before parsing file system specific options.

 * The nosuid option is stronger than any of the devices and setuid

 * options, so those are canceled when nosuid is seen.

 *

 * All options which are added here need to be added to the

 * list of standard options in usr/src/cmd/fs.d/fslib.c as well.

 */

/*

 * VFS Mount options table

 */

static char *ro_cancel[] = { MNTOPT_RW, NULL };

static char *rw_cancel[] = { MNTOPT_RO, NULL };

static char *suid_cancel[] = { MNTOPT_NOSUID, NULL };

static char *nosuid_cancel[] = { MNTOPT_SUID, MNTOPT_DEVICES, MNTOPT_NODEVICES,

    MNTOPT_NOSETUID, MNTOPT_SETUID, NULL };

static char *devices_cancel[] = { MNTOPT_NODEVICES, NULL };

static char *nodevices_cancel[] = { MNTOPT_DEVICES, NULL };

static char *setuid_cancel[] = { MNTOPT_NOSETUID, NULL };

static char *nosetuid_cancel[] = { MNTOPT_SETUID, NULL };

static char *nbmand_cancel[] = { MNTOPT_NONBMAND, NULL };

static char *nonbmand_cancel[] = { MNTOPT_NBMAND, NULL };

static char *exec_cancel[] = { MNTOPT_NOEXEC, NULL };

static char *noexec_cancel[] = { MNTOPT_EXEC, NULL };

static const mntopt_t mntopts[] = {

/*

 *	option name		cancel options		default arg	flags

 */

	{ MNTOPT_REMOUNT,	NULL,			NULL,

		MO_NODISPLAY, (void *)0 },

	{ MNTOPT_RO,		ro_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_RW,		rw_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_SUID,		suid_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_NOSUID,	nosuid_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_DEVICES,	devices_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_NODEVICES,	nodevices_cancel,	NULL,		0,

		(void *)0 },

	{ MNTOPT_SETUID,	setuid_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_NOSETUID,	nosetuid_cancel,	NULL,		0,

		(void *)0 },

	{ MNTOPT_NBMAND,	nbmand_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_NONBMAND,	nonbmand_cancel,	NULL,		0,

		(void *)0 },

	{ MNTOPT_EXEC,		exec_cancel,		NULL,		0,

		(void *)0 },

	{ MNTOPT_NOEXEC,	noexec_cancel,		NULL,		0,

		(void *)0 },

};

const mntopts_t vfs_mntopts = {

	sizeof (mntopts) / sizeof (mntopt_t),

	(mntopt_t *)&mntopts[0]

};

/*

 * File system operation dispatch functions.

 */

int

fsop_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)

{

	return (*(vfsp)->vfs_op->vfs_mount)(vfsp, mvp, uap, cr);

}

int

fsop_unmount(vfs_t *vfsp, int flag, cred_t *cr)

{

	return (*(vfsp)->vfs_op->vfs_unmount)(vfsp, flag, cr);

}

int

fsop_root(vfs_t *vfsp, vnode_t **vpp)

{

	refstr_t *mntpt;

	int ret = (*(vfsp)->vfs_op->vfs_root)(vfsp, vpp);

	/*

	 * Make sure this root has a path.  With lofs, it is possible to have

	 * a NULL mountpoint.

	 */

	if (ret == 0 && vfsp->vfs_mntpt != NULL && (*vpp)->v_path == NULL) {

		mntpt = vfs_getmntpoint(vfsp);

		vn_setpath_str(*vpp, refstr_value(mntpt),

		    strlen(refstr_value(mntpt)));

		refstr_rele(mntpt);

	}

	return (ret);

}

int

fsop_statfs(vfs_t *vfsp, statvfs64_t *sp)

{

	return (*(vfsp)->vfs_op->vfs_statvfs)(vfsp, sp);

}

int

fsop_sync(vfs_t *vfsp, short flag, cred_t *cr)

{

	return (*(vfsp)->vfs_op->vfs_sync)(vfsp, flag, cr);

}

int

fsop_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)

{

	return (*(vfsp)->vfs_op->vfs_vget)(vfsp, vpp, fidp);

}

int

fsop_mountroot(vfs_t *vfsp, enum whymountroot reason)

{

	return (*(vfsp)->vfs_op->vfs_mountroot)(vfsp, reason);

}

void

fsop_freefs(vfs_t *vfsp)

{

	(*(vfsp)->vfs_op->vfs_freevfs)(vfsp);

}

int

fsop_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate)

{

	return ((*(vfsp)->vfs_op->vfs_vnstate)(vfsp, vp, nstate));

}

int

fsop_sync_by_kind(int fstype, short flag, cred_t *cr)

{

	ASSERT((fstype >= 0) && (fstype < nfstype));

	if (ALLOCATED_VFSSW(&vfssw[fstype]) && VFS_INSTALLED(&vfssw[fstype]))

		return (*vfssw[fstype].vsw_vfsops.vfs_sync) (NULL, flag, cr);

	else

		return (ENOTSUP);

}

/*

 * File system initialization.  vfs_setfsops() must be called from a file

 * system's init routine.

 */

static int

fs_copyfsops(const fs_operation_def_t *template, vfsops_t *actual,

    int *unused_ops)

{

	static const fs_operation_trans_def_t vfs_ops_table[] = {

		VFSNAME_MOUNT, offsetof(vfsops_t, vfs_mount),

			fs_nosys, fs_nosys,

		VFSNAME_UNMOUNT, offsetof(vfsops_t, vfs_unmount),

			fs_nosys, fs_nosys,

		VFSNAME_ROOT, offsetof(vfsops_t, vfs_root),

			fs_nosys, fs_nosys,

		VFSNAME_STATVFS, offsetof(vfsops_t, vfs_statvfs),

			fs_nosys, fs_nosys,

		VFSNAME_SYNC, offsetof(vfsops_t, vfs_sync),

			(fs_generic_func_p) fs_sync,

			(fs_generic_func_p) fs_sync,	/* No errors allowed */

		VFSNAME_VGET, offsetof(vfsops_t, vfs_vget),

			fs_nosys, fs_nosys,

		VFSNAME_MOUNTROOT, offsetof(vfsops_t, vfs_mountroot),

			fs_nosys, fs_nosys,

		VFSNAME_FREEVFS, offsetof(vfsops_t, vfs_freevfs),

			(fs_generic_func_p)fs_freevfs,

			(fs_generic_func_p)fs_freevfs,	/* Shouldn't fail */

		VFSNAME_VNSTATE, offsetof(vfsops_t, vfs_vnstate),

			(fs_generic_func_p)fs_nosys,

			(fs_generic_func_p)fs_nosys,

		NULL, 0, NULL, NULL

	};

	return (fs_build_vector(actual, unused_ops, vfs_ops_table, template));

}

int

vfs_setfsops(int fstype, const fs_operation_def_t *template, vfsops_t **actual)

{

	int error;

	int unused_ops;

	/* Verify that fstype refers to a loaded fs (and not fsid 0). */

	if ((fstype <= 0) || (fstype >= nfstype))

		return (EINVAL);

	if (!ALLOCATED_VFSSW(&vfssw[fstype]))

		return (EINVAL);

	/* Set up the operations vector. */

	error = fs_copyfsops(template, &vfssw[fstype].vsw_vfsops, &unused_ops);

	if (error != 0)

		return (error);

	vfssw[fstype].vsw_flag |= VSW_INSTALLED;

	if (actual != NULL)

		*actual = &vfssw[fstype].vsw_vfsops;

#if DEBUG

	if (unused_ops != 0)

		cmn_err(CE_WARN, "vfs_setfsops: %s: %d operations supplied "

		    "but not used", vfssw[fstype].vsw_name, unused_ops);

#endif

	return (0);

}

int

vfs_makefsops(const fs_operation_def_t *template, vfsops_t **actual)

{

	int error;

	int unused_ops;

	*actual = (vfsops_t *)kmem_alloc(sizeof (vfsops_t), KM_SLEEP);

	error = fs_copyfsops(template, *actual, &unused_ops);

	if (error != 0) {

		kmem_free(*actual, sizeof (vfsops_t));

		*actual = NULL;

		return (error);

	}

	return (0);

}

/*

 * Free a vfsops structure created as a result of vfs_makefsops().

 * NOTE: For a vfsops structure initialized by vfs_setfsops(), use

 * vfs_freevfsops_by_type().

 */

void

vfs_freevfsops(vfsops_t *vfsops)

{

	kmem_free(vfsops, sizeof (vfsops_t));

}

/*

 * Since the vfsops structure is part of the vfssw table and wasn't

 * really allocated, we're not really freeing anything.  We keep

 * the name for consistency with vfs_freevfsops().  We do, however,

 * need to take care of a little bookkeeping.

 * NOTE: For a vfsops structure created by vfs_setfsops(), use

 * vfs_freevfsops_by_type().

 */

int

vfs_freevfsops_by_type(int fstype)

{

	/* Verify that fstype refers to a loaded fs (and not fsid 0). */

	if ((fstype <= 0) || (fstype >= nfstype))

		return (EINVAL);

	WLOCK_VFSSW();

	if ((vfssw[fstype].vsw_flag & VSW_INSTALLED) == 0) {

		WUNLOCK_VFSSW();

		return (EINVAL);

	}

	vfssw[fstype].vsw_flag &= ~VSW_INSTALLED;

	WUNLOCK_VFSSW();

	return (0);

}

/* Support routines used to reference vfs_op */

/* Set the operations vector for a vfs */

void

vfs_setops(vfs_t *vfsp, vfsops_t *vfsops)

{

	vfsops_t	*op;

	ASSERT(vfsp != NULL);

	ASSERT(vfsops != NULL);

	op = vfsp->vfs_op;

	membar_consumer();

	if ((vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) &&

	    casptr(&vfsp->vfs_op, op, vfsops) == op) {

		return;

	}

	fsem_setvfsops(vfsp, vfsops);

}

/* Retrieve the operations vector for a vfs */

vfsops_t *

vfs_getops(vfs_t *vfsp)

{

	vfsops_t	*op;

	ASSERT(vfsp != NULL);

	op = vfsp->vfs_op;

	membar_consumer();

	if ((vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) &&

	    op == vfsp->vfs_op) {

		return (op);

	} else {

		return (fsem_getvfsops(vfsp));

	}

}

/*

 * Returns non-zero (1) if the vfsops matches that of the vfs.

 * Returns zero (0) if not.

 */

int

vfs_matchops(vfs_t *vfsp, vfsops_t *vfsops)

{

	return (vfs_getops(vfsp) == vfsops);

}

/*

 * Returns non-zero (1) if the file system has installed a non-default,

 * non-error vfs_sync routine.  Returns zero (0) otherwise.

 */

int

vfs_can_sync(vfs_t *vfsp)

{

	/* vfs_sync() routine is not the default/error function */

	return (vfs_getops(vfsp)->vfs_sync != fs_sync);

}

/*

 * Initialize a vfs structure.

 */

void

vfs_init(vfs_t *vfsp, vfsops_t *op, void *data)

{

	vfsp->vfs_count = 0;

	vfsp->vfs_next = vfsp;

	vfsp->vfs_prev = vfsp;

	vfsp->vfs_zone_next = vfsp;

	vfsp->vfs_zone_prev = vfsp;

	vfsp->vfs_flag = 0;

	vfsp->vfs_data = (data);

	vfsp->vfs_resource = NULL;

	vfsp->vfs_mntpt = NULL;

	vfsp->vfs_mntopts.mo_count = 0;

	vfsp->vfs_mntopts.mo_list = NULL;

	vfsp->vfs_implp = NULL;

	vfsp->vfs_zone = NULL;

	/*

	 * Note: Don't initialize any member of the vfs_impl_t structure

	 * here as it could be a problem for unbundled file systems.

	 */

	vfs_setops((vfsp), (op));

	sema_init(&vfsp->vfs_reflock, 1, NULL, SEMA_DEFAULT, NULL);

}

/*

 * Allocate and initialize the vfs implementation private data

 * structure, vfs_impl_t.

 */

void

vfsimpl_setup(vfs_t *vfsp)

{

	vfsp->vfs_implp = kmem_alloc(sizeof (vfs_impl_t), KM_SLEEP);

	/* Note that this are #define'd in vfs.h */

	vfsp->vfs_femhead = NULL;

	vfsp->vfs_vskap = NULL;

	vfsp->vfs_fstypevsp = NULL;

}