/*
- * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
*/
#include <sys/systm.h>
-#include <sys/kernel.h>
#include <sys/param.h>
+#include <sys/kernel.h>
#include <sys/file_internal.h>
#include <sys/dirent.h>
#include <sys/stat.h>
#include <sys/buf.h>
+#include <sys/buf_internal.h>
#include <sys/mount.h>
#include <sys/vnode_if.h>
#include <sys/vnode_internal.h>
#include <sys/disk.h>
#include <sys/kauth.h>
#include <sys/uio_internal.h>
+#include <sys/fsctl.h>
+#include <sys/cprotect.h>
+#include <sys/xattr.h>
+#include <string.h>
#include <miscfs/specfs/specdev.h>
#include <miscfs/fifofs/fifo.h>
#include "hfscommon/headers/BTreesInternal.h"
#include "hfscommon/headers/FileMgrInternal.h"
-
#define KNDETACH_VNLOCKED 0x00000001
-#define CARBON_TEMP_DIR_NAME "Cleanup At Startup"
-
-
/* Global vfs data structures for hfs */
/* Always F_FULLFSYNC? 1=yes,0=no (default due to "various" reasons is 'no') */
int always_do_fullfsync = 0;
-SYSCTL_INT (_kern, OID_AUTO, always_do_fullfsync, CTLFLAG_RW, &always_do_fullfsync, 0, "always F_FULLFSYNC when fsync is called");
+SYSCTL_DECL(_vfs_generic);
+SYSCTL_INT (_vfs_generic, OID_AUTO, always_do_fullfsync, CTLFLAG_RW | CTLFLAG_LOCKED, &always_do_fullfsync, 0, "always F_FULLFSYNC when fsync is called");
-static int hfs_makenode(struct vnode *dvp, struct vnode **vpp,
+int hfs_makenode(struct vnode *dvp, struct vnode **vpp,
struct componentname *cnp, struct vnode_attr *vap,
vfs_context_t ctx);
+int hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, __unused struct proc *p);
+int hfs_metasync_all(struct hfsmount *hfsmp);
-static int hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, __unused struct proc *p);
-static int hfs_metasync_all(struct hfsmount *hfsmp);
+int hfs_removedir(struct vnode *, struct vnode *, struct componentname *,
+ int, int);
+int hfs_removefile(struct vnode *, struct vnode *, struct componentname *,
+ int, int, int, struct vnode *, int);
-static int hfs_removedir(struct vnode *, struct vnode *, struct componentname *,
- int);
+/* Used here and in cnode teardown -- for symlinks */
+int hfs_removefile_callback(struct buf *bp, void *hfsmp);
-static int hfs_removefile(struct vnode *, struct vnode *, struct componentname *,
- int, int, int);
+int hfs_movedata (struct vnode *, struct vnode*);
+static int hfs_move_fork (struct filefork *srcfork, struct cnode *src,
+ struct filefork *dstfork, struct cnode *dst);
#if FIFO
static int hfsfifo_read(struct vnop_read_args *);
static int hfsfifo_write(struct vnop_write_args *);
static int hfsfifo_close(struct vnop_close_args *);
-static int hfsfifo_kqfilt_add(struct vnop_kqfilt_add_args *);
-static int hfsfifo_kqfilt_remove(struct vnop_kqfilt_remove_args *);
extern int (**fifo_vnodeop_p)(void *);
#endif /* FIFO */
-static int hfs_vnop_close(struct vnop_close_args*);
-static int hfs_vnop_create(struct vnop_create_args*);
-static int hfs_vnop_exchange(struct vnop_exchange_args*);
-static int hfs_vnop_fsync(struct vnop_fsync_args*);
-static int hfs_vnop_mkdir(struct vnop_mkdir_args*);
-static int hfs_vnop_mknod(struct vnop_mknod_args*);
-static int hfs_vnop_getattr(struct vnop_getattr_args*);
-static int hfs_vnop_open(struct vnop_open_args*);
-static int hfs_vnop_readdir(struct vnop_readdir_args*);
-static int hfs_vnop_remove(struct vnop_remove_args*);
-static int hfs_vnop_rename(struct vnop_rename_args*);
-static int hfs_vnop_rmdir(struct vnop_rmdir_args*);
-static int hfs_vnop_symlink(struct vnop_symlink_args*);
-static int hfs_vnop_setattr(struct vnop_setattr_args*);
-static int hfs_vnop_readlink(struct vnop_readlink_args *);
-static int hfs_vnop_pathconf(struct vnop_pathconf_args *);
-static int hfs_vnop_kqfiltremove(struct vnop_kqfilt_remove_args *);
-static int hfs_vnop_whiteout(struct vnop_whiteout_args *);
-static int hfsspec_read(struct vnop_read_args *);
-static int hfsspec_write(struct vnop_write_args *);
-static int hfsspec_close(struct vnop_close_args *);
+int hfs_vnop_close(struct vnop_close_args*);
+int hfs_vnop_create(struct vnop_create_args*);
+int hfs_vnop_exchange(struct vnop_exchange_args*);
+int hfs_vnop_fsync(struct vnop_fsync_args*);
+int hfs_vnop_mkdir(struct vnop_mkdir_args*);
+int hfs_vnop_mknod(struct vnop_mknod_args*);
+int hfs_vnop_getattr(struct vnop_getattr_args*);
+int hfs_vnop_open(struct vnop_open_args*);
+int hfs_vnop_readdir(struct vnop_readdir_args*);
+int hfs_vnop_remove(struct vnop_remove_args*);
+int hfs_vnop_rename(struct vnop_rename_args*);
+int hfs_vnop_rmdir(struct vnop_rmdir_args*);
+int hfs_vnop_symlink(struct vnop_symlink_args*);
+int hfs_vnop_setattr(struct vnop_setattr_args*);
+int hfs_vnop_readlink(struct vnop_readlink_args *);
+int hfs_vnop_pathconf(struct vnop_pathconf_args *);
+int hfs_vnop_whiteout(struct vnop_whiteout_args *);
+int hfs_vnop_mmap(struct vnop_mmap_args *ap);
+int hfsspec_read(struct vnop_read_args *);
+int hfsspec_write(struct vnop_write_args *);
+int hfsspec_close(struct vnop_close_args *);
/* Options for hfs_removedir and hfs_removefile */
#define HFSRM_SKIP_RESERVE 0x01
*
*****************************************************************************/
+/*
+ * Is the given cnode either the .journal or .journal_info_block file on
+ * a volume with an active journal? Many VNOPs use this to deny access
+ * to those files.
+ *
+ * Note: the .journal file on a volume with an external journal still
+ * returns true here, even though it does not actually hold the contents
+ * of the volume's journal.
+ */
+static _Bool
+hfs_is_journal_file(struct hfsmount *hfsmp, struct cnode *cp)
+{
+ if (hfsmp->jnl != NULL &&
+ (cp->c_fileid == hfsmp->hfs_jnlinfoblkid ||
+ cp->c_fileid == hfsmp->hfs_jnlfileid)) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
/*
* Create a regular file.
*/
-static int
+int
hfs_vnop_create(struct vnop_create_args *ap)
{
int error;
/* Make sure it was file. */
if ((error == 0) && !vnode_isreg(*args.a_vpp)) {
vnode_put(*args.a_vpp);
+ *args.a_vpp = NULLVP;
error = EEXIST;
}
args.a_cnp->cn_nameiop = CREATE;
/*
* Make device special file.
*/
-static int
+int
hfs_vnop_mknod(struct vnop_mknod_args *ap)
{
struct vnode_attr *vap = ap->a_vap;
return (0);
}
+#if HFS_COMPRESSION
+/*
+ * hfs_ref_data_vp(): returns the data fork vnode for a given cnode.
+ * In the (hopefully rare) case where the data fork vnode is not
+ * present, it will use hfs_vget() to create a new vnode for the
+ * data fork.
+ *
+ * NOTE: If successful and a vnode is returned, the caller is responsible
+ * for releasing the returned vnode with vnode_rele().
+ */
+static int
+hfs_ref_data_vp(struct cnode *cp, struct vnode **data_vp, int skiplock)
+{
+ int vref = 0;
+
+ if (!data_vp || !cp) /* sanity check incoming parameters */
+ return EINVAL;
+
+ /* maybe we should take the hfs cnode lock here, and if so, use the skiplock parameter to tell us not to */
+
+ if (!skiplock) hfs_lock(cp, HFS_SHARED_LOCK);
+ struct vnode *c_vp = cp->c_vp;
+ if (c_vp) {
+ /* we already have a data vnode */
+ *data_vp = c_vp;
+ vref = vnode_ref(*data_vp);
+ if (!skiplock) hfs_unlock(cp);
+ if (vref == 0) {
+ return 0;
+ }
+ return EINVAL;
+ }
+ /* no data fork vnode in the cnode, so ask hfs for one. */
+
+ if (!cp->c_rsrc_vp) {
+ /* if we don't have either a c_vp or c_rsrc_vp, we can't really do anything useful */
+ *data_vp = NULL;
+ if (!skiplock) hfs_unlock(cp);
+ return EINVAL;
+ }
+
+ if (0 == hfs_vget(VTOHFS(cp->c_rsrc_vp), cp->c_cnid, data_vp, 1, 0) &&
+ 0 != data_vp) {
+ vref = vnode_ref(*data_vp);
+ vnode_put(*data_vp);
+ if (!skiplock) hfs_unlock(cp);
+ if (vref == 0) {
+ return 0;
+ }
+ return EINVAL;
+ }
+ /* there was an error getting the vnode */
+ *data_vp = NULL;
+ if (!skiplock) hfs_unlock(cp);
+ return EINVAL;
+}
+
+/*
+ * hfs_lazy_init_decmpfs_cnode(): returns the decmpfs_cnode for a cnode,
+ * allocating it if necessary; returns NULL if there was an allocation error
+ */
+static decmpfs_cnode *
+hfs_lazy_init_decmpfs_cnode(struct cnode *cp)
+{
+ if (!cp->c_decmp) {
+ decmpfs_cnode *dp = NULL;
+ MALLOC_ZONE(dp, decmpfs_cnode *, sizeof(decmpfs_cnode), M_DECMPFS_CNODE, M_WAITOK);
+ if (!dp) {
+ /* error allocating a decmpfs cnode */
+ return NULL;
+ }
+ decmpfs_cnode_init(dp);
+ if (!OSCompareAndSwapPtr(NULL, dp, (void * volatile *)&cp->c_decmp)) {
+ /* another thread got here first, so free the decmpfs_cnode we allocated */
+ decmpfs_cnode_destroy(dp);
+ FREE_ZONE(dp, sizeof(*dp), M_DECMPFS_CNODE);
+ }
+ }
+
+ return cp->c_decmp;
+}
+
+/*
+ * hfs_file_is_compressed(): returns 1 if the file is compressed, and 0 (zero) if not.
+ * if the file's compressed flag is set, makes sure that the decmpfs_cnode field
+ * is allocated by calling hfs_lazy_init_decmpfs_cnode(), then makes sure it is populated,
+ * or else fills it in via the decmpfs_file_is_compressed() function.
+ */
+int
+hfs_file_is_compressed(struct cnode *cp, int skiplock)
+{
+ int ret = 0;
+
+ /* fast check to see if file is compressed. If flag is clear, just answer no */
+ if (!(cp->c_bsdflags & UF_COMPRESSED)) {
+ return 0;
+ }
+
+ decmpfs_cnode *dp = hfs_lazy_init_decmpfs_cnode(cp);
+ if (!dp) {
+ /* error allocating a decmpfs cnode, treat the file as uncompressed */
+ return 0;
+ }
+
+ /* flag was set, see if the decmpfs_cnode state is valid (zero == invalid) */
+ uint32_t decmpfs_state = decmpfs_cnode_get_vnode_state(dp);
+ switch(decmpfs_state) {
+ case FILE_IS_COMPRESSED:
+ case FILE_IS_CONVERTING: /* treat decompressing files as if they are compressed */
+ return 1;
+ case FILE_IS_NOT_COMPRESSED:
+ return 0;
+ /* otherwise the state is not cached yet */
+ }
+
+ /* decmpfs hasn't seen this file yet, so call decmpfs_file_is_compressed() to init the decmpfs_cnode struct */
+ struct vnode *data_vp = NULL;
+ if (0 == hfs_ref_data_vp(cp, &data_vp, skiplock)) {
+ if (data_vp) {
+ ret = decmpfs_file_is_compressed(data_vp, VTOCMP(data_vp)); // fill in decmpfs_cnode
+ vnode_rele(data_vp);
+ }
+ }
+ return ret;
+}
+
+/* hfs_uncompressed_size_of_compressed_file() - get the uncompressed size of the file.
+ * if the caller has passed a valid vnode (has a ref count > 0), then hfsmp and fid are not required.
+ * if the caller doesn't have a vnode, pass NULL in vp, and pass valid hfsmp and fid.
+ * files size is returned in size (required)
+ * if the indicated file is a directory (or something that doesn't have a data fork), then this call
+ * will return an error and the caller should fall back to treating the item as an uncompressed file
+ */
+int
+hfs_uncompressed_size_of_compressed_file(struct hfsmount *hfsmp, struct vnode *vp, cnid_t fid, off_t *size, int skiplock)
+{
+ int ret = 0;
+ int putaway = 0; /* flag to remember if we used hfs_vget() */
+
+ if (!size) {
+ return EINVAL; /* no place to put the file size */
+ }
+
+ if (NULL == vp) {
+ if (!hfsmp || !fid) { /* make sure we have the required parameters */
+ return EINVAL;
+ }
+ if (0 != hfs_vget(hfsmp, fid, &vp, skiplock, 0)) { /* vnode is null, use hfs_vget() to get it */
+ vp = NULL;
+ } else {
+ putaway = 1; /* note that hfs_vget() was used to aquire the vnode */
+ }
+ }
+ /* this double check for compression (hfs_file_is_compressed)
+ * ensures the cached size is present in case decmpfs hasn't
+ * encountered this node yet.
+ */
+ if (vp) {
+ if (hfs_file_is_compressed(VTOC(vp), skiplock) ) {
+ *size = decmpfs_cnode_get_vnode_cached_size(VTOCMP(vp)); /* file info will be cached now, so get size */
+ } else {
+ if (VTOCMP(vp) && VTOCMP(vp)->cmp_type >= CMP_MAX) {
+ if (VTOCMP(vp)->cmp_type != DATALESS_CMPFS_TYPE) {
+ // if we don't recognize this type, just use the real data fork size
+ if (VTOC(vp)->c_datafork) {
+ *size = VTOC(vp)->c_datafork->ff_size;
+ ret = 0;
+ } else {
+ ret = EINVAL;
+ }
+ } else {
+ *size = decmpfs_cnode_get_vnode_cached_size(VTOCMP(vp)); /* file info will be cached now, so get size */
+ ret = 0;
+ }
+ } else {
+ ret = EINVAL;
+ }
+ }
+ }
+
+ if (putaway) { /* did we use hfs_vget() to get this vnode? */
+ vnode_put(vp); /* if so, release it and set it to null */
+ vp = NULL;
+ }
+ return ret;
+}
+
+int
+hfs_hides_rsrc(vfs_context_t ctx, struct cnode *cp, int skiplock)
+{
+ if (ctx == decmpfs_ctx)
+ return 0;
+ if (!hfs_file_is_compressed(cp, skiplock))
+ return 0;
+ return decmpfs_hides_rsrc(ctx, cp->c_decmp);
+}
+
+int
+hfs_hides_xattr(vfs_context_t ctx, struct cnode *cp, const char *name, int skiplock)
+{
+ if (ctx == decmpfs_ctx)
+ return 0;
+ if (!hfs_file_is_compressed(cp, skiplock))
+ return 0;
+ return decmpfs_hides_xattr(ctx, cp->c_decmp, name);
+}
+#endif /* HFS_COMPRESSION */
+
/*
* Open a file/directory.
*/
-static int
+int
hfs_vnop_open(struct vnop_open_args *ap)
{
struct vnode *vp = ap->a_vp;
struct filefork *fp;
struct timeval tv;
int error;
+ static int past_bootup = 0;
+ struct cnode *cp = VTOC(vp);
+ struct hfsmount *hfsmp = VTOHFS(vp);
+
+#if HFS_COMPRESSION
+ if (ap->a_mode & FWRITE) {
+ /* open for write */
+ if ( hfs_file_is_compressed(cp, 1) ) { /* 1 == don't take the cnode lock */
+ /* opening a compressed file for write, so convert it to decompressed */
+ struct vnode *data_vp = NULL;
+ error = hfs_ref_data_vp(cp, &data_vp, 1); /* 1 == don't take the cnode lock */
+ if (0 == error) {
+ if (data_vp) {
+ error = decmpfs_decompress_file(data_vp, VTOCMP(data_vp), -1, 1, 0);
+ vnode_rele(data_vp);
+ } else {
+ error = EINVAL;
+ }
+ }
+ if (error != 0)
+ return error;
+ }
+ } else {
+ /* open for read */
+ if (hfs_file_is_compressed(cp, 1) ) { /* 1 == don't take the cnode lock */
+ if (VNODE_IS_RSRC(vp)) {
+ /* opening the resource fork of a compressed file, so nothing to do */
+ } else {
+ /* opening a compressed file for read, make sure it validates */
+ error = decmpfs_validate_compressed_file(vp, VTOCMP(vp));
+ if (error != 0)
+ return error;
+ }
+ }
+ }
+#endif
/*
* Files marked append-only must be opened for appending.
*/
- if ((VTOC(vp)->c_flags & APPEND) && !vnode_isdir(vp) &&
+ if ((cp->c_bsdflags & APPEND) && !vnode_isdir(vp) &&
(ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
return (EPERM);
if (vnode_isreg(vp) && !UBCINFOEXISTS(vp))
return (EBUSY); /* file is in use by the kernel */
- /* Don't allow journal file to be opened externally. */
- if (VTOC(vp)->c_fileid == VTOHFS(vp)->hfs_jnlfileid)
+ /* Don't allow journal to be opened externally. */
+ if (hfs_is_journal_file(hfsmp, cp))
return (EPERM);
- /*
- * On the first (non-busy) open of a fragmented
- * file attempt to de-frag it (if its less than 20MB).
- */
- if ((VTOHFS(vp)->hfs_flags & HFS_READ_ONLY) ||
- (VTOHFS(vp)->jnl == NULL) ||
+
+ if ((hfsmp->hfs_flags & HFS_READ_ONLY) ||
+ (hfsmp->jnl == NULL) ||
#if NAMEDSTREAMS
!vnode_isreg(vp) || vnode_isinuse(vp, 0) || vnode_isnamedstream(vp)) {
#else
return (0);
}
- if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
+ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK)))
return (error);
+
+#if QUOTA
+ /* If we're going to write to the file, initialize quotas. */
+ if ((ap->a_mode & FWRITE) && (hfsmp->hfs_flags & HFS_QUOTAS))
+ (void)hfs_getinoquota(cp);
+#endif /* QUOTA */
+
+ /*
+ * On the first (non-busy) open of a fragmented
+ * file attempt to de-frag it (if its less than 20MB).
+ */
fp = VTOF(vp);
if (fp->ff_blocks &&
fp->ff_extents[7].blockCount != 0 &&
fp->ff_size <= (20 * 1024 * 1024)) {
+ int no_mods = 0;
struct timeval now;
- struct cnode *cp = VTOC(vp);
/*
* Wait until system bootup is done (3 min).
* And don't relocate a file that's been modified
* within the past minute -- this can lead to
* system thrashing.
*/
- microuptime(&tv);
+
+ if (!past_bootup) {
+ microuptime(&tv);
+ if (tv.tv_sec > (60*3)) {
+ past_bootup = 1;
+ }
+ }
+
microtime(&now);
- if (tv.tv_sec > (60 * 3) &&
- ((now.tv_sec - cp->c_mtime) > 60)) {
- (void) hfs_relocate(vp, VTOVCB(vp)->nextAllocation + 4096,
- vfs_context_ucred(ap->a_context),
- vfs_context_proc(ap->a_context));
+ if ((now.tv_sec - cp->c_mtime) > 60) {
+ no_mods = 1;
+ }
+
+ if (past_bootup && no_mods) {
+ (void) hfs_relocate(vp, hfsmp->nextAllocation + 4096,
+ vfs_context_ucred(ap->a_context),
+ vfs_context_proc(ap->a_context));
}
}
- hfs_unlock(VTOC(vp));
+
+ hfs_unlock(cp);
return (0);
}
/*
* Close a file/directory.
*/
-static int
+int
hfs_vnop_close(ap)
struct vnop_close_args /* {
struct vnode *a_vp;
struct proc *p = vfs_context_proc(ap->a_context);
struct hfsmount *hfsmp;
int busy;
- int knownrefs = 0;
int tooktrunclock = 0;
+ int knownrefs = 0;
if ( hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) != 0)
return (0);
cp = VTOC(vp);
hfsmp = VTOHFS(vp);
- /*
- * If the rsrc fork is a named stream, it holds a usecount on
- * the data fork, which prevents the data fork from getting recycled, which
- * then prevents the de-allocation of its extra blocks.
- * Do checks for truncation on close. Purge extra extents if they
- * exist. Make sure the vp is not a directory, that it has a resource
- * fork, and that rsrc fork is a named stream.
+ /*
+ * If the rsrc fork is a named stream, it can cause the data fork to
+ * stay around, preventing de-allocation of these blocks.
+ * Do checks for truncation on close. Purge extra extents if they exist.
+ * Make sure the vp is not a directory, and that it has a resource fork,
+ * and that resource fork is also a named stream.
*/
-
+
if ((vp->v_type == VREG) && (cp->c_rsrc_vp)
&& (vnode_isnamedstream(cp->c_rsrc_vp))) {
uint32_t blks;
blks = howmany(VTOF(vp)->ff_size, VTOVCB(vp)->blockSize);
/*
- * If there are any extra blocks and there are only 2 refs on
- * this vp (ourselves + rsrc fork holding ref on us), go ahead
- * and try to truncate the extra blocks away.
+ * If there are extra blocks and there are only 2 refs on
+ * this vp (ourselves + rsrc fork holding ref on us), go ahead
+ * and try to truncate.
*/
if ((blks < VTOF(vp)->ff_blocks) && (!vnode_isinuse(vp, 2))) {
- // release cnode lock ; must acquire truncate lock BEFORE cnode lock
- hfs_unlock (cp);
+ // release cnode lock; must acquire truncate lock BEFORE cnode lock
+ hfs_unlock(cp);
- hfs_lock_truncate(cp, TRUE);
+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK);
tooktrunclock = 1;
-
- if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) != 0) {
- hfs_unlock_truncate(cp, TRUE);
- return (0);
- }
- //now re-test to make sure it's still valid.
+ if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) != 0) {
+ hfs_unlock_truncate(cp, 0);
+ // bail out if we can't re-acquire cnode lock
+ return 0;
+ }
+ // now re-test to make sure it's still valid
if (cp->c_rsrc_vp) {
knownrefs = 1 + vnode_isnamedstream(cp->c_rsrc_vp);
- if (!vnode_isinuse(vp, knownrefs)) {
+ if (!vnode_isinuse(vp, knownrefs)){
+ // now we can truncate the file, if necessary
blks = howmany(VTOF(vp)->ff_size, VTOVCB(vp)->blockSize);
- if (blks < VTOF(vp)->ff_blocks) {
- (void) hfs_truncate(vp, VTOF(vp)->ff_size, IO_NDELAY, 0, ap->a_context);
+ if (blks < VTOF(vp)->ff_blocks){
+ (void) hfs_truncate(vp, VTOF(vp)->ff_size, IO_NDELAY, 0, 0, ap->a_context);
}
}
}
}
}
+
// if we froze the fs and we're exiting, then "thaw" the fs
if (hfsmp->hfs_freezing_proc == p && proc_exiting(p)) {
hfsmp->hfs_freezing_proc = NULL;
- hfs_global_exclusive_lock_release(hfsmp);
- lck_rw_unlock_exclusive(&hfsmp->hfs_insync);
+ hfs_unlock_global (hfsmp);
+ lck_rw_unlock_exclusive(&hfsmp->hfs_insync);
}
busy = vnode_isinuse(vp, 1);
} else if (vnode_issystem(vp) && !busy) {
vnode_recycle(vp);
}
- if (tooktrunclock) {
- hfs_unlock_truncate(cp, TRUE);
+
+ if (tooktrunclock){
+ hfs_unlock_truncate(cp, 0);
}
-
hfs_unlock(cp);
+
+ if (ap->a_fflag & FWASWRITTEN) {
+ hfs_sync_ejectable(hfsmp);
+ }
+
return (0);
}
/*
* Get basic attributes.
*/
-static int
+int
hfs_vnop_getattr(struct vnop_getattr_args *ap)
{
#define VNODE_ATTR_TIMES \
uint64_t data_size;
enum vtype v_type;
int error = 0;
-
cp = VTOC(vp);
+#if HFS_COMPRESSION
+ /* we need to inspect the decmpfs state of the file before we take the hfs cnode lock */
+ int compressed = 0;
+ int hide_size = 0;
+ off_t uncompressed_size = -1;
+ if (VATTR_IS_ACTIVE(vap, va_data_size) || VATTR_IS_ACTIVE(vap, va_total_alloc) || VATTR_IS_ACTIVE(vap, va_data_alloc) || VATTR_IS_ACTIVE(vap, va_total_size)) {
+ /* we only care about whether the file is compressed if asked for the uncompressed size */
+ if (VNODE_IS_RSRC(vp)) {
+ /* if it's a resource fork, decmpfs may want us to hide the size */
+ hide_size = hfs_hides_rsrc(ap->a_context, cp, 0);
+ } else {
+ /* if it's a data fork, we need to know if it was compressed so we can report the uncompressed size */
+ compressed = hfs_file_is_compressed(cp, 0);
+ }
+ if ((VATTR_IS_ACTIVE(vap, va_data_size) || VATTR_IS_ACTIVE(vap, va_total_size))) {
+ // if it's compressed
+ if (compressed || (!VNODE_IS_RSRC(vp) && cp->c_decmp && cp->c_decmp->cmp_type >= CMP_MAX)) {
+ if (0 != hfs_uncompressed_size_of_compressed_file(NULL, vp, 0, &uncompressed_size, 0)) {
+ /* failed to get the uncompressed size, we'll check for this later */
+ uncompressed_size = -1;
+ } else {
+ // fake that it's compressed
+ compressed = 1;
+ }
+ }
+ }
+ }
+#endif
+
/*
* Shortcut for vnode_authorize path. Each of the attributes
* in this set is updated atomically so we don't need to take
vap->va_uid = cp->c_uid;
vap->va_gid = cp->c_gid;
vap->va_mode = cp->c_mode;
- vap->va_flags = cp->c_flags;
+ vap->va_flags = cp->c_bsdflags;
vap->va_supported |= VNODE_ATTR_AUTH & ~VNODE_ATTR_va_acl;
if ((cp->c_attr.ca_recflags & kHFSHasSecurityMask) == 0) {
vap->va_acl = (kauth_acl_t) KAUTH_FILESEC_NONE;
VATTR_SET_SUPPORTED(vap, va_acl);
}
+
return (0);
}
+
hfsmp = VTOHFS(vp);
v_type = vnode_vtype(vp);
-
/*
* If time attributes are requested and we have cnode times
* that require updating, then acquire an exclusive lock on
if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK)))
return (error);
hfs_touchtimes(hfsmp, cp);
- } else {
+ }
+ else {
if ((error = hfs_lock(cp, HFS_SHARED_LOCK)))
return (error);
}
if (VATTR_IS_ACTIVE(vap, va_data_alloc)) {
u_int64_t blocks;
- blocks = VCTOF(vp, cp)->ff_blocks;
- VATTR_RETURN(vap, va_data_alloc, blocks * (u_int64_t)hfsmp->blockSize);
+#if HFS_COMPRESSION
+ if (hide_size) {
+ VATTR_RETURN(vap, va_data_alloc, 0);
+ } else if (compressed) {
+ /* for compressed files, we report all allocated blocks as belonging to the data fork */
+ blocks = cp->c_blocks;
+ VATTR_RETURN(vap, va_data_alloc, blocks * (u_int64_t)hfsmp->blockSize);
+ }
+ else
+#endif
+ {
+ blocks = VCTOF(vp, cp)->ff_blocks;
+ VATTR_RETURN(vap, va_data_alloc, blocks * (u_int64_t)hfsmp->blockSize);
+ }
}
}
if (v_type == VDIR) {
VATTR_RETURN(vap, va_total_size, (cp->c_entries + 2) * AVERAGE_HFSDIRENTRY_SIZE);
} else {
- u_int64_t total_size = 0;
+ u_int64_t total_size = ~0ULL;
struct cnode *rcp;
-
- if (cp->c_datafork) {
- total_size = cp->c_datafork->ff_size;
+#if HFS_COMPRESSION
+ if (hide_size) {
+ /* we're hiding the size of this file, so just return 0 */
+ total_size = 0;
+ } else if (compressed) {
+ if (uncompressed_size == -1) {
+ /*
+ * We failed to get the uncompressed size above,
+ * so we'll fall back to the standard path below
+ * since total_size is still -1
+ */
+ } else {
+ /* use the uncompressed size we fetched above */
+ total_size = uncompressed_size;
+ }
}
-
- if (cp->c_blocks - VTOF(vp)->ff_blocks) {
- /* We deal with resource fork vnode iocount at the end of the function */
- error = hfs_vgetrsrc(hfsmp, vp, &rvp, TRUE);
- if (error) {
- goto out;
+#endif
+ if (total_size == ~0ULL) {
+ if (cp->c_datafork) {
+ total_size = cp->c_datafork->ff_size;
}
- rcp = VTOC(rvp);
- if (rcp && rcp->c_rsrcfork) {
- total_size += rcp->c_rsrcfork->ff_size;
+
+ if (cp->c_blocks - VTOF(vp)->ff_blocks) {
+ /* We deal with rsrc fork vnode iocount at the end of the function */
+ error = hfs_vgetrsrc(hfsmp, vp, &rvp, TRUE, FALSE);
+ if (error) {
+ /*
+ * Note that we call hfs_vgetrsrc with error_on_unlinked
+ * set to FALSE. This is because we may be invoked via
+ * fstat() on an open-unlinked file descriptor and we must
+ * continue to support access to the rsrc fork until it disappears.
+ * The code at the end of this function will be
+ * responsible for releasing the iocount generated by
+ * hfs_vgetrsrc. This is because we can't drop the iocount
+ * without unlocking the cnode first.
+ */
+ goto out;
+ }
+
+ rcp = VTOC(rvp);
+ if (rcp && rcp->c_rsrcfork) {
+ total_size += rcp->c_rsrcfork->ff_size;
+ }
}
}
-
+
VATTR_RETURN(vap, va_total_size, total_size);
}
}
vap->va_backup_time.tv_sec = cp->c_btime;
vap->va_backup_time.tv_nsec = 0;
+ /* See if we need to emit the date added field to the user */
+ if (VATTR_IS_ACTIVE(vap, va_addedtime)) {
+ u_int32_t dateadded = hfs_get_dateadded (cp);
+ if (dateadded) {
+ vap->va_addedtime.tv_sec = dateadded;
+ vap->va_addedtime.tv_nsec = 0;
+ VATTR_SET_SUPPORTED (vap, va_addedtime);
+ }
+ }
+
/* XXX is this really a good 'optimal I/O size'? */
vap->va_iosize = hfsmp->hfs_logBlockSize;
vap->va_uid = cp->c_uid;
vap->va_gid = cp->c_gid;
vap->va_mode = cp->c_mode;
- vap->va_flags = cp->c_flags;
+ vap->va_flags = cp->c_bsdflags;
/*
* Exporting file IDs from HFS Plus:
vap->va_linkid = (u_int64_t)cp->c_cnid;
vap->va_parentid = (u_int64_t)cp->c_parentcnid;
}
- vap->va_fsid = cp->c_dev;
+ vap->va_fsid = hfsmp->hfs_raw_dev;
vap->va_filerev = 0;
vap->va_encoding = cp->c_encoding;
vap->va_rdev = (v_type == VBLK || v_type == VCHR) ? cp->c_rdev : 0;
+#if HFS_COMPRESSION
+ if (VATTR_IS_ACTIVE(vap, va_data_size)) {
+ if (hide_size)
+ vap->va_data_size = 0;
+ else if (compressed) {
+ if (uncompressed_size == -1) {
+ /* failed to get the uncompressed size above, so just return data_size */
+ vap->va_data_size = data_size;
+ } else {
+ /* use the uncompressed size we fetched above */
+ vap->va_data_size = uncompressed_size;
+ }
+ } else
+ vap->va_data_size = data_size;
+// vap->va_supported |= VNODE_ATTR_va_data_size;
+ VATTR_SET_SUPPORTED(vap, va_data_size);
+ }
+#else
vap->va_data_size = data_size;
-
+ vap->va_supported |= VNODE_ATTR_va_data_size;
+#endif
+
/* Mark them all at once instead of individual VATTR_SET_SUPPORTED calls. */
vap->va_supported |= VNODE_ATTR_va_create_time | VNODE_ATTR_va_modify_time |
VNODE_ATTR_va_change_time| VNODE_ATTR_va_backup_time |
VNODE_ATTR_va_flags |VNODE_ATTR_va_fileid |
VNODE_ATTR_va_linkid | VNODE_ATTR_va_parentid |
VNODE_ATTR_va_fsid | VNODE_ATTR_va_filerev |
- VNODE_ATTR_va_encoding | VNODE_ATTR_va_rdev |
- VNODE_ATTR_va_data_size;
+ VNODE_ATTR_va_encoding | VNODE_ATTR_va_rdev;
- /* If this is the root, let VFS to find out the mount name, which may be different from the real name.
- * Otherwise, we need to just take care for hardlinked files, which need to be looked up, if necessary
+ /* If this is the root, let VFS to find out the mount name, which
+ * may be different from the real name. Otherwise, we need to take care
+ * for hardlinked files, which need to be looked up, if necessary
*/
if (VATTR_IS_ACTIVE(vap, va_name) && (cp->c_cnid != kHFSRootFolderID)) {
struct cat_desc linkdesc;
int lockflags;
int uselinkdesc = 0;
cnid_t nextlinkid = 0;
- cnid_t prevlinkid = 0;
+ cnid_t prevlinkid = 0;
/* Get the name for ATTR_CMN_NAME. We need to take special care for hardlinks
* here because the info. for the link ID requested by getattrlist may be
* different than what's currently in the cnode. This is because the cnode
* will be filled in with the information for the most recent link ID that went
* through namei/lookup(). If there are competing lookups for hardlinks that point
- * to the same inode, one (or more) getattrlists could be vended incorrect name information.
- * Also, we need to beware of open-unlinked files which could have a namelen of 0. Note
- * that if another hardlink sibling of this file is being unlinked, that could also thrash
- * the name fields but it should *not* be treated like an open-unlinked file here.
+ * to the same inode, one (or more) getattrlists could be vended incorrect name information.
+ * Also, we need to beware of open-unlinked files which could have a namelen of 0.
*/
- if ((cp->c_flag & C_HARDLINK) &&
+
+ if ((cp->c_flag & C_HARDLINK) &&
((cp->c_desc.cd_namelen == 0) || (vap->va_linkid != cp->c_cnid))) {
- /* If we have no name and our linkID is the raw inode number, then we may
- * have an open-unlinked file. Go to the next link in this case.
+ /* If we have no name and our link ID is the raw inode number, then we may
+ * have an open-unlinked file. Go to the next link in this case.
*/
if ((cp->c_desc.cd_namelen == 0) && (vap->va_linkid == cp->c_fileid)) {
- if ((error = hfs_lookuplink(hfsmp, vap->va_linkid, &prevlinkid, &nextlinkid))) {
+ if ((error = hfs_lookup_siblinglinks(hfsmp, vap->va_linkid, &prevlinkid, &nextlinkid))){
goto out;
}
- }
+ }
else {
+ /* just use link obtained from vap above */
nextlinkid = vap->va_linkid;
}
- /* Now probe the catalog for the linkID. Note that we don't know if we have
- * the exclusive lock here for the cnode, so we can't just update the descriptor.
- * Instead, we should just store the descriptor's value locally and then use it to pass
- * out the name value as needed below.
- */
- if (nextlinkid) {
+
+ /* We need to probe the catalog for the descriptor corresponding to the link ID
+ * stored in nextlinkid. Note that we don't know if we have the exclusive lock
+ * for the cnode here, so we can't just update the descriptor. Instead,
+ * we should just store the descriptor's value locally and then use it to pass
+ * out the name value as needed below.
+ */
+ if (nextlinkid){
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
- error = cat_findname(hfsmp, nextlinkid, &linkdesc);
- hfs_systemfile_unlock(hfsmp, lockflags);
+ error = cat_findname(hfsmp, nextlinkid, &linkdesc);
+ hfs_systemfile_unlock(hfsmp, lockflags);
if (error == 0) {
uselinkdesc = 1;
}
}
}
-
- /* By this point, we either patched the name above, and the c_desc points
- * to correct data, or it already did, in which case we just proceed by copying
- * the name into the VAP. Note that we will never set va_name to supported if
- * nextlinkid is never initialized. This could happen in the degenerate case above
- * involving the raw inode number, where it has no nextlinkid. In this case, we will
- * simply not export the name as supported.
+
+ /* By this point, we've either patched up the name above and the c_desc
+ * points to the correct data, or it already did, in which case we just proceed
+ * by copying the name into the vap. Note that we will never set va_name to
+ * supported if nextlinkid is never initialized. This could happen in the degenerate
+ * case above involving the raw inode number, where it has no nextlinkid. In this case
+ * we will simply not mark the name bit as supported.
*/
if (uselinkdesc) {
- strlcpy(vap->va_name, (const char *)linkdesc.cd_nameptr, MAXPATHLEN);
+ strlcpy(vap->va_name, (const char*) linkdesc.cd_nameptr, MAXPATHLEN);
VATTR_SET_SUPPORTED(vap, va_name);
- cat_releasedesc(&linkdesc);
- }
+ cat_releasedesc(&linkdesc);
+ }
else if (cp->c_desc.cd_namelen) {
- strlcpy(vap->va_name, (const char *)cp->c_desc.cd_nameptr, MAXPATHLEN);
+ strlcpy(vap->va_name, (const char*) cp->c_desc.cd_nameptr, MAXPATHLEN);
VATTR_SET_SUPPORTED(vap, va_name);
}
}
out:
hfs_unlock(cp);
- /*
- * We need to drop the iocount on the rsrc fork vnode only *after* we've
- * released the cnode lock, since vnode_put can trigger an inactive call, which
- * will go back into the HFS and try to acquire a cnode lock.
+ /*
+ * We need to vnode_put the rsrc fork vnode only *after* we've released
+ * the cnode lock, since vnode_put can trigger an inactive call, which
+ * will go back into HFS and try to acquire a cnode lock.
*/
if (rvp) {
- vnode_put(rvp);
+ vnode_put (rvp);
}
+
return (error);
}
-static int
+int
hfs_vnop_setattr(ap)
struct vnop_setattr_args /* {
struct vnode *a_vp;
int error = 0;
uid_t nuid;
gid_t ngid;
+ time_t orig_ctime;
+
+ orig_ctime = VTOC(vp)->c_ctime;
+
+#if HFS_COMPRESSION
+ int decmpfs_reset_state = 0;
+ /*
+ we call decmpfs_update_attributes even if the file is not compressed
+ because we want to update the incoming flags if the xattrs are invalid
+ */
+ error = decmpfs_update_attributes(vp, vap);
+ if (error)
+ return error;
+
+ //
+ // if this is not a size-changing setattr and it is not just
+ // an atime update, then check for a snapshot.
+ //
+ if (!VATTR_IS_ACTIVE(vap, va_data_size) && !(vap->va_active == VNODE_ATTR_va_access_time)) {
+ check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_METADATA_MOD, NULL);
+ }
+#endif
+
+
+#if CONFIG_PROTECT
+ if ((error = cp_handle_vnop(vp, CP_WRITE_ACCESS, 0)) != 0) {
+ return (error);
+ }
+#endif /* CONFIG_PROTECT */
hfsmp = VTOHFS(vp);
- /* Don't allow modification of the journal file. */
- if (hfsmp->hfs_jnlfileid == VTOC(vp)->c_fileid) {
+ /* Don't allow modification of the journal. */
+ if (hfs_is_journal_file(hfsmp, VTOC(vp))) {
return (EPERM);
}
* File size change request.
* We are guaranteed that this is not a directory, and that
* the filesystem object is writeable.
+ *
+ * NOTE: HFS COMPRESSION depends on the data_size being set *before* the bsd flags are updated
*/
VATTR_SET_SUPPORTED(vap, va_data_size);
if (VATTR_IS_ACTIVE(vap, va_data_size) && !vnode_islnk(vp)) {
+#if HFS_COMPRESSION
+ /* keep the compressed state locked until we're done truncating the file */
+ decmpfs_cnode *dp = VTOCMP(vp);
+ if (!dp) {
+ /*
+ * call hfs_lazy_init_decmpfs_cnode() to make sure that the decmpfs_cnode
+ * is filled in; we need a decmpfs_cnode to lock out decmpfs state changes
+ * on this file while it's truncating
+ */
+ dp = hfs_lazy_init_decmpfs_cnode(VTOC(vp));
+ if (!dp) {
+ /* failed to allocate a decmpfs_cnode */
+ return ENOMEM; /* what should this be? */
+ }
+ }
+
+ check_for_tracked_file(vp, orig_ctime, vap->va_data_size == 0 ? NAMESPACE_HANDLER_TRUNCATE_OP|NAMESPACE_HANDLER_DELETE_OP : NAMESPACE_HANDLER_TRUNCATE_OP, NULL);
+
+ decmpfs_lock_compressed_data(dp, 1);
+ if (hfs_file_is_compressed(VTOC(vp), 1)) {
+ error = decmpfs_decompress_file(vp, dp, -1/*vap->va_data_size*/, 0, 1);
+ if (error != 0) {
+ decmpfs_unlock_compressed_data(dp, 1);
+ return error;
+ }
+ }
+#endif
/* Take truncate lock before taking cnode lock. */
- hfs_lock_truncate(VTOC(vp), TRUE);
+ hfs_lock_truncate(VTOC(vp), HFS_EXCLUSIVE_LOCK);
/* Perform the ubc_setsize before taking the cnode lock. */
ubc_setsize(vp, vap->va_data_size);
if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK))) {
- hfs_unlock_truncate(VTOC(vp), TRUE);
+ hfs_unlock_truncate(VTOC(vp), 0);
+#if HFS_COMPRESSION
+ decmpfs_unlock_compressed_data(dp, 1);
+#endif
return (error);
}
cp = VTOC(vp);
- error = hfs_truncate(vp, vap->va_data_size, vap->va_vaflags & 0xffff, 1, ap->a_context);
+ error = hfs_truncate(vp, vap->va_data_size, vap->va_vaflags & 0xffff, 1, 0, ap->a_context);
- hfs_unlock_truncate(cp, TRUE);
+ hfs_unlock_truncate(cp, 0);
+#if HFS_COMPRESSION
+ decmpfs_unlock_compressed_data(dp, 1);
+#endif
if (error)
goto out;
}
* Mode change request.
* We are guaranteed that the mode value is valid and that in
* conjunction with the owner and group, this change is legal.
- */
+ */
VATTR_SET_SUPPORTED(vap, va_mode);
if (VATTR_IS_ACTIVE(vap, va_mode) &&
((error = hfs_chmod(vp, (int)vap->va_mode, cred, p)) != 0))
if (VATTR_IS_ACTIVE(vap, va_flags)) {
u_int16_t *fdFlags;
- cp->c_flags = vap->va_flags;
+#if HFS_COMPRESSION
+ if ((cp->c_bsdflags ^ vap->va_flags) & UF_COMPRESSED) {
+ /*
+ * the UF_COMPRESSED was toggled, so reset our cached compressed state
+ * but we don't want to actually do the update until we've released the cnode lock down below
+ * NOTE: turning the flag off doesn't actually decompress the file, so that we can
+ * turn off the flag and look at the "raw" file for debugging purposes
+ */
+ decmpfs_reset_state = 1;
+ }
+#endif
+
+ cp->c_bsdflags = vap->va_flags;
cp->c_touch_chgtime = TRUE;
/*
if ((error = hfs_update(vp, TRUE)) != 0)
goto out;
- HFS_KNOTE(vp, NOTE_ATTRIB);
out:
- if (cp)
+ if (cp) {
+ /* Purge origin cache for cnode, since caller now has correct link ID for it
+ * We purge it here since it was acquired for us during lookup, and we no longer need it.
+ */
+ if ((cp->c_flag & C_HARDLINK) && (vp->v_type != VDIR)){
+ hfs_relorigin(cp, 0);
+ }
+
hfs_unlock(cp);
+#if HFS_COMPRESSION
+ if (decmpfs_reset_state) {
+ /*
+ * we've changed the UF_COMPRESSED flag, so reset the decmpfs state for this cnode
+ * but don't do it while holding the hfs cnode lock
+ */
+ decmpfs_cnode *dp = VTOCMP(vp);
+ if (!dp) {
+ /*
+ * call hfs_lazy_init_decmpfs_cnode() to make sure that the decmpfs_cnode
+ * is filled in; we need a decmpfs_cnode to prevent decmpfs state changes
+ * on this file if it's locked
+ */
+ dp = hfs_lazy_init_decmpfs_cnode(VTOC(vp));
+ if (!dp) {
+ /* failed to allocate a decmpfs_cnode */
+ return ENOMEM; /* what should this be? */
+ }
+ }
+ decmpfs_cnode_set_vnode_state(dp, FILE_TYPE_UNKNOWN, 0);
+ }
+#endif
+ }
return (error);
}
* Change the mode on a file.
* cnode must be locked before calling.
*/
-__private_extern__
int
hfs_chmod(struct vnode *vp, int mode, __unused kauth_cred_t cred, __unused struct proc *p)
{
if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord)
return (0);
- // XXXdbg - don't allow modification of the journal or journal_info_block
- if (VTOHFS(vp)->jnl && cp && cp->c_datafork) {
- struct HFSPlusExtentDescriptor *extd;
-
- extd = &cp->c_datafork->ff_extents[0];
- if (extd->startBlock == VTOVCB(vp)->vcbJinfoBlock || extd->startBlock == VTOHFS(vp)->jnl_start) {
- return EPERM;
- }
+ // Don't allow modification of the journal or journal_info_block
+ if (hfs_is_journal_file(VTOHFS(vp), cp)) {
+ return EPERM;
}
#if OVERRIDE_UNKNOWN_PERMISSIONS
}
-__private_extern__
int
hfs_write_access(struct vnode *vp, kauth_cred_t cred, struct proc *p, Boolean considerFlags)
{
}
/* If immutable bit set, nobody gets to write it. */
- if (considerFlags && (cp->c_flags & IMMUTABLE))
+ if (considerFlags && (cp->c_bsdflags & IMMUTABLE))
return (EPERM);
/* Otherwise, user id 0 always gets access. */
* Perform chown operation on cnode cp;
* code must be locked prior to call.
*/
-__private_extern__
int
#if !QUOTA
hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, __unused kauth_cred_t cred,
* case the file is being tracked through its file ID. Typically
* its used after creating a new file during a safe-save.
*/
-static int
+int
hfs_vnop_exchange(ap)
struct vnop_exchange_args /* {
struct vnode *a_fvp;
const unsigned char *to_nameptr;
char from_iname[32];
char to_iname[32];
- u_int32_t tempflag;
+ uint32_t to_flag_special;
+ uint32_t from_flag_special;
cnid_t from_parid;
cnid_t to_parid;
int lockflags;
int error = 0, started_tr = 0, got_cookie = 0;
cat_cookie_t cookie;
+ time_t orig_from_ctime, orig_to_ctime;
/* The files must be on the same volume. */
if (vnode_mount(from_vp) != vnode_mount(to_vp))
if (from_vp == to_vp)
return (EINVAL);
- if ((error = hfs_lockpair(VTOC(from_vp), VTOC(to_vp), HFS_EXCLUSIVE_LOCK)))
- return (error);
+ orig_from_ctime = VTOC(from_vp)->c_ctime;
+ orig_to_ctime = VTOC(to_vp)->c_ctime;
- from_cp = VTOC(from_vp);
- to_cp = VTOC(to_vp);
- hfsmp = VTOHFS(from_vp);
- /* Only normal files can be exchanged. */
- if (!vnode_isreg(from_vp) || !vnode_isreg(to_vp) ||
- VNODE_IS_RSRC(from_vp) || VNODE_IS_RSRC(to_vp)) {
- error = EINVAL;
- goto exit;
+#if CONFIG_PROTECT
+ /*
+ * Do not allow exchangedata/F_MOVEDATAEXTENTS on data-protected filesystems
+ * because the EAs will not be swapped. As a result, the persistent keys would not
+ * match and the files will be garbage.
+ */
+ if (cp_fs_protected (vnode_mount(from_vp))) {
+ return EINVAL;
}
+#endif
- // XXXdbg - don't allow modification of the journal or journal_info_block
- if (hfsmp->jnl) {
- struct HFSPlusExtentDescriptor *extd;
+#if HFS_COMPRESSION
+ if ( hfs_file_is_compressed(VTOC(from_vp), 0) ) {
+ if ( 0 != ( error = decmpfs_decompress_file(from_vp, VTOCMP(from_vp), -1, 0, 1) ) ) {
+ return error;
+ }
+ }
+
+ if ( hfs_file_is_compressed(VTOC(to_vp), 0) ) {
+ if ( 0 != ( error = decmpfs_decompress_file(to_vp, VTOCMP(to_vp), -1, 0, 1) ) ) {
+ return error;
+ }
+ }
+#endif // HFS_COMPRESSION
+
+ /*
+ * Normally, we want to notify the user handlers about the event,
+ * except if it's a handler driving the event.
+ */
+ if ((ap->a_options & FSOPT_EXCHANGE_DATA_ONLY) == 0) {
+ check_for_tracked_file(from_vp, orig_from_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL);
+ check_for_tracked_file(to_vp, orig_to_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL);
+ } else {
+ /*
+ * We're doing a data-swap.
+ * Take the truncate lock/cnode lock, then verify there are no mmap references.
+ * Issue a hfs_filedone to flush out all of the remaining state for this file.
+ * Allow the rest of the codeflow to re-acquire the cnode locks in order.
+ */
+
+ hfs_lock_truncate (VTOC(from_vp), HFS_SHARED_LOCK);
+
+ if ((error = hfs_lock(VTOC(from_vp), HFS_EXCLUSIVE_LOCK))) {
+ hfs_unlock_truncate (VTOC(from_vp), 0);
+ return error;
+ }
- if (from_cp->c_datafork) {
- extd = &from_cp->c_datafork->ff_extents[0];
- if (extd->startBlock == VTOVCB(from_vp)->vcbJinfoBlock || extd->startBlock == hfsmp->jnl_start) {
- error = EPERM;
- goto exit;
- }
+ /* Verify the source file is not in use by anyone besides us (including mmap refs) */
+ if (vnode_isinuse(from_vp, 1)) {
+ error = EBUSY;
+ hfs_unlock(VTOC(from_vp));
+ hfs_unlock_truncate (VTOC(from_vp), 0);
+ return error;
}
- if (to_cp->c_datafork) {
- extd = &to_cp->c_datafork->ff_extents[0];
- if (extd->startBlock == VTOVCB(to_vp)->vcbJinfoBlock || extd->startBlock == hfsmp->jnl_start) {
- error = EPERM;
- goto exit;
- }
+ /* Flush out the data in the source file */
+ VTOC(from_vp)->c_flag |= C_SWAPINPROGRESS;
+ error = hfs_filedone (from_vp, ap->a_context);
+ VTOC(from_vp)->c_flag &= ~C_SWAPINPROGRESS;
+ hfs_unlock(VTOC(from_vp));
+ hfs_unlock_truncate(VTOC(from_vp), 0);
+
+ if (error) {
+ return error;
}
}
+ if ((error = hfs_lockpair(VTOC(from_vp), VTOC(to_vp), HFS_EXCLUSIVE_LOCK)))
+ return (error);
+
+ from_cp = VTOC(from_vp);
+ to_cp = VTOC(to_vp);
+ hfsmp = VTOHFS(from_vp);
+
+ /* Resource forks cannot be exchanged. */
+ if (VNODE_IS_RSRC(from_vp) || VNODE_IS_RSRC(to_vp)) {
+ error = EINVAL;
+ goto exit;
+ }
+
+ // Don't allow modification of the journal or journal_info_block
+ if (hfs_is_journal_file(hfsmp, from_cp) ||
+ hfs_is_journal_file(hfsmp, to_cp)) {
+ error = EPERM;
+ goto exit;
+ }
+
+ /*
+ * Ok, now that all of the pre-flighting is done, call the underlying
+ * function if needed.
+ */
+ if (ap->a_options & FSOPT_EXCHANGE_DATA_ONLY) {
+ error = hfs_movedata(from_vp, to_vp);
+ goto exit;
+ }
+
+
if ((error = hfs_start_transaction(hfsmp)) != 0) {
goto exit;
}
/* Save a copy of from attributes before swapping. */
bcopy(&from_cp->c_desc, &tempdesc, sizeof(struct cat_desc));
bcopy(&from_cp->c_attr, &tempattr, sizeof(struct cat_attr));
- tempflag = from_cp->c_flag & (C_HARDLINK | C_HASXATTRS);
+
+ /* Save whether or not each cnode is a hardlink or has EAs */
+ from_flag_special = from_cp->c_flag & (C_HARDLINK | C_HASXATTRS);
+ to_flag_special = to_cp->c_flag & (C_HARDLINK | C_HASXATTRS);
+
+ /* Drop the special bits from each cnode */
+ from_cp->c_flag &= ~(C_HARDLINK | C_HASXATTRS);
+ to_cp->c_flag &= ~(C_HARDLINK | C_HASXATTRS);
/*
* Swap the descriptors and all non-fork related attributes.
bcopy(&to_cp->c_desc, &from_cp->c_desc, sizeof(struct cat_desc));
from_cp->c_hint = 0;
- from_cp->c_fileid = from_cp->c_cnid;
+ /*
+ * If 'to' was a hardlink, then we copied over its link ID/CNID/(namespace ID)
+ * when we bcopy'd the descriptor above. However, we need to be careful
+ * when setting up the fileID below, because we cannot assume that the
+ * file ID is the same as the CNID if either one was a hardlink.
+ * The file ID is stored in the c_attr as the ca_fileid. So it needs
+ * to be pulled explicitly; we cannot just use the CNID.
+ */
+ from_cp->c_fileid = to_cp->c_attr.ca_fileid;
+
from_cp->c_itime = to_cp->c_itime;
from_cp->c_btime = to_cp->c_btime;
from_cp->c_atime = to_cp->c_atime;
from_cp->c_ctime = to_cp->c_ctime;
from_cp->c_gid = to_cp->c_gid;
from_cp->c_uid = to_cp->c_uid;
- from_cp->c_flags = to_cp->c_flags;
+ from_cp->c_bsdflags = to_cp->c_bsdflags;
from_cp->c_mode = to_cp->c_mode;
from_cp->c_linkcount = to_cp->c_linkcount;
- from_cp->c_flag = to_cp->c_flag & (C_HARDLINK | C_HASXATTRS);
+ from_cp->c_attr.ca_linkref = to_cp->c_attr.ca_linkref;
+ from_cp->c_attr.ca_firstlink = to_cp->c_attr.ca_firstlink;
+
+ /*
+ * The cnode flags need to stay with the cnode and not get transferred
+ * over along with everything else because they describe the content; they are
+ * not attributes that reflect changes specific to the file ID. In general,
+ * fields that are tied to the file ID are the ones that will move.
+ *
+ * This reflects the fact that the file may have borrowed blocks, dirty metadata,
+ * or other extents, which may not yet have been written to the catalog. If
+ * they were, they would have been transferred above in the ExchangeFileIDs call above...
+ *
+ * The flags that are special are:
+ * C_HARDLINK, C_HASXATTRS
+ *
+ * These flags move with the item and file ID in the namespace since their
+ * state is tied to that of the file ID.
+ *
+ * So to transfer the flags, we have to take the following steps
+ * 1) Store in a localvar whether or not the special bits are set.
+ * 2) Drop the special bits from the current flags
+ * 3) swap the special flag bits to their destination
+ */
+ from_cp->c_flag |= to_flag_special;
+
from_cp->c_attr.ca_recflags = to_cp->c_attr.ca_recflags;
bcopy(to_cp->c_finderinfo, from_cp->c_finderinfo, 32);
bcopy(&tempdesc, &to_cp->c_desc, sizeof(struct cat_desc));
to_cp->c_hint = 0;
- to_cp->c_fileid = to_cp->c_cnid;
+ /*
+ * Pull the file ID from the tempattr we copied above. We can't assume
+ * it is the same as the CNID.
+ */
+ to_cp->c_fileid = tempattr.ca_fileid;
to_cp->c_itime = tempattr.ca_itime;
to_cp->c_btime = tempattr.ca_btime;
to_cp->c_atime = tempattr.ca_atime;
to_cp->c_ctime = tempattr.ca_ctime;
to_cp->c_gid = tempattr.ca_gid;
to_cp->c_uid = tempattr.ca_uid;
- to_cp->c_flags = tempattr.ca_flags;
+ to_cp->c_bsdflags = tempattr.ca_flags;
to_cp->c_mode = tempattr.ca_mode;
to_cp->c_linkcount = tempattr.ca_linkcount;
- to_cp->c_flag = tempflag;
+ to_cp->c_attr.ca_linkref = tempattr.ca_linkref;
+ to_cp->c_attr.ca_firstlink = tempattr.ca_firstlink;
+
+ /*
+ * Only OR in the "from" flags into our cnode flags below.
+ * Leave the rest of the flags alone.
+ */
+ to_cp->c_flag |= from_flag_special;
+
to_cp->c_attr.ca_recflags = tempattr.ca_recflags;
bcopy(tempattr.ca_finderinfo, to_cp->c_finderinfo, 32);
/* Rehash the cnodes using their new file IDs */
- hfs_chash_rehash(from_cp, to_cp);
+ hfs_chash_rehash(hfsmp, from_cp, to_cp);
/*
* When a file moves out of "Cleanup At Startup"
* we can drop its NODUMP status.
*/
- if ((from_cp->c_flags & UF_NODUMP) &&
+ if ((from_cp->c_bsdflags & UF_NODUMP) &&
(from_cp->c_parentcnid != to_cp->c_parentcnid)) {
- from_cp->c_flags &= ~UF_NODUMP;
+ from_cp->c_bsdflags &= ~UF_NODUMP;
from_cp->c_touch_chgtime = TRUE;
}
- if ((to_cp->c_flags & UF_NODUMP) &&
+ if ((to_cp->c_bsdflags & UF_NODUMP) &&
(to_cp->c_parentcnid != from_cp->c_parentcnid)) {
- to_cp->c_flags &= ~UF_NODUMP;
+ to_cp->c_bsdflags &= ~UF_NODUMP;
to_cp->c_touch_chgtime = TRUE;
}
- HFS_KNOTE(from_vp, NOTE_ATTRIB);
- HFS_KNOTE(to_vp, NOTE_ATTRIB);
-
exit:
if (got_cookie) {
cat_postflight(hfsmp, &cookie, vfs_context_proc(ap->a_context));
return (error);
}
+int
+hfs_vnop_mmap(struct vnop_mmap_args *ap)
+{
+ struct vnode *vp = ap->a_vp;
+ int error;
+
+ if (VNODE_IS_RSRC(vp)) {
+ /* allow pageins of the resource fork */
+ } else {
+ int compressed = hfs_file_is_compressed(VTOC(vp), 1); /* 1 == don't take the cnode lock */
+ time_t orig_ctime = VTOC(vp)->c_ctime;
+
+ if (!compressed && (VTOC(vp)->c_bsdflags & UF_COMPRESSED)) {
+ error = check_for_dataless_file(vp, NAMESPACE_HANDLER_READ_OP);
+ if (error != 0) {
+ return error;
+ }
+ }
+
+ if (ap->a_fflags & PROT_WRITE) {
+ check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL);
+ }
+ }
+
+ //
+ // NOTE: we return ENOTSUP because we want the cluster layer
+ // to actually do all the real work.
+ //
+ return (ENOTSUP);
+}
+
+/*
+ * hfs_movedata
+ *
+ * This is a non-symmetric variant of exchangedata. In this function,
+ * the contents of the fork in from_vp are moved to the fork
+ * specified by to_vp.
+ *
+ * The cnodes pointed to by 'from_vp' and 'to_vp' must be locked.
+ *
+ * The vnode pointed to by 'to_vp' *must* be empty prior to invoking this function.
+ * We impose this restriction because we may not be able to fully delete the entire
+ * file's contents in a single transaction, particularly if it has a lot of extents.
+ * In the normal file deletion codepath, the file is screened for two conditions:
+ * 1) bigger than 400MB, and 2) more than 8 extents. If so, the file is relocated to
+ * the hidden directory and the deletion is broken up into multiple truncates. We can't
+ * do that here because both files need to exist in the namespace. The main reason this
+ * is imposed is that we may have to touch a whole lot of bitmap blocks if there are
+ * many extents.
+ *
+ * Any data written to 'from_vp' after this call completes is not guaranteed
+ * to be moved.
+ *
+ * Arguments:
+ * vnode from_vp: source file
+ * vnode to_vp: destination file; must be empty
+ *
+ * Returns:
+ * EFBIG - Destination file was not empty
+ * 0 - success
+ *
+ *
+ */
+int hfs_movedata (struct vnode *from_vp, struct vnode *to_vp) {
+
+ struct cnode *from_cp;
+ struct cnode *to_cp;
+ struct hfsmount *hfsmp = NULL;
+ int error = 0;
+ int started_tr = 0;
+ int lockflags = 0;
+ int overflow_blocks;
+ int rsrc = 0;
+
+
+ /* Get the HFS pointers */
+ from_cp = VTOC(from_vp);
+ to_cp = VTOC(to_vp);
+ hfsmp = VTOHFS(from_vp);
+
+ /* Verify that neither source/dest file is open-unlinked */
+ if (from_cp->c_flag & (C_DELETED | C_NOEXISTS)) {
+ error = EBUSY;
+ goto movedata_exit;
+ }
+
+ if (to_cp->c_flag & (C_DELETED | C_NOEXISTS)) {
+ error = EBUSY;
+ goto movedata_exit;
+ }
+
+ /*
+ * Verify the source file is not in use by anyone besides us.
+ *
+ * This function is typically invoked by a namespace handler
+ * process responding to a temporarily stalled system call.
+ * The FD that it is working off of is opened O_EVTONLY, so
+ * it really has no active usecounts (the kusecount from O_EVTONLY
+ * is subtracted from the total usecounts).
+ *
+ * As a result, we shouldn't have any active usecounts against
+ * this vnode when we go to check it below.
+ */
+ if (vnode_isinuse(from_vp, 0)) {
+ error = EBUSY;
+ goto movedata_exit;
+ }
+
+ if (from_cp->c_rsrc_vp == from_vp) {
+ rsrc = 1;
+ }
+
+ /*
+ * We assume that the destination file is already empty.
+ * Verify that it is.
+ */
+ if (rsrc) {
+ if (to_cp->c_rsrcfork->ff_size > 0) {
+ error = EFBIG;
+ goto movedata_exit;
+ }
+ }
+ else {
+ if (to_cp->c_datafork->ff_size > 0) {
+ error = EFBIG;
+ goto movedata_exit;
+ }
+ }
+
+ /* If the source has the rsrc open, make sure the destination is also the rsrc */
+ if (rsrc) {
+ if (to_vp != to_cp->c_rsrc_vp) {
+ error = EINVAL;
+ goto movedata_exit;
+ }
+ }
+ else {
+ /* Verify that both forks are data forks */
+ if (to_vp != to_cp->c_vp) {
+ error = EINVAL;
+ goto movedata_exit;
+ }
+ }
+
+ /*
+ * See if the source file has overflow extents. If it doesn't, we don't
+ * need to call into MoveData, and the catalog will be enough.
+ */
+ if (rsrc) {
+ overflow_blocks = overflow_extents(from_cp->c_rsrcfork);
+ }
+ else {
+ overflow_blocks = overflow_extents(from_cp->c_datafork);
+ }
+
+ if ((error = hfs_start_transaction (hfsmp)) != 0) {
+ goto movedata_exit;
+ }
+ started_tr = 1;
+
+ /* Lock the system files: catalog, extents, attributes */
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);
+
+ /* Copy over any catalog allocation data into the new spot. */
+ if (rsrc) {
+ if ((error = hfs_move_fork (from_cp->c_rsrcfork, from_cp, to_cp->c_rsrcfork, to_cp))){
+ hfs_systemfile_unlock(hfsmp, lockflags);
+ goto movedata_exit;
+ }
+ }
+ else {
+ if ((error = hfs_move_fork (from_cp->c_datafork, from_cp, to_cp->c_datafork, to_cp))) {
+ hfs_systemfile_unlock(hfsmp, lockflags);
+ goto movedata_exit;
+ }
+ }
+
+ /*
+ * Note that because all we're doing is moving the extents around, we can
+ * probably do this in a single transaction: Each extent record (group of 8)
+ * is 64 bytes. A extent overflow B-Tree node is typically 4k. This means
+ * each node can hold roughly ~60 extent records == (480 extents).
+ *
+ * If a file was massively fragmented and had 20k extents, this means we'd
+ * roughly touch 20k/480 == 41 to 42 nodes, plus the index nodes, for half
+ * of the operation. (inserting or deleting). So if we're manipulating 80-100
+ * nodes, this is basically 320k of data to write to the journal in
+ * a bad case.
+ */
+ if (overflow_blocks != 0) {
+ if (rsrc) {
+ error = MoveData(hfsmp, from_cp->c_cnid, to_cp->c_cnid, 1);
+ }
+ else {
+ error = MoveData (hfsmp, from_cp->c_cnid, to_cp->c_cnid, 0);
+ }
+ }
+
+ if (error) {
+ /* Reverse the operation. Copy the fork data back into the source */
+ if (rsrc) {
+ hfs_move_fork (to_cp->c_rsrcfork, to_cp, from_cp->c_rsrcfork, from_cp);
+ }
+ else {
+ hfs_move_fork (to_cp->c_datafork, to_cp, from_cp->c_datafork, from_cp);
+ }
+ }
+ else {
+ struct cat_fork *src_data = NULL;
+ struct cat_fork *src_rsrc = NULL;
+ struct cat_fork *dst_data = NULL;
+ struct cat_fork *dst_rsrc = NULL;
+
+ /* Touch the times*/
+ to_cp->c_touch_acctime = TRUE;
+ to_cp->c_touch_chgtime = TRUE;
+ to_cp->c_touch_modtime = TRUE;
+
+ from_cp->c_touch_acctime = TRUE;
+ from_cp->c_touch_chgtime = TRUE;
+ from_cp->c_touch_modtime = TRUE;
+
+ hfs_touchtimes(hfsmp, to_cp);
+ hfs_touchtimes(hfsmp, from_cp);
+
+ if (from_cp->c_datafork) {
+ src_data = &from_cp->c_datafork->ff_data;
+ }
+ if (from_cp->c_rsrcfork) {
+ src_rsrc = &from_cp->c_rsrcfork->ff_data;
+ }
+
+ if (to_cp->c_datafork) {
+ dst_data = &to_cp->c_datafork->ff_data;
+ }
+ if (to_cp->c_rsrcfork) {
+ dst_rsrc = &to_cp->c_rsrcfork->ff_data;
+ }
+
+ /* Update the catalog nodes */
+ (void) cat_update(hfsmp, &from_cp->c_desc, &from_cp->c_attr,
+ src_data, src_rsrc);
+
+ (void) cat_update(hfsmp, &to_cp->c_desc, &to_cp->c_attr,
+ dst_data, dst_rsrc);
+
+ }
+ /* unlock the system files */
+ hfs_systemfile_unlock(hfsmp, lockflags);
+
+
+movedata_exit:
+ if (started_tr) {
+ hfs_end_transaction(hfsmp);
+ }
+
+ return error;
+
+}
+
+/*
+ * Copy all of the catalog and runtime data in srcfork to dstfork.
+ *
+ * This allows us to maintain the invalid ranges across the movedata operation so
+ * we don't need to force all of the pending IO right now. In addition, we move all
+ * non overflow-extent extents into the destination here.
+ */
+static int hfs_move_fork (struct filefork *srcfork, struct cnode *src_cp,
+ struct filefork *dstfork, struct cnode *dst_cp) {
+ struct rl_entry *invalid_range;
+ int size = sizeof(struct HFSPlusExtentDescriptor);
+ size = size * kHFSPlusExtentDensity;
+
+ /* If the dstfork has any invalid ranges, bail out */
+ invalid_range = TAILQ_FIRST(&dstfork->ff_invalidranges);
+ if (invalid_range != NULL) {
+ return EFBIG;
+ }
+
+ if (dstfork->ff_data.cf_size != 0 || dstfork->ff_data.cf_new_size != 0) {
+ return EFBIG;
+ }
+
+ /* First copy the invalid ranges */
+ while ((invalid_range = TAILQ_FIRST(&srcfork->ff_invalidranges))) {
+ off_t start = invalid_range->rl_start;
+ off_t end = invalid_range->rl_end;
+
+ /* Remove it from the srcfork and add it to dstfork */
+ rl_remove(start, end, &srcfork->ff_invalidranges);
+ rl_add(start, end, &dstfork->ff_invalidranges);
+ }
+
+ /*
+ * Ignore the ff_union. We don't move symlinks or system files.
+ * Now copy the in-catalog extent information
+ */
+ dstfork->ff_data.cf_size = srcfork->ff_data.cf_size;
+ dstfork->ff_data.cf_new_size = srcfork->ff_data.cf_new_size;
+ dstfork->ff_data.cf_vblocks = srcfork->ff_data.cf_vblocks;
+ dstfork->ff_data.cf_blocks = srcfork->ff_data.cf_blocks;
+
+ /* just memcpy the whole array of extents to the new location. */
+ memcpy (dstfork->ff_data.cf_extents, srcfork->ff_data.cf_extents, size);
+
+ /*
+ * Copy the cnode attribute data.
+ *
+ */
+ src_cp->c_blocks -= srcfork->ff_data.cf_vblocks;
+ src_cp->c_blocks -= srcfork->ff_data.cf_blocks;
+
+ dst_cp->c_blocks += srcfork->ff_data.cf_vblocks;
+ dst_cp->c_blocks += srcfork->ff_data.cf_blocks;
+
+ /* Now delete the entries in the source fork */
+ srcfork->ff_data.cf_size = 0;
+ srcfork->ff_data.cf_new_size = 0;
+ srcfork->ff_data.cf_union.cfu_bytesread = 0;
+ srcfork->ff_data.cf_vblocks = 0;
+ srcfork->ff_data.cf_blocks = 0;
+
+ /* Zero out the old extents */
+ bzero (srcfork->ff_data.cf_extents, size);
+ return 0;
+}
+
/*
* cnode must be locked
*/
-__private_extern__
int
hfs_fsync(struct vnode *vp, int waitfor, int fullsync, struct proc *p)
{
struct filefork *fp = NULL;
int retval = 0;
struct hfsmount *hfsmp = VTOHFS(vp);
+ struct rl_entry *invalid_range;
struct timeval tv;
- int wait;
+ int waitdata; /* attributes necessary for data retrieval */
+ int wait; /* all other attributes (e.g. atime, etc.) */
int lockflag;
int took_trunc_lock = 0;
+ int locked_buffers = 0;
+ /*
+ * Applications which only care about data integrity rather than full
+ * file integrity may opt out of (delay) expensive metadata update
+ * operations as a performance optimization.
+ */
wait = (waitfor == MNT_WAIT);
+ waitdata = (waitfor == MNT_DWAIT) | wait;
if (always_do_fullfsync)
fullsync = 1;
/* HFS directories don't have any data blocks. */
if (vnode_isdir(vp))
goto metasync;
+ fp = VTOF(vp);
/*
* For system files flush the B-tree header and
}
} else if (UBCINFOEXISTS(vp)) {
hfs_unlock(cp);
- hfs_lock_truncate(cp, TRUE);
+ hfs_lock_truncate(cp, HFS_SHARED_LOCK);
took_trunc_lock = 1;
+ if (fp->ff_unallocblocks != 0) {
+ hfs_unlock_truncate(cp, 0);
+
+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK);
+ }
/* Don't hold cnode lock when calling into cluster layer. */
- (void) cluster_push(vp, wait ? IO_SYNC : 0);
+ (void) cluster_push(vp, waitdata ? IO_SYNC : 0);
hfs_lock(cp, HFS_FORCE_LOCK);
}
*
* Files with NODUMP can bypass zero filling here.
*/
- if ((wait || (cp->c_flag & C_ZFWANTSYNC)) &&
- ((cp->c_flags & UF_NODUMP) == 0) &&
- UBCINFOEXISTS(vp) && (vnode_issystem(vp) ==0) && (fp = VTOF(vp)) &&
- cp->c_zftimeout != 0) {
+ if (fp && (((cp->c_flag & C_ALWAYS_ZEROFILL) && !TAILQ_EMPTY(&fp->ff_invalidranges)) ||
+ ((wait || (cp->c_flag & C_ZFWANTSYNC)) &&
+ ((cp->c_bsdflags & UF_NODUMP) == 0) &&
+ UBCINFOEXISTS(vp) && (vnode_issystem(vp) ==0) &&
+ cp->c_zftimeout != 0))) {
+
microuptime(&tv);
- if (!fullsync && tv.tv_sec < (long)cp->c_zftimeout) {
+ if ((cp->c_flag & C_ALWAYS_ZEROFILL) == 0 && !fullsync && tv.tv_sec < (long)cp->c_zftimeout) {
/* Remember that a force sync was requested. */
cp->c_flag |= C_ZFWANTSYNC;
goto datasync;
}
- if (!took_trunc_lock) {
- hfs_unlock(cp);
- hfs_lock_truncate(cp, TRUE);
- hfs_lock(cp, HFS_FORCE_LOCK);
- took_trunc_lock = 1;
- }
-
- while (!CIRCLEQ_EMPTY(&fp->ff_invalidranges)) {
- struct rl_entry *invalid_range = CIRCLEQ_FIRST(&fp->ff_invalidranges);
- off_t start = invalid_range->rl_start;
- off_t end = invalid_range->rl_end;
+ if (!TAILQ_EMPTY(&fp->ff_invalidranges)) {
+ if (!took_trunc_lock || (cp->c_truncatelockowner == HFS_SHARED_OWNER)) {
+ hfs_unlock(cp);
+ if (took_trunc_lock) {
+ hfs_unlock_truncate(cp, 0);
+ }
+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK);
+ hfs_lock(cp, HFS_FORCE_LOCK);
+ took_trunc_lock = 1;
+ }
+ while ((invalid_range = TAILQ_FIRST(&fp->ff_invalidranges))) {
+ off_t start = invalid_range->rl_start;
+ off_t end = invalid_range->rl_end;
- /* The range about to be written must be validated
- * first, so that VNOP_BLOCKMAP() will return the
- * appropriate mapping for the cluster code:
- */
- rl_remove(start, end, &fp->ff_invalidranges);
+ /* The range about to be written must be validated
+ * first, so that VNOP_BLOCKMAP() will return the
+ * appropriate mapping for the cluster code:
+ */
+ rl_remove(start, end, &fp->ff_invalidranges);
- /* Don't hold cnode lock when calling into cluster layer. */
+ /* Don't hold cnode lock when calling into cluster layer. */
+ hfs_unlock(cp);
+ (void) cluster_write(vp, (struct uio *) 0,
+ fp->ff_size, end + 1, start, (off_t)0,
+ IO_HEADZEROFILL | IO_NOZERODIRTY | IO_NOCACHE);
+ hfs_lock(cp, HFS_FORCE_LOCK);
+ cp->c_flag |= C_MODIFIED;
+ }
hfs_unlock(cp);
- (void) cluster_write(vp, (struct uio *) 0,
- fp->ff_size, end + 1, start, (off_t)0,
- IO_HEADZEROFILL | IO_NOZERODIRTY | IO_NOCACHE);
+ (void) cluster_push(vp, waitdata ? IO_SYNC : 0);
hfs_lock(cp, HFS_FORCE_LOCK);
- cp->c_flag |= C_MODIFIED;
}
- hfs_unlock(cp);
- (void) cluster_push(vp, wait ? IO_SYNC : 0);
- hfs_lock(cp, HFS_FORCE_LOCK);
-
cp->c_flag &= ~C_ZFWANTSYNC;
cp->c_zftimeout = 0;
}
datasync:
- if (took_trunc_lock)
- hfs_unlock_truncate(cp, TRUE);
-
+ if (took_trunc_lock) {
+ hfs_unlock_truncate(cp, 0);
+ took_trunc_lock = 0;
+ }
/*
* if we have a journal and if journal_active() returns != 0 then the
* we shouldn't do anything to a locked block (because it is part
/*
* Flush all dirty buffers associated with a vnode.
+ * Record how many of them were dirty AND locked (if necessary).
*/
- buf_flushdirtyblks(vp, wait, lockflag, "hfs_fsync");
+ locked_buffers = buf_flushdirtyblks_skipinfo(vp, waitdata, lockflag, "hfs_fsync");
+ if ((lockflag & BUF_SKIP_LOCKED) && (locked_buffers) && (vnode_vtype(vp) == VLNK)) {
+ /*
+ * If there are dirty symlink buffers, then we may need to take action
+ * to prevent issues later on if we are journaled. If we're fsyncing a
+ * symlink vnode then we are in one of three cases:
+ *
+ * 1) automatic sync has fired. In this case, we don't want the behavior to change.
+ *
+ * 2) Someone has opened the FD for the symlink (not what it points to)
+ * and has issued an fsync against it. This should be rare, and we don't
+ * want the behavior to change.
+ *
+ * 3) We are being called by a vclean which is trying to reclaim this
+ * symlink vnode. If this is the case, then allowing this fsync to
+ * proceed WITHOUT flushing the journal could result in the vclean
+ * invalidating the buffer's blocks before the journal transaction is
+ * written to disk. To prevent this, we force a journal flush
+ * if the vnode is in the middle of a recycle (VL_TERMINATE or VL_DEAD is set).
+ */
+ if (vnode_isrecycled(vp)) {
+ fullsync = 1;
+ }
+ }
metasync:
if (vnode_isreg(vp) && vnode_issystem(vp)) {
* changes get to stable storage.
*/
if (fullsync) {
- if (hfsmp->jnl) {
- journal_flush(hfsmp->jnl);
- } else {
- retval = hfs_metasync_all(hfsmp);
- /* XXX need to pass context! */
- VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, NULL);
- }
+ if (hfsmp->jnl) {
+ hfs_journal_flush(hfsmp, FALSE);
+
+ if (journal_uses_fua(hfsmp->jnl)) {
+ /*
+ * the journal_flush did NOT issue a sync track cache command,
+ * and the fullsync indicates we are supposed to flush all cached
+ * data to the media, so issue the sync track cache command
+ * explicitly
+ */
+ VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, NULL);
+ }
+ } else {
+ retval = hfs_metasync_all(hfsmp);
+ /* XXX need to pass context! */
+ VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, NULL);
+ }
}
}
/* Sync an hfs catalog b-tree node */
-static int
+int
hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, __unused struct proc *p)
{
vnode_t vp;
* we rely on fsck_hfs to fix that up (which it can do without any loss
* of data).
*/
-static int
+int
hfs_metasync_all(struct hfsmount *hfsmp)
{
int lockflags;
}
-__private_extern__
int
hfs_btsync(struct vnode *vp, int sync_transaction)
{
/*
* Remove a directory.
*/
-static int
+int
hfs_vnop_rmdir(ap)
struct vnop_rmdir_args /* {
struct vnode *a_dvp;
struct cnode *dcp = VTOC(dvp);
struct cnode *cp = VTOC(vp);
int error;
+ time_t orig_ctime;
+
+ orig_ctime = VTOC(vp)->c_ctime;
if (!S_ISDIR(cp->c_mode)) {
return (ENOTDIR);
if (dvp == vp) {
return (EINVAL);
}
+
+ check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL);
+ cp = VTOC(vp);
+
if ((error = hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK))) {
return (error);
}
- error = hfs_removedir(dvp, vp, ap->a_cnp, 0);
+
+ /* Check for a race with rmdir on the parent directory */
+ if (dcp->c_flag & (C_DELETED | C_NOEXISTS)) {
+ hfs_unlockpair (dcp, cp);
+ return ENOENT;
+ }
+ error = hfs_removedir(dvp, vp, ap->a_cnp, 0, 0);
+
hfs_unlockpair(dcp, cp);
return (error);
*
* Both dvp and vp cnodes are locked
*/
-static int
+int
hfs_removedir(struct vnode *dvp, struct vnode *vp, struct componentname *cnp,
- int skip_reserve)
+ int skip_reserve, int only_unlink)
{
struct cnode *cp;
struct cnode *dcp;
if (cp->c_entries != 0) {
return (ENOTEMPTY);
}
+
+ /*
+ * If the directory is open or in use (e.g. opendir() or current working
+ * directory for some process); wait for inactive/reclaim to actually
+ * remove cnode from the catalog. Both inactive and reclaim codepaths are capable
+ * of removing open-unlinked directories from the catalog, as well as getting rid
+ * of EAs still on the element. So change only_unlink to true, so that it will get
+ * cleaned up below.
+ *
+ * Otherwise, we can get into a weird old mess where the directory has C_DELETED,
+ * but it really means C_NOEXISTS because the item was actually removed from the
+ * catalog. Then when we try to remove the entry from the catalog later on, it won't
+ * really be there anymore.
+ */
+ if (vnode_isinuse(vp, 0)) {
+ only_unlink = 1;
+ }
- /* Check if we're removing the last link to an empty directory. */
+ /* Deal with directory hardlinks */
if (cp->c_flag & C_HARDLINK) {
- /* We could also return EBUSY here */
+ /*
+ * Note that if we have a directory which was a hardlink at any point,
+ * its actual directory data is stored in the directory inode in the hidden
+ * directory rather than the leaf element(s) present in the namespace.
+ *
+ * If there are still other hardlinks to this directory,
+ * then we'll just eliminate this particular link and the vnode will still exist.
+ * If this is the last link to an empty directory, then we'll open-unlink the
+ * directory and it will be only tagged with C_DELETED (as opposed to C_NOEXISTS).
+ *
+ * We could also return EBUSY here.
+ */
+
return hfs_unlink(hfsmp, dvp, vp, cnp, skip_reserve);
}
-
- if ((hfsmp->hfs_attribute_vp != NULL) &&
- (cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0) {
-
- return hfs_removefile(dvp, vp, cnp, 0, 0, 1);
+
+ /*
+ * In a few cases, we may want to allow the directory to persist in an
+ * open-unlinked state. If the directory is being open-unlinked (still has usecount
+ * references), or if it has EAs, or if it was being deleted as part of a rename,
+ * then we go ahead and move it to the hidden directory.
+ *
+ * If the directory is being open-unlinked, then we want to keep the catalog entry
+ * alive so that future EA calls and fchmod/fstat etc. do not cause issues later.
+ *
+ * If the directory had EAs, then we want to use the open-unlink trick so that the
+ * EA removal is not done in one giant transaction. Otherwise, it could cause a panic
+ * due to overflowing the journal.
+ *
+ * Finally, if it was deleted as part of a rename, we move it to the hidden directory
+ * in order to maintain rename atomicity.
+ *
+ * Note that the allow_dirs argument to hfs_removefile specifies that it is
+ * supposed to handle directories for this case.
+ */
+
+ if (((hfsmp->hfs_attribute_vp != NULL) &&
+ ((cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0)) ||
+ (only_unlink != 0)) {
+
+ int ret = hfs_removefile(dvp, vp, cnp, 0, 0, 1, NULL, only_unlink);
+ /*
+ * Even though hfs_vnop_rename calls vnode_recycle for us on tvp we call
+ * it here just in case we were invoked by rmdir() on a directory that had
+ * EAs. To ensure that we start reclaiming the space as soon as possible,
+ * we call vnode_recycle on the directory.
+ */
+ vnode_recycle(vp);
+
+ return ret;
+
}
dcp->c_flag |= C_DIR_MODIFICATION;
* the current directory and thus be
* non-empty.)
*/
- if ((dcp->c_flags & APPEND) || (cp->c_flags & (IMMUTABLE | APPEND))) {
+ if ((dcp->c_bsdflags & APPEND) || (cp->c_bsdflags & (IMMUTABLE | APPEND))) {
error = EPERM;
goto out;
}
desc.cd_encoding = cp->c_encoding;
desc.cd_hint = 0;
- if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid)) {
+ if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid, NULL, &error)) {
error = 0;
goto out;
}
(void)hfs_chkiq(cp, -1, NOCRED, 0);
#endif /* QUOTA */
- HFS_KNOTE(dvp, NOTE_WRITE | NOTE_LINK | NOTE_ATTRIB);
-
hfs_volupdate(hfsmp, VOL_RMDIR, (dcp->c_cnid == kHFSRootFolderID));
- /*
- * directory open or in use (e.g. opendir() or current working
- * directory for some process); wait for inactive to actually
- * remove catalog entry
- */
- if (vnode_isinuse(vp, 0)) {
- cp->c_flag |= C_DELETED;
- } else {
- cp->c_mode = 0; /* Makes the vnode go away...see inactive */
- cp->c_flag |= C_NOEXISTS;
- }
+ /* Mark C_NOEXISTS since the catalog entry is now gone */
+ cp->c_flag |= C_NOEXISTS;
out:
dcp->c_flag &= ~C_DIR_MODIFICATION;
wakeup((caddr_t)&dcp->c_flag);
- HFS_KNOTE(vp, NOTE_DELETE);
-
if (started_tr) {
hfs_end_transaction(hfsmp);
}
/*
* Remove a file or link.
*/
-static int
+int
hfs_vnop_remove(ap)
struct vnop_remove_args /* {
struct vnode *a_dvp;
struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct cnode *dcp = VTOC(dvp);
- struct cnode *cp = VTOC(vp);
- struct vnode *rvp = cp->c_rsrc_vp;
- int error=0, recycle_rsrc=0, rvid=0;
+ struct cnode *cp;
+ struct vnode *rvp = NULL;
+ int error=0, recycle_rsrc=0;
+ time_t orig_ctime;
+ uint32_t rsrc_vid = 0;
if (dvp == vp) {
return (EINVAL);
}
- hfs_lock_truncate(cp, TRUE);
+ orig_ctime = VTOC(vp)->c_ctime;
+ if ( (!vnode_isnamedstream(vp)) && ((ap->a_flags & VNODE_REMOVE_SKIP_NAMESPACE_EVENT) == 0)) {
+ error = check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL);
+ if (error) {
+ // XXXdbg - decide on a policy for handling namespace handler failures!
+ // for now we just let them proceed.
+ }
+ }
+ error = 0;
+
+ cp = VTOC(vp);
+
+relock:
+
+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK);
if ((error = hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK))) {
- hfs_unlock_truncate(cp, TRUE);
+ hfs_unlock_truncate(cp, 0);
+ if (rvp) {
+ vnode_put (rvp);
+ }
return (error);
}
- error = hfs_removefile(dvp, vp, ap->a_cnp, ap->a_flags, 0, 0);
+
+ /*
+ * Lazily respond to determining if there is a valid resource fork
+ * vnode attached to 'cp' if it is a regular file or symlink.
+ * If the vnode does not exist, then we may proceed without having to
+ * create it.
+ *
+ * If, however, it does exist, then we need to acquire an iocount on the
+ * vnode after acquiring its vid. This ensures that if we have to do I/O
+ * against it, it can't get recycled from underneath us in the middle
+ * of this call.
+ *
+ * Note: this function may be invoked for directory hardlinks, so just skip these
+ * steps if 'vp' is a directory.
+ */
- //
- // If the remove succeeded and it's an open-unlinked file that has
- // a resource fork vnode that's not in use, we will want to recycle
- // the rvp *after* we're done unlocking everything. Otherwise the
- // resource vnode will keep a v_parent reference on this vnode which
- // prevents it from going through inactive/reclaim which means that
- // the disk space associated with this file won't get free'd until
- // something forces the resource vnode to get recycled (and that can
- // take a very long time).
- //
- if (error == 0 && (cp->c_flag & C_DELETED) && rvp && !vnode_isinuse(rvp, 0)) {
- rvid = vnode_vid(rvp);
+
+ if ((vp->v_type == VLNK) || (vp->v_type == VREG)) {
+ if ((cp->c_rsrc_vp) && (rvp == NULL)) {
+ /* We need to acquire the rsrc vnode */
+ rvp = cp->c_rsrc_vp;
+ rsrc_vid = vnode_vid (rvp);
+
+ /* Unlock everything to acquire iocount on the rsrc vnode */
+ hfs_unlock_truncate (cp, 0);
+ hfs_unlockpair (dcp, cp);
+
+ /* Use the vid to maintain identity on rvp */
+ if (vnode_getwithvid(rvp, rsrc_vid)) {
+ /*
+ * If this fails, then it was recycled or
+ * reclaimed in the interim. Reset fields and
+ * start over.
+ */
+ rvp = NULL;
+ rsrc_vid = 0;
+ }
+ goto relock;
+ }
+ }
+
+ /*
+ * Check to see if we raced rmdir for the parent directory
+ * hfs_removefile already checks for a race on vp/cp
+ */
+ if (dcp->c_flag & (C_DELETED | C_NOEXISTS)) {
+ error = ENOENT;
+ goto rm_done;
+ }
+
+ error = hfs_removefile(dvp, vp, ap->a_cnp, ap->a_flags, 0, 0, NULL, 0);
+
+ /*
+ * If the remove succeeded in deleting the file, then we may need to mark
+ * the resource fork for recycle so that it is reclaimed as quickly
+ * as possible. If it were not recycled quickly, then this resource fork
+ * vnode could keep a v_parent reference on the data fork, which prevents it
+ * from going through reclaim (by giving it extra usecounts), except in the force-
+ * unmount case.
+ *
+ * However, a caveat: we need to continue to supply resource fork
+ * access to open-unlinked files even if the resource fork is not open. This is
+ * a requirement for the compressed files work. Luckily, hfs_vgetrsrc will handle
+ * this already if the data fork has been re-parented to the hidden directory.
+ *
+ * As a result, all we really need to do here is mark the resource fork vnode
+ * for recycle. If it goes out of core, it can be brought in again if needed.
+ * If the cnode was instead marked C_NOEXISTS, then there wouldn't be any
+ * more work.
+ */
+ if ((error == 0) && (rvp)) {
recycle_rsrc = 1;
}
* recycle the vnode which in turn might require the
* truncate lock)
*/
- hfs_unlock_truncate(cp, TRUE);
+rm_done:
+ hfs_unlock_truncate(cp, 0);
hfs_unlockpair(dcp, cp);
- if (recycle_rsrc && vnode_getwithvid(rvp, rvid) == 0) {
- vnode_ref(rvp);
- vnode_rele(rvp);
+ if (recycle_rsrc) {
+ /* inactive or reclaim on rvp will clean up the blocks from the rsrc fork */
vnode_recycle(rvp);
- vnode_put(rvp);
}
+ if (rvp) {
+ /* drop iocount on rsrc fork, was obtained at beginning of fxn */
+ vnode_put(rvp);
+ }
+
return (error);
}
-static int
+int
hfs_removefile_callback(struct buf *bp, void *hfsmp) {
if ( !(buf_flags(bp) & B_META))
* hfs_removefile
*
* Similar to hfs_vnop_remove except there are additional options.
+ * This function may be used to remove directories if they have
+ * lots of EA's -- note the 'allow_dirs' argument.
+ *
+ * This function is able to delete blocks & fork data for the resource
+ * fork even if it does not exist in core (and have a backing vnode).
+ * It should infer the correct behavior based on the number of blocks
+ * in the cnode and whether or not the resource fork pointer exists or
+ * not. As a result, one only need pass in the 'vp' corresponding to the
+ * data fork of this file (or main vnode in the case of a directory).
+ * Passing in a resource fork will result in an error.
+ *
+ * Because we do not create any vnodes in this function, we are not at
+ * risk of deadlocking against ourselves by double-locking.
*
* Requires cnode and truncate locks to be held.
*/
-static int
+int
hfs_removefile(struct vnode *dvp, struct vnode *vp, struct componentname *cnp,
- int flags, int skip_reserve, int allow_dirs)
+ int flags, int skip_reserve, int allow_dirs,
+ __unused struct vnode *rvp, int only_unlink)
{
- struct vnode *rvp = NULL;
struct cnode *cp;
struct cnode *dcp;
+ struct vnode *rsrc_vp = NULL;
struct hfsmount *hfsmp;
struct cat_desc desc;
struct timeval tv;
- vfs_context_t ctx = cnp->cn_context;
int dataforkbusy = 0;
int rsrcforkbusy = 0;
- int truncated = 0;
int lockflags;
int error = 0;
int started_tr = 0;
int isbigfile = 0, defer_remove=0, isdir=0;
+ int update_vh = 0;
cp = VTOC(vp);
dcp = VTOC(dvp);
return (0);
}
- if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid)) {
+ if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid, NULL, &error)) {
return 0;
}
if (VNODE_IS_RSRC(vp)) {
return (EPERM);
}
+ else {
+ /*
+ * We know it's a data fork.
+ * Probe the cnode to see if we have a valid resource fork
+ * in hand or not.
+ */
+ rsrc_vp = cp->c_rsrc_vp;
+ }
+
/* Don't allow deleting the journal or journal_info_block. */
- if (hfsmp->jnl &&
- (cp->c_fileid == hfsmp->hfs_jnlfileid || cp->c_fileid == hfsmp->hfs_jnlinfoblkid)) {
+ if (hfs_is_journal_file(hfsmp, cp)) {
return (EPERM);
}
+
+ /*
+ * If removing a symlink, then we need to ensure that the
+ * data blocks for the symlink are not still in-flight or pending.
+ * If so, we will unlink the symlink here, making its blocks
+ * available for re-allocation by a subsequent transaction. That is OK, but
+ * then the I/O for the data blocks could then go out before the journal
+ * transaction that created it was flushed, leading to I/O ordering issues.
+ */
+ if (vp->v_type == VLNK) {
+ /*
+ * This will block if the asynchronous journal flush is in progress.
+ * If this symlink is not being renamed over and doesn't have any open FDs,
+ * then we'll remove it from the journal's bufs below in kill_block.
+ */
+ buf_wait_for_shadow_io (vp, 0);
+ }
+
/*
* Hard links require special handling.
*/
return hfs_unlink(hfsmp, dvp, vp, cnp, skip_reserve);
}
}
+
/* Directories should call hfs_rmdir! (unless they have a lot of attributes) */
if (vnode_isdir(vp)) {
if (allow_dirs == 0)
/* Remove our entry from the namei cache. */
cache_purge(vp);
-
+
/*
- * Acquire a vnode for a non-empty resource fork.
- * (needed for hfs_truncate)
+ * If the caller was operating on a file (as opposed to a
+ * directory with EAs), then we need to figure out
+ * whether or not it has a valid resource fork vnode.
+ *
+ * If there was a valid resource fork vnode, then we need
+ * to use hfs_truncate to eliminate its data. If there is
+ * no vnode, then we hold the cnode lock which would
+ * prevent it from being created. As a result,
+ * we can use the data deletion functions which do not
+ * require that a cnode/vnode pair exist.
*/
- if (isdir == 0 && (cp->c_blocks - VTOF(vp)->ff_blocks)) {
- /*
- * We must avoid calling hfs_vgetrsrc() when we have
- * an active resource fork vnode to avoid deadlocks
- * when that vnode is in the VL_TERMINATE state. We
- * can defer removing the file and its resource fork
- * until the call to hfs_vnop_inactive() occurs.
- */
- if (cp->c_rsrc_vp) {
- defer_remove = 1;
- } else {
- error = hfs_vgetrsrc(hfsmp, vp, &rvp, FALSE);
- if (error)
- goto out;
- /* Defer the vnode_put on rvp until the hfs_unlock(). */
- cp->c_flag |= C_NEED_RVNODE_PUT;
- }
- }
+
/* Check if this file is being used. */
if (isdir == 0) {
dataforkbusy = vnode_isinuse(vp, 0);
- rsrcforkbusy = rvp ? vnode_isinuse(rvp, 0) : 0;
+ /*
+ * At this point, we know that 'vp' points to the
+ * a data fork because we checked it up front. And if
+ * there is no rsrc fork, rsrc_vp will be NULL.
+ */
+ if (rsrc_vp && (cp->c_blocks - VTOF(vp)->ff_blocks)) {
+ rsrcforkbusy = vnode_isinuse(rsrc_vp, 0);
+ }
}
/* Check if we have to break the deletion into multiple pieces. */
(cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0) {
defer_remove = 1;
}
+
+ /* If we are explicitly told to only unlink item and move to hidden dir, then do it */
+ if (only_unlink) {
+ defer_remove = 1;
+ }
/*
* Carbon semantics prohibit deleting busy files.
if (hfsmp->hfs_flags & HFS_QUOTAS)
(void)hfs_getinoquota(cp);
#endif /* QUOTA */
-
- /* Check if we need a ubc_setsize. */
- if (isdir == 0 && (!dataforkbusy || !rsrcforkbusy)) {
+
+ /*
+ * Do a ubc_setsize to indicate we need to wipe contents if:
+ * 1) item is a regular file.
+ * 2) Neither fork is busy AND we are not told to unlink this.
+ *
+ * We need to check for the defer_remove since it can be set without
+ * having a busy data or rsrc fork
+ */
+ if (isdir == 0 && (!dataforkbusy || !rsrcforkbusy) && (defer_remove == 0)) {
/*
* A ubc_setsize can cause a pagein so defer it
* until after the cnode lock is dropped. The
if (!dataforkbusy && cp->c_datafork->ff_blocks && !isbigfile) {
cp->c_flag |= C_NEED_DATA_SETSIZE;
}
- if (!rsrcforkbusy && rvp) {
+ if (!rsrcforkbusy && rsrc_vp) {
cp->c_flag |= C_NEED_RSRC_SETSIZE;
}
}
started_tr = 1;
// XXXdbg - if we're journaled, kill any dirty symlink buffers
- if (hfsmp->jnl && vnode_islnk(vp))
+ if (hfsmp->jnl && vnode_islnk(vp) && (defer_remove == 0)) {
buf_iterate(vp, hfs_removefile_callback, BUF_SKIP_NONLOCKED, (void *)hfsmp);
+ }
/*
- * Truncate any non-busy forks. Busy forks will
+ * Prepare to truncate any non-busy forks. Busy forks will
* get truncated when their vnode goes inactive.
+ * Note that we will only enter this region if we
+ * can avoid creating an open-unlinked file. If
+ * either region is busy, we will have to create an open
+ * unlinked file.
*
- * Since we're already inside a transaction,
- * tell hfs_truncate to skip the ubc_setsize.
+ * Since we are deleting the file, we need to stagger the runtime
+ * modifications to do things in such a way that a crash won't
+ * result in us getting overlapped extents or any other
+ * bad inconsistencies. As such, we call prepare_release_storage
+ * which updates the UBC, updates quota information, and releases
+ * any loaned blocks that belong to this file. No actual
+ * truncation or bitmap manipulation is done until *AFTER*
+ * the catalog record is removed.
*/
- if (isdir == 0) {
- int mode = cp->c_mode;
-
+ if (isdir == 0 && (!dataforkbusy && !rsrcforkbusy) && (only_unlink == 0)) {
+
if (!dataforkbusy && !isbigfile && cp->c_datafork->ff_blocks != 0) {
- cp->c_mode = 0; /* Suppress hfs_update */
- error = hfs_truncate(vp, (off_t)0, IO_NDELAY, 1, ctx);
- cp->c_mode = mode;
- if (error)
+
+ error = hfs_prepare_release_storage (hfsmp, vp);
+ if (error) {
goto out;
- truncated = 1;
+ }
+ update_vh = 1;
}
- if (!rsrcforkbusy && rvp) {
- cp->c_mode = 0; /* Suppress hfs_update */
- error = hfs_truncate(rvp, (off_t)0, IO_NDELAY, 1, ctx);
- cp->c_mode = mode;
- if (error)
+
+ /*
+ * If the resource fork vnode does not exist, we can skip this step.
+ */
+ if (!rsrcforkbusy && rsrc_vp) {
+ error = hfs_prepare_release_storage (hfsmp, rsrc_vp);
+ if (error) {
goto out;
- truncated = 1;
+ }
+ update_vh = 1;
}
}
-
+
/*
* Protect against a race with rename by using the component
* name passed in and parent id from dvp (instead of using
- * the cp->c_desc which may have changed).
+ * the cp->c_desc which may have changed). Also, be aware that
+ * because we allow directories to be passed in, we need to special case
+ * this temporary descriptor in case we were handed a directory.
*/
- desc.cd_flags = 0;
+ if (isdir) {
+ desc.cd_flags = CD_ISDIR;
+ }
+ else {
+ desc.cd_flags = 0;
+ }
desc.cd_encoding = cp->c_desc.cd_encoding;
desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;
desc.cd_namelen = cnp->cn_namelen;
/*
* There are two cases to consider:
- * 1. File is busy/big/defer_remove ==> move/rename the file
+ * 1. File/Dir is busy/big/defer_remove ==> move/rename the file/dir
* 2. File is not in use ==> remove the file
+ *
+ * We can get a directory in case 1 because it may have had lots of attributes,
+ * which need to get removed here.
*/
if (dataforkbusy || rsrcforkbusy || isbigfile || defer_remove) {
char delname[32];
struct cat_desc todir_desc;
/*
- * Orphan this file (move to hidden directory).
+ * Orphan this file or directory (move to hidden directory).
+ * Again, we need to take care that we treat directories as directories,
+ * and files as files. Because directories with attributes can be passed in
+ * check to make sure that we have a directory or a file before filling in the
+ * temporary descriptor's flags. We keep orphaned directories AND files in
+ * the FILE_HARDLINKS private directory since we're generalizing over all
+ * orphaned filesystem objects.
*/
bzero(&todir_desc, sizeof(todir_desc));
todir_desc.cd_parentcnid = 2;
to_desc.cd_nameptr = (const u_int8_t *)delname;
to_desc.cd_namelen = strlen(delname);
to_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;
- to_desc.cd_flags = 0;
+ if (isdir) {
+ to_desc.cd_flags = CD_ISDIR;
+ }
+ else {
+ to_desc.cd_flags = 0;
+ }
to_desc.cd_cnid = cp->c_cnid;
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
dcp->c_mtime = tv.tv_sec;
(void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);
- /* Update the file's state */
+ /* Update the file or directory's state */
cp->c_flag |= C_DELETED;
cp->c_ctime = tv.tv_sec;
--cp->c_linkcount;
if (error)
goto out;
- } else /* Not busy */ {
+ }
+ else {
+ /*
+ * Nobody is using this item; we can safely remove everything.
+ */
+ struct filefork *temp_rsrc_fork = NULL;
+#if QUOTA
+ off_t savedbytes;
+ int blksize = hfsmp->blockSize;
+#endif
+ u_int32_t fileid = cp->c_fileid;
+
+ /*
+ * Figure out if we need to read the resource fork data into
+ * core before wiping out the catalog record.
+ *
+ * 1) Must not be a directory
+ * 2) cnode's c_rsrcfork ptr must be NULL.
+ * 3) rsrc fork must have actual blocks
+ */
+ if ((isdir == 0) && (cp->c_rsrcfork == NULL) &&
+ (cp->c_blocks - VTOF(vp)->ff_blocks)) {
+ /*
+ * The resource fork vnode & filefork did not exist.
+ * Create a temporary one for use in this function only.
+ */
+ MALLOC_ZONE (temp_rsrc_fork, struct filefork *, sizeof (struct filefork), M_HFSFORK, M_WAITOK);
+ bzero(temp_rsrc_fork, sizeof(struct filefork));
+ temp_rsrc_fork->ff_cp = cp;
+ rl_init(&temp_rsrc_fork->ff_invalidranges);
+ }
- if (cp->c_blocks > 0) {
- printf("hfs_remove: attempting to delete a non-empty file %s\n",
- cp->c_desc.cd_nameptr);
- error = EBUSY;
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
+
+ /* Look up the resource fork first, if necessary */
+ if (temp_rsrc_fork) {
+ error = cat_lookup (hfsmp, &desc, 1, (struct cat_desc*) NULL,
+ (struct cat_attr*) NULL, &temp_rsrc_fork->ff_data, NULL);
+ if (error) {
+ FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK);
+ hfs_systemfile_unlock (hfsmp, lockflags);
+ goto out;
+ }
+ }
+
+ if (!skip_reserve) {
+ if ((error = cat_preflight(hfsmp, CAT_DELETE, NULL, 0))) {
+ if (temp_rsrc_fork) {
+ FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK);
+ }
+ hfs_systemfile_unlock(hfsmp, lockflags);
+ goto out;
+ }
+ }
+
+ error = cat_delete(hfsmp, &desc, &cp->c_attr);
+
+ if (error && error != ENXIO && error != ENOENT) {
+ printf("hfs_removefile: deleting file %s (%d), err: %d\n",
+ cp->c_desc.cd_nameptr, cp->c_attr.ca_fileid, error);
+ }
+
+ if (error == 0) {
+ /* Update the parent directory */
+ if (dcp->c_entries > 0)
+ dcp->c_entries--;
+ dcp->c_dirchangecnt++;
+ dcp->c_ctime = tv.tv_sec;
+ dcp->c_mtime = tv.tv_sec;
+ (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);
+ }
+ hfs_systemfile_unlock(hfsmp, lockflags);
+
+ if (error) {
+ if (temp_rsrc_fork) {
+ FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK);
+ }
goto out;
}
-
- lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
- if (!skip_reserve) {
- if ((error = cat_preflight(hfsmp, CAT_DELETE, NULL, 0))) {
- hfs_systemfile_unlock(hfsmp, lockflags);
- goto out;
- }
+
+ /*
+ * Now that we've wiped out the catalog record, the file effectively doesn't
+ * exist anymore. So update the quota records to reflect the loss of the
+ * data fork and the resource fork.
+ */
+#if QUOTA
+ if (cp->c_datafork->ff_blocks > 0) {
+ savedbytes = ((off_t)cp->c_datafork->ff_blocks * (off_t)blksize);
+ (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0);
+ }
+
+ /*
+ * We may have just deleted the catalog record for a resource fork even
+ * though it did not exist in core as a vnode. However, just because there
+ * was a resource fork pointer in the cnode does not mean that it had any blocks.
+ */
+ if (temp_rsrc_fork || cp->c_rsrcfork) {
+ if (cp->c_rsrcfork) {
+ if (cp->c_rsrcfork->ff_blocks > 0) {
+ savedbytes = ((off_t)cp->c_rsrcfork->ff_blocks * (off_t)blksize);
+ (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0);
+ }
+ }
+ else {
+ /* we must have used a temporary fork */
+ savedbytes = ((off_t)temp_rsrc_fork->ff_blocks * (off_t)blksize);
+ (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0);
+ }
+ }
+
+ if (hfsmp->hfs_flags & HFS_QUOTAS) {
+ (void)hfs_chkiq(cp, -1, NOCRED, 0);
+ }
+#endif
+
+ /*
+ * If we didn't get any errors deleting the catalog entry, then go ahead
+ * and release the backing store now. The filefork pointers are still valid.
+ */
+ if (temp_rsrc_fork) {
+ error = hfs_release_storage (hfsmp, cp->c_datafork, temp_rsrc_fork, fileid);
+ }
+ else {
+ /* if cp->c_rsrcfork == NULL, hfs_release_storage will skip over it. */
+ error = hfs_release_storage (hfsmp, cp->c_datafork, cp->c_rsrcfork, fileid);
}
-
- error = cat_delete(hfsmp, &desc, &cp->c_attr);
-
- if (error && error != ENXIO && error != ENOENT && truncated) {
- if ((cp->c_datafork && cp->c_datafork->ff_size != 0) ||
- (cp->c_rsrcfork && cp->c_rsrcfork->ff_size != 0)) {
- panic("hfs: remove: couldn't delete a truncated file! (%d, data sz %lld; rsrc sz %lld)",
- error, cp->c_datafork->ff_size, cp->c_rsrcfork->ff_size);
- } else {
- printf("hfs: remove: strangely enough, deleting truncated file %s (%d) got err %d\n",
- cp->c_desc.cd_nameptr, cp->c_attr.ca_fileid, error);
- }
+ if (error) {
+ /*
+ * If we encountered an error updating the extents and bitmap,
+ * mark the volume inconsistent. At this point, the catalog record has
+ * already been deleted, so we can't recover it at this point. We need
+ * to proceed and update the volume header and mark the cnode C_NOEXISTS.
+ * The subsequent fsck should be able to recover the free space for us.
+ */
+ hfs_mark_volume_inconsistent(hfsmp);
}
- if (error == 0) {
- /* Update the parent directory */
- if (dcp->c_entries > 0)
- dcp->c_entries--;
- dcp->c_dirchangecnt++;
- dcp->c_ctime = tv.tv_sec;
- dcp->c_mtime = tv.tv_sec;
- (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);
+ else {
+ /* reset update_vh to 0, since hfs_release_storage should have done it for us */
+ update_vh = 0;
}
- hfs_systemfile_unlock(hfsmp, lockflags);
- if (error)
- goto out;
-#if QUOTA
- if (hfsmp->hfs_flags & HFS_QUOTAS)
- (void)hfs_chkiq(cp, -1, NOCRED, 0);
-#endif /* QUOTA */
+ /* Get rid of the temporary rsrc fork */
+ if (temp_rsrc_fork) {
+ FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK);
+ }
- cp->c_mode = 0;
- truncated = 0; // because the catalog entry is gone
cp->c_flag |= C_NOEXISTS;
cp->c_flag &= ~C_DELETED;
+
cp->c_touch_chgtime = TRUE; /* XXX needed ? */
--cp->c_linkcount;
-
+
+ /*
+ * We must never get a directory if we're in this else block. We could
+ * accidentally drop the number of files in the volume header if we did.
+ */
hfs_volupdate(hfsmp, VOL_RMFILE, (dcp->c_cnid == kHFSRootFolderID));
+
}
/*
*/
cat_releasedesc(&cp->c_desc);
- HFS_KNOTE(dvp, NOTE_WRITE);
-
out:
if (error) {
cp->c_flag &= ~C_DELETED;
}
-
- /* Commit the truncation to the catalog record */
- if (truncated) {
- cp->c_flag |= C_FORCEUPDATE;
- cp->c_touch_chgtime = TRUE;
- cp->c_touch_modtime = TRUE;
- (void) hfs_update(vp, 0);
- }
+
+ if (update_vh) {
+ /*
+ * If we bailed out earlier, we may need to update the volume header
+ * to deal with the borrowed blocks accounting.
+ */
+ hfs_volupdate (hfsmp, VOL_UPDATE, 0);
+ }
if (started_tr) {
hfs_end_transaction(hfsmp);
dcp->c_flag &= ~C_DIR_MODIFICATION;
wakeup((caddr_t)&dcp->c_flag);
- HFS_KNOTE(vp, NOTE_DELETE);
- if (rvp) {
- HFS_KNOTE(rvp, NOTE_DELETE);
- }
-
return (error);
}
* - all the vnodes are from the same file system
*
* When the target is a directory, HFS must ensure that its empty.
+ *
+ * Note that this function requires up to 6 vnodes in order to work properly
+ * if it is operating on files (and not on directories). This is because only
+ * files can have resource forks, and we now require iocounts to be held on the
+ * vnodes corresponding to the resource forks (if applicable) as well as
+ * the files or directories undergoing rename. The problem with not holding
+ * iocounts on the resource fork vnodes is that it can lead to a deadlock
+ * situation: The rsrc fork of the source file may be recycled and reclaimed
+ * in order to provide a vnode for the destination file's rsrc fork. Since
+ * data and rsrc forks share the same cnode, we'd eventually try to lock the
+ * source file's cnode in order to sync its rsrc fork to disk, but it's already
+ * been locked. By taking the rsrc fork vnodes up front we ensure that they
+ * cannot be recycled, and that the situation mentioned above cannot happen.
*/
-static int
+int
hfs_vnop_rename(ap)
struct vnop_rename_args /* {
struct vnode *a_fdvp;
struct vnode *tdvp = ap->a_tdvp;
struct vnode *fvp = ap->a_fvp;
struct vnode *fdvp = ap->a_fdvp;
- struct vnode *rvp = NULLVP;
+ /*
+ * Note that we only need locals for the target/destination's
+ * resource fork vnode (and only if necessary). We don't care if the
+ * source has a resource fork vnode or not.
+ */
+ struct vnode *tvp_rsrc = NULLVP;
+ uint32_t tvp_rsrc_vid = 0;
struct componentname *tcnp = ap->a_tcnp;
struct componentname *fcnp = ap->a_fcnp;
struct proc *p = vfs_context_proc(ap->a_context);
struct cnode *fdcp;
struct cnode *tdcp;
struct cnode *tcp;
+ struct cnode *error_cnode;
struct cat_desc from_desc;
struct cat_desc to_desc;
struct cat_desc out_desc;
int took_trunc_lock = 0;
int lockflags;
int error;
- int rsrc_vid = 0;
- int recycle_rsrc = 0;
+ time_t orig_from_ctime, orig_to_ctime;
+ int emit_rename = 1;
+ int emit_delete = 1;
+
+ orig_from_ctime = VTOC(fvp)->c_ctime;
+ if (tvp && VTOC(tvp)) {
+ orig_to_ctime = VTOC(tvp)->c_ctime;
+ } else {
+ orig_to_ctime = ~0;
+ }
+
+ hfsmp = VTOHFS(tdvp);
+ /*
+ * Do special case checks here. If fvp == tvp then we need to check the
+ * cnode with locks held.
+ */
+ if (fvp == tvp) {
+ int is_hardlink = 0;
+ /*
+ * In this case, we do *NOT* ever emit a DELETE event.
+ * We may not necessarily emit a RENAME event
+ */
+ emit_delete = 0;
+ if ((error = hfs_lock(VTOC(fvp), HFS_SHARED_LOCK))) {
+ return error;
+ }
+ /* Check to see if the item is a hardlink or not */
+ is_hardlink = (VTOC(fvp)->c_flag & C_HARDLINK);
+ hfs_unlock (VTOC(fvp));
+
+ /*
+ * If the item is not a hardlink, then case sensitivity must be off, otherwise
+ * two names should not resolve to the same cnode unless they were case variants.
+ */
+ if (is_hardlink) {
+ emit_rename = 0;
+ /*
+ * Hardlinks are a little trickier. We only want to emit a rename event
+ * if the item is a hardlink, the parent directories are the same, case sensitivity
+ * is off, and the case folded names are the same. See the fvp == tvp case below for more
+ * info.
+ */
+
+ if ((fdvp == tdvp) && ((hfsmp->hfs_flags & HFS_CASE_SENSITIVE) == 0)) {
+ if (hfs_namecmp((const u_int8_t *)fcnp->cn_nameptr, fcnp->cn_namelen,
+ (const u_int8_t *)tcnp->cn_nameptr, tcnp->cn_namelen) == 0) {
+ /* Then in this case only it is ok to emit a rename */
+ emit_rename = 1;
+ }
+ }
+ }
+ }
+ if (emit_rename) {
+ check_for_tracked_file(fvp, orig_from_ctime, NAMESPACE_HANDLER_RENAME_OP, NULL);
+ }
+
+ if (tvp && VTOC(tvp)) {
+ if (emit_delete) {
+ check_for_tracked_file(tvp, orig_to_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL);
+ }
+ }
- /* When tvp exist, take the truncate lock for the hfs_removefile(). */
+retry:
+ /* When tvp exists, take the truncate lock for hfs_removefile(). */
if (tvp && (vnode_isreg(tvp) || vnode_islnk(tvp))) {
- hfs_lock_truncate(VTOC(tvp), TRUE);
+ hfs_lock_truncate(VTOC(tvp), HFS_EXCLUSIVE_LOCK);
took_trunc_lock = 1;
}
- retry:
error = hfs_lockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL,
- HFS_EXCLUSIVE_LOCK);
+ HFS_EXCLUSIVE_LOCK, &error_cnode);
if (error) {
- if (took_trunc_lock)
- hfs_unlock_truncate(VTOC(tvp), TRUE);
+ if (took_trunc_lock) {
+ hfs_unlock_truncate(VTOC(tvp), 0);
+ took_trunc_lock = 0;
+ }
+
+ /*
+ * We hit an error path. If we were trying to re-acquire the locks
+ * after coming through here once, we might have already obtained
+ * an iocount on tvp's resource fork vnode. Drop that before dealing
+ * with the failure. Note this is safe -- since we are in an
+ * error handling path, we can't be holding the cnode locks.
+ */
+ if (tvp_rsrc) {
+ vnode_put (tvp_rsrc);
+ tvp_rsrc_vid = 0;
+ tvp_rsrc = NULL;
+ }
+
+ /*
+ * tvp might no longer exist. If the cause of the lock failure
+ * was tvp, then we can try again with tvp/tcp set to NULL.
+ * This is ok because the vfs syscall will vnode_put the vnodes
+ * after we return from hfs_vnop_rename.
+ */
+ if ((error == ENOENT) && (tvp != NULL) && (error_cnode == VTOC(tvp))) {
+ tcp = NULL;
+ tvp = NULL;
+ goto retry;
+ }
+
return (error);
}
fcp = VTOC(fvp);
tdcp = VTOC(tdvp);
tcp = tvp ? VTOC(tvp) : NULL;
- hfsmp = VTOHFS(tdvp);
- /* Check for a race against unlink. */
- if ((fcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, fdvp, fcnp, fcp->c_fileid)) {
+ /*
+ * Acquire iocounts on the destination's resource fork vnode
+ * if necessary. If dst/src are files and the dst has a resource
+ * fork vnode, then we need to try and acquire an iocount on the rsrc vnode.
+ * If it does not exist, then we don't care and can skip it.
+ */
+ if ((vnode_isreg(fvp)) || (vnode_islnk(fvp))) {
+ if ((tvp) && (tcp->c_rsrc_vp) && (tvp_rsrc == NULL)) {
+ tvp_rsrc = tcp->c_rsrc_vp;
+ /*
+ * We can look at the vid here because we're holding the
+ * cnode lock on the underlying cnode for this rsrc vnode.
+ */
+ tvp_rsrc_vid = vnode_vid (tvp_rsrc);
+
+ /* Unlock everything to acquire iocount on this rsrc vnode */
+ if (took_trunc_lock) {
+ hfs_unlock_truncate (VTOC(tvp), 0);
+ took_trunc_lock = 0;
+ }
+ hfs_unlockfour(fdcp, fcp, tdcp, tcp);
+
+ if (vnode_getwithvid (tvp_rsrc, tvp_rsrc_vid)) {
+ /* iocount acquisition failed. Reset fields and start over.. */
+ tvp_rsrc_vid = 0;
+ tvp_rsrc = NULL;
+ }
+ goto retry;
+ }
+ }
+
+ /* Ensure we didn't race src or dst parent directories with rmdir. */
+ if (fdcp->c_flag & (C_NOEXISTS | C_DELETED)) {
+ error = ENOENT;
+ goto out;
+ }
+
+ if (tdcp->c_flag & (C_NOEXISTS | C_DELETED)) {
+ error = ENOENT;
+ goto out;
+ }
+
+
+ /* Check for a race against unlink. The hfs_valid_cnode checks validate
+ * the parent/child relationship with fdcp and tdcp, as well as the
+ * component name of the target cnodes.
+ */
+ if ((fcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, fdvp, fcnp, fcp->c_fileid, NULL, &error)) {
error = ENOENT;
goto out;
}
- if (tcp && ((tcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, tdvp, tcnp, tcp->c_fileid))) {
+ if (tcp && ((tcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, tdvp, tcnp, tcp->c_fileid, NULL, &error))) {
//
// hmm, the destination vnode isn't valid any more.
// in this case we can just drop him and pretend he
// never existed in the first place.
//
if (took_trunc_lock) {
- hfs_unlock_truncate(VTOC(tvp), TRUE);
- took_trunc_lock = 0;
+ hfs_unlock_truncate(VTOC(tvp), 0);
+ took_trunc_lock = 0;
}
+ error = 0;
hfs_unlockfour(fdcp, fcp, tdcp, tcp);
/*
* Make sure "from" vnode and its parent are changeable.
*/
- if ((fcp->c_flags & (IMMUTABLE | APPEND)) || (fdcp->c_flags & APPEND)) {
+ if ((fcp->c_bsdflags & (IMMUTABLE | APPEND)) || (fdcp->c_bsdflags & APPEND)) {
error = EPERM;
goto out;
}
goto out;
}
+ /* Don't allow modification of the journal or journal_info_block */
+ if (hfs_is_journal_file(hfsmp, fcp) ||
+ (tcp && hfs_is_journal_file(hfsmp, tcp))) {
+ error = EPERM;
+ goto out;
+ }
+
#if QUOTA
if (tvp)
(void)hfs_getinoquota(tcp);
/* Preflighting done, take fvp out of the name space. */
cache_purge(fvp);
- /*
- * When a file moves out of "Cleanup At Startup"
- * we can drop its NODUMP status.
- */
- if ((fcp->c_flags & UF_NODUMP) &&
- vnode_isreg(fvp) &&
- (fdvp != tdvp) &&
- (fdcp->c_desc.cd_nameptr != NULL) &&
- (strncmp((const char *)fdcp->c_desc.cd_nameptr,
- CARBON_TEMP_DIR_NAME,
- sizeof(CARBON_TEMP_DIR_NAME)) == 0)) {
- fcp->c_flags &= ~UF_NODUMP;
- fcp->c_touch_chgtime = TRUE;
- (void) hfs_update(fvp, 0);
- }
-
bzero(&from_desc, sizeof(from_desc));
from_desc.cd_nameptr = (const u_int8_t *)fcnp->cn_nameptr;
from_desc.cd_namelen = fcnp->cn_namelen;
got_cookie = 1;
/*
- * If the destination exists then it may need to be removed.
+ * If the destination exists then it may need to be removed.
+ *
+ * Due to HFS's locking system, we should always move the
+ * existing 'tvp' element to the hidden directory in hfs_vnop_rename.
+ * Because the VNOP_LOOKUP call enters and exits the filesystem independently
+ * of the actual vnop that it was trying to do (stat, link, readlink),
+ * we must release the cnode lock of that element during the interim to
+ * do MAC checking, vnode authorization, and other calls. In that time,
+ * the item can be deleted (or renamed over). However, only in the rename
+ * case is it inappropriate to return ENOENT from any of those calls. Either
+ * the call should return information about the old element (stale), or get
+ * information about the newer element that we are about to write in its place.
+ *
+ * HFS lookup has been modified to detect a rename and re-drive its
+ * lookup internally. For other calls that have already succeeded in
+ * their lookup call and are waiting to acquire the cnode lock in order
+ * to proceed, that cnode lock will not fail due to the cnode being marked
+ * C_NOEXISTS, because it won't have been marked as such. It will only
+ * have C_DELETED. Thus, they will simply act on the stale open-unlinked
+ * element. All future callers will get the new element.
+ *
+ * To implement this behavior, we pass the "only_unlink" argument to
+ * hfs_removefile and hfs_removedir. This will result in the vnode acting
+ * as though it is open-unlinked. Additionally, when we are done moving the
+ * element to the hidden directory, we vnode_recycle the target so that it is
+ * reclaimed as soon as possible. Reclaim and inactive are both
+ * capable of clearing out unused blocks for an open-unlinked file or dir.
*/
if (tvp) {
/*
*/
if (fvp == tvp) {
if (!(fcp->c_flag & C_HARDLINK)) {
+ /*
+ * If they're not hardlinks, then fvp == tvp must mean we
+ * are using case-insensitive HFS because case-sensitive would
+ * not use the same vnode for both. In this case we just update
+ * the catalog for: a -> A
+ */
goto skip_rm; /* simple case variant */
- } else if ((fdvp != tdvp) ||
+ }
+ /* For all cases below, we must be using hardlinks */
+ else if ((fdvp != tdvp) ||
(hfsmp->hfs_flags & HFS_CASE_SENSITIVE)) {
+ /*
+ * If the parent directories are not the same, AND the two items
+ * are hardlinks, posix says to do nothing:
+ * dir1/fred <-> dir2/bob and the op was mv dir1/fred -> dir2/bob
+ * We just return 0 in this case.
+ *
+ * If case sensitivity is on, and we are using hardlinks
+ * then renaming is supposed to do nothing.
+ * dir1/fred <-> dir2/FRED, and op == mv dir1/fred -> dir2/FRED
+ */
goto out; /* matching hardlinks, nothing to do */
} else if (hfs_namecmp((const u_int8_t *)fcnp->cn_nameptr, fcnp->cn_namelen,
(const u_int8_t *)tcnp->cn_nameptr, tcnp->cn_namelen) == 0) {
+ /*
+ * If we get here, then the following must be true:
+ * a) We are running case-insensitive HFS+.
+ * b) Both paths 'fvp' and 'tvp' are in the same parent directory.
+ * c) the two names are case-variants of each other.
+ *
+ * In this case, we are really only dealing with a single catalog record
+ * whose name is being updated.
+ *
+ * op is dir1/fred -> dir1/FRED
+ *
+ * We need to special case the name matching, because if
+ * dir1/fred <-> dir1/bob were the two links, and the
+ * op was dir1/fred -> dir1/bob
+ * That would fail/do nothing.
+ */
goto skip_rm; /* case-variant hardlink in the same dir */
} else {
goto out; /* matching hardlink, nothing to do */
}
}
- if (vnode_isdir(tvp))
- error = hfs_removedir(tdvp, tvp, tcnp, HFSRM_SKIP_RESERVE);
- else {
- if (tcp){
- rvp = tcp->c_rsrc_vp;
- }
- error = hfs_removefile(tdvp, tvp, tcnp, 0, HFSRM_SKIP_RESERVE, 0);
-
- /* If the destination file had a resource fork vnode, we couldn't do
- * anything about it in hfs_removefile because we didn't have a reference on it.
- * We need to take action here to prevent it from leaking blocks. If removefile
- * succeeded, then squirrel away the vid of the resource fork vnode and force a
- * recycle after dropping all of the locks. The vid is guaranteed not to change
- * at this point because we still hold the cnode lock.
+
+ if (vnode_isdir(tvp)) {
+ /*
+ * hfs_removedir will eventually call hfs_removefile on the directory
+ * we're working on, because only hfs_removefile does the renaming of the
+ * item to the hidden directory. The directory will stay around in the
+ * hidden directory with C_DELETED until it gets an inactive or a reclaim.
+ * That way, we can destroy all of the EAs as needed and allow new ones to be
+ * written.
*/
- if ((error == 0) && (tcp->c_flag & C_DELETED) && rvp && !vnode_isinuse(rvp, 0)) {
- rsrc_vid = vnode_vid(rvp);
- recycle_rsrc = 1;
+ error = hfs_removedir(tdvp, tvp, tcnp, HFSRM_SKIP_RESERVE, 1);
+ }
+ else {
+ error = hfs_removefile(tdvp, tvp, tcnp, 0, HFSRM_SKIP_RESERVE, 0, NULL, 1);
+
+ /*
+ * If the destination file had a resource fork vnode, then we need to get rid of
+ * its blocks when there are no more references to it. Because the call to
+ * hfs_removefile above always open-unlinks things, we need to force an inactive/reclaim
+ * on the resource fork vnode, in order to prevent block leaks. Otherwise,
+ * the resource fork vnode could prevent the data fork vnode from going out of scope
+ * because it holds a v_parent reference on it. So we mark it for termination
+ * with a call to vnode_recycle. hfs_vnop_reclaim has been modified so that it
+ * can clean up the blocks of open-unlinked files and resource forks.
+ *
+ * We can safely call vnode_recycle on the resource fork because we took an iocount
+ * reference on it at the beginning of the function.
+ */
+
+ if ((error == 0) && (tcp->c_flag & C_DELETED) && (tvp_rsrc)) {
+ vnode_recycle(tvp_rsrc);
}
}
- if (error)
+ if (error) {
goto out;
+ }
+
tvp_deleted = 1;
+
+ /* Mark 'tcp' as being deleted due to a rename */
+ tcp->c_flag |= C_RENAMED;
+
+ /*
+ * Aggressively mark tvp/tcp for termination to ensure that we recover all blocks
+ * as quickly as possible.
+ */
+ vnode_recycle(tvp);
}
skip_rm:
/*
- * All done with tvp and fvp
+ * All done with tvp and fvp.
+ *
+ * We also jump to this point if there was no destination observed during lookup and namei.
+ * However, because only iocounts are held at the VFS layer, there is nothing preventing a
+ * competing thread from racing us and creating a file or dir at the destination of this rename
+ * operation. If this occurs, it may cause us to get a spurious EEXIST out of the cat_rename
+ * call below. To preserve rename's atomicity, we need to signal VFS to re-drive the
+ * namei/lookup and restart the rename operation. EEXIST is an allowable errno to be bubbled
+ * out of the rename syscall, but not for this reason, since it is a synonym errno for ENOTEMPTY.
+ * To signal VFS, we return ERECYCLE (which is also used for lookup restarts). This errno
+ * will be swallowed and it will restart the operation.
*/
-
+
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
error = cat_rename(hfsmp, &from_desc, &tdcp->c_desc, &to_desc, &out_desc);
hfs_systemfile_unlock(hfsmp, lockflags);
if (error) {
+ if (error == EEXIST) {
+ error = ERECYCLE;
+ }
goto out;
}
fcp->c_parentcnid = tdcp->c_fileid;
fcp->c_hint = 0;
+ /* Now indicate this cnode needs to have date-added written to the finderinfo */
+ fcp->c_flag |= C_NEEDS_DATEADDED;
+ (void) hfs_update (fvp, 0);
+
+
hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_RMDIR : VOL_RMFILE,
(fdcp->c_cnid == kHFSRootFolderID));
hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_MKDIR : VOL_MKFILE,
tdcp->c_flag |= C_FORCEUPDATE; // XXXdbg - force it out!
(void) hfs_update(tdvp, 0);
+
+ /* Update the vnode's name now that the rename has completed. */
+ vnode_update_identity(fvp, tdvp, tcnp->cn_nameptr, tcnp->cn_namelen,
+ tcnp->cn_hash, (VNODE_UPDATE_PARENT | VNODE_UPDATE_NAME));
+
+ /*
+ * At this point, we may have a resource fork vnode attached to the
+ * 'from' vnode. If it exists, we will want to update its name, because
+ * it contains the old name + _PATH_RSRCFORKSPEC. ("/..namedfork/rsrc").
+ *
+ * Note that the only thing we need to update here is the name attached to
+ * the vnode, since a resource fork vnode does not have a separate resource
+ * cnode -- it's still 'fcp'.
+ */
+ if (fcp->c_rsrc_vp) {
+ char* rsrc_path = NULL;
+ int len;
+
+ /* Create a new temporary buffer that's going to hold the new name */
+ MALLOC_ZONE (rsrc_path, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
+ len = snprintf (rsrc_path, MAXPATHLEN, "%s%s", tcnp->cn_nameptr, _PATH_RSRCFORKSPEC);
+ len = MIN(len, MAXPATHLEN);
+
+ /*
+ * vnode_update_identity will do the following for us:
+ * 1) release reference on the existing rsrc vnode's name.
+ * 2) copy/insert new name into the name cache
+ * 3) attach the new name to the resource vnode
+ * 4) update the vnode's vid
+ */
+ vnode_update_identity (fcp->c_rsrc_vp, fvp, rsrc_path, len, 0, (VNODE_UPDATE_NAME | VNODE_UPDATE_CACHE));
+
+ /* Free the memory associated with the resource fork's name */
+ FREE_ZONE (rsrc_path, MAXPATHLEN, M_NAMEI);
+ }
out:
if (got_cookie) {
cat_postflight(hfsmp, &cookie, p);
hfs_end_transaction(hfsmp);
}
- /* Note that if hfs_removedir or hfs_removefile was invoked above they will already have
- generated a NOTE_WRITE for tdvp and a NOTE_DELETE for tvp.
- */
- if (error == 0) {
- HFS_KNOTE(fvp, NOTE_RENAME);
- HFS_KNOTE(fdvp, NOTE_WRITE);
- if (tdvp != fdvp) HFS_KNOTE(tdvp, NOTE_WRITE);
- };
-
fdcp->c_flag &= ~C_DIR_MODIFICATION;
wakeup((caddr_t)&fdcp->c_flag);
if (fdvp != tdvp) {
wakeup((caddr_t)&tdcp->c_flag);
}
- if (took_trunc_lock)
- hfs_unlock_truncate(VTOC(tvp), TRUE);
+ if (took_trunc_lock) {
+ hfs_unlock_truncate(VTOC(tvp), 0);
+ }
hfs_unlockfour(fdcp, fcp, tdcp, tcp);
-
- /* Now that we've dropped locks, see if we need to force recycle on the old
- * destination's rsrc fork, preventing a leak of the rsrc fork's blocks. Note that
- * doing the ref/rele is in order to twiddle the VL_INACTIVE bit to the vnode's flags
- * so that on the last vnode_put for this vnode, we will force vnop_inactive to be triggered.
- */
- if ((recycle_rsrc) && (vnode_getwithvid(rvp, rsrc_vid) == 0)) {
- vnode_ref(rvp);
- vnode_rele(rvp);
- vnode_recycle(rvp);
- vnode_put (rvp);
+
+ /* Now vnode_put the resource fork vnode if necessary */
+ if (tvp_rsrc) {
+ vnode_put(tvp_rsrc);
+ tvp_rsrc = NULL;
}
-
/* After tvp is removed the only acceptable error is EIO */
if (error && tvp_deleted)
error = EIO;
/*
* Make a directory.
*/
-static int
+int
hfs_vnop_mkdir(struct vnop_mkdir_args *ap)
{
/***** HACK ALERT ********/
/*
* Create a symbolic link.
*/
-static int
+int
hfs_vnop_symlink(struct vnop_symlink_args *ap)
{
struct vnode **vpp = ap->a_vpp;
*
* Don't need truncate lock since a symlink is treated as a system file.
*/
- error = hfs_truncate(vp, len, IO_NOZEROFILL, 1, ap->a_context);
+ error = hfs_truncate(vp, len, IO_NOZEROFILL, 1, 0, ap->a_context);
/* On errors, remove the symlink file */
if (error) {
/* hfs_removefile() requires holding the truncate lock */
hfs_unlock(cp);
- hfs_lock_truncate(cp, TRUE);
+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK);
hfs_lock(cp, HFS_FORCE_LOCK);
if (hfs_start_transaction(hfsmp) != 0) {
goto out;
}
- (void) hfs_removefile(dvp, vp, ap->a_cnp, 0, 0, 0);
- hfs_unlock_truncate(cp, TRUE);
+ (void) hfs_removefile(dvp, vp, ap->a_cnp, 0, 0, 0, NULL, 0);
+ hfs_unlock_truncate(cp, 0);
goto out;
}
/* Write the link to disk */
- bp = buf_getblk(vp, (daddr64_t)0, roundup((int)fp->ff_size, VTOHFS(vp)->hfs_phys_block_size),
+ bp = buf_getblk(vp, (daddr64_t)0, roundup((int)fp->ff_size, hfsmp->hfs_physical_block_size),
0, 0, BLK_META);
if (hfsmp->jnl) {
journal_modify_block_start(hfsmp->jnl, bp);
* If the directory is marked as deleted-but-in-use (cp->c_flag & C_DELETED),
* do NOT synthesize entries for "." and "..".
*/
-static int
+int
hfs_vnop_readdir(ap)
struct vnop_readdir_args /* {
vnode_t a_vp;
int lockflags;
int extended;
int nfs_cookies;
- caddr_t bufstart;
cnid_t cnid_hint = 0;
items = 0;
startoffset = offset = uio_offset(uio);
- bufstart = CAST_DOWN(caddr_t, uio_iov_base(uio));
extended = (ap->a_flags & VNODE_READDIR_EXTENDED);
nfs_cookies = extended && (ap->a_flags & VNODE_READDIR_REQSEEKOFF);
/* Sanity check the uio data. */
- if ((uio_iovcnt(uio) > 1) ||
- (uio_resid(uio) < (int)sizeof(struct dirent))) {
+ if (uio_iovcnt(uio) > 1)
return (EINVAL);
+
+ if (VTOC(vp)->c_bsdflags & UF_COMPRESSED) {
+ int compressed = hfs_file_is_compressed(VTOC(vp), 0); /* 0 == take the cnode lock */
+ if (VTOCMP(vp) != NULL && !compressed) {
+ error = check_for_dataless_file(vp, NAMESPACE_HANDLER_READ_OP);
+ if (error) {
+ return error;
+ }
+ }
}
+
+ cp = VTOC(vp);
+ hfsmp = VTOHFS(vp);
+
/* Note that the dirhint calls require an exclusive lock. */
if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
return (error);
- cp = VTOC(vp);
- hfsmp = VTOHFS(vp);
/* Pick up cnid hint (if any). */
if (nfs_cookies) {
if (index == 0) {
dirhint->dh_threadhint = cp->c_dirthreadhint;
+ }
+ else {
+ /*
+ * If we have a non-zero index, there is a possibility that during the last
+ * call to hfs_vnop_readdir we hit EOF for this directory. If that is the case
+ * then we don't want to return any new entries for the caller. Just return 0
+ * items, mark the eofflag, and bail out. Because we won't have done any work, the
+ * code at the end of the function will release the dirhint for us.
+ *
+ * Don't forget to unlock the catalog lock on the way out, too.
+ */
+ if (dirhint->dh_desc.cd_flags & CD_EOF) {
+ error = 0;
+ eofflag = 1;
+ uio_setoffset(uio, startoffset);
+ hfs_systemfile_unlock (hfsmp, lockflags);
+
+ goto seekoffcalc;
+ }
}
/* Pack the buffer with dirent entries. */
- error = cat_getdirentries(hfsmp, cp->c_entries, dirhint, uio, extended, &items, &eofflag);
+ error = cat_getdirentries(hfsmp, cp->c_entries, dirhint, uio, ap->a_flags, &items, &eofflag);
if (index == 0 && error == 0) {
cp->c_dirthreadhint = dirhint->dh_threadhint;
}
out:
- if (hfsmp->jnl && user_start) {
+ if (user_start) {
vsunlock(user_start, user_len, TRUE);
}
/* If we didn't do anything then go ahead and dump the hint. */
/*
* Read contents of a symbolic link.
*/
-static int
+int
hfs_vnop_readlink(ap)
struct vnop_readlink_args /* {
struct vnode *a_vp;
/* Zero length sym links are not allowed */
if (fp->ff_size == 0 || fp->ff_size > MAXPATHLEN) {
- printf("hfs: zero length symlink on fileid %d\n", cp->c_fileid);
error = EINVAL;
goto exit;
}
struct buf *bp = NULL;
MALLOC(fp->ff_symlinkptr, char *, fp->ff_size, M_TEMP, M_WAITOK);
+ if (fp->ff_symlinkptr == NULL) {
+ error = ENOMEM;
+ goto exit;
+ }
error = (int)buf_meta_bread(vp, (daddr64_t)0,
- roundup((int)fp->ff_size,
- VTOHFS(vp)->hfs_phys_block_size),
+ roundup((int)fp->ff_size, VTOHFS(vp)->hfs_physical_block_size),
vfs_context_ucred(ap->a_context), &bp);
if (error) {
if (bp)
/*
* Get configurable pathname variables.
*/
-static int
+int
hfs_vnop_pathconf(ap)
struct vnop_pathconf_args /* {
struct vnode *a_vp;
break;
case _PC_NAME_MAX:
if (VTOHFS(ap->a_vp)->hfs_flags & HFS_STANDARD)
- *ap->a_retval = kHFSMaxFileNameChars; /* 255 */
+ *ap->a_retval = kHFSMaxFileNameChars; /* 31 */
else
- *ap->a_retval = kHFSPlusMaxFileNameChars; /* 31 */
+ *ap->a_retval = kHFSPlusMaxFileNameChars; /* 255 */
break;
case _PC_PATH_MAX:
*ap->a_retval = PATH_MAX; /* 1024 */
*ap->a_retval = 200112; /* _POSIX_NO_TRUNC */
break;
case _PC_NAME_CHARS_MAX:
- *ap->a_retval = kHFSPlusMaxFileNameChars;
+ if (VTOHFS(ap->a_vp)->hfs_flags & HFS_STANDARD)
+ *ap->a_retval = kHFSMaxFileNameChars; /* 31 */
+ else
+ *ap->a_retval = kHFSPlusMaxFileNameChars; /* 255 */
break;
case _PC_CASE_SENSITIVE:
if (VTOHFS(ap->a_vp)->hfs_flags & HFS_CASE_SENSITIVE)
*ap->a_retval = 1;
break;
case _PC_FILESIZEBITS:
- *ap->a_retval = 64; /* number of bits to store max file size */
+ if (VTOHFS(ap->a_vp)->hfs_flags & HFS_STANDARD)
+ *ap->a_retval = 32;
+ else
+ *ap->a_retval = 64; /* number of bits to store max file size */
+ break;
+ case _PC_XATTR_SIZE_BITS:
+ /* Number of bits to store maximum extended attribute size */
+ *ap->a_retval = HFS_XATTR_SIZE_BITS;
break;
default:
return (EINVAL);
*
* The cnode must be locked exclusive
*/
-__private_extern__
int
hfs_update(struct vnode *vp, __unused int waitfor)
{
// cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_UPDATE);
cp->c_flag |= C_MODIFIED;
- HFS_KNOTE(vp, NOTE_ATTRIB);
-
return (0);
}
return error;
}
- /*
- * For files with invalid ranges (holes) the on-disk
- * field representing the size of the file (cf_size)
- * must be no larger than the start of the first hole.
- */
- if (dataforkp && !CIRCLEQ_EMPTY(&cp->c_datafork->ff_invalidranges)) {
- bcopy(dataforkp, &datafork, sizeof(datafork));
- datafork.cf_size = CIRCLEQ_FIRST(&cp->c_datafork->ff_invalidranges)->rl_start;
- dataforkp = &datafork;
- } else if (dataforkp && (cp->c_datafork->ff_unallocblocks != 0)) {
- // always make sure the block count and the size
- // of the file match the number of blocks actually
- // allocated to the file on disk
- bcopy(dataforkp, &datafork, sizeof(datafork));
- // make sure that we don't assign a negative block count
- if (cp->c_datafork->ff_blocks < cp->c_datafork->ff_unallocblocks) {
- panic("hfs: ff_blocks %d is less than unalloc blocks %d\n",
- cp->c_datafork->ff_blocks, cp->c_datafork->ff_unallocblocks);
- }
- datafork.cf_blocks = (cp->c_datafork->ff_blocks - cp->c_datafork->ff_unallocblocks);
- datafork.cf_size = datafork.cf_blocks * HFSTOVCB(hfsmp)->blockSize;
- dataforkp = &datafork;
- }
-
+ /*
+ * Modify the values passed to cat_update based on whether or not
+ * the file has invalid ranges or borrowed blocks.
+ */
+ if (dataforkp) {
+ off_t numbytes = 0;
+
+ /* copy the datafork into a temporary copy so we don't pollute the cnode's */
+ bcopy(dataforkp, &datafork, sizeof(datafork));
+ dataforkp = &datafork;
+
+ /*
+ * If there are borrowed blocks, ensure that they are subtracted
+ * from the total block count before writing the cnode entry to disk.
+ * Only extents that have actually been marked allocated in the bitmap
+ * should be reflected in the total block count for this fork.
+ */
+ if (cp->c_datafork->ff_unallocblocks != 0) {
+ // make sure that we don't assign a negative block count
+ if (cp->c_datafork->ff_blocks < cp->c_datafork->ff_unallocblocks) {
+ panic("hfs: ff_blocks %d is less than unalloc blocks %d\n",
+ cp->c_datafork->ff_blocks, cp->c_datafork->ff_unallocblocks);
+ }
+
+ /* Also cap the LEOF to the total number of bytes that are allocated. */
+ datafork.cf_blocks = (cp->c_datafork->ff_blocks - cp->c_datafork->ff_unallocblocks);
+ datafork.cf_size = datafork.cf_blocks * HFSTOVCB(hfsmp)->blockSize;
+ }
+
+ /*
+ * For files with invalid ranges (holes) the on-disk
+ * field representing the size of the file (cf_size)
+ * must be no larger than the start of the first hole.
+ * However, note that if the first invalid range exists
+ * solely within borrowed blocks, then our LEOF and block
+ * count should both be zero. As a result, set it to the
+ * min of the current cf_size and the start of the first
+ * invalid range, because it may have already been reduced
+ * to zero by the borrowed blocks check above.
+ */
+ if (!TAILQ_EMPTY(&cp->c_datafork->ff_invalidranges)) {
+ numbytes = TAILQ_FIRST(&cp->c_datafork->ff_invalidranges)->rl_start;
+ datafork.cf_size = MIN((numbytes), (datafork.cf_size));
+ }
+ }
+
/*
* For resource forks with delayed allocations, make sure
* the block count and file size match the number of blocks
hfs_end_transaction(hfsmp);
- HFS_KNOTE(vp, NOTE_ATTRIB);
-
return (error);
}
* Allocate a new node
* Note - Function does not create and return a vnode for whiteout creation.
*/
-static int
+int
hfs_makenode(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
struct vnode_attr *vap, vfs_context_t ctx)
{
struct cnode *cp = NULL;
- struct cnode *dcp;
+ struct cnode *dcp = NULL;
struct vnode *tvp;
struct hfsmount *hfsmp;
struct cat_desc in_desc, out_desc;
int error, started_tr = 0;
enum vtype vnodetype;
int mode;
+ int newvnode_flags = 0;
+ u_int32_t gnv_flags = 0;
+ int protectable_target = 0;
- dcp = VTOC(dvp);
- if ((error = hfs_lock(dcp, HFS_EXCLUSIVE_LOCK)))
+#if CONFIG_PROTECT
+ struct cprotect *entry = NULL;
+ uint32_t cp_class = 0;
+ if (VATTR_IS_ACTIVE(vap, va_dataprotect_class)) {
+ cp_class = vap->va_dataprotect_class;
+ }
+ int protected_mount = 0;
+#endif
+
+
+ if ((error = hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK)))
return (error);
+ /* set the cnode pointer only after successfully acquiring lock */
+ dcp = VTOC(dvp);
+
+ /* Don't allow creation of new entries in open-unlinked directories */
+ if ((error = hfs_checkdeleted(dcp))) {
+ hfs_unlock(dcp);
+ return error;
+ }
+
dcp->c_flag |= C_DIR_MODIFICATION;
-
+
hfsmp = VTOHFS(dvp);
+
*vpp = NULL;
tvp = NULL;
out_desc.cd_flags = 0;
vnodetype = VREG;
mode = MAKEIMODE(vnodetype, vap->va_mode);
+ if (S_ISDIR (mode) || S_ISREG (mode)) {
+ protectable_target = 1;
+ }
+
+
/* Check if were out of usable disk space. */
if ((hfs_freeblks(hfsmp, 1) == 0) && (vfs_context_suser(ctx) != 0)) {
error = ENOSPC;
}
}
+#if CONFIG_PROTECT
+ if (cp_fs_protected(hfsmp->hfs_mp)) {
+ protected_mount = 1;
+ }
+ /*
+ * On a content-protected HFS+/HFSX filesystem, files and directories
+ * cannot be created without atomically setting/creating the EA that
+ * contains the protection class metadata and keys at the same time, in
+ * the same transaction. As a result, pre-set the "EAs exist" flag
+ * on the cat_attr for protectable catalog record creations. This will
+ * cause the cnode creation routine in hfs_getnewvnode to mark the cnode
+ * as having EAs.
+ */
+ if ((protected_mount) && (protectable_target)) {
+ attr.ca_recflags |= kHFSHasAttributesMask;
+ }
+#endif
+
+
+ /*
+ * Add the date added to the item. See above, as
+ * all of the dates are set to the itime.
+ */
+ hfs_write_dateadded (&attr, attr.ca_atime);
+
attr.ca_uid = vap->va_uid;
attr.ca_gid = vap->va_gid;
VATTR_SET_SUPPORTED(vap, va_mode);
VATTR_SET_SUPPORTED(vap, va_uid);
VATTR_SET_SUPPORTED(vap, va_gid);
+#if QUOTA
+ /* check to see if this node's creation would cause us to go over
+ * quota. If so, abort this operation.
+ */
+ if (hfsmp->hfs_flags & HFS_QUOTAS) {
+ if ((error = hfs_quotacheck(hfsmp, 1, attr.ca_uid, attr.ca_gid,
+ vfs_context_ucred(ctx)))) {
+ goto exit;
+ }
+ }
+#endif
+
+
/* Tag symlinks with a type and creator. */
if (vnodetype == VLNK) {
struct FndrFileInfo *fip;
in_desc.cd_hint = dcp->c_childhint;
in_desc.cd_encoding = 0;
+#if CONFIG_PROTECT
+ /*
+ * To preserve file creation atomicity with regards to the content protection EA,
+ * we must create the file in the catalog and then write out the EA in the same
+ * transaction. Pre-flight any operations that we can (such as allocating/preparing
+ * the buffer, wrapping the keys) before we start the txn and take the requisite
+ * b-tree locks. We pass '0' as the fileid because we do not know it yet.
+ */
+ if ((protected_mount) && (protectable_target)) {
+ error = cp_entry_create_keys (&entry, dcp, hfsmp, cp_class, 0, attr.ca_mode);
+ if (error) {
+ goto exit;
+ }
+ }
+#endif
+
if ((error = hfs_start_transaction(hfsmp)) != 0) {
goto exit;
}
dcp->c_ctime = tv.tv_sec;
dcp->c_mtime = tv.tv_sec;
(void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);
- HFS_KNOTE(dvp, NOTE_ATTRIB);
+
+#if CONFIG_PROTECT
+ /*
+ * If we are creating a content protected file, now is when
+ * we create the EA. We must create it in the same transaction
+ * that creates the file. We can also guarantee that the file
+ * MUST exist because we are still holding the catalog lock
+ * at this point.
+ */
+ if ((attr.ca_fileid != 0) && (protected_mount) && (protectable_target)) {
+ error = cp_setxattr (NULL, entry, hfsmp, attr.ca_fileid, XATTR_CREATE);
+
+ if (error) {
+ int delete_err;
+ /*
+ * If we fail the EA creation, then we need to delete the file.
+ * Luckily, we are still holding all of the right locks.
+ */
+ delete_err = cat_delete (hfsmp, &out_desc, &attr);
+ if (delete_err == 0) {
+ /* Update the parent directory */
+ if (dcp->c_entries > 0)
+ dcp->c_entries--;
+ dcp->c_dirchangecnt++;
+ dcp->c_ctime = tv.tv_sec;
+ dcp->c_mtime = tv.tv_sec;
+ (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);
+ }
+
+ /* Emit EINVAL if we fail to create EA*/
+ error = EINVAL;
+ }
+ }
+#endif
}
hfs_systemfile_unlock(hfsmp, lockflags);
if (error)
dcp->c_flag &= ~C_NEG_ENTRIES;
}
- if (vnodetype == VDIR) {
- HFS_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
- } else {
- HFS_KNOTE(dvp, NOTE_WRITE);
- };
-
hfs_volupdate(hfsmp, vnodetype == VDIR ? VOL_MKDIR : VOL_MKFILE,
(dcp->c_cnid == kHFSRootFolderID));
started_tr = 0;
}
+#if CONFIG_PROTECT
+ /*
+ * At this point, we must have encountered success with writing the EA.
+ * Update MKB with the data for the cached key, then destroy it. This may
+ * prevent information leakage by ensuring the cache key is only unwrapped
+ * to perform file I/O and it is allowed.
+ */
+
+ if ((attr.ca_fileid != 0) && (protected_mount) && (protectable_target)) {
+ cp_update_mkb (entry, attr.ca_fileid);
+ cp_entry_destroy (&entry);
+ }
+#endif
+
/* Do not create vnode for whiteouts */
if (S_ISWHT(mode)) {
goto exit;
- }
+ }
+
+ gnv_flags |= GNV_CREATE;
/*
* Create a vnode for the object just created.
- *
+ *
+ * NOTE: Maintaining the cnode lock on the parent directory is important,
+ * as it prevents race conditions where other threads want to look up entries
+ * in the directory and/or add things as we are in the process of creating
+ * the vnode below. However, this has the potential for causing a
+ * double lock panic when dealing with shadow files on a HFS boot partition.
+ * The panic could occur if we are not cleaning up after ourselves properly
+ * when done with a shadow file or in the error cases. The error would occur if we
+ * try to create a new vnode, and then end up reclaiming another shadow vnode to
+ * create the new one. However, if everything is working properly, this should
+ * be a non-issue as we would never enter that reclaim codepath.
+ *
* The cnode is locked on successful return.
*/
- error = hfs_getnewvnode(hfsmp, dvp, cnp, &out_desc, GNV_CREATE, &attr, NULL, &tvp);
+ error = hfs_getnewvnode(hfsmp, dvp, cnp, &out_desc, gnv_flags, &attr,
+ NULL, &tvp, &newvnode_flags);
if (error)
goto exit;
cp = VTOC(tvp);
+ *vpp = tvp;
+
#if QUOTA
/*
- * We call hfs_chkiq with FORCE flag so that if we
- * fall through to the rmdir we actually have
- * accounted for the inode
- */
+ * Once we create this vnode, we need to initialize its quota data
+ * structures, if necessary. We know that it is OK to just go ahead and
+ * initialize because we've already validated earlier (through the hfs_quotacheck
+ * function) to see if creating this cnode/vnode would cause us to go over quota.
+ */
if (hfsmp->hfs_flags & HFS_QUOTAS) {
- if ((error = hfs_getinoquota(cp)) ||
- (error = hfs_chkiq(cp, 1, vfs_context_ucred(ctx), FORCE))) {
-
- if (vnode_isdir(tvp))
- (void) hfs_removedir(dvp, tvp, cnp, 0);
- else {
- hfs_unlock(cp);
- hfs_lock_truncate(cp, TRUE);
- hfs_lock(cp, HFS_FORCE_LOCK);
- (void) hfs_removefile(dvp, tvp, cnp, 0, 0, 0);
- hfs_unlock_truncate(cp, TRUE);
- }
- /*
- * we successfully allocated a new vnode, but
- * the quota check is telling us we're beyond
- * our limit, so we need to dump our lock + reference
- */
- hfs_unlock(cp);
- vnode_put(tvp);
-
- goto exit;
- }
+ (void) hfs_getinoquota(cp);
}
-#endif /* QUOTA */
+#endif
- *vpp = tvp;
exit:
cat_releasedesc(&out_desc);
+
+#if CONFIG_PROTECT
+ /*
+ * We may have jumped here in error-handling various situations above.
+ * If we haven't already dumped the temporary CP used to initialize
+ * the file atomically, then free it now. cp_entry_destroy should null
+ * out the pointer if it was called already.
+ */
+ if (entry) {
+ cp_entry_destroy (&entry);
+ }
+#endif
/*
- * Check if a file is located in the "Cleanup At Startup"
- * directory. If it is then tag it as NODUMP so that we
- * can be lazy about zero filling data holes.
+ * Make sure we release cnode lock on dcp.
*/
- if ((error == 0) && dvp && (vnodetype == VREG) &&
- (dcp->c_desc.cd_nameptr != NULL) &&
- (strncmp((const char *)dcp->c_desc.cd_nameptr,
- CARBON_TEMP_DIR_NAME,
- sizeof(CARBON_TEMP_DIR_NAME)) == 0)) {
- struct vnode *ddvp;
-
- dcp->c_flag &= ~C_DIR_MODIFICATION;
- wakeup((caddr_t)&dcp->c_flag);
-
- hfs_unlock(dcp);
- dvp = NULL;
-
- /*
- * The parent of "Cleanup At Startup" should
- * have the ASCII name of the userid.
- */
- if (hfs_vget(hfsmp, dcp->c_parentcnid, &ddvp, 0) == 0) {
- if (VTOC(ddvp)->c_desc.cd_nameptr) {
- uid_t uid;
-
- uid = strtoul((const char *)VTOC(ddvp)->c_desc.cd_nameptr, 0, 0);
- if ((uid == cp->c_uid) ||
- (uid == vfs_context_ucred(ctx)->cr_uid)) {
- cp->c_flags |= UF_NODUMP;
- cp->c_touch_chgtime = TRUE;
- }
- }
- hfs_unlock(VTOC(ddvp));
- vnode_put(ddvp);
- }
- }
- if (dvp) {
+ if (dcp) {
dcp->c_flag &= ~C_DIR_MODIFICATION;
wakeup((caddr_t)&dcp->c_flag);
/*
- * Return a referenced vnode for the resource fork
- *
- * cnode for vnode vp must already be locked.
- *
- * can_drop_lock is true if its safe to temporally drop/re-acquire the cnode lock
+ * hfs_vgetrsrc acquires a resource fork vnode corresponding to the cnode that is
+ * found in 'vp'. The rsrc fork vnode is returned with the cnode locked and iocount
+ * on the rsrc vnode.
+ *
+ * *rvpp is an output argument for returning the pointer to the resource fork vnode.
+ * In most cases, the resource fork vnode will not be set if we return an error.
+ * However, if error_on_unlinked is set, we may have already acquired the resource fork vnode
+ * before we discover the error (the file has gone open-unlinked). In this case only,
+ * we may return a vnode in the output argument despite an error.
+ *
+ * If can_drop_lock is set, then it is safe for this function to temporarily drop
+ * and then re-acquire the cnode lock. We may need to do this, for example, in order to
+ * acquire an iocount or promote our lock.
+ *
+ * error_on_unlinked is an argument which indicates that we are to return an error if we
+ * discover that the cnode has gone into an open-unlinked state ( C_DELETED or C_NOEXISTS)
+ * is set in the cnode flags. This is only necessary if can_drop_lock is true, otherwise
+ * there's really no reason to double-check for errors on the cnode.
*/
-__private_extern__
+
int
-hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp, struct vnode **rvpp, int can_drop_lock)
+hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp, struct vnode **rvpp,
+ int can_drop_lock, int error_on_unlinked)
{
struct vnode *rvp;
struct vnode *dvp = NULLVP;
struct cnode *cp = VTOC(vp);
int error;
int vid;
+ int delete_status = 0;
+
+ if (vnode_vtype(vp) == VDIR) {
+ return EINVAL;
+ }
+
+ /*
+ * Need to check the status of the cnode to validate it hasn't gone
+ * open-unlinked on us before we can actually do work with it.
+ */
+ delete_status = hfs_checkdeleted(cp);
+ if ((delete_status) && (error_on_unlinked)) {
+ return delete_status;
+ }
restart:
- /* Attempt to use exising vnode */
+ /* Attempt to use existing vnode */
if ((rvp = cp->c_rsrc_vp)) {
vid = vnode_vid(rvp);
if (can_drop_lock) {
(void) hfs_lock(cp, HFS_FORCE_LOCK);
+
+ /*
+ * When we relinquished our cnode lock, the cnode could have raced
+ * with a delete and gotten deleted. If the caller did not want
+ * us to ignore open-unlinked files, then re-check the C_DELETED
+ * state and see if we need to return an ENOENT here because the item
+ * got deleted in the intervening time.
+ */
+ if (error_on_unlinked) {
+ if ((delete_status = hfs_checkdeleted(cp))) {
+ /*
+ * If error == 0, this means that we succeeded in acquiring an iocount on the
+ * rsrc fork vnode. However, if we're in this block of code, that means that we noticed
+ * that the cnode has gone open-unlinked. In this case, the caller requested that we
+ * not do any other work and return an errno. The caller will be responsible for
+ * dropping the iocount we just acquired because we can't do it until we've released
+ * the cnode lock.
+ */
+ if (error == 0) {
+ *rvpp = rvp;
+ }
+ return delete_status;
+ }
+ }
+
/*
* When our lock was relinquished, the resource fork
* could have been recycled. Check for this and try
} else {
struct cat_fork rsrcfork;
struct componentname cn;
+ struct cat_desc *descptr = NULL;
+ struct cat_desc to_desc;
+ char delname[32];
int lockflags;
-
+ int newvnode_flags = 0;
+
/*
* Make sure cnode lock is exclusive, if not upgrade it.
*
* and that its safe to have the cnode lock dropped and reacquired.
*/
if (cp->c_lockowner != current_thread()) {
- if (!can_drop_lock)
+ if (!can_drop_lock) {
return (EINVAL);
+ }
/*
- * If the upgrade fails we loose the lock and
+ * If the upgrade fails we lose the lock and
* have to take the exclusive lock on our own.
*/
if (lck_rw_lock_shared_to_exclusive(&cp->c_rwlock) == FALSE)
cp->c_lockowner = current_thread();
}
+ /*
+ * hfs_vgetsrc may be invoked for a cnode that has already been marked
+ * C_DELETED. This is because we need to continue to provide rsrc
+ * fork access to open-unlinked files. In this case, build a fake descriptor
+ * like in hfs_removefile. If we don't do this, buildkey will fail in
+ * cat_lookup because this cnode has no name in its descriptor. However,
+ * only do this if the caller did not specify that they wanted us to
+ * error out upon encountering open-unlinked files.
+ */
+
+ if ((error_on_unlinked) && (can_drop_lock)) {
+ if ((error = hfs_checkdeleted(cp))) {
+ return error;
+ }
+ }
+
+ if ((cp->c_flag & C_DELETED ) && (cp->c_desc.cd_namelen == 0)) {
+ bzero (&to_desc, sizeof(to_desc));
+ bzero (delname, 32);
+ MAKE_DELETED_NAME(delname, sizeof(delname), cp->c_fileid);
+ to_desc.cd_nameptr = (const u_int8_t*) delname;
+ to_desc.cd_namelen = strlen(delname);
+ to_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;
+ to_desc.cd_flags = 0;
+ to_desc.cd_cnid = cp->c_cnid;
+
+ descptr = &to_desc;
+ }
+ else {
+ descptr = &cp->c_desc;
+ }
+
+
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
- /* Get resource fork data */
- error = cat_lookup(hfsmp, &cp->c_desc, 1, (struct cat_desc *)0,
- (struct cat_attr *)0, &rsrcfork, NULL);
+ /*
+ * Get resource fork data
+ *
+ * We call cat_idlookup (instead of cat_lookup) below because we can't
+ * trust the descriptor in the provided cnode for lookups at this point.
+ * Between the time of the original lookup of this vnode and now, the
+ * descriptor could have gotten swapped or replaced. If this occurred,
+ * the parent/name combo originally desired may not necessarily be provided
+ * if we use the descriptor. Even worse, if the vnode represents
+ * a hardlink, we could have removed one of the links from the namespace
+ * but left the descriptor alone, since hfs_unlink does not invalidate
+ * the descriptor in the cnode if other links still point to the inode.
+ *
+ * Consider the following (slightly contrived) scenario:
+ * /tmp/a <--> /tmp/b (hardlinks).
+ * 1. Thread A: open rsrc fork on /tmp/b.
+ * 1a. Thread A: does lookup, goes out to lunch right before calling getnamedstream.
+ * 2. Thread B does 'mv /foo/b /tmp/b'
+ * 2. Thread B succeeds.
+ * 3. Thread A comes back and wants rsrc fork info for /tmp/b.
+ *
+ * Even though the hardlink backing /tmp/b is now eliminated, the descriptor
+ * is not removed/updated during the unlink process. So, if you were to
+ * do a lookup on /tmp/b, you'd acquire an entirely different record's resource
+ * fork.
+ *
+ * As a result, we use the fileid, which should be invariant for the lifetime
+ * of the cnode (possibly barring calls to exchangedata).
+ */
+
+ error = cat_idlookup (hfsmp, cp->c_attr.ca_fileid, 0, 1, NULL, NULL, &rsrcfork);
hfs_systemfile_unlock(hfsmp, lockflags);
- if (error)
+ if (error) {
return (error);
-
+ }
+
/*
* Supply hfs_getnewvnode with a component name.
*/
cn.cn_pnbuf = NULL;
- if (cp->c_desc.cd_nameptr) {
+ if (descptr->cd_nameptr) {
MALLOC_ZONE(cn.cn_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
cn.cn_nameiop = LOOKUP;
cn.cn_flags = ISLASTCN | HASBUF;
cn.cn_hash = 0;
cn.cn_consume = 0;
cn.cn_namelen = snprintf(cn.cn_nameptr, MAXPATHLEN,
- "%s%s", cp->c_desc.cd_nameptr,
+ "%s%s", descptr->cd_nameptr,
_PATH_RSRCFORKSPEC);
}
dvp = vnode_getparent(vp);
error = hfs_getnewvnode(hfsmp, dvp, cn.cn_pnbuf ? &cn : NULL,
- &cp->c_desc, GNV_WANTRSRC | GNV_SKIPLOCK, &cp->c_attr,
- &rsrcfork, &rvp);
+ descptr, GNV_WANTRSRC | GNV_SKIPLOCK, &cp->c_attr,
+ &rsrcfork, &rvp, &newvnode_flags);
if (dvp)
vnode_put(dvp);
if (cn.cn_pnbuf)
return (0);
}
-
-static void
-filt_hfsdetach(struct knote *kn)
-{
- struct vnode *vp;
-
- vp = (struct vnode *)kn->kn_hook;
- if (vnode_getwithvid(vp, kn->kn_hookid))
- return;
-
- if (1) { /* ! KNDETACH_VNLOCKED */
- if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) == 0) {
- (void) KNOTE_DETACH(&VTOC(vp)->c_knotes, kn);
- hfs_unlock(VTOC(vp));
- }
- }
-
- vnode_put(vp);
-}
-
-/*ARGSUSED*/
-static int
-filt_hfsread(struct knote *kn, long hint)
-{
- struct vnode *vp = (struct vnode *)kn->kn_hook;
- int dropvp = 0;
-
- if (hint == 0) {
- if ((vnode_getwithvid(vp, kn->kn_hookid) != 0)) {
- hint = NOTE_REVOKE;
- } else
- dropvp = 1;
- }
- if (hint == NOTE_REVOKE) {
- /*
- * filesystem is gone, so set the EOF flag and schedule
- * the knote for deletion.
- */
- kn->kn_flags |= (EV_EOF | EV_ONESHOT);
- return (1);
- }
-
- /* poll(2) semantics dictate always saying there is data */
- if (!(kn->kn_flags & EV_POLL)) {
- off_t amount;
-
- amount = VTOF(vp)->ff_size - kn->kn_fp->f_fglob->fg_offset;
- if (amount > (off_t)INTPTR_MAX)
- kn->kn_data = INTPTR_MAX;
- else if (amount < (off_t)INTPTR_MIN)
- kn->kn_data = INTPTR_MIN;
- else
- kn->kn_data = (intptr_t)amount;
- } else {
- kn->kn_data = 1;
- }
-
- if (dropvp)
- vnode_put(vp);
-
- return (kn->kn_data != 0);
-}
-
-/*ARGSUSED*/
-static int
-filt_hfswrite(struct knote *kn, long hint)
-{
- struct vnode *vp = (struct vnode *)kn->kn_hook;
-
- if (hint == 0) {
- if ((vnode_getwithvid(vp, kn->kn_hookid) != 0)) {
- hint = NOTE_REVOKE;
- } else
- vnode_put(vp);
- }
- if (hint == NOTE_REVOKE) {
- /*
- * filesystem is gone, so set the EOF flag and schedule
- * the knote for deletion.
- */
- kn->kn_data = 0;
- kn->kn_flags |= (EV_EOF | EV_ONESHOT);
- return (1);
- }
- kn->kn_data = 0;
- return (1);
-}
-
-static int
-filt_hfsvnode(struct knote *kn, long hint)
-{
- struct vnode *vp = (struct vnode *)kn->kn_hook;
-
- if (hint == 0) {
- if ((vnode_getwithvid(vp, kn->kn_hookid) != 0)) {
- hint = NOTE_REVOKE;
- } else
- vnode_put(vp);
- }
- if (kn->kn_sfflags & hint)
- kn->kn_fflags |= hint;
- if ((hint == NOTE_REVOKE)) {
- kn->kn_flags |= (EV_EOF | EV_ONESHOT);
- return (1);
- }
-
- return (kn->kn_fflags != 0);
-}
-
-static struct filterops hfsread_filtops =
- { 1, NULL, filt_hfsdetach, filt_hfsread };
-static struct filterops hfswrite_filtops =
- { 1, NULL, filt_hfsdetach, filt_hfswrite };
-static struct filterops hfsvnode_filtops =
- { 1, NULL, filt_hfsdetach, filt_hfsvnode };
-
-/*
- * Add a kqueue filter.
- */
-static int
-hfs_vnop_kqfiltadd(
- struct vnop_kqfilt_add_args /* {
- struct vnode *a_vp;
- struct knote *a_kn;
- struct proc *p;
- vfs_context_t a_context;
- } */ *ap)
-{
- struct vnode *vp = ap->a_vp;
- struct knote *kn = ap->a_kn;
- int error;
-
- switch (kn->kn_filter) {
- case EVFILT_READ:
- if (vnode_isreg(vp)) {
- kn->kn_fop = &hfsread_filtops;
- } else {
- return EINVAL;
- };
- break;
- case EVFILT_WRITE:
- if (vnode_isreg(vp)) {
- kn->kn_fop = &hfswrite_filtops;
- } else {
- return EINVAL;
- };
- break;
- case EVFILT_VNODE:
- kn->kn_fop = &hfsvnode_filtops;
- break;
- default:
- return (1);
- }
-
- kn->kn_hook = (caddr_t)vp;
- kn->kn_hookid = vnode_vid(vp);
-
- if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
- return (error);
- KNOTE_ATTACH(&VTOC(vp)->c_knotes, kn);
- hfs_unlock(VTOC(vp));
-
- return (0);
-}
-
-/*
- * Remove a kqueue filter
- */
-static int
-hfs_vnop_kqfiltremove(ap)
- struct vnop_kqfilt_remove_args /* {
- struct vnode *a_vp;
- uintptr_t ident;
- vfs_context_t a_context;
- } */__unused *ap;
-{
- int result;
-
- result = ENOTSUP; /* XXX */
-
- return (result);
-}
-
/*
* Wrapper for special device reads
*/
-static int
+int
hfsspec_read(ap)
struct vnop_read_args /* {
struct vnode *a_vp;
/*
* Wrapper for special device writes
*/
-static int
+int
hfsspec_write(ap)
struct vnop_write_args /* {
struct vnode *a_vp;
*
* Update the times on the cnode then do device close.
*/
-static int
+int
hfsspec_close(ap)
struct vnop_close_args /* {
struct vnode *a_vp;
struct vnode *vp = ap->a_vp;
struct cnode *cp;
- if (vnode_isinuse(ap->a_vp, 1)) {
+ if (vnode_isinuse(ap->a_vp, 0)) {
if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) == 0) {
cp = VTOC(vp);
hfs_touchtimes(VTOHFS(vp), cp);
return (VOCALL (fifo_vnodeop_p, VOFFSET(vnop_close), ap));
}
-/*
- * kqfilt_add wrapper for fifos.
- *
- * Fall through to hfs kqfilt_add routines if needed
- */
-int
-hfsfifo_kqfilt_add(ap)
- struct vnop_kqfilt_add_args *ap;
-{
- int error;
-
- error = VOCALL(fifo_vnodeop_p, VOFFSET(vnop_kqfilt_add), ap);
- if (error)
- error = hfs_vnop_kqfiltadd(ap);
- return (error);
-}
-
-/*
- * kqfilt_remove wrapper for fifos.
- *
- * Fall through to hfs kqfilt_remove routines if needed
- */
-int
-hfsfifo_kqfilt_remove(ap)
- struct vnop_kqfilt_remove_args *ap;
-{
- int error;
-
- error = VOCALL(fifo_vnodeop_p, VOFFSET(vnop_kqfilt_remove), ap);
- if (error)
- error = hfs_vnop_kqfiltremove(ap);
- return (error);
-}
#endif /* FIFO */
/*
* Synchronize a file's in-core state with that on disk.
*/
-static int
+int
hfs_vnop_fsync(ap)
struct vnop_fsync_args /* {
struct vnode *a_vp;
struct vnode* vp = ap->a_vp;
int error;
+ /* Note: We check hfs flags instead of vfs mount flag because during
+ * read-write update, hfs marks itself read-write much earlier than
+ * the vfs, and hence won't result in skipping of certain writes like
+ * zero'ing out of unused nodes, creation of hotfiles btree, etc.
+ */
+ if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY) {
+ return 0;
+ }
+
+#if CONFIG_PROTECT
+ if ((error = cp_handle_vnop(vp, CP_WRITE_ACCESS, 0)) != 0) {
+ return (error);
+ }
+#endif /* CONFIG_PROTECT */
+
/*
* We need to allow ENOENT lock errors since unlink
* systenm call can call VNOP_FSYNC during vclean.
}
-static int
+int
hfs_vnop_whiteout(ap)
struct vnop_whiteout_args /* {
struct vnode *a_dvp;
}
int (**hfs_vnodeop_p)(void *);
+int (**hfs_std_vnodeop_p) (void *);
#define VOPFUNC int (*)(void *)
+static int hfs_readonly_op (__unused void* ap) { return (EROFS); }
+
+/*
+ * In 10.6 and forward, HFS Standard is read-only and deprecated. The vnop table below
+ * is for use with HFS standard to block out operations that would modify the file system
+ */
+
+struct vnodeopv_entry_desc hfs_standard_vnodeop_entries[] = {
+ { &vnop_default_desc, (VOPFUNC)vn_default_error },
+ { &vnop_lookup_desc, (VOPFUNC)hfs_vnop_lookup }, /* lookup */
+ { &vnop_create_desc, (VOPFUNC)hfs_readonly_op }, /* create (READONLY) */
+ { &vnop_mknod_desc, (VOPFUNC)hfs_readonly_op }, /* mknod (READONLY) */
+ { &vnop_open_desc, (VOPFUNC)hfs_vnop_open }, /* open */
+ { &vnop_close_desc, (VOPFUNC)hfs_vnop_close }, /* close */
+ { &vnop_getattr_desc, (VOPFUNC)hfs_vnop_getattr }, /* getattr */
+ { &vnop_setattr_desc, (VOPFUNC)hfs_readonly_op }, /* setattr */
+ { &vnop_read_desc, (VOPFUNC)hfs_vnop_read }, /* read */
+ { &vnop_write_desc, (VOPFUNC)hfs_readonly_op }, /* write (READONLY) */
+ { &vnop_ioctl_desc, (VOPFUNC)hfs_vnop_ioctl }, /* ioctl */
+ { &vnop_select_desc, (VOPFUNC)hfs_vnop_select }, /* select */
+ { &vnop_revoke_desc, (VOPFUNC)nop_revoke }, /* revoke */
+ { &vnop_exchange_desc, (VOPFUNC)hfs_readonly_op }, /* exchange (READONLY)*/
+ { &vnop_mmap_desc, (VOPFUNC)err_mmap }, /* mmap */
+ { &vnop_fsync_desc, (VOPFUNC)hfs_readonly_op}, /* fsync (READONLY) */
+ { &vnop_remove_desc, (VOPFUNC)hfs_readonly_op }, /* remove (READONLY) */
+ { &vnop_link_desc, (VOPFUNC)hfs_readonly_op }, /* link ( READONLLY) */
+ { &vnop_rename_desc, (VOPFUNC)hfs_readonly_op }, /* rename (READONLY)*/
+ { &vnop_mkdir_desc, (VOPFUNC)hfs_readonly_op }, /* mkdir (READONLY) */
+ { &vnop_rmdir_desc, (VOPFUNC)hfs_readonly_op }, /* rmdir (READONLY) */
+ { &vnop_symlink_desc, (VOPFUNC)hfs_readonly_op }, /* symlink (READONLY) */
+ { &vnop_readdir_desc, (VOPFUNC)hfs_vnop_readdir }, /* readdir */
+ { &vnop_readdirattr_desc, (VOPFUNC)hfs_vnop_readdirattr }, /* readdirattr */
+ { &vnop_readlink_desc, (VOPFUNC)hfs_vnop_readlink }, /* readlink */
+ { &vnop_inactive_desc, (VOPFUNC)hfs_vnop_inactive }, /* inactive */
+ { &vnop_reclaim_desc, (VOPFUNC)hfs_vnop_reclaim }, /* reclaim */
+ { &vnop_strategy_desc, (VOPFUNC)hfs_vnop_strategy }, /* strategy */
+ { &vnop_pathconf_desc, (VOPFUNC)hfs_vnop_pathconf }, /* pathconf */
+ { &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */
+ { &vnop_allocate_desc, (VOPFUNC)hfs_readonly_op }, /* allocate (READONLY) */
+#if CONFIG_SEARCHFS
+ { &vnop_searchfs_desc, (VOPFUNC)hfs_vnop_search }, /* search fs */
+#else
+ { &vnop_searchfs_desc, (VOPFUNC)err_searchfs }, /* search fs */
+#endif
+ { &vnop_bwrite_desc, (VOPFUNC)hfs_readonly_op }, /* bwrite (READONLY) */
+ { &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* pagein */
+ { &vnop_pageout_desc,(VOPFUNC) hfs_readonly_op }, /* pageout (READONLY) */
+ { &vnop_copyfile_desc, (VOPFUNC)hfs_readonly_op }, /* copyfile (READONLY)*/
+ { &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */
+ { &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */
+ { &vnop_blockmap_desc, (VOPFUNC)hfs_vnop_blockmap }, /* blockmap */
+ { &vnop_getxattr_desc, (VOPFUNC)hfs_vnop_getxattr},
+ { &vnop_setxattr_desc, (VOPFUNC)hfs_readonly_op}, /* set xattr (READONLY) */
+ { &vnop_removexattr_desc, (VOPFUNC)hfs_readonly_op}, /* remove xattr (READONLY) */
+ { &vnop_listxattr_desc, (VOPFUNC)hfs_vnop_listxattr},
+ { &vnop_whiteout_desc, (VOPFUNC)hfs_readonly_op}, /* whiteout (READONLY) */
+#if NAMEDSTREAMS
+ { &vnop_getnamedstream_desc, (VOPFUNC)hfs_vnop_getnamedstream },
+ { &vnop_makenamedstream_desc, (VOPFUNC)hfs_readonly_op },
+ { &vnop_removenamedstream_desc, (VOPFUNC)hfs_readonly_op },
+#endif
+ { NULL, (VOPFUNC)NULL }
+};
+
+struct vnodeopv_desc hfs_std_vnodeop_opv_desc =
+{ &hfs_std_vnodeop_p, hfs_standard_vnodeop_entries };
+
+
+/* VNOP table for HFS+ */
struct vnodeopv_entry_desc hfs_vnodeop_entries[] = {
{ &vnop_default_desc, (VOPFUNC)vn_default_error },
{ &vnop_lookup_desc, (VOPFUNC)hfs_vnop_lookup }, /* lookup */
{ &vnop_select_desc, (VOPFUNC)hfs_vnop_select }, /* select */
{ &vnop_revoke_desc, (VOPFUNC)nop_revoke }, /* revoke */
{ &vnop_exchange_desc, (VOPFUNC)hfs_vnop_exchange }, /* exchange */
- { &vnop_mmap_desc, (VOPFUNC)err_mmap }, /* mmap */
+ { &vnop_mmap_desc, (VOPFUNC)hfs_vnop_mmap }, /* mmap */
{ &vnop_fsync_desc, (VOPFUNC)hfs_vnop_fsync }, /* fsync */
{ &vnop_remove_desc, (VOPFUNC)hfs_vnop_remove }, /* remove */
{ &vnop_link_desc, (VOPFUNC)hfs_vnop_link }, /* link */
{ &vnop_pathconf_desc, (VOPFUNC)hfs_vnop_pathconf }, /* pathconf */
{ &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */
{ &vnop_allocate_desc, (VOPFUNC)hfs_vnop_allocate }, /* allocate */
+#if CONFIG_SEARCHFS
{ &vnop_searchfs_desc, (VOPFUNC)hfs_vnop_search }, /* search fs */
+#else
+ { &vnop_searchfs_desc, (VOPFUNC)err_searchfs }, /* search fs */
+#endif
{ &vnop_bwrite_desc, (VOPFUNC)hfs_vnop_bwrite }, /* bwrite */
{ &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* pagein */
{ &vnop_pageout_desc,(VOPFUNC) hfs_vnop_pageout }, /* pageout */
{ &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */
{ &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */
{ &vnop_blockmap_desc, (VOPFUNC)hfs_vnop_blockmap }, /* blockmap */
- { &vnop_kqfilt_add_desc, (VOPFUNC)hfs_vnop_kqfiltadd }, /* kqfilt_add */
- { &vnop_kqfilt_remove_desc, (VOPFUNC)hfs_vnop_kqfiltremove }, /* kqfilt_remove */
{ &vnop_getxattr_desc, (VOPFUNC)hfs_vnop_getxattr},
{ &vnop_setxattr_desc, (VOPFUNC)hfs_vnop_setxattr},
{ &vnop_removexattr_desc, (VOPFUNC)hfs_vnop_removexattr},
struct vnodeopv_desc hfs_vnodeop_opv_desc =
{ &hfs_vnodeop_p, hfs_vnodeop_entries };
+
+/* Spec Op vnop table for HFS+ */
int (**hfs_specop_p)(void *);
struct vnodeopv_entry_desc hfs_specop_entries[] = {
{ &vnop_default_desc, (VOPFUNC)vn_default_error },
{ &vnop_bwrite_desc, (VOPFUNC)hfs_vnop_bwrite },
{ &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* Pagein */
{ &vnop_pageout_desc, (VOPFUNC)hfs_vnop_pageout }, /* Pageout */
- { &vnop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */
+ { &vnop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */
{ &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */
{ &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */
{ (struct vnodeop_desc*)NULL, (VOPFUNC)NULL }
{ &hfs_specop_p, hfs_specop_entries };
#if FIFO
+/* HFS+ FIFO VNOP table */
int (**hfs_fifoop_p)(void *);
struct vnodeopv_entry_desc hfs_fifoop_entries[] = {
{ &vnop_default_desc, (VOPFUNC)vn_default_error },
{ &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */
{ &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */
{ &vnop_blockmap_desc, (VOPFUNC)hfs_vnop_blockmap }, /* blockmap */
- { &vnop_kqfilt_add_desc, (VOPFUNC)hfsfifo_kqfilt_add }, /* kqfilt_add */
- { &vnop_kqfilt_remove_desc, (VOPFUNC)hfsfifo_kqfilt_remove }, /* kqfilt_remove */
{ (struct vnodeop_desc*)NULL, (VOPFUNC)NULL }
};
struct vnodeopv_desc hfs_fifoop_opv_desc =
projects / apple / xnu.git / blobdiff