/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2014 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#include <sys/cdefs.h>
#ifdef KERNEL
#include <sys/kernel_types.h>
+#include <sys/param.h>
#include <sys/signal.h>
#endif
/*
* Vnode types. VNON means no type.
*/
-enum vtype { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD, VSTR,
- VCPLX };
+enum vtype {
+ /* 0 */
+ VNON,
+ /* 1 - 5 */
+ VREG, VDIR, VBLK, VCHR, VLNK,
+ /* 6 - 10 */
+ VSOCK, VFIFO, VBAD, VSTR, VCPLX
+};
/*
* Vnode tag types.
* 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_HFS, VT_ZFS, VT_DEVFS, VT_WEBDAV, VT_UDF, VT_AFP,
- VT_CDDA, VT_CIFS, VT_OTHER};
+ /* 0 */
+ VT_NON,
+ /* 1 reserved, overlaps with (CTL_VFS, VFS_NUMMNTOPS) */
+ VT_UFS,
+ /* 2 - 5 */
+ VT_NFS, VT_MFS, VT_MSDOSFS, VT_LFS,
+ /* 6 - 10 */
+ VT_LOFS, VT_FDESC, VT_PORTAL, VT_NULL, VT_UMAP,
+ /* 11 - 15 */
+ VT_KERNFS, VT_PROCFS, VT_AFS, VT_ISOFS, VT_MOCKFS,
+ /* 16 - 20 */
+ VT_HFS, VT_ZFS, VT_DEVFS, VT_WEBDAV, VT_UDF,
+ /* 21 - 24 */
+ VT_AFP, VT_CDDA, VT_CIFS, VT_OTHER
+};
/*
#define IO_BACKGROUND IO_PASSIVE /* used for backward compatibility. to be removed after IO_BACKGROUND is no longer
* used by DiskImages in-kernel mode */
#define IO_NOAUTH 0x8000 /* No authorization checks. */
-
+#define IO_NODIRECT 0x10000 /* don't use direct synchronous writes if IO_NOCACHE is specified */
+#define IO_ENCRYPTED 0x20000 /* Retrieve encrypted blocks from the filesystem */
+#define IO_RETURN_ON_THROTTLE 0x40000
+#define IO_SINGLE_WRITER 0x80000
+#define IO_SYSCALL_DISPATCH 0x100000 /* I/O was originated from a file table syscall */
+#define IO_SWAP_DISPATCH 0x200000 /* I/O was originated from the swap layer */
+#define IO_SKIP_ENCRYPTION 0x400000 /* Skips en(de)cryption on the IO. Must be initiated from kernel */
/*
* Component Name: this structure describes the pathname
uint32_t cn_flags; /* flags (see below) */
#ifdef BSD_KERNEL_PRIVATE
vfs_context_t cn_context;
- void * pad_obsolete2;
+ struct nameidata *cn_ndp; /* pointer back to nameidata */
/* XXX use of these defines are deprecated */
#define cn_proc (cn_context->vc_proc + 0) /* non-lvalue */
#define cn_cred (cn_context->vc_ucred + 0) /* non-lvalue */
#else
- void * obsolete1; /* use vfs_context_t */
- void * obsolete2; /* use vfs_context_t */
+ void * cn_reserved1; /* use vfs_context_t */
+ void * cn_reserved2; /* use vfs_context_t */
#endif
/*
* Shared between lookup and commit routines.
* component name operational modifier flags
*/
#define FOLLOW 0x00000040 /* follow symbolic links */
-#define NOTRIGGER 0x10000000 /* don't trigger automounts */
/*
* component name parameter descriptors.
#define ISDOTDOT 0x00002000 /* current component name is .. */
#define MAKEENTRY 0x00004000 /* entry is to be added to name cache */
#define ISLASTCN 0x00008000 /* this is last component of pathname */
-#define ISWHITEOUT 0x00020000 /* found whiteout */
-#define DOWHITEOUT 0x00040000 /* do whiteouts */
-
/* The following structure specifies a vnode for creation */
struct vnode_fsparam {
#define VNCREATE_FLAVOR 0
#define VCREATESIZE sizeof(struct vnode_fsparam)
+
+#ifdef KERNEL_PRIVATE
+/*
+ * Resolver callback SPI for trigger vnodes
+ *
+ * Only available from kernels built with CONFIG_TRIGGERS option
+ */
+
+/*!
+ @enum Pathname Lookup Operations
+ @abstract Constants defining pathname operations (passed to resolver callbacks)
+ */
+enum path_operation {
+ OP_LOOKUP,
+ OP_MOUNT,
+ OP_UNMOUNT,
+ OP_STATFS,
+ OP_OPEN,
+ OP_LINK,
+ OP_UNLINK,
+ OP_RENAME,
+ OP_CHDIR,
+ OP_CHROOT,
+ OP_MKNOD,
+ OP_MKFIFO,
+ OP_SYMLINK,
+ OP_ACCESS,
+ OP_PATHCONF,
+ OP_READLINK,
+ OP_GETATTR,
+ OP_SETATTR,
+ OP_TRUNCATE,
+ OP_COPYFILE,
+ OP_MKDIR,
+ OP_RMDIR,
+ OP_REVOKE,
+ OP_EXCHANGEDATA,
+ OP_SEARCHFS,
+ OP_FSCTL,
+ OP_GETXATTR,
+ OP_SETXATTR,
+ OP_REMOVEXATTR,
+ OP_LISTXATTR,
+ OP_MAXOP /* anything beyond previous entry is invalid */
+};
+
+/*!
+ @enum resolver status
+ @abstract Constants defining resolver status
+ @constant RESOLVER_RESOLVED the resolver has finished (typically means a successful mount)
+ @constant RESOLVER_NOCHANGE the resolver status didn't change
+ @constant RESOLVER_UNRESOLVED the resolver has finished (typically means a successful unmount)
+ @constant RESOLVER_ERROR the resolver encountered an error (errno passed in aux value)
+ @constant RESOLVER_STOP a request to destroy trigger XXX do we need this???
+ */
+enum resolver_status {
+ RESOLVER_RESOLVED,
+ RESOLVER_NOCHANGE,
+ RESOLVER_UNRESOLVED,
+ RESOLVER_ERROR,
+ RESOLVER_STOP
+};
+
+typedef uint64_t resolver_result_t;
+
+/*
+ * Compound resolver result
+ *
+ * The trigger vnode callbacks use a compound result value. In addition
+ * to the resolver status, it contains a sequence number and an auxiliary
+ * value.
+ *
+ * The sequence value is used by VFS to sequence-stamp trigger vnode
+ * state transitions. It is expected to be incremented each time a
+ * resolver changes state (ie resolved or unresolved). A result
+ * containing a stale sequence (older than a trigger vnode's current
+ * value) will be ignored by VFS.
+ *
+ * The auxiliary value is currently only used to deliver the errno
+ * value for RESOLVER_ERROR status conditions. When a RESOLVER_ERROR
+ * occurs, VFS will propagate this error back to the syscall that
+ * encountered the trigger vnode.
+ */
+extern resolver_result_t vfs_resolver_result(uint32_t seq, enum resolver_status stat, int aux);
+
+/*
+ * Extract values from a compound resolver result
+ */
+extern enum resolver_status vfs_resolver_status(resolver_result_t);
+extern uint32_t vfs_resolver_sequence(resolver_result_t);
+extern int vfs_resolver_auxiliary(resolver_result_t);
+
+
+/*!
+ @typedef trigger_vnode_resolve_callback_t
+ @abstract function prototype for a trigger vnode resolve callback
+ @discussion This function is associated with a trigger vnode during a vnode create. It is
+ typically called when a lookup operation occurs for a trigger vnode
+ @param vp The trigger vnode which needs resolving
+ @param cnp Various data about lookup, e.g. filename and state flags
+ @param pop The pathname operation that initiated the lookup (see enum path_operation).
+ @param flags
+ @param data Arbitrary data supplied by vnode trigger creator
+ @param ctx Context for authentication.
+ @return RESOLVER_RESOLVED, RESOLVER_NOCHANGE, RESOLVER_UNRESOLVED or RESOLVER_ERROR
+*/
+typedef resolver_result_t (* trigger_vnode_resolve_callback_t)(
+ vnode_t vp,
+ const struct componentname * cnp,
+ enum path_operation pop,
+ int flags,
+ void * data,
+ vfs_context_t ctx);
+
+/*!
+ @typedef trigger_vnode_unresolve_callback_t
+ @abstract function prototype for a trigger vnode unresolve callback
+ @discussion This function is associated with a trigger vnode during a vnode create. It is
+ called to unresolve a trigger vnode (typically this means unmount).
+ @param vp The trigger vnode which needs unresolving
+ @param flags Unmount flags
+ @param data Arbitrary data supplied by vnode trigger creator
+ @param ctx Context for authentication.
+ @return RESOLVER_NOCHANGE, RESOLVER_UNRESOLVED or RESOLVER_ERROR
+*/
+typedef resolver_result_t (* trigger_vnode_unresolve_callback_t)(
+ vnode_t vp,
+ int flags,
+ void * data,
+ vfs_context_t ctx);
+
+/*!
+ @typedef trigger_vnode_rearm_callback_t
+ @abstract function prototype for a trigger vnode rearm callback
+ @discussion This function is associated with a trigger vnode during a vnode create. It is
+ called to verify a rearm from VFS (i.e. should VFS rearm the trigger?).
+ @param vp The trigger vnode which needs rearming
+ @param flags
+ @param data Arbitrary data supplied by vnode trigger creator
+ @param ctx Context for authentication.
+ @return RESOLVER_NOCHANGE or RESOLVER_ERROR
+*/
+typedef resolver_result_t (* trigger_vnode_rearm_callback_t)(
+ vnode_t vp,
+ int flags,
+ void * data,
+ vfs_context_t ctx);
+
+/*!
+ @typedef trigger_vnode_reclaim_callback_t
+ @abstract function prototype for a trigger vnode reclaim callback
+ @discussion This function is associated with a trigger vnode during a vnode create. It is
+ called to deallocate private callback argument data
+ @param vp The trigger vnode associated with the data
+ @param data The arbitrary data supplied by vnode trigger creator
+*/
+typedef void (* trigger_vnode_reclaim_callback_t)(
+ vnode_t vp,
+ void * data);
+
+/*!
+ @function vnode_trigger_update
+ @abstract Update a trigger vnode's state.
+ @discussion This allows a resolver to notify VFS of a state change in a trigger vnode.
+ @param vp The trigger vnode whose information to update.
+ @param result A compound resolver result value
+ @return EINVAL if result value is invalid or vp isn't a trigger vnode
+ */
+extern int vnode_trigger_update(vnode_t vp, resolver_result_t result);
+
+struct vnode_trigger_info {
+ trigger_vnode_resolve_callback_t vti_resolve_func;
+ trigger_vnode_unresolve_callback_t vti_unresolve_func;
+ trigger_vnode_rearm_callback_t vti_rearm_func;
+ trigger_vnode_reclaim_callback_t vti_reclaim_func;
+ void * vti_data; /* auxiliary data (optional) */
+ uint32_t vti_flags; /* optional flags (see below) */
+};
+
+/*
+ * SPI for creating a trigger vnode
+ *
+ * Uses the VNCREATE_TRIGGER flavor with existing vnode_create() KPI
+ *
+ * Only one resolver per vnode.
+ *
+ * ERRORS (in addition to vnode_create errors):
+ * EINVAL (invalid resolver info, like invalid flags)
+ * ENOTDIR (only directories can have a resolver)
+ * EPERM (vnode cannot be a trigger - eg root dir of a file system)
+ * ENOMEM
+ */
+struct vnode_trigger_param {
+ struct vnode_fsparam vnt_params; /* same as for VNCREATE_FLAVOR */
+ trigger_vnode_resolve_callback_t vnt_resolve_func;
+ trigger_vnode_unresolve_callback_t vnt_unresolve_func;
+ trigger_vnode_rearm_callback_t vnt_rearm_func;
+ trigger_vnode_reclaim_callback_t vnt_reclaim_func;
+ void * vnt_data; /* auxiliary data (optional) */
+ uint32_t vnt_flags; /* optional flags (see below) */
+};
+
+#define VNCREATE_TRIGGER (('T' << 8) + ('V'))
+#define VNCREATE_TRIGGER_SIZE sizeof(struct vnode_trigger_param)
+
+/*
+ * vnode trigger flags (vnt_flags)
+ *
+ * VNT_AUTO_REARM:
+ * On unmounts of a trigger mount, automatically re-arm the trigger.
+ *
+ * VNT_NO_DIRECT_MOUNT:
+ * A trigger vnode instance that doesn't directly trigger a mount,
+ * instead it triggers the mounting of sub-trigger nodes.
+ */
+#define VNT_AUTO_REARM (1 << 0)
+#define VNT_NO_DIRECT_MOUNT (1 << 1)
+#define VNT_VALID_MASK (VNT_AUTO_REARM | VNT_NO_DIRECT_MOUNT)
+
+#endif /* KERNEL_PRIVATE */
+
+
/*
* Vnode attributes, new-style.
*
* Note that this structure may be extended, but existing fields must not move.
*/
-#define VATTR_INIT(v) do {(v)->va_supported = (v)->va_active = 0ll; (v)->va_vaflags = 0;} while(0)
+#define VATTR_INIT(v) do {(v)->va_supported = (v)->va_active = 0ll; (v)->va_vaflags = 0; } while(0)
#define VATTR_SET_ACTIVE(v, a) ((v)->va_active |= VNODE_ATTR_ ## a)
#define VATTR_SET_SUPPORTED(v, a) ((v)->va_supported |= VNODE_ATTR_ ## a)
#define VATTR_IS_SUPPORTED(v, a) ((v)->va_supported & VNODE_ATTR_ ## a)
#define VATTR_CLEAR_ACTIVE(v, a) ((v)->va_active &= ~VNODE_ATTR_ ## a)
#define VATTR_CLEAR_SUPPORTED(v, a) ((v)->va_supported &= ~VNODE_ATTR_ ## a)
+#define VATTR_CLEAR_SUPPORTED_ALL(v) ((v)->va_supported = 0)
#define VATTR_IS_ACTIVE(v, a) ((v)->va_active & VNODE_ATTR_ ## a)
#define VATTR_ALL_SUPPORTED(v) (((v)->va_active & (v)->va_supported) == (v)->va_active)
#define VATTR_INACTIVE_SUPPORTED(v) do {(v)->va_active &= ~(v)->va_supported; (v)->va_supported = 0;} while(0)
#define VNODE_ATTR_va_guuid (1LL<<27) /* 08000000 */
#define VNODE_ATTR_va_nchildren (1LL<<28) /* 10000000 */
#define VNODE_ATTR_va_dirlinkcount (1LL<<29) /* 20000000 */
+#define VNODE_ATTR_va_addedtime (1LL<<30) /* 40000000 */
+#define VNODE_ATTR_va_dataprotect_class (1LL<<31) /* 80000000 */
+#define VNODE_ATTR_va_dataprotect_flags (1LL<<32) /* 100000000 */
+#define VNODE_ATTR_va_document_id (1LL<<33) /* 200000000 */
+#define VNODE_ATTR_va_devid (1LL<<34) /* 400000000 */
+#define VNODE_ATTR_va_objtype (1LL<<35) /* 800000000 */
+#define VNODE_ATTR_va_objtag (1LL<<36) /* 1000000000 */
+#define VNODE_ATTR_va_user_access (1LL<<37) /* 2000000000 */
+#define VNODE_ATTR_va_finderinfo (1LL<<38) /* 4000000000 */
+#define VNODE_ATTR_va_rsrc_length (1LL<<39) /* 8000000000 */
+#define VNODE_ATTR_va_rsrc_alloc (1LL<<40) /* 10000000000 */
+#define VNODE_ATTR_va_fsid64 (1LL<<41) /* 20000000000 */
+#define VNODE_ATTR_va_write_gencount (1LL<<42) /* 40000000000 */
#define VNODE_ATTR_BIT(n) (VNODE_ATTR_ ## n)
/*
VNODE_ATTR_BIT(va_name) | \
VNODE_ATTR_BIT(va_type) | \
VNODE_ATTR_BIT(va_nchildren) | \
- VNODE_ATTR_BIT(va_dirlinkcount))
+ VNODE_ATTR_BIT(va_dirlinkcount) | \
+ VNODE_ATTR_BIT(va_addedtime) | \
+ VNODE_ATTR_BIT(va_devid) | \
+ VNODE_ATTR_BIT(va_objtype) | \
+ VNODE_ATTR_BIT(va_objtag) | \
+ VNODE_ATTR_BIT(va_user_access) | \
+ VNODE_ATTR_BIT(va_finderinfo) | \
+ VNODE_ATTR_BIT(va_rsrc_length) | \
+ VNODE_ATTR_BIT(va_rsrc_alloc) | \
+ VNODE_ATTR_BIT(va_fsid64) | \
+ VNODE_ATTR_BIT(va_write_gencount))
/*
* Attributes that can be applied to a new file object.
*/
VNODE_ATTR_BIT(va_encoding) | \
VNODE_ATTR_BIT(va_type) | \
VNODE_ATTR_BIT(va_uuuid) | \
- VNODE_ATTR_BIT(va_guuid))
+ VNODE_ATTR_BIT(va_guuid) | \
+ VNODE_ATTR_BIT(va_dataprotect_class) | \
+ VNODE_ATTR_BIT(va_dataprotect_flags) | \
+ VNODE_ATTR_BIT(va_document_id))
+#include <sys/_types/_fsid_t.h>
struct vnode_attr {
/* bitfields */
uint64_t va_nchildren; /* Number of items in a directory */
uint64_t va_dirlinkcount; /* Real references to dir (i.e. excluding "." and ".." refs) */
- /* add new fields here only */
+#ifdef BSD_KERNEL_PRIVATE
+ struct kauth_acl *va_base_acl;
+#else
+ void * va_reserved1;
+#endif /* BSD_KERNEL_PRIVATE */
+ struct timespec va_addedtime; /* timestamp when item was added to parent directory */
+ /* Data Protection fields */
+ uint32_t va_dataprotect_class; /* class specified for this file if it didn't exist */
+ uint32_t va_dataprotect_flags; /* flags from NP open(2) to the filesystem */
+
+ /* Document revision tracking */
+ uint32_t va_document_id;
+
+ /* Fields for Bulk args */
+ uint32_t va_devid; /* devid of filesystem */
+ uint32_t va_objtype; /* type of object */
+ uint32_t va_objtag; /* vnode tag of filesystem */
+ uint32_t va_user_access; /* access for user */
+ uint8_t va_finderinfo[32]; /* Finder Info */
+ uint64_t va_rsrc_length; /* Resource Fork length */
+ uint64_t va_rsrc_alloc; /* Resource Fork allocation size */
+ fsid_t va_fsid64; /* fsid, of the correct type */
+
+ uint32_t va_write_gencount; /* counter that increments each time the file changes */
+
+ /* add new fields here only */
};
+#ifdef BSD_KERNEL_PRIVATE
+/*
+ * Flags for va_dataprotect_flags
+ */
+#define VA_DP_RAWENCRYPTED 0x0001
+
+#endif
+
/*
* Flags for va_vaflags.
*/
-#define VA_UTIMES_NULL 0x010000 /* utimes argument was NULL */
-#define VA_EXCLUSIVE 0x020000 /* exclusive create request */
+#define VA_UTIMES_NULL 0x010000 /* utimes argument was NULL */
+#define VA_EXCLUSIVE 0x020000 /* exclusive create request */
+#define VA_NOINHERIT 0x040000 /* Don't inherit ACLs from parent */
+#define VA_NOAUTH 0x080000
/*
* Modes. Some values same as Ixxx entries from inode.h for now.
#define REVOKEALL 0x0001 /* vnop_revoke: revoke all aliases */
-/* VNOP_REMOVE: do not delete busy files (Carbon remove file semantics) */
-#define VNODE_REMOVE_NODELETEBUSY 0x0001
+/* VNOP_REMOVE/unlink flags */
+#define VNODE_REMOVE_NODELETEBUSY 0x0001 /* Don't delete busy files (Carbon) */
+#define VNODE_REMOVE_SKIP_NAMESPACE_EVENT 0x0002 /* Do not upcall to userland handlers */
/* VNOP_READDIR flags: */
#define VNODE_READDIR_EXTENDED 0x0001 /* use extended directory entries */
#define VNODE_READDIR_REQSEEKOFF 0x0002 /* requires seek offset (cookies) */
#define VNODE_READDIR_SEEKOFF32 0x0004 /* seek offset values should fit in 32 bits */
-
+#define VNODE_READDIR_NAMEMAX 0x0008 /* For extended readdir, try to limit names to NAME_MAX bytes */
#define NULLVP ((struct vnode *)NULL)
*/
int vnode_israge(vnode_t);
+/*!
+ @function vnode_needssnapshots
+ @abstract Check if a vnode needs snapshots events (regardless of its ctime status)
+ @param vp The vnode to test.
+ @return Nonzero if vnode needs snapshot events, 0 otherwise
+ */
+int vnode_needssnapshots(vnode_t);
+
/*!
@function vnode_setnocache
@abstract Set a vnode to not have its data cached in memory (i.e. we write-through to disk and always read from disk).
@abstract Get the credential associated with a vfs_context_t.
@discussion Succeeds if and only if the context has a thread, the thread has a task, and the task has a BSD proc.
@param ctx Context whose associated process to find.
- @return Process if available, NULL otherwise.
+ @returns credential if process available; NULL otherwise
*/
kauth_cred_t vfs_context_ucred(vfs_context_t);
vfs_context_t vfs_context_current(void);
#ifdef KERNEL_PRIVATE
int vfs_context_bind(vfs_context_t);
+
+/*!
+ @function vfs_ctx_skipatime
+ @abstract Check to see if this context should skip updating a vnode's access times.
+ @discussion This is currently tied to the vnode rapid aging process. If the process is marked for rapid aging,
+ then the kernel should not update vnodes it touches for access time purposes. This will check to see if the
+ specified process and/or thread is marked for rapid aging when it manipulates vnodes.
+ @param ctx The context being investigated.
+ @return 1 if we should skip access time updates.
+ @return 0 if we should NOT skip access time updates.
+ */
+
+int vfs_ctx_skipatime(vfs_context_t ctx);
+
#endif
/*!
*/
int vnode_getwithvid(vnode_t, uint32_t);
+#ifdef BSD_KERNEL_PRIVATE
+int vnode_getwithvid_drainok(vnode_t, uint32_t);
+#endif /* BSD_KERNEL_PRIVATE */
+
/*!
@function vnode_getwithref
@abstract Increase the iocount on a vnode on which a usecount (persistent reference) is held.
*/
int vnode_ismonitored(vnode_t);
+
+/*!
+ @function vnode_isdyldsharedcache
+ @abstract Check whether a file is a dyld shared cache file.
+ @param vp Vnode to examine.
+ @discussion Will not reenter the filesystem.
+ @return nonzero if a dyld shared cache file, zero otherwise.
+ */
+int vnode_isdyldsharedcache(vnode_t);
+
+
/*!
@function vfs_get_notify_attributes
@abstract Determine what attributes are required to send up a notification with vnode_notify().
*/
#define VNODE_LOOKUP_NOFOLLOW 0x01
#define VNODE_LOOKUP_NOCROSSMOUNT 0x02
-#define VNODE_LOOKUP_DOWHITEOUT 0x04
/*!
@function vnode_lookup
@abstract Convert a path into a vnode.
#define VNODE_ITERATE_INACTIVE 0x200
#ifdef BSD_KERNEL_PRIVATE
#define VNODE_ALWAYS 0x400
+#define VNODE_DRAINO 0x800
#endif /* BSD_KERNEL_PRIVATE */
/*
*/
vnode_t vnode_getparent(vnode_t vp);
+/*!
+ @function vnode_setdirty
+ @abstract Mark the vnode as having data or metadata that needs to be written out during reclaim
+ @discussion The vnode should be marked as dirty anytime a file system defers flushing of data or meta-data associated with it.
+ @param the vnode to mark as dirty
+ @return 0 if successful else an error code.
+ */
+int vnode_setdirty(vnode_t);
+
+/*!
+ @function vnode_cleardirty
+ @abstract Mark the vnode as clean i.e. all its data or metadata has been flushed
+ @discussion The vnode should be marked as clean whenever the file system is done flushing data or meta-data associated with it.
+ @param the vnode to clear as being dirty
+ @return 0 if successful else an error code.
+ */
+int vnode_cleardirty(vnode_t);
+
+/*!
+ @function vnode_isdirty
+ @abstract Determine if a vnode is marked dirty.
+ @discussion The vnode should be marked as clean whenever the file system is done flushing data or meta-data associated with it.
+ @param vp the vnode to test.
+ @return Non-zero if the vnode is dirty, 0 otherwise.
+ */
+int vnode_isdirty(vnode_t);
+
+
+
+#ifdef KERNEL_PRIVATE
+/*!
+ @function vnode_lookup_continue_needed
+ @abstract Determine whether vnode needs additional processing in VFS before being opened.
+ @discussion If result is zero, filesystem can open this vnode. If result is nonzero,
+ additional processing is needed in VFS (e.g. symlink, mountpoint). Nonzero results should
+ be passed up to VFS.
+ @param vp Vnode to consider opening (found by filesystem).
+ @param cnp Componentname as passed to filesystem from VFS.
+ @result 0 to indicate that a vnode can be opened, or an error that should be passed up to VFS.
+ */
+int vnode_lookup_continue_needed(vnode_t vp, struct componentname *cnp);
+
+/*!
+ @function vnode_istty
+ @abstract Determine if the given vnode represents a tty device.
+ @param vp Vnode to examine.
+ @result Non-zero to indicate that the vnode represents a tty device. Zero otherwise.
+ */
+int vnode_istty(vnode_t vp);
+#endif /* KERNEL_PRIVATE */
+
#ifdef BSD_KERNEL_PRIVATE
/* Not in export list so can be private */
struct stat;
enum vtype vnode_iftovt(int);
int vnode_vttoif(enum vtype);
int vnode_isshadow(vnode_t);
-int vnode_istty(vnode_t vp);
+boolean_t vnode_on_reliable_media(vnode_t);
/*
* Indicate that a file has multiple hard links. VFS will always call
* VNOP_LOOKUP on this vnode. Volfs will always ask for it's parent
*/
vnode_t vnode_parent(vnode_t);
void vnode_setparent(vnode_t, vnode_t);
-const char * vnode_name(vnode_t);
+/*!
+ @function vnode_getname_printable
+ @abstract Get a non-null printable name of a vnode.
+ @Used to make sure a printable name is returned for all vnodes. If a name exists or can be artificially created, the routine creates a new entry in the VFS namecache. Otherwise, the function returns an artificially created vnode name which is safer and easier to use. vnode_putname_printable() should be used to release names obtained by this routine.
+ @param vp The vnode whose name to grab.
+ @return The printable name.
+ */
+const char *vnode_getname_printable(vnode_t vp);
+
+/*!
+ @function vnode_putname_printable
+ @abstract Release a reference on a name from the VFS cache if it was added by the matching vnode_getname_printable() call.
+ @param name String to release.
+ @return void.
+ */
+void vnode_putname_printable(const char *name);
void vnode_setname(vnode_t, char *);
int vnode_isnoflush(vnode_t);
void vnode_setnoflush(vnode_t);
void vnode_clearnoflush(vnode_t);
/* XXX temporary until we can arrive at a KPI for NFS, Seatbelt */
thread_t vfs_context_thread(vfs_context_t);
-
+#if CONFIG_IOSCHED
+vnode_t vnode_mountdevvp(vnode_t);
+#endif
#endif /* BSD_KERNEL_PRIVATE */
+/*
+ * Helper functions for implementing VNOP_GETATTRLISTBULK for a filesystem
+ */
+
+/*!
+ @function vfs_setup_vattr_from_attrlist
+ @abstract Setup a vnode_attr structure given an attrlist structure.
+ @Used by a VNOP_GETATTRLISTBULK implementation to setup a vnode_attr structure from a attribute list. It also returns the fixed size of the attribute buffer required.
+ @param alp Pointer to attribute list structure.
+ @param vap Pointer to vnode_attr structure.
+ @param obj_vtype Type of object - If VNON is passed, then the type is ignored and common, file and dir attrs are used to initialise the vattrs. If set to VDIR, only common and directory attributes are used. For all other types, only common and file attrbutes are used.
+ @param attr_fixed_sizep. Returns the fixed length required in the attrbute buffer for the object. NULL should be passed if it is not required.
+ @param ctx vfs context of caller.
+ @return error.
+ */
+errno_t vfs_setup_vattr_from_attrlist(struct attrlist * /* alp */, struct vnode_attr * /* vap */, enum vtype /* obj_vtype */, ssize_t * /* attr_fixed_sizep */, vfs_context_t /* ctx */);
+
+/*!
+ @function vfs_attr_pack
+ @abstract Pack a vnode_attr structure into a buffer in the same format as getattrlist(2).
+ @Used by a VNOP_GETATTRLISTBULK implementation to pack data provided into a vnode_attr structure into a buffer the way getattrlist(2) does.
+ @param vp If available, the vnode for which the attributes are being given, NULL if vnode is not available (which will usually be the case for a VNOP_GETATTRLISTBULK implementation.
+ @param auio - a uio_t initialised with one iovec..
+ @param alp - Pointer to an attrlist structure.
+ @param options - options for call (same as options for getattrlistbulk(2)).
+ @param vap Pointer to a filled in vnode_attr structure. Data from the vnode_attr structure will be used to copy and lay out the data in the required format for getatrlistbulk(2) by this function.
+ @param fndesc Currently unused
+ @param ctx vfs context of caller.
+ @return error.
+ */
+errno_t vfs_attr_pack(vnode_t /* vp */, uio_t /* uio */, struct attrlist * /* alp */, uint64_t /* options */, struct vnode_attr * /* vap */, void * /* fndesc */, vfs_context_t /* ctx */);
+
__END_DECLS
#endif /* KERNEL */
projects / apple / xnu.git / blobdiff