 @@ -1,606 +1,610 @@
-/*	$NetBSD: vnode.h,v 1.257 2016/01/22 22:43:25 dholland Exp $	*/
+/*	$NetBSD: vnode.h,v 1.258 2016/01/23 16:02:09 christos Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)vnode.h	8.17 (Berkeley) 5/20/95
  */
 #ifndef _SYS_VNODE_H_
 #define	_SYS_VNODE_H_
 #include <sys/event.h>
 #include <sys/queue.h>
 #include <sys/condvar.h>
 #include <sys/rwlock.h>
 #include <sys/mutex.h>
 #include <sys/time.h>
 /* XXX: clean up includes later */
 #if defined(_KERNEL) || defined(_KMEMUSER)
 #include <uvm/uvm_param.h>	/* XXX */
 #include <uvm/uvm_pglist.h>	/* XXX */
 #include <uvm/uvm_object.h>	/* XXX */
 #include <uvm/uvm_extern.h>	/* XXX */
 struct namecache;
 struct uvm_ractx;
 #endif
 /*
  * The vnode is the focus of all file activity in UNIX.  There is a
  * unique vnode allocated for each active file, each current directory,
  * each mounted-on file, text file, and the root.
  */
 /*
  * Vnode types.  VNON means no type.
  */
 enum vtype	{ VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD };
 #define	VNODE_TYPES \
     "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD"
 /*
  * Vnode tag types.
  * These are for the benefit of external programs only (e.g., pstat)
  * and should NEVER be inspected by the kernel.
  */
 enum vtagtype	{
 	VT_NON, VT_UFS, VT_NFS, VT_MFS, VT_MSDOSFS, VT_LFS, VT_LOFS,
 	VT_FDESC, VT_PORTAL, VT_NULL, VT_UMAP, VT_KERNFS, VT_PROCFS,
 	VT_AFS, VT_ISOFS, VT_UNION, VT_ADOSFS, VT_EXT2FS, VT_CODA,
 	VT_FILECORE, VT_NTFS, VT_VFS, VT_OVERLAY, VT_SMBFS, VT_PTYFS,
 	VT_TMPFS, VT_UDF, VT_SYSVBFS, VT_PUFFS, VT_HFS, VT_EFS, VT_ZFS,
 	VT_RUMP, VT_NILFS, VT_V7FS, VT_CHFS
 };
 #define	VNODE_TAGS \
     "VT_NON", "VT_UFS", "VT_NFS", "VT_MFS", "VT_MSDOSFS", "VT_LFS", "VT_LOFS", \
     "VT_FDESC", "VT_PORTAL", "VT_NULL", "VT_UMAP", "VT_KERNFS", "VT_PROCFS", \
     "VT_AFS", "VT_ISOFS", "VT_UNION", "VT_ADOSFS", "VT_EXT2FS", "VT_CODA", \
     "VT_FILECORE", "VT_NTFS", "VT_VFS", "VT_OVERLAY", "VT_SMBFS", "VT_PTYFS", \
     "VT_TMPFS", "VT_UDF", "VT_SYSVBFS", "VT_PUFFS", "VT_HFS", "VT_EFS", \
     "VT_ZFS", "VT_RUMP", "VT_NILFS", "VT_V7FS", "VT_CHFS"
 #if defined(_KERNEL) || defined(_KMEMUSER)
 struct vnode;
 struct buf;
 LIST_HEAD(buflists, buf);
 TAILQ_HEAD(vnodelst, vnode);
 /*
  * Reading or writing any of these items requires holding the appropriate
  * lock.  Field markings and the corresponding locks:
+ *
  *	:	stable, reference to the vnode is required
  *	f	vnode_free_list_lock, or vrele_lock for vrele_list
  *	i	v_interlock
  *	m	mntvnode_lock
  *	n	namecache_lock
  *	s	syncer_data_lock
  *	u	locked by underlying filesystem
  *	v	vnode lock
  *	x	v_interlock + bufcache_lock to modify, either to inspect
+ *
  * Each underlying filesystem allocates its own private area and hangs
  * it from v_data.
  */
 struct vnode {
 	struct uvm_object v_uobj;		/* i: the VM object */
 	kcondvar_t	v_cv;			/* i: synchronization */
 	voff_t		v_size;			/* i: size of file */
 	voff_t		v_writesize;		/* i: new size after write */
 	int		v_iflag;		/* i: VI_* flags */
 	int		v_vflag;		/* v: VV_* flags */
 	int		v_uflag;		/* u: VU_* flags */
 	int		v_numoutput;		/* i: # of pending writes */
 	int		v_writecount;		/* i: ref count of writers */
 	int		v_holdcnt;		/* i: page & buffer refs */
 	int		v_synclist_slot;	/* s: synclist slot index */
 	struct mount	*v_mount;		/* v: ptr to vfs we are in */
 	int		(**v_op)(void *);	/* :: vnode operations vector */
 	TAILQ_ENTRY(vnode) v_freelist;		/* f: vnode freelist */
 	struct vnodelst	*v_freelisthd;		/* f: which freelist? */
 	TAILQ_ENTRY(vnode) v_mntvnodes;		/* m: vnodes for mount point */
 	struct buflists	v_cleanblkhd;		/* x: clean blocklist head */
 	struct buflists	v_dirtyblkhd;		/* x: dirty blocklist head */
 	TAILQ_ENTRY(vnode) v_synclist;		/* s: vnodes with dirty bufs */
 	LIST_HEAD(, namecache) v_dnclist;	/* n: namecaches (children) */
 	LIST_HEAD(, namecache) v_nclist;	/* n: namecaches (parent) */
 	union {
 		struct mount	*vu_mountedhere;/* v: ptr to vfs (VDIR) */
 		struct socket	*vu_socket;	/* v: unix ipc (VSOCK) */
 		struct specnode	*vu_specnode;	/* v: device (VCHR, VBLK) */
 		struct fifoinfo	*vu_fifoinfo;	/* v: fifo (VFIFO) */
 		struct uvm_ractx *vu_ractx;	/* i: read-ahead ctx (VREG) */
 	} v_un;
 	enum vtype	v_type;			/* :: vnode type */
 	enum vtagtype	v_tag;			/* :: type of underlying data */
 	krwlock_t	v_lock;			/* v: lock for this vnode */
 	void 		*v_data;		/* :: private data for fs */
 	struct klist	v_klist;		/* i: notes attached to vnode */
 };
 #define	v_usecount	v_uobj.uo_refs
 #define	v_interlock	v_uobj.vmobjlock
 #define	v_mountedhere	v_un.vu_mountedhere
 #define	v_socket	v_un.vu_socket
 #define	v_specnode	v_un.vu_specnode
 #define	v_fifoinfo	v_un.vu_fifoinfo
 #define	v_ractx		v_un.vu_ractx
 typedef struct vnodelst vnodelst_t;
 typedef struct vnode vnode_t;
 #endif
 /*
  * Vnode flags.  The first set are locked by vnode lock or are stable.
  * VSYSTEM is only used to skip vflush()ing quota files.  VISTTY is used
  * when reading dead vnodes.
  */
 #define	VV_ROOT		0x00000001	/* root of its file system */
 #define	VV_SYSTEM	0x00000002	/* vnode being used by kernel */
 #define	VV_ISTTY	0x00000004	/* vnode represents a tty */
 #define	VV_MAPPED	0x00000008	/* vnode might have user mappings */
 #define	VV_MPSAFE	0x00000010	/* file system code is MP safe */
 #define	VV_LOCKSWORK	0x00000020	/* FS supports locking discipline */
 /*
  * The second set are locked by vp->v_interlock.
  */
 #define	VI_TEXT		0x00000100	/* vnode is a pure text prototype */
 #define	VI_EXECMAP	0x00000200	/* might have PROT_EXEC mappings */
 #define	VI_WRMAP	0x00000400	/* might have PROT_WRITE u. mappings */
 #define	VI_WRMAPDIRTY	0x00000800	/* might have dirty pages */
 #ifdef _VFS_VNODE_PRIVATE
 #define	VI_XLOCK	0x00001000	/* vnode is locked to change type */
 #endif	/* _VFS_VNODE_PRIVATE */
 #define	VI_ONWORKLST	0x00004000	/* On syncer work-list */
 #ifdef _VFS_VNODE_PRIVATE
 #define	VI_MARKER	0x00008000	/* Dummy marker vnode */
 #endif	/* _VFS_VNODE_PRIVATE */
 #ifdef _VFS_VNODE_PRIVATE
 #define	VI_CLEAN	0x00080000	/* has been reclaimed */
 #define	VI_CHANGING	0x00100000	/* vnode changes state */
 #endif	/* _VFS_VNODE_PRIVATE */
 /*
  * The third set are locked by the underlying file system.
  */
 #define	VU_DIROP	0x01000000	/* LFS: involved in a directory op */
 #define	VNODE_FLAGBITS \
     "\20\1ROOT\2SYSTEM\3ISTTY\4MAPPED\5MPSAFE\6LOCKSWORK\11TEXT\12EXECMAP" \
     "\13WRMAP\14WRMAPDIRTY\15XLOCK\17ONWORKLST\20MARKER" \
     "\24CLEAN\25CHANGING\31DIROP"
 #define	VSIZENOTSET	((voff_t)-1)
 /*
  * vnode lock flags
  */
 #define	LK_SHARED	0x00000001	/* shared lock */
 #define	LK_EXCLUSIVE	0x00000002	/* exclusive lock */
 #define	LK_NOWAIT	0x00000010	/* do not sleep to await lock */
 #define	LK_RETRY	0x00020000	/* vn_lock: retry until locked */
 /*
  * Vnode attributes.  A field value of VNOVAL represents a field whose value
  * is unavailable (getattr) or which is not to be changed (setattr).
  */
 struct vattr {
 	enum vtype	va_type;	/* vnode type (for create) */
 	mode_t		va_mode;	/* files access mode and type */
 	nlink_t		va_nlink;	/* number of references to file */
 	uid_t		va_uid;		/* owner user id */
 	gid_t		va_gid;		/* owner group id */
 	dev_t		va_fsid;	/* file system id (dev for now) */
 	ino_t		va_fileid;	/* file id */
 	u_quad_t	va_size;	/* file size in bytes */
 	long		va_blocksize;	/* blocksize preferred for i/o */
 	struct timespec	va_atime;	/* time of last access */
 	struct timespec	va_mtime;	/* time of last modification */
 	struct timespec	va_ctime;	/* time file changed */
 	struct timespec va_birthtime;	/* time file created */
 	u_long		va_gen;		/* generation number of file */
 	u_long		va_flags;	/* flags defined for file */
 	dev_t		va_rdev;	/* device the special file represents */
 	u_quad_t	va_bytes;	/* bytes of disk space held by file */
 	u_quad_t	va_filerev;	/* file modification number */
 	u_int		va_vaflags;	/* operations flags, see below */
 	long		va_spare;	/* remain quad aligned */
 };
 /*
  * Flags for va_vaflags.
  */
 #define	VA_UTIMES_NULL	0x01		/* utimes argument was NULL */
 #define	VA_EXCLUSIVE	0x02		/* exclusive create request */
 #ifdef _KERNEL
 /*
  * Flags for ioflag.
  */
 #define	IO_UNIT		0x00010		/* do I/O as atomic unit */
 #define	IO_APPEND	0x00020		/* append write to end */
 #define	IO_SYNC		(0x40|IO_DSYNC)	/* sync I/O file integrity completion */
 #define	IO_NODELOCKED	0x00080		/* underlying node already locked */
 #define	IO_NDELAY	0x00100		/* FNDELAY flag set in file table */
 #define	IO_DSYNC	0x00200		/* sync I/O data integrity completion */
 #define	IO_ALTSEMANTICS	0x00400		/* use alternate i/o semantics */
 #define	IO_NORMAL	0x00800		/* operate on regular data */
 #define	IO_EXT		0x01000		/* operate on extended attributes */
 #define	IO_DIRECT	0x02000		/* direct I/O hint */
 #define	IO_JOURNALLOCKED 0x04000	/* journal is already locked */
 #define	IO_ADV_MASK	0x00003		/* access pattern hint */
 #define	IO_ADV_SHIFT	0
 #define	IO_ADV_ENCODE(adv)	(((adv) << IO_ADV_SHIFT) & IO_ADV_MASK)
 #define	IO_ADV_DECODE(ioflag)	(((ioflag) & IO_ADV_MASK) >> IO_ADV_SHIFT)
 /*
  *  Modes.
  */
 #define	VREAD	00004		/* read, write, execute permissions */
 #define	VWRITE	00002
 #define	VEXEC	00001
 /*
  * Token indicating no attribute value yet assigned.
  */
 #define	VNOVAL	(-1)
 /*
  * Convert between vnode types and inode formats (since POSIX.1
  * defines mode word of stat structure in terms of inode formats).
  */
 extern const enum vtype	iftovt_tab[];
 extern const int	vttoif_tab[];
 #define	IFTOVT(mode)	(iftovt_tab[((mode) & S_IFMT) >> 12])
 #define	VTTOIF(indx)	(vttoif_tab[(int)(indx)])
 #define	MAKEIMODE(indx, mode)	(int)(VTTOIF(indx) | (mode))
 /*
  * Flags to various vnode functions.
  */
 #define	SKIPSYSTEM	0x0001		/* vflush: skip vnodes marked VSYSTEM */
 #define	FORCECLOSE	0x0002		/* vflush: force file closeure */
 #define	WRITECLOSE	0x0004		/* vflush: only close writable files */
 #define	V_SAVE		0x0001		/* vinvalbuf: sync file first */
 /*
  * Flags to various vnode operations.
  */
 #define	REVOKEALL	0x0001		/* revoke: revoke all aliases */
 #define	FSYNC_WAIT	0x0001		/* fsync: wait for completion */
 #define	FSYNC_DATAONLY	0x0002		/* fsync: hint: sync file data only */
 #define	FSYNC_RECLAIM	0x0004		/* fsync: hint: vnode is being reclaimed */
 #define	FSYNC_LAZY	0x0008		/* fsync: lazy sync (trickle) */
 #define	FSYNC_NOLOG	0x0010		/* fsync: do not flush the log */
 #define	FSYNC_CACHE	0x0100		/* fsync: flush disk caches too */
 #define	UPDATE_WAIT	0x0001		/* update: wait for completion */
 #define	UPDATE_DIROP	0x0002		/* update: hint to fs to wait or not */
 #define	UPDATE_CLOSE	0x0004		/* update: clean up on close */
 #define VDEAD_NOWAIT	0x0001		/* vdead_check: do not sleep */
 void holdrelel(struct vnode *);
 void vholdl(struct vnode *);
 void vref(struct vnode *);
 static __inline void holdrele(struct vnode *) __unused;
 static __inline void vhold(struct vnode *) __unused;
 /*
  * decrease buf or page ref
  */
 static __inline void
 holdrele(struct vnode *vp)
