/*

 * 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.

 */

#ifndef _SYS_VNODE_H

#define	_SYS_VNODE_H

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

#include <sys/types.h>

#include <sys/t_lock.h>

#include <sys/rwstlock.h>

#include <sys/time_impl.h>

#include <sys/cred.h>

#include <sys/uio.h>

#include <sys/resource.h>

#include <vm/seg_enum.h>

#include <sys/kstat.h>

#include <sys/kmem.h>

#ifdef	_KERNEL

#include <sys/buf.h>

#endif	/* _KERNEL */

#ifdef	__cplusplus

extern "C" {

#endif

typedef int (*fs_generic_func_p) ();

/*

 * File systems use arrays of fs_operation_def structures to form

 * name/value pairs of operations.  These arrays get passed to:

 *

 * 	- vn_make_ops() to create vnodeops

 * 	- vfs_makefsops()/vfs_setfsops() to create vfsops.

 */

typedef struct fs_operation_def {

	char *name;			/* name of operation (NULL at end) */

	fs_generic_func_p func;		/* function implementing operation */

} fs_operation_def_t;

/*

 * The operation registration mechanism uses two master tables of operations:

 * one for vnode operations (vn_ops_table[]) and one for vfs operations

 * (vfs_ops_table[]).  These tables are arrays of fs_operation_trans_def

 * structures.  They contain all of the information necessary for the system

 * to populate an operations structure (e.g., vnodeops, vfsops).

 *

 * File systems call registration routines (vfs_setfsops(), vfs_makefsops(),

 * and vn_make_ops()) and pass in their operations specification tables

 * (arrays of fs_operation_def structures).  These routines use the master

 * table(s) of operations to build a vnodeops or vfsops structure.

 */

typedef struct fs_operation_trans_def {

	char *name;			/* name of operation (NULL at end) */

	int offset;			/* byte offset within ops vector */

	fs_generic_func_p defaultFunc;	/* default function */

	fs_generic_func_p errorFunc; 	/* error function */

} fs_operation_trans_def_t;

/*

 * Statistics for all vnode operations.

 * All operations record number of ops (since boot/mount/zero'ed).

 * Certain I/O operations (read, write, readdir) also record number

 * of bytes transferred.

 * This appears in two places in the system: one is embedded in each

 * vfs_t.  There is also an array of vopstats_t structures allocated

 * on a per-fstype basis.

 */

#define	VOPSTATS_STR	"vopstats_"	/* Initial string for vopstat kstats */

typedef struct vopstats {

	kstat_named_t	nopen;		/* VOP_OPEN */

	kstat_named_t	nclose;		/* VOP_CLOSE */

	kstat_named_t	nread;		/* VOP_READ */

	kstat_named_t	read_bytes;

	kstat_named_t	nwrite;		/* VOP_WRITE */

	kstat_named_t	write_bytes;

	kstat_named_t	nioctl;		/* VOP_IOCTL */

	kstat_named_t	nsetfl;		/* VOP_SETFL */

	kstat_named_t	ngetattr;	/* VOP_GETATTR */

	kstat_named_t	nsetattr;	/* VOP_SETATTR */

	kstat_named_t	naccess;	/* VOP_ACCESS */

	kstat_named_t	nlookup;	/* VOP_LOOKUP */

	kstat_named_t	ncreate;	/* VOP_CREATE */

	kstat_named_t	nremove;	/* VOP_REMOVE */

	kstat_named_t	nlink;		/* VOP_LINK */

	kstat_named_t	nrename;	/* VOP_RENAME */

	kstat_named_t	nmkdir;		/* VOP_MKDIR */

	kstat_named_t	nrmdir;		/* VOP_RMDIR */

	kstat_named_t	nreaddir;	/* VOP_READDIR */

	kstat_named_t	readdir_bytes;

	kstat_named_t	nsymlink;	/* VOP_SYMLINK */

	kstat_named_t	nreadlink;	/* VOP_READLINK */

	kstat_named_t	nfsync;		/* VOP_FSYNC */

	kstat_named_t	ninactive;	/* VOP_INACTIVE */

	kstat_named_t	nfid;		/* VOP_FID */

	kstat_named_t	nrwlock;	/* VOP_RWLOCK */

	kstat_named_t	nrwunlock;	/* VOP_RWUNLOCK */

	kstat_named_t	nseek;		/* VOP_SEEK */

	kstat_named_t	ncmp;		/* VOP_CMP */

	kstat_named_t	nfrlock;	/* VOP_FRLOCK */

	kstat_named_t	nspace;		/* VOP_SPACE */

	kstat_named_t	nrealvp;	/* VOP_REALVP */

	kstat_named_t	ngetpage;	/* VOP_GETPAGE */

	kstat_named_t	nputpage;	/* VOP_PUTPAGE */

	kstat_named_t	nmap;		/* VOP_MAP */

	kstat_named_t	naddmap;	/* VOP_ADDMAP */

	kstat_named_t	ndelmap;	/* VOP_DELMAP */

	kstat_named_t	npoll;		/* VOP_POLL */

	kstat_named_t	ndump;		/* VOP_DUMP */

	kstat_named_t	npathconf;	/* VOP_PATHCONF */

	kstat_named_t	npageio;	/* VOP_PAGEIO */

	kstat_named_t	ndumpctl;	/* VOP_DUMPCTL */

	kstat_named_t	ndispose;	/* VOP_DISPOSE */

	kstat_named_t	nsetsecattr;	/* VOP_SETSECATTR */

	kstat_named_t	ngetsecattr;	/* VOP_GETSECATTR */

	kstat_named_t	nshrlock;	/* VOP_SHRLOCK */

	kstat_named_t	nvnevent;	/* VOP_VNEVENT */

} vopstats_t;

/*

 * The vnode is the focus of all file activity in UNIX.

 * A vnode is allocated for each active file, each current

 * directory, each mounted-on file, and the root.

 *

 * Each vnode is usually associated with a file-system-specific node (for

 * UFS, this is the in-memory inode).  Generally, a vnode and an fs-node

 * should be created and destroyed together as a pair.

 *

 * If a vnode is reused for a new file, it should be reinitialized by calling

 * either vn_reinit() or vn_recycle().

 *

 * vn_reinit() resets the entire vnode as if it was returned by vn_alloc().

 * The caller is responsible for setting up the entire vnode after calling

 * vn_reinit().  This is important when using kmem caching where the vnode is

 * allocated by a constructor, for instance.

 *

 * vn_recycle() is used when the file system keeps some state around in both

 * the vnode and the associated FS-node.  In UFS, for example, the inode of

 * a deleted file can be reused immediately.  The v_data, v_vfsp, v_op, etc.

 * remains the same but certain fields related to the previous instance need

 * to be reset.  In particular:

 *	v_femhead

 *	v_path

 *	v_rdcnt, v_wrcnt

 *	v_mmap_read, v_mmap_write

 */

/*

 * vnode types.  VNON means no type.  These values are unrelated to

 * values in on-disk inodes.

 */

typedef enum vtype {

	VNON	= 0,

	VREG	= 1,

	VDIR	= 2,

	VBLK	= 3,

	VCHR	= 4,

	VLNK	= 5,

	VFIFO	= 6,

	VDOOR	= 7,

	VPROC	= 8,

	VSOCK	= 9,

	VPORT	= 10,

	VBAD	= 11

} vtype_t;

/*

 * Many of the fields in the vnode are read-only once they are initialized

 * at vnode creation time.  Other fields are protected by locks.

 *

 * IMPORTANT: vnodes should be created ONLY by calls to vn_alloc().  They

 * may not be embedded into the file-system specific node (inode).  The

 * size of vnodes may change.

 *

 * The v_lock protects:

 *   v_flag

 *   v_stream

 *   v_count

 *   v_shrlocks

 *   v_path

 *

 * A special lock (implemented by vn_vfswlock in vnode.c) protects:

 *   v_vfsmountedhere

 *

 * The global flock_lock mutex (in flock.c) protects:

 *   v_filocks

 *

 * IMPORTANT NOTE:

 *

 *   The following vnode fields are considered public and may safely be

 *   accessed by file systems or other consumers:

 *

 *     v_lock

 *     v_flag

 *     v_count

 *     v_data

 *     v_vfsp

 *     v_stream

 *     v_type

 *     v_rdev

 *

 * ALL OTHER FIELDS SHOULD BE ACCESSED ONLY BY THE OWNER OF THAT FIELD.

 * In particular, file systems should not access other fields; they may

 * change or even be removed.  The functionality which was once provided

 * by these fields is available through vn_* functions.

 */

struct fem_head;	/* from fem.h */

typedef struct vnode {

	kmutex_t	v_lock;		/* protects vnode fields */

	uint_t		v_flag;		/* vnode flags (see below) */

	uint_t		v_count;	/* reference count */

	void		*v_data;	/* private data for fs */

	struct vfs	*v_vfsp;	/* ptr to containing VFS */

	struct stdata	*v_stream;	/* associated stream */

	enum vtype	v_type;		/* vnode type */

	dev_t		v_rdev;		/* device (VCHR, VBLK) */

	/* PRIVATE FIELDS BELOW - DO NOT USE */

	struct vfs	*v_vfsmountedhere; /* ptr to vfs mounted here */

	struct vnodeops	*v_op;		/* vnode operations */

	struct page	*v_pages;	/* vnode pages list */

	pgcnt_t		v_npages;	/* # pages on this vnode */

	pgcnt_t		v_msnpages;	/* # pages charged to v_mset */

	struct page	*v_scanfront;	/* scanner front hand */

	struct page	*v_scanback;	/* scanner back hand */

	struct filock	*v_filocks;	/* ptr to filock list */

	struct shrlocklist *v_shrlocks;	/* ptr to shrlock list */

	krwlock_t	v_nbllock;	/* sync for NBMAND locks */

	kcondvar_t	v_cv;		/* synchronize locking */

	void		*v_locality;	/* hook for locality info */

	struct fem_head	*v_femhead;	/* fs monitoring */

	char		*v_path;	/* cached path */

	uint_t		v_rdcnt;	/* open for read count  (VREG only) */

	uint_t		v_wrcnt;	/* open for write count (VREG only) */

	u_longlong_t	v_mmap_read;	/* mmap read count */

	u_longlong_t	v_mmap_write;	/* mmap write count */

	void		*v_mpssdata;	/* info for large page mappings */

	hrtime_t	v_scantime;	/* last time this vnode was scanned */

	ushort_t	v_mset;		/* memory set ID */

	uint_t		v_msflags;	/* memory set flags */

	struct vnode	*v_msnext;	/* list of vnodes on an mset */

	struct vnode	*v_msprev;	/* list of vnodes on an mset */

	krwlock_t	v_mslock;	/* protects v_mset */

} vnode_t;

#define	IS_DEVVP(vp)	\

	((vp)->v_type == VCHR || (vp)->v_type == VBLK || (vp)->v_type == VFIFO)

/*

 * vnode flags.

 */

#define	VROOT		0x01	/* root of its file system */

#define	VNOCACHE	0x02	/* don't keep cache pages on vnode */

#define	VNOMAP		0x04	/* file cannot be mapped/faulted */

#define	VDUP		0x08	/* file should be dup'ed rather then opened */

#define	VNOSWAP		0x10	/* file cannot be used as virtual swap device */

#define	VNOMOUNT	0x20	/* file cannot be covered by mount */

#define	VISSWAP		0x40	/* vnode is being used for swap */

#define	VSWAPLIKE	0x80	/* vnode acts like swap (but may not be) */

#define	IS_SWAPVP(vp)	(((vp)->v_flag & (VISSWAP | VSWAPLIKE)) != 0)

typedef struct vn_vfslocks_entry {

	rwstlock_t ve_lock;

	void *ve_vpvfs;

	struct vn_vfslocks_entry *ve_next;

	uint32_t ve_refcnt;

	char pad[64 - sizeof (rwstlock_t) - 2 * sizeof (void *) - \

	    sizeof (uint32_t)];

} vn_vfslocks_entry_t;

/*

 * The following two flags are used to lock the v_vfsmountedhere field

 */

#define	VVFSLOCK	0x100

#define	VVFSWAIT	0x200

/*

 * Used to serialize VM operations on a vnode

 */

#define	VVMLOCK		0x400

/*

 * Tell vn_open() not to fail a directory open for writing but

 * to go ahead and call VOP_OPEN() to let the filesystem check.

 */

#define	VDIROPEN	0x800

/*

 * Flag to let the VM system know that this file is most likely a binary

 * or shared library since it has been mmap()ed EXEC at some time.

 */

#define	VVMEXEC		0x1000

#define	VPXFS		0x2000  /* clustering: global fs proxy vnode */

#define	IS_PXFSVP(vp)	((vp)->v_flag & VPXFS)

#define	V_XATTRDIR	0x4000	/* attribute unnamed directory */

#define	V_LOCALITY	0x8000	/* whether locality aware */

/*

 * Flag that indicates the VM should maintain the v_pages list with all modified

 * pages on one end and unmodified pages at the other. This makes finding dirty

 * pages to write back to disk much faster at the expense of taking a minor

 * fault on the first store instruction which touches a writable page.

 */

#define	VMODSORT	(0x10000)

#define	IS_VMODSORT(vp) \

	(pvn_vmodsort_supported != 0 && ((vp)->v_flag  & VMODSORT) != 0)

#define	VISSWAPFS	0x20000	/* vnode is being used for swapfs */

#define	IS_SWAPFSVP(vp)	(((vp)->v_flag & VISSWAPFS) != 0)

/*

 * Vnode attributes.  A bit-mask is supplied as part of the

 * structure to indicate the attributes the caller wants to

 * set (setattr) or extract (getattr).

 */

/*

 * Note that va_nodeid and va_nblocks are 64bit data type.

 * We support large files over NFSV3. With Solaris client and

 * Server that generates 64bit ino's and sizes these fields

 * will overflow if they are 32 bit sizes.

 */

typedef struct vattr {

	uint_t		va_mask;	/* bit-mask of attributes */

	vtype_t		va_type;	/* vnode type (for create) */

	mode_t		va_mode;	/* file access mode */

	uid_t		va_uid;		/* owner user id */

	gid_t		va_gid;		/* owner group id */

	dev_t		va_fsid;	/* file system id (dev for now) */

	u_longlong_t	va_nodeid;	/* node id */

	nlink_t		va_nlink;	/* number of references to file */

	u_offset_t	va_size;	/* file size in bytes */

	timestruc_t	va_atime;	/* time of last access */

	timestruc_t	va_mtime;	/* time of last modification */

	timestruc_t	va_ctime;	/* time of last status change */

	dev_t		va_rdev;	/* device the file represents */

	uint_t		va_blksize;	/* fundamental block size */

	u_longlong_t	va_nblocks;	/* # of blocks allocated */

	uint_t		va_seq;		/* sequence number */

} vattr_t;

#ifdef _SYSCALL32

/*

 * For bigtypes time_t changed to 64 bit on the 64-bit kernel.

 * Define an old version for user/kernel interface

 */

#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4

#pragma pack(4)

#endif

typedef struct vattr32 {

	uint32_t	va_mask;	/* bit-mask of attributes */

	vtype_t		va_type;	/* vnode type (for create) */

	mode32_t	va_mode;	/* file access mode */

	uid32_t		va_uid;		/* owner user id */

	gid32_t		va_gid;		/* owner group id */

	dev32_t		va_fsid;	/* file system id (dev for now) */

	u_longlong_t	va_nodeid;	/* node id */

	nlink_t		va_nlink;	/* number of references to file */

	u_offset_t	va_size;	/* file size in bytes */

	timestruc32_t	va_atime;	/* time of last access */

	timestruc32_t	va_mtime;	/* time of last modification */

	timestruc32_t	va_ctime;	/* time of last status change */

	dev32_t		va_rdev;	/* device the file represents */

	uint32_t	va_blksize;	/* fundamental block size */

	u_longlong_t	va_nblocks;	/* # of blocks allocated */

	uint32_t	va_seq;		/* sequence number */

} vattr32_t;

#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4

#pragma pack()

#endif

#else  /* not _SYSCALL32 */

#define	vattr32		vattr

typedef vattr_t		vattr32_t;

#endif /* _SYSCALL32 */

/*

 * Attributes of interest to the caller of setattr or getattr.

 */

#define	AT_TYPE		0x0001

#define	AT_MODE		0x0002

#define	AT_UID		0x0004

#define	AT_GID		0x0008

#define	AT_FSID		0x0010

#define	AT_NODEID	0x0020

#define	AT_NLINK	0x0040

#define	AT_SIZE		0x0080

#define	AT_ATIME	0x0100

#define	AT_MTIME	0x0200

#define	AT_CTIME	0x0400

#define	AT_RDEV		0x0800

#define	AT_BLKSIZE	0x1000

#define	AT_NBLOCKS	0x2000

/*			0x4000 */	/* unused */

#define	AT_SEQ		0x8000

#define	AT_ALL		(AT_TYPE|AT_MODE|AT_UID|AT_GID|AT_FSID|AT_NODEID|\

			AT_NLINK|AT_SIZE|AT_ATIME|AT_MTIME|AT_CTIME|\

			AT_RDEV|AT_BLKSIZE|AT_NBLOCKS|AT_SEQ)

