/*- * SPDX-License-Identifier: BSD-3-Clause * * 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. */ #ifndef FAT_VNODE_H #define FAT_VNODE_H // Modified to support the Haiku FAT driver. #ifdef FS_SHELL #include "fssh_api_wrapper.h" #else #include <fs_interface.h> #include <lock.h> #endif #include "sys/buf.h" #include "sys/bufobj.h" #include "sys/lockmgr.h" #include "sys/namei.h" #include "sys/ucred.h" #include "fs/msdosfs/direntry.h" #include "fs/msdosfs/denode.h" #include "dosfs.h" // In the Haiku port, one struct vnode per volume is set up to represent its device file. // It will have type VBLK. All other struct vnodes (those that actually represent // files on the volume) will have type VREG or VDIR. enum vtype { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD, VMARKER }; #define VLASTTYPE VMARKER enum vstate { VSTATE_UNINITIALIZED, VSTATE_CONSTRUCTED, VSTATE_DESTROYING, VSTATE_DEAD }; #define VLASTSTATE VSTATE_DEAD /* * Reading or writing any of these items requires holding the appropriate lock. * * Lock reference: * u - Only a reference to the vnode is needed to read. * v - vnode lock * */ struct vnode { /* * Fields which define the identity of the vnode. */ enum vtype v_type : 8; /* u vnode type */ enum vstate v_state : 8; /* u vnode state */ void* v_data; /* u private data for fs */ /* * Filesystem instance stuff */ struct mount* v_mount; /* u ptr to vfs we are in */ /* * Type specific fields, only one applies to any given vnode. */ union { struct cdev* v_rdev; /* v device (VCHR, VBLK) */ }; /* * Locking */ struct lock v_lock; /* u (if fs don't have one) */ struct lock* v_vnlock; /* u pointer to vnode lock */ /* * The machinery of being a vnode */ struct bufobj v_bufobj; /* * Buffer cache object */ /* * Hooks for various subsystems and features. */ u_short v_vflag; /* v vnode flags */ // Members added for Haiku port ino_t v_parent; /* v inode of parent directory */ const char* v_mime; /* v mime type for VREG nodes, otherwise NULL */ void* v_cache; /* v file cache for VREG nodes, otherwise NULL */ void* v_file_map; /* v file map for VREG nodes, otherwise NULL */ bool v_resizing; /* v disable IO (see comment in dosfs_wstat) */ bool v_sync; /* v use synchronous IO */ }; /* * Vnode flags. * VV flags are protected by the vnode lock and live in v_vflag */ #define VV_ROOT 0x0001 /* root of its filesystem */ /* * Flags for ioflag. */ #define IO_SYNC 0x0080 /* do I/O synchronously */ /* * Flags for accmode_t. */ #define VEXEC 000000000100 /* execute/search permission */ #define VWRITE 000000000200 /* write permission */ #define VREAD 000000000400 /* read permission */ #define VREF(vp) vref(vp) #define VN_LOCK_AREC(vp) lockallowrecurse((vp)->v_vnlock) /*! Verify vp is exclusively (i.e. write) locked. */ static inline void assert_vop_elocked(struct vnode* vp, const char* str) { if (vp == NULL) return; ASSERT_WRITE_LOCKED_RW_LOCK(&vp->v_vnlock->haikuRW); } #define ASSERT_VOP_ELOCKED(vp, str) assert_vop_elocked((vp), (str)) // In FreeBSD, this verifies that vp is either write-locked or read-locked. In Haiku, there is no // equivalent assert. #define ASSERT_VOP_LOCKED(vp, str) ((void)0) #define DOINGASYNC(vp) (((vp)->v_mount->mnt_flag & MNT_ASYNC) != 0) // FreeBSD would generate vnode_if.h, vnode_if_typedef.h, and vnode_if_newproto.h at build time // and #include them here (the latter two indirectly via the first). // For the Haiku port, vnode_if.h was generated manually by running a script: // sys/tools/vnode_if.awk sys/kern/vnode_if.src -h // and vnode_if_typedef.h by running: // sys/tools/vnode_if.awk sys/kern/vnode_if.src -q // and vnode_if_newproto.h by running: // sys/tools/vnode_if.awk sys/kern/vnode_if.src -p // Modified excerpts from these headers are pasted below. // This struct is referenced by the ported code but has no effect in the Haiku port. struct vop_vector { }; static inline int VOP_ACCESS(struct vnode* vp, accmode_t accmode, struct ucred* cred, thread_id td) { struct mount* bsdVolume = (struct mount*)vp->v_mount; int mode = 0; if ((accmode & VREAD) != 0) mode |= R_OK; if ((accmode & VWRITE) != 0) mode |= W_OK; if ((accmode & VEXEC) != 0) mode |= X_OK; return B_TO_POSIX_ERROR(_dosfs_access(bsdVolume, vp, mode)); } static inline int VOP_UNLOCK(struct vnode* vp) { lockmgr(vp->v_vnlock, LK_RELEASE, NULL); return 0; } // End of vnode_if.h content typedef int (*vn_get_ino_t)(struct mount*, void*, int, struct vnode**); typedef int vfs_hash_cmp_t(struct vnode* vp, void* arg); int vfs_hash_get(struct mount* mp, uint64 hash, int flags, thread_id td, struct vnode** vpp, vfs_hash_cmp_t* fn, void* arg); int vfs_hash_insert(struct vnode* vp, uint64 hash, int flags, thread_id td, struct vnode** vpp, vfs_hash_cmp_t* fn, void* arg); void vfs_hash_rehash(struct vnode* vp, uint64 hash); void vfs_hash_remove(struct vnode* vp); struct componentname; void cache_enter(struct vnode* dvp, struct vnode* vp, struct componentname* cnp); int getnewvnode(const char* tag, struct mount* mp, struct vop_vector* vops, struct vnode** vpp); /*! In FreeBSD, this tells the VFS to add vp to its list of mp's nodes. In Haiku, the equivalent actions are done automatically as part of get_vnode / publish_vnode. */ static inline int insmntque(struct vnode* vp, struct mount* mp) { return 0; } /*! In FreeBSD, this generates a serial number based on system time. The driver uses it to initialize denode::de_modrev. However, in the Haiku port, de_modrev is ignored. */ static inline u_quad_t init_va_filerev(void) { return 0; } /*! Put a ref to vp and write-unlock it. */ static inline void vput(struct vnode* vp) { // The driver might call vput to balance a getnewvnode() call. The getnewvnode stand-in // written for the Haiku port, which leaves the node in VSTATE_UNINITIALIZED, doesn't get a // ref to the node though. if (vp->v_state != VSTATE_UNINITIALIZED) put_vnode(vp->v_mount->mnt_fsvolume, VTODE(vp)->de_inode); rw_lock_write_unlock(&vp->v_vnlock->haikuRW); } /*! Put a ref to vp. */ static inline void vrele(struct vnode* vp) { put_vnode(vp->v_mount->mnt_fsvolume, VTODE(vp)->de_inode); } /*! Get a ref to vp. */ static inline void vref(struct vnode* vp) { acquire_vnode(vp->v_mount->mnt_fsvolume, VTODE(vp)->de_inode); } /*! Get the node ref count from the VFS. Not implemented in Haiku port (function is used in driver but only for debug output). */ static __inline int vrefcnt(struct vnode* vp) { return -1; } int vget(struct vnode* vp, int flags); /*! Prepare the VFS to discard vp. */ static inline void vgone(struct vnode* vp) { remove_vnode(vp->v_mount->mnt_fsvolume, VTODE(vp)->de_inode); } int vtruncbuf(struct vnode* vp, off_t length, int blksize); int vn_fsync_buf(struct vnode* vp, int waitfor); int vn_vget_ino_gen(struct vnode* vp, vn_get_ino_t alloc, void* alloc_arg, int lkflags, struct vnode** rvp); void vfs_timestamp(struct timespec* tsp); static inline void vn_set_state(struct vnode* vp, enum vstate state) { vp->v_state = state; } #endif // FAT_VNODE_H