+{
 	mutex_enter(vp->v_interlock);
 	holdrelel(vp);
 	mutex_exit(vp->v_interlock);
+}
 /*
  * increase buf or page ref
  */
 static __inline void
 vhold(struct vnode *vp)
+{
 	mutex_enter(vp->v_interlock);
 	vholdl(vp);
 	mutex_exit(vp->v_interlock);
+}
 #define	NULLVP	((struct vnode *)NULL)
 static __inline void
 VN_KNOTE(struct vnode *vp, long hint)
+{
 	mutex_enter(vp->v_interlock);
 	KNOTE(&vp->v_klist, hint);
 	mutex_exit(vp->v_interlock);
+}
 /*
  * Global vnode data.
  */
 extern struct vnode	*rootvnode;	/* root (i.e. "/") vnode */
 extern int		desiredvnodes;	/* number of vnodes desired */
 extern u_int		numvnodes;	/* current number of vnodes */
 #endif /* _KERNEL */
 /*
  * Mods for exensibility.
  */
 /*
  * Flags for vdesc_flags:
  */
 #define	VDESC_MAX_VPS		8
 /* Low order 16 flag bits are reserved for willrele flags for vp arguments. */
 #define	VDESC_VP0_WILLRELE	0x00000001
 #define	VDESC_VP1_WILLRELE	0x00000002
 #define	VDESC_VP2_WILLRELE	0x00000004
 #define	VDESC_VP3_WILLRELE	0x00000008
 #define	VDESC_VP0_WILLUNLOCK	0x00000100
 #define	VDESC_VP1_WILLUNLOCK	0x00000200
 #define	VDESC_VP2_WILLUNLOCK	0x00000400
 #define	VDESC_VP3_WILLUNLOCK	0x00000800
 #define	VDESC_VP0_WILLPUT	0x00000101
 #define	VDESC_VP1_WILLPUT	0x00000202
 #define	VDESC_VP2_WILLPUT	0x00000404
 #define	VDESC_VP3_WILLPUT	0x00000808
 /*
  * VDESC_NO_OFFSET is used to identify the end of the offset list
  * and in places where no such field exists.
  */
 #define	VDESC_NO_OFFSET -1
 /*
  * This structure describes the vnode operation taking place.
  */
 struct vnodeop_desc {
 	int		vdesc_offset;	/* offset in vector--first for speed */
 	const char	*vdesc_name;	/* a readable name for debugging */
 	int		vdesc_flags;	/* VDESC_* flags */
 	/*
 	 * These ops are used by bypass routines to map and locate arguments.
 	 * Creds and procs are not needed in bypass routines, but sometimes
 	 * they are useful to (for example) transport layers.
 	 * Nameidata is useful because it has a cred in it.
 	 */
 	const int	*vdesc_vp_offsets;	/* list ended by VDESC_NO_OFFSET */
 	int		vdesc_vpp_offset;	/* return vpp location */
 	int		vdesc_cred_offset;	/* cred location, if any */
 	int		vdesc_componentname_offset; /* if any */
 };
 #ifdef _KERNEL
 /*
  * Interlock for scanning list of vnodes attached to a mountpoint
  */
 extern kmutex_t		mntvnode_lock;
 /*
  * Union filesystem hook for vn_readdir().
  */
 extern int (*vn_union_readdir_hook) (struct vnode **, struct file *, struct lwp *);
 /*
  * Macros for offsets in the vdesc struct.
  */
 #define	VOPARG_OFFSETOF(type, member)	offsetof(type, member)
 #define	VOPARG_OFFSETTO(type,offset,sp)	((type)(((char *)(sp)) + (offset)))
 /*
  * This structure is used to configure the new vnodeops vector.
  */
 struct vnodeopv_entry_desc {
 	const struct vnodeop_desc *opve_op;	/* which operation this is */
 	int (*opve_impl)(void *);	/* code implementing this operation */
 };
 struct vnodeopv_desc {
 			/* ptr to the ptr to the vector where op should go */
 	int (***opv_desc_vector_p)(void *);
 	const struct vnodeopv_entry_desc *opv_desc_ops; /* null terminated list */
 };
 /*
  * A default routine which just returns an error.
  */
 int vn_default_error(void *);
 /*
  * A generic structure.
  * This can be used by bypass routines to identify generic arguments.
  */
 struct vop_generic_args {
 	struct vnodeop_desc *a_desc;
 	/* other random data follows, presumably */
 };
 /*
  * VOCALL calls an op given an ops vector.  We break it out because BSD's
  * vclean changes the ops vector and then wants to call ops with the old
  * vector.
  */
 /*
  * actually, vclean doesn't use it anymore, but nfs does,
  * for device specials and fifos.
  */
 #define	VOCALL(OPSV,OFF,AP) (( *((OPSV)[(OFF)])) (AP))
 /*
  * This call works for vnodes in the kernel.
  */
 #define	VCALL(VP,OFF,AP) VOCALL((VP)->v_op,(OFF),(AP))
 #define	VDESC(OP) (& __CONCAT(OP,_desc))
 #define	VOFFSET(OP) (VDESC(OP)->vdesc_offset)
 /* XXX This include should go away */
 #include <sys/mount.h>
 /*
  * Finally, include the default set of vnode operations.
  */
 #include <sys/vnode_if.h>
 /*
  * Public vnode manipulation functions.
  */
 struct file;
 struct filedesc;
 struct nameidata;
 struct proc;
 struct stat;
 struct uio;
 struct vattr;
 struct vnode;
 /* see vnode(9) */
 void	vfs_vnode_sysinit(void);
 int 	bdevvp(dev_t, struct vnode **);
 int 	cdevvp(dev_t, struct vnode **);
 int	vaccess(enum vtype, mode_t, uid_t, gid_t, mode_t, kauth_cred_t);
 void 	vattr_null(struct vattr *);
 void	vdevgone(int, int, int, enum vtype);
 int	vfinddev(dev_t, enum vtype, struct vnode **);
 int	vflush(struct mount *, struct vnode *, int);
 int	vflushbuf(struct vnode *, int);
 int 	vget(struct vnode *, int, bool);
 void 	vgone(struct vnode *);
 int	vinvalbuf(struct vnode *, int, kauth_cred_t, struct lwp *, bool, int);
 void	vprint(const char *, struct vnode *);
 void 	vput(struct vnode *);
 bool	vrecycle(struct vnode *);
 void 	vrele(struct vnode *);
 void 	vrele_async(struct vnode *);
 void	vrele_flush(void);
 int	vtruncbuf(struct vnode *, daddr_t, bool, int);
 void	vwakeup(struct buf *);
 int	vdead_check(struct vnode *, int);
 void	vrevoke(struct vnode *);
 struct vnode *
 	vnalloc(struct mount *);
 void	vnfree(struct vnode *);
 void	vremfree(struct vnode *);
 int	vcache_get(struct mount *, const void *, size_t, struct vnode **);
 int	vcache_new(struct mount *, struct vnode *,
 	    struct vattr *, kauth_cred_t, struct vnode **);
 int	vcache_rekey_enter(struct mount *, struct vnode *,
 	    const void *, size_t, const void *, size_t);
 void	vcache_rekey_exit(struct mount *, struct vnode *,
 	    const void *, size_t, const void *, size_t);
 void	vcache_remove(struct mount *, const void *, size_t);
 /* see vnsubr(9) */
 int	vn_bwrite(void *);
 int 	vn_close(struct vnode *, int, kauth_cred_t);
 int	vn_isunder(struct vnode *, struct vnode *, struct lwp *);
 int	vn_lock(struct vnode *, int);
 void	vn_markexec(struct vnode *);
 int	vn_marktext(struct vnode *);
 int 	vn_open(struct nameidata *, int, int);
 int 	vn_rdwr(enum uio_rw, struct vnode *, void *, int, off_t, enum uio_seg,
     int, kauth_cred_t, size_t *, struct lwp *);
 int	vn_readdir(struct file *, char *, int, u_int, int *, struct lwp *,
     off_t **, int *);
 int	vn_stat(struct vnode *, struct stat *);
 int	vn_kqfilter(struct file *, struct knote *);
 int	vn_writechk(struct vnode *);
 int	vn_openchk(struct vnode *, kauth_cred_t, int);
 int	vn_extattr_get(struct vnode *, int, int, const char *, size_t *,
 	    void *, struct lwp *);
 int	vn_extattr_set(struct vnode *, int, int, const char *, size_t,
 	    const void *, struct lwp *);
 int	vn_extattr_rm(struct vnode *, int, int, const char *, struct lwp *);
 void	vn_ra_allocctx(struct vnode *);
 int	vn_fifo_bypass(void *);
 /* initialise global vnode management */
 void	vntblinit(void);
 /* misc stuff */
 void	sched_sync(void *);
 void	vn_syncer_add_to_worklist(struct vnode *, int);
 void	vn_syncer_remove_from_worklist(struct vnode *);
 int	dorevoke(struct vnode *, kauth_cred_t);
 int	rawdev_mounted(struct vnode *, struct vnode **);
 uint8_t	vtype2dt(enum vtype);
 /* see vfssubr(9) */
 void	vfs_getnewfsid(struct mount *);
 int	vfs_drainvnodes(long);
 void	vfs_timestamp(struct timespec *);
 #if defined(DDB) || defined(DEBUGPRINT)
 void	vfs_vnode_print(struct vnode *, int, void (*)(const char *, ...)
     __printflike(1, 2));
 void	vfs_mount_print(struct mount *, int, void (*)(const char *, ...)
     __printflike(1, 2));
 #endif /* DDB */
 #endif /* _KERNEL */
 #endif /* !_SYS_VNODE_H_ */

 @@ -1,268 +1,270 @@