#define	AT_STAT		(AT_MODE|AT_UID|AT_GID|AT_FSID|AT_NODEID|AT_NLINK|\

			AT_SIZE|AT_ATIME|AT_MTIME|AT_CTIME|AT_RDEV|AT_TYPE)

#define	AT_TIMES	(AT_ATIME|AT_MTIME|AT_CTIME)

#define	AT_NOSET	(AT_NLINK|AT_RDEV|AT_FSID|AT_NODEID|AT_TYPE|\

			AT_BLKSIZE|AT_NBLOCKS|AT_SEQ)

/*

 *  Modes.  Some values same as S_xxx entries from stat.h for convenience.

 */

#define	VSUID		04000		/* set user id on execution */

#define	VSGID		02000		/* set group id on execution */

#define	VSVTX		01000		/* save swapped text even after use */

/*

 * Permissions.

 */

#define	VREAD		00400

#define	VWRITE		00200

#define	VEXEC		00100

#define	MODEMASK	07777		/* mode bits plus permission bits */

#define	PERMMASK	00777		/* permission bits */

/*

 * Check whether mandatory file locking is enabled.

 */

#define	MANDMODE(mode)		(((mode) & (VSGID|(VEXEC>>3))) == VSGID)

#define	MANDLOCK(vp, mode)	((vp)->v_type == VREG && MANDMODE(mode))