-/*	$NetBSD: wapbl.h,v 1.16 2014/09/05 05:42:50 matt Exp $	*/
+/*	$NetBSD: wapbl.h,v 1.17 2016/01/23 16:02:09 christos Exp $	*/
 /*-
  * Copyright (c) 2003,2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Wasabi Systems, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _SYS_WAPBL_H
 #define	_SYS_WAPBL_H
 #include <sys/mutex.h>
 #if defined(_KERNEL) || defined(_KMEMUSER)
 #include <miscfs/specfs/specdev.h>
 #endif
 /* This header file describes the api and data structures for
  * write ahead physical block logging (WAPBL) support.
  */
 #if defined(_KERNEL_OPT)
 #include "opt_wapbl.h"
 #endif
 #ifdef WAPBL_DEBUG
 #ifndef WAPBL_DEBUG_PRINT
 #define	WAPBL_DEBUG_PRINT (WAPBL_PRINT_REPLAY | WAPBL_PRINT_OPEN)
 #endif
 #if 0
 #define	WAPBL_DEBUG_BUFBYTES
 #endif
 #endif
 #ifdef WAPBL_DEBUG_PRINT
 enum {
 	WAPBL_PRINT_OPEN = 0x1,
 	WAPBL_PRINT_FLUSH = 0x2,
 	WAPBL_PRINT_TRUNCATE = 0x4,
 	WAPBL_PRINT_TRANSACTION = 0x8,
 	WAPBL_PRINT_BUFFER = 0x10,
 	WAPBL_PRINT_BUFFER2 = 0x20,
 	WAPBL_PRINT_ALLOC = 0x40,
 	WAPBL_PRINT_INODE = 0x80,
 	WAPBL_PRINT_WRITE = 0x100,
 	WAPBL_PRINT_IO = 0x200,
 	WAPBL_PRINT_REPLAY = 0x400,
 	WAPBL_PRINT_ERROR = 0x800,
 	WAPBL_PRINT_DISCARD = 0x1000,
 	WAPBL_PRINT_BIODONE = 0x2000,
 };
 #define	WAPBL_PRINTF(mask, a) if (wapbl_debug_print & (mask)) printf  a
 extern int wapbl_debug_print;
 #else
 #define	WAPBL_PRINTF(mask, a)
 #endif
 /****************************************************************/
 #include <sys/queue.h>
 #include <sys/vnode.h>
 #include <sys/buf.h>
 #ifdef _KERNEL
 struct wapbl_entry;
 struct wapbl_replay;
 struct wapbl;
 typedef void (*wapbl_flush_fn_t)(struct mount *, daddr_t *, int *, int);
 /*
  * This structure holds per transaction log information
  */
 struct wapbl_entry {
 	struct wapbl *we_wapbl;
 	SIMPLEQ_ENTRY(wapbl_entry) we_entries;
 	size_t we_bufcount;		/* Count of unsynced buffers */
 	size_t we_reclaimable_bytes;	/* Number on disk bytes for this
 					   transaction */
 	int	we_error;
 #ifdef WAPBL_DEBUG_BUFBYTES
 	size_t we_unsynced_bufbytes;	/* Byte count of unsynced buffers */
 #endif
 };
 /* Start using a log */
 int	wapbl_start(struct wapbl **, struct mount *, struct vnode *, daddr_t,
 		    size_t, size_t, struct wapbl_replay *,
 		    wapbl_flush_fn_t, wapbl_flush_fn_t);
 /* Discard the current transaction, potentially dangerous */
 void	wapbl_discard(struct wapbl *);
 /* stop using a log */
 int	wapbl_stop(struct wapbl *, int);
 /*
  * Begin a new transaction or increment transaction recursion
  * level if called while a transaction is already in progress
  * by the current process.
  */
 int	wapbl_begin(struct wapbl *, const char *, int);
 /* End a transaction or decrement the transaction recursion level */
 void	wapbl_end(struct wapbl *);
 /*
  * Add a new buffer to the current transaction.  The buffers
  * data will be copied to the current transaction log and the
  * buffer will be marked B_LOCKED so that it will not be
  * flushed to disk by the syncer or reallocated.
  */
 void	wapbl_add_buf(struct wapbl *, struct buf *);
 /* Remove a buffer from the current transaction. */
 void	wapbl_remove_buf(struct wapbl *, struct buf *);
 void	wapbl_resize_buf(struct wapbl *, struct buf *, long, long);
 /*
  * This will flush all completed transactions to disk and
  * start asynchronous writes on the associated buffers
  */
 int	wapbl_flush(struct wapbl *, int);
 /*
  * Inodes that are allocated but have zero link count
  * must be registered with the current transaction
  * so they may be recorded in the log and cleaned up later.
  * registration/unregistration of ino numbers already registered is ok.
  */
 void	wapbl_register_inode(struct wapbl *, ino_t, mode_t);
 void	wapbl_unregister_inode(struct wapbl *, ino_t, mode_t);
 /*
  * Metadata block deallocations must be registered so
  * that revocations records can be written and to prevent
  * the corresponding blocks from being reused as data
  * blocks until the log is on disk.
  */
 void	wapbl_register_deallocation(struct wapbl *, daddr_t, int);
 void	wapbl_jlock_assert(struct wapbl *wl);
 void	wapbl_junlock_assert(struct wapbl *wl);
 void	wapbl_print(struct wapbl *wl, int full, void (*pr)(const char *, ...)
     __printflike(1, 2));
 #if defined(WAPBL_DEBUG) || defined(DDB)
 void	wapbl_dump(struct wapbl *);
 #endif
 void	wapbl_biodone(struct buf *);
 extern struct wapbl_ops wapbl_ops;
 static __inline struct mount *
 wapbl_vptomp(struct vnode *vp)
+{
 	struct mount *mp;
 	mp = NULL;
 	if (vp != NULL) {
 		if (vp->v_type == VBLK)
 			mp = spec_node_getmountedfs(vp);
 		else
 			mp = vp->v_mount;
+	}
 	return mp;
+}
 static __inline bool
 wapbl_vphaswapbl(struct vnode *vp)
+{
 	struct mount *mp;
 	if (vp == NULL)
 		return false;
 	mp = wapbl_vptomp(vp);
 	return mp && mp->mnt_wapbl;
+}
 #endif /* _KERNEL */
 /****************************************************************/
 /* Replay support */
 #ifdef WAPBL_INTERNAL
 LIST_HEAD(wapbl_blk_head, wapbl_blk);
 struct wapbl_replay {
 	struct vnode *wr_logvp;
 	struct vnode *wr_devvp;
 	daddr_t wr_logpbn;
 	int wr_log_dev_bshift;
 	int wr_fs_dev_bshift;
 	int64_t wr_circ_off;
 	int64_t wr_circ_size;
 	uint32_t wr_generation;
 	void *wr_scratch;
 	struct wapbl_blk_head *wr_blkhash;
 	u_long wr_blkhashmask;
 	int wr_blkhashcnt;
 	off_t wr_inodeshead;
 	off_t wr_inodestail;
 	int wr_inodescnt;
 	struct {
 		uint32_t wr_inumber;
 		uint32_t wr_imode;
 	} *wr_inodes;
 };
 #define	wapbl_replay_isopen(wr) ((wr)->wr_scratch != 0)
 /* Supply this to provide i/o support */
 int wapbl_write(void *, size_t, struct vnode *, daddr_t);
 int wapbl_read(void *, size_t, struct vnode *, daddr_t);
 /****************************************************************/
 #else
 struct wapbl_replay;
 #endif /* WAPBL_INTERNAL */
 /****************************************************************/
 int	wapbl_replay_start(struct wapbl_replay **, struct vnode *,
 	daddr_t, size_t, size_t);
 void	wapbl_replay_stop(struct wapbl_replay *);
 void	wapbl_replay_free(struct wapbl_replay *);
 int	wapbl_replay_write(struct wapbl_replay *, struct vnode *);
 int	wapbl_replay_can_read(struct wapbl_replay *, daddr_t, long);
 int	wapbl_replay_read(struct wapbl_replay *, void *, daddr_t, long);
 /****************************************************************/
 #endif /* !_SYS_WAPBL_H */