/*

 * Flags for vnode operations.

 */

enum rm		{ RMFILE, RMDIRECTORY };	/* rm or rmdir (remove) */

enum symfollow	{ NO_FOLLOW, FOLLOW };		/* follow symlinks (or not) */

enum vcexcl	{ NONEXCL, EXCL };		/* (non)excl create */

enum create	{ CRCREAT, CRMKNOD, CRMKDIR };	/* reason for create */

typedef enum rm		rm_t;

typedef enum symfollow	symfollow_t;

typedef enum vcexcl	vcexcl_t;

typedef enum create	create_t;

/* Vnode Events - Used by VOP_VNEVENT */

typedef enum vnevent	{

	VE_SUPPORT	= 0,	/* Query */

	VE_RENAME_SRC	= 1,	/* Rename, with vnode as source */

	VE_RENAME_DEST	= 2,	/* Rename, with vnode as target/destination */

	VE_REMOVE	= 3,	/* Remove of vnode's name */

	VE_RMDIR	= 4	/* Remove of directory vnode's name */

} vnevent_t;

/*

 * Values for checking vnode open and map counts

 */

enum v_mode { V_READ, V_WRITE, V_RDORWR, V_RDANDWR };

typedef enum v_mode v_mode_t;

#define	V_TRUE	1

#define	V_FALSE	0

/*

 * Structure used on VOP_GETSECATTR and VOP_SETSECATTR operations

 */

typedef struct vsecattr {

	uint_t		vsa_mask;	/* See below */

	int		vsa_aclcnt;	/* ACL entry count */

	void		*vsa_aclentp;	/* pointer to ACL entries */