/*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
- * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
+ * The contents of this file constitute Original Code as defined in and
+ * are subject to the Apple Public Source License Version 1.1 (the
+ * "License"). You may not use this file except in compliance with the
+ * License. Please obtain a copy of the License at
+ * http://www.apple.com/publicsource and read it before using this file.
*
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * This Original Code and all software distributed under the License are
+ * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
+ * License for the specific language governing rights and limitations
+ * under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
#include <sys/systm.h>
#include <sys/kernel.h>
-#include <sys/file.h>
+#include <sys/file_internal.h>
#include <sys/dirent.h>
#include <sys/stat.h>
#include <sys/buf.h>
#include <sys/mount.h>
-#include <sys/vnode.h>
+#include <sys/vnode_internal.h>
#include <sys/malloc.h>
-#include <sys/namei.h>
#include <sys/ubc.h>
+#include <sys/paths.h>
#include <sys/quota.h>
#include <sys/time.h>
#include <sys/disk.h>
+#include <sys/kauth.h>
+#include <sys/uio_internal.h>
#include <miscfs/specfs/specdev.h>
#include <miscfs/fifofs/fifo.h>
#include <machine/spl.h>
#include <sys/kdebug.h>
+#include <sys/sysctl.h>
#include "hfs.h"
#include "hfs_catalog.h"
#include "hfs_cnode.h"
-#include "hfs_lockf.h"
#include "hfs_dbg.h"
#include "hfs_mount.h"
#include "hfs_quota.h"
/* 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");
extern unsigned long strtoul(const char *, char **, int);
-extern int groupmember(gid_t gid, struct ucred *cred);
-
-static int hfs_makenode(int mode, struct vnode *dvp, struct vnode **vpp,
- struct componentname *cnp);
-
-static int hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp,
- struct vnode **rvpp, struct proc *p);
+static int hfs_makenode(struct vnode *dvp, struct vnode **vpp,
+ struct componentname *cnp, struct vnode_attr *vap,
+ vfs_context_t ctx);
-static int hfs_metasync(struct hfsmount *hfsmp, daddr_t node, struct proc *p);
+static int hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, struct proc *p);
static int hfs_removedir(struct vnode *, struct vnode *, struct componentname *,
int);
static int hfs_removefile(struct vnode *, struct vnode *, struct componentname *,
- int);
+ int, int);
+
+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*);
/* Options for hfs_removedir and hfs_removefile */
-#define HFSRM_PARENT_LOCKED 0x01
-#define HFSRM_SKIP_RESERVE 0x02
-#define HFSRM_SAVE_NAME 0x04
-#define HFSRM_RENAMEOPTS 0x07
+#define HFSRM_SKIP_RESERVE 0x01
-int hfs_write_access(struct vnode *vp, struct ucred *cred, struct proc *p, Boolean considerFlags);
+int hfs_write_access(struct vnode *vp, kauth_cred_t cred, struct proc *p, Boolean considerFlags);
-int hfs_chflags(struct vnode *vp, u_long flags, struct ucred *cred,
- struct proc *p);
-int hfs_chmod(struct vnode *vp, int mode, struct ucred *cred,
+int hfs_chmod(struct vnode *vp, int mode, kauth_cred_t cred,
struct proc *p);
int hfs_chown(struct vnode *vp, uid_t uid, gid_t gid,
- struct ucred *cred, struct proc *p);
+ kauth_cred_t cred, struct proc *p);
/*****************************************************************************
*
*****************************************************************************/
/*
- * Create a regular file
-#% create dvp L U U
-#% create vpp - L -
-#
- vop_create {
- IN WILLRELE struct vnode *dvp;
- OUT struct vnode **vpp;
- IN struct componentname *cnp;
- IN struct vattr *vap;
-
- We are responsible for freeing the namei buffer,
- it is done in hfs_makenode()
-*/
-
+ * Create a regular file.
+ */
static int
-hfs_create(ap)
- struct vop_create_args /* {
- struct vnode *a_dvp;
- struct vnode **a_vpp;
- struct componentname *a_cnp;
- struct vattr *a_vap;
- } */ *ap;
+hfs_vnop_create(struct vnop_create_args *ap)
{
- struct vattr *vap = ap->a_vap;
-
- return (hfs_makenode(MAKEIMODE(vap->va_type, vap->va_mode),
- ap->a_dvp, ap->a_vpp, ap->a_cnp));
+ return hfs_makenode(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap, ap->a_context);
}
-
/*
- * Mknod vnode call
-
-#% mknod dvp L U U
-#% mknod vpp - X -
-#
- vop_mknod {
- IN WILLRELE struct vnode *dvp;
- OUT WILLRELE struct vnode **vpp;
- IN struct componentname *cnp;
- IN struct vattr *vap;
- */
-/* ARGSUSED */
-
+ * Make device special file.
+ */
static int
-hfs_mknod(ap)
- struct vop_mknod_args /* {
- struct vnode *a_dvp;
- struct vnode **a_vpp;
- struct componentname *a_cnp;
- struct vattr *a_vap;
- } */ *ap;
+hfs_vnop_mknod(struct vnop_mknod_args *ap)
{
- struct vattr *vap = ap->a_vap;
+ struct vnode_attr *vap = ap->a_vap;
+ struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct cnode *cp;
int error;
- if (VTOVCB(ap->a_dvp)->vcbSigWord != kHFSPlusSigWord) {
- VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
- vput(ap->a_dvp);
- return (EOPNOTSUPP);
+ if (VTOVCB(dvp)->vcbSigWord != kHFSPlusSigWord) {
+ return (ENOTSUP);
}
/* Create the vnode */
- error = hfs_makenode(MAKEIMODE(vap->va_type, vap->va_mode),
- ap->a_dvp, vpp, ap->a_cnp);
+ error = hfs_makenode(dvp, vpp, ap->a_cnp, vap, ap->a_context);
if (error)
return (error);
+
cp = VTOC(*vpp);
- cp->c_flag |= C_ACCESS | C_CHANGE | C_UPDATE;
+ cp->c_touch_acctime = TRUE;
+ cp->c_touch_chgtime = TRUE;
+ cp->c_touch_modtime = TRUE;
+
if ((vap->va_rdev != VNOVAL) &&
(vap->va_type == VBLK || vap->va_type == VCHR))
cp->c_rdev = vap->va_rdev;
- /*
- * Remove cnode so that it will be reloaded by lookup and
- * checked to see if it is an alias of an existing vnode.
- * Note: unlike UFS, we don't bash v_type here.
- */
- vput(*vpp);
- vgone(*vpp);
- *vpp = 0;
+
return (0);
}
-
/*
- * Open called.
-#% open vp L L L
-#
- vop_open {
- IN struct vnode *vp;
- IN int mode;
- IN struct ucred *cred;
- IN struct proc *p;
- */
-
-
+ * Open a file/directory.
+ */
static int
-hfs_open(ap)
- struct vop_open_args /* {
- struct vnode *a_vp;
- int a_mode;
- struct ucred *a_cred;
- struct proc *a_p;
- } */ *ap;
+hfs_vnop_open(struct vnop_open_args *ap)
{
struct vnode *vp = ap->a_vp;
- struct filefork *fp = VTOF(vp);
+ struct filefork *fp;
struct timeval tv;
+ int error;
/*
* Files marked append-only must be opened for appending.
*/
- if ((vp->v_type != VDIR) && (VTOC(vp)->c_flags & APPEND) &&
+ if ((VTOC(vp)->c_flags & APPEND) && !vnode_isdir(vp) &&
(ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
return (EPERM);
- if (ap->a_mode & O_EVTONLY) {
- if (vp->v_type == VREG) {
- ++VTOF(vp)->ff_evtonly_refs;
- } else {
- ++VTOC(vp)->c_evtonly_refs;
- };
- };
+ 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)
+ 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) ||
- !UBCISVALID(vp) || ubc_isinuse(vp, 1)) {
+ (VTOHFS(vp)->jnl == NULL) ||
+ !vnode_isreg(vp) || vnode_isinuse(vp, 0)) {
return (0);
}
+
+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
+ return (error);
fp = VTOF(vp);
if (fp->ff_blocks &&
fp->ff_extents[7].blockCount != 0 &&
* Wait until system bootup is done (3 min).
*/
microuptime(&tv);
- if (tv.tv_sec < (60 * 3)) {
- return (0);
+ if (tv.tv_sec > (60 * 3)) {
+ (void) hfs_relocate(vp, VTOVCB(vp)->nextAllocation + 4096,
+ vfs_context_ucred(ap->a_context),
+ vfs_context_proc(ap->a_context));
}
- (void) hfs_relocate(vp, VTOVCB(vp)->nextAllocation + 4096, ap->a_cred, ap->a_p);
}
+ hfs_unlock(VTOC(vp));
return (0);
}
-/*
- * Close called.
- *
- * Update the times on the cnode.
-#% close vp U U U
-#
- vop_close {
- IN struct vnode *vp;
- IN int fflag;
- IN struct ucred *cred;
- IN struct proc *p;
- */
-
+/*
+ * Close a file/directory.
+ */
static int
-hfs_close(ap)
- struct vop_close_args /* {
+hfs_vnop_close(ap)
+ struct vnop_close_args /* {
struct vnode *a_vp;
int a_fflag;
- struct ucred *a_cred;
- struct proc *a_p;
+ vfs_context_t a_context;
} */ *ap;
{
register struct vnode *vp = ap->a_vp;
- register struct cnode *cp = VTOC(vp);
- register struct filefork *fp = VTOF(vp);
- struct proc *p = ap->a_p;
- struct timeval tv;
- off_t leof;
- u_long blks, blocksize;
- int devBlockSize;
- int error;
-
- simple_lock(&vp->v_interlock);
- if ((!UBCISVALID(vp) && vp->v_usecount > 1)
- || (UBCISVALID(vp) && ubc_isinuse(vp, 1))) {
- tv = time;
- CTIMES(cp, &tv, &tv);
- }
- simple_unlock(&vp->v_interlock);
-
- if (ap->a_fflag & O_EVTONLY) {
- if (vp->v_type == VREG) {
- --VTOF(vp)->ff_evtonly_refs;
- } else {
- --VTOC(vp)->c_evtonly_refs;
- };
- };
+ register struct cnode *cp;
+ struct proc *p = vfs_context_proc(ap->a_context);
+ struct hfsmount *hfsmp;
+ int busy;
- /*
- * VOP_CLOSE can be called with vp locked (from vclean).
- * We check for this case using VOP_ISLOCKED and bail.
- *
- * XXX During a force unmount we won't do the cleanup below!
- */
- if (vp->v_type == VDIR || VOP_ISLOCKED(vp))
+ if ( hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) != 0)
return (0);
+ cp = VTOC(vp);
+ hfsmp = VTOHFS(vp);
- leof = fp->ff_size;
-
- if ((fp->ff_blocks > 0) &&
- !ISSET(cp->c_flag, C_DELETED) &&
- ((VTOHFS(vp)->hfs_flags & HFS_READ_ONLY) == 0)) {
- enum vtype our_type = vp->v_type;
- u_long our_id = vp->v_id;
- int was_nocache = ISSET(vp->v_flag, VNOCACHE_DATA);
-
- error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
- if (error)
- return (0);
- /*
- * Since we can context switch in vn_lock our vnode
- * could get recycled (eg umount -f). Double check
- * that its still ours.
- */
- if (vp->v_type != our_type || vp->v_id != our_id
- || cp != VTOC(vp) || !UBCINFOEXISTS(vp)) {
- VOP_UNLOCK(vp, 0, p);
- return (0);
- }
-
- /*
- * Last chance to explicitly zero out the areas
- * that are currently marked invalid:
- */
- VOP_DEVBLOCKSIZE(cp->c_devvp, &devBlockSize);
- (void) cluster_push(vp);
- SET(vp->v_flag, VNOCACHE_DATA); /* Don't cache zeros */
- 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;
-
- /* The range about to be written must be validated
- * first, so that VOP_CMAP() will return the
- * appropriate mapping for the cluster code:
- */
- rl_remove(start, end, &fp->ff_invalidranges);
-
- (void) cluster_write(vp, (struct uio *) 0, leof,
- invalid_range->rl_end + 1, invalid_range->rl_start,
- (off_t)0, devBlockSize, IO_HEADZEROFILL | IO_NOZERODIRTY);
-
- if (ISSET(vp->v_flag, VHASDIRTY))
- (void) cluster_push(vp);
+ // 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);
+ }
- cp->c_flag |= C_MODIFIED;
- }
- cp->c_flag &= ~C_ZFWANTSYNC;
- cp->c_zftimeout = 0;
- blocksize = VTOVCB(vp)->blockSize;
- blks = leof / blocksize;
- if (((off_t)blks * (off_t)blocksize) != leof)
- blks++;
- /*
- * Shrink the peof to the smallest size neccessary to contain the leof.
- */
- if (blks < fp->ff_blocks)
- (void) VOP_TRUNCATE(vp, leof, IO_NDELAY, ap->a_cred, p);
- (void) cluster_push(vp);
+ busy = vnode_isinuse(vp, 1);
- if (!was_nocache)
- CLR(vp->v_flag, VNOCACHE_DATA);
-
- /*
- * If the VOP_TRUNCATE didn't happen to flush the vnode's
- * information out to disk, force it to be updated now that
- * all invalid ranges have been zero-filled and validated:
- */
- if (cp->c_flag & C_MODIFIED) {
- tv = time;
- VOP_UPDATE(vp, &tv, &tv, 0);
- }
- VOP_UNLOCK(vp, 0, p);
+ if (busy) {
+ hfs_touchtimes(VTOHFS(vp), cp);
+ }
+ if (vnode_isdir(vp)) {
+ hfs_reldirhints(cp, busy);
+ } else if (vnode_issystem(vp) && !busy) {
+ vnode_recycle(vp);
}
- if ((vp->v_flag & VSYSTEM) && (vp->v_usecount == 1))
- vgone(vp);
+
+ hfs_unlock(cp);
return (0);
}
/*
-#% access vp L L L
-#
- vop_access {
- IN struct vnode *vp;
- IN int mode;
- IN struct ucred *cred;
- IN struct proc *p;
-
- */
-
+ * Get basic attributes.
+ */
static int
-hfs_access(ap)
- struct vop_access_args /* {
- struct vnode *a_vp;
- int a_mode;
- struct ucred *a_cred;
- struct proc *a_p;
- } */ *ap;
+hfs_vnop_getattr(struct vnop_getattr_args *ap)
{
struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
- struct ucred *cred = ap->a_cred;
- register gid_t *gp;
- mode_t mode = ap->a_mode;
- mode_t mask = 0;
- int i;
- int error;
+ struct vnode_attr *vap = ap->a_vap;
+ struct vnode *rvp = NULL;
+ struct hfsmount *hfsmp;
+ struct cnode *cp;
+ enum vtype v_type;
+ int error = 0;
- /*
- * Disallow write attempts on read-only file systems;
- * unless the file is a socket, fifo, or a block or
- * character device resident on the file system.
- */
- if (mode & VWRITE) {
- switch (vp->v_type) {
- case VDIR:
- case VLNK:
- case VREG:
- if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY)
- return (EROFS);
-#if QUOTA
- if ((error = hfs_getinoquota(cp)))
- return (error);
-#endif /* QUOTA */
- break;
- }
- /* If immutable bit set, nobody gets to write it. */
- if (cp->c_flags & IMMUTABLE)
- return (EPERM);
+ if ((error = hfs_lock(VTOC(vp), HFS_SHARED_LOCK))) {
+ return (error);
}
+ cp = VTOC(vp);
+ hfsmp = VTOHFS(vp);
+ hfs_touchtimes(hfsmp, cp);
+ v_type = vnode_vtype(vp);
+ VATTR_RETURN(vap, va_rdev, (v_type == VBLK || v_type == VCHR) ? cp->c_rdev : 0);
+ if (v_type == VDIR) {
+ if (VATTR_IS_ACTIVE(vap, va_nlink)) {
+ int entries;
+
+ entries = cp->c_nlink;
+ if (vnode_isvroot(vp)) {
+ if (hfsmp->hfs_privdir_desc.cd_cnid != 0)
+ --entries; /* hide private dir */
+ if (hfsmp->jnl || ((HFSTOVCB(hfsmp)->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY)))
+ entries -= 2; /* hide the journal files */
+ }
+ VATTR_RETURN(vap, va_nlink, (uint64_t)entries);
+ }
+
+ if (VATTR_IS_ACTIVE(vap, va_nchildren)) {
+ int entries;
+
+ entries = cp->c_entries;
+ if (vnode_isvroot(vp)) {
+ if (hfsmp->hfs_privdir_desc.cd_cnid != 0)
+ --entries; /* hide private dir */
+ if (hfsmp->jnl)
+ entries -= 2; /* hide the journal files */
+ }
+ VATTR_RETURN(vap, va_nchildren, entries);
+ }
+ } else {
+ VATTR_RETURN(vap, va_nlink, (uint64_t)cp->c_nlink);
+ }
- /* Otherwise, user id 0 always gets access. */
- if (cred->cr_uid == 0)
- return (0);
+ /* conditional because 64-bit arithmetic can be expensive */
+ if (VATTR_IS_ACTIVE(vap, va_total_size)) {
+ if (v_type == VDIR) {
+ VATTR_RETURN(vap, va_total_size, cp->c_nlink * AVERAGE_HFSDIRENTRY_SIZE);
+ } else {
+ uint64_t total_size = 0;
+ struct cnode *rcp;
+
+ if (cp->c_datafork) {
+ total_size = cp->c_datafork->ff_size;
+ }
- mask = 0;
+ if (cp->c_blocks - VTOF(vp)->ff_blocks) {
+ /* hfs_vgetrsrc does not use struct proc - therefore passing NULL */
+ error = hfs_vgetrsrc(hfsmp, vp, &rvp, NULL);
+ if (error) {
+ goto out;
+ }
+
+ rcp = VTOC(rvp);
+ if (rcp && rcp->c_rsrcfork) {
+ total_size += rcp->c_rsrcfork->ff_size;
+ }
+ }
- /* Otherwise, check the owner. */
- if ( (cp->c_uid == cred->cr_uid) || (cp->c_uid == UNKNOWNUID) ) {
- if (mode & VEXEC)
- mask |= S_IXUSR;
- if (mode & VREAD)
- mask |= S_IRUSR;
- if (mode & VWRITE)
- mask |= S_IWUSR;
- return ((cp->c_mode & mask) == mask ? 0 : EACCES);
+ VATTR_RETURN(vap, va_total_size, total_size);
+ /* Include size of attibute data (extents), if any */
+ if (cp->c_attrblks) {
+ vap->va_total_size += (uint64_t)cp->c_attrblks * (uint64_t)hfsmp->blockSize;
+ }
+ }
}
-
- /* Otherwise, check the groups. */
- if (! (VTOVFS(vp)->mnt_flag & MNT_UNKNOWNPERMISSIONS)) {
- for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++)
- if (cp->c_gid == *gp) {
- if (mode & VEXEC)
- mask |= S_IXGRP;
- if (mode & VREAD)
- mask |= S_IRGRP;
- if (mode & VWRITE)
- mask |= S_IWGRP;
- return ((cp->c_mode & mask) == mask ? 0 : EACCES);
+ if (VATTR_IS_ACTIVE(vap, va_total_alloc)) {
+ if (v_type == VDIR) {
+ VATTR_RETURN(vap, va_total_alloc, 0);
+ } else {
+ VATTR_RETURN(vap, va_total_alloc, (uint64_t)cp->c_blocks * (uint64_t)hfsmp->blockSize);
+ /* Include size of attibute data (extents), if any */
+ if (cp->c_attrblks) {
+ vap->va_total_alloc += (uint64_t)cp->c_attrblks * (uint64_t)hfsmp->blockSize;
}
+ }
}
+ /* XXX broken... if ask for "data size" of rsrc fork vp you get rsrc fork size! */
+ if (v_type == VDIR) {
+ VATTR_RETURN(vap, va_data_size, cp->c_nlink * AVERAGE_HFSDIRENTRY_SIZE);
+ } else {
+ VATTR_RETURN(vap, va_data_size, VTOF(vp)->ff_size);
+ }
+ if (VATTR_IS_ACTIVE(vap, va_data_alloc) && (v_type != VDIR)) {
+ /* XXX do we need to account for ff_unallocblocks ? */
+ VATTR_RETURN(vap, va_data_alloc, (uint64_t)VTOF(vp)->ff_blocks * (uint64_t)hfsmp->blockSize);
+ }
+ /* XXX is this really a good 'optimal I/O size'? */
+ VATTR_RETURN(vap, va_iosize, hfsmp->hfs_logBlockSize);
+ VATTR_RETURN(vap, va_uid, cp->c_uid);
+ VATTR_RETURN(vap, va_gid, cp->c_gid);
+ VATTR_RETURN(vap, va_mode, cp->c_mode);
+#if 0
+ /* XXX is S_IFXATTR still needed ??? */
+ if (VNODE_IS_RSRC(vp))
+ vap->va_mode |= S_IFXATTR;
+#endif
+ VATTR_RETURN(vap, va_flags, cp->c_flags);
- /* Otherwise, check everyone else. */
- if (mode & VEXEC)
- mask |= S_IXOTH;
- if (mode & VREAD)
- mask |= S_IROTH;
- if (mode & VWRITE)
- mask |= S_IWOTH;
- return ((cp->c_mode & mask) == mask ? 0 : EACCES);
-}
-
-
-
-/*
-#% getattr vp = = =
-#
- vop_getattr {
- IN struct vnode *vp;
- IN struct vattr *vap;
- IN struct ucred *cred;
- IN struct proc *p;
-
- */
-
-
-/* ARGSUSED */
-static int
-hfs_getattr(ap)
- struct vop_getattr_args /* {
- struct vnode *a_vp;
- struct vattr *a_vap;
- struct ucred *a_cred;
- struct proc *a_p;
- } */ *ap;
-{
- struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
- struct vattr *vap = ap->a_vap;
- struct timeval tv;
-
- tv = time;
- CTIMES(cp, &tv, &tv);
-
- vap->va_type = vp->v_type;
- vap->va_mode = cp->c_mode;
- vap->va_nlink = cp->c_nlink;
/*
- * [2856576] Since we are dynamically changing the owner, also
- * effectively turn off the set-user-id and set-group-id bits,
- * just like chmod(2) would when changing ownership. This prevents
- * a security hole where set-user-id programs run as whoever is
- * logged on (or root if nobody is logged in yet!)
+ * If the VFS wants extended security data, and we know that we
+ * don't have any (because it never told us it was setting any)
+ * then we can return the supported bit and no data. If we do
+ * have extended security, we can just leave the bit alone and
+ * the VFS will use the fallback path to fetch it.
*/
- if (cp->c_uid == UNKNOWNUID) {
- vap->va_mode &= ~(S_ISUID | S_ISGID);
- vap->va_uid = ap->a_cred->cr_uid;
- } else {
- vap->va_uid = cp->c_uid;
+ if (VATTR_IS_ACTIVE(vap, va_acl)) {
+ if ((cp->c_attr.ca_recflags & kHFSHasSecurityMask) == 0) {
+ vap->va_acl = KAUTH_FILESEC_NONE;
+ VATTR_SET_SUPPORTED(vap, va_acl);
+ }
}
- vap->va_gid = cp->c_gid;
- vap->va_fsid = cp->c_dev;
+ vap->va_create_time.tv_sec = cp->c_itime;
+ vap->va_create_time.tv_nsec = 0;
+ VATTR_SET_SUPPORTED(vap, va_create_time);
+
+ if (VATTR_IS_ACTIVE(vap, va_access_time)) {
+ /* Access times are lazyily updated, get current time if needed */
+ if (cp->c_touch_acctime) {
+ struct timeval tv;
+
+ microtime(&tv);
+ vap->va_access_time.tv_sec = tv.tv_sec;
+ } else {
+ vap->va_access_time.tv_sec = cp->c_atime;
+ }
+ vap->va_access_time.tv_nsec = 0;
+ VATTR_SET_SUPPORTED(vap, va_access_time);
+ }
+ vap->va_modify_time.tv_sec = cp->c_mtime;
+ vap->va_modify_time.tv_nsec = 0;
+ VATTR_SET_SUPPORTED(vap, va_modify_time);
+ vap->va_change_time.tv_sec = cp->c_ctime;
+ vap->va_change_time.tv_nsec = 0;
+ VATTR_SET_SUPPORTED(vap, va_change_time);
+ vap->va_backup_time.tv_sec = cp->c_btime;
+ vap->va_backup_time.tv_nsec = 0;
+ VATTR_SET_SUPPORTED(vap, va_backup_time);
+
/*
* Exporting file IDs from HFS Plus:
*
* c_cnid belongs to the active directory entry (ie the link)
* and the c_fileid is for the actual inode (ie the data file).
*
- * The stat call (getattr) will always return the c_fileid
- * and Carbon APIs, which are hardlink-ignorant, will always
- * receive the c_cnid (from getattrlist).
+ * The stat call (getattr) uses va_fileid and the Carbon APIs,
+ * which are hardlink-ignorant, will ask for va_linkid.
*/
- vap->va_fileid = cp->c_fileid;
- vap->va_atime.tv_sec = cp->c_atime;
- vap->va_atime.tv_nsec = 0;
- vap->va_mtime.tv_sec = cp->c_mtime;
- vap->va_mtime.tv_nsec = cp->c_mtime_nsec;
- vap->va_ctime.tv_sec = cp->c_ctime;
- vap->va_ctime.tv_nsec = 0;
- vap->va_gen = 0;
- vap->va_flags = cp->c_flags;
- vap->va_rdev = 0;
- vap->va_blocksize = VTOVFS(vp)->mnt_stat.f_iosize;
- vap->va_filerev = 0;
- if (vp->v_type == VDIR) {
- vap->va_size = cp->c_nlink * AVERAGE_HFSDIRENTRY_SIZE;
- vap->va_bytes = 0;
- } else {
- vap->va_size = VTOF(vp)->ff_size;
- vap->va_bytes = (u_quad_t)cp->c_blocks *
- (u_quad_t)VTOVCB(vp)->blockSize;
- if (vp->v_type == VBLK || vp->v_type == VCHR)
- vap->va_rdev = cp->c_rdev;
+ VATTR_RETURN(vap, va_fileid, (uint64_t)cp->c_fileid);
+ VATTR_RETURN(vap, va_linkid, (uint64_t)cp->c_cnid);
+ VATTR_RETURN(vap, va_parentid, (uint64_t)cp->c_parentcnid);
+ VATTR_RETURN(vap, va_fsid, cp->c_dev);
+ VATTR_RETURN(vap, va_filerev, 0);
+
+ VATTR_RETURN(vap, va_encoding, cp->c_encoding);
+
+ /* if this is the root, let VFS to find out the mount name, which may be different from the real name */
+ if (VATTR_IS_ACTIVE(vap, va_name) && !vnode_isvroot(vp)) {
+ /* Return the name for ATTR_CMN_NAME */
+ if (cp->c_desc.cd_namelen == 0) {
+ error = ENOENT;
+ goto out;
+ }
+
+ strncpy(vap->va_name, cp->c_desc.cd_nameptr, MAXPATHLEN);
+ vap->va_name[MAXPATHLEN-1] = '\0';
+ VATTR_SET_SUPPORTED(vap, va_name);
}
- return (0);
-}
-
-/*
- * Set attribute vnode op. called from several syscalls
-#% setattr vp L L L
-#
- vop_setattr {
- IN struct vnode *vp;
- IN struct vattr *vap;
- IN struct ucred *cred;
- IN struct proc *p;
- */
+out:
+ hfs_unlock(cp);
+ if (rvp) {
+ vnode_put(rvp);
+ }
+ return (error);
+}
static int
-hfs_setattr(ap)
- struct vop_setattr_args /* {
+hfs_vnop_setattr(ap)
+ struct vnop_setattr_args /* {
struct vnode *a_vp;
- struct vattr *a_vap;
- struct ucred *a_cred;
- struct proc *a_p;
+ struct vnode_attr *a_vap;
+ vfs_context_t a_context;
} */ *ap;
{
- struct vattr *vap = ap->a_vap;
+ struct vnode_attr *vap = ap->a_vap;
struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
- struct ucred *cred = ap->a_cred;
- struct proc *p = ap->a_p;
- struct timeval atimeval, mtimeval;
- int error;
+ struct cnode *cp = NULL;
+ struct hfsmount *hfsmp;
+ kauth_cred_t cred = vfs_context_ucred(ap->a_context);
+ struct proc *p = vfs_context_proc(ap->a_context);
+ int error = 0;
+ uid_t nuid;
+ gid_t ngid;
- /*
- * Check for unsettable attributes.
- */
- if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
- (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
- (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
- ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
- return (EINVAL);
- }
+ hfsmp = VTOHFS(vp);
- // XXXdbg
- // don't allow people to set the attributes of symlinks
- // (nfs has a bad habit of doing ths and it can cause
- // problems for journaling).
- //
- if (vp->v_type == VLNK) {
- return 0;
+ /* Don't allow modification of the journal file. */
+ if (hfsmp->hfs_jnlfileid == VTOC(vp)->c_fileid) {
+ return (EPERM);
}
+ /*
+ * File size change request.
+ * We are guaranteed that this is not a directory, and that
+ * the filesystem object is writeable.
+ */
+ VATTR_SET_SUPPORTED(vap, va_data_size);
+ if (VATTR_IS_ACTIVE(vap, va_data_size) && !vnode_islnk(vp)) {
+
+ /* Take truncate lock before taking cnode lock. */
+ hfs_lock_truncate(VTOC(vp), TRUE);
+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK))) {
+ hfs_unlock_truncate(VTOC(vp));
+ return (error);
+ }
+ cp = VTOC(vp);
+ error = hfs_truncate(vp, vap->va_data_size, vap->va_vaflags & 0xffff, 0, ap->a_context);
- if (vap->va_flags != VNOVAL) {
- if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY)
- return (EROFS);
- if ((error = hfs_chflags(vp, vap->va_flags, cred, p)))
+ hfs_unlock_truncate(cp);
+ if (error)
+ goto out;
+ }
+ if (cp == NULL) {
+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
return (error);
- if (vap->va_flags & (IMMUTABLE | APPEND))
- return (0);
+ cp = VTOC(vp);
}
- if (cp->c_flags & (IMMUTABLE | APPEND))
- return (EPERM);
+ /*
+ * Owner/group change request.
+ * We are guaranteed that the new owner/group is valid and legal.
+ */
+ VATTR_SET_SUPPORTED(vap, va_uid);
+ VATTR_SET_SUPPORTED(vap, va_gid);
+ nuid = VATTR_IS_ACTIVE(vap, va_uid) ? vap->va_uid : (uid_t)VNOVAL;
+ ngid = VATTR_IS_ACTIVE(vap, va_gid) ? vap->va_gid : (gid_t)VNOVAL;
+ if (((nuid != (uid_t)VNOVAL) || (ngid != (gid_t)VNOVAL)) &&
+ ((error = hfs_chown(vp, nuid, ngid, cred, p)) != 0))
+ goto out;
- // XXXdbg - don't allow modification of the journal or journal_info_block
- if (VTOHFS(vp)->jnl && cp->c_datafork) {
- struct HFSPlusExtentDescriptor *extd;
+ /*
+ * 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))
+ goto out;
- extd = &cp->c_datafork->ff_extents[0];
- if (extd->startBlock == VTOVCB(vp)->vcbJinfoBlock || extd->startBlock == VTOHFS(vp)->jnl_start) {
- return EPERM;
- }
+ /*
+ * File flags change.
+ * We are guaranteed that only flags allowed to change given the
+ * current securelevel are being changed.
+ */
+ VATTR_SET_SUPPORTED(vap, va_flags);
+ if (VATTR_IS_ACTIVE(vap, va_flags)) {
+ cp->c_flags = vap->va_flags;
+ cp->c_touch_chgtime = TRUE;
}
/*
- * Go through the fields and update iff not VNOVAL.
+ * If the file's extended security data is being changed, we
+ * need to note the change. Note that because we don't store
+ * the data, we do not set the SUPPORTED bit; this will cause
+ * the VFS to use a fallback strategy.
*/
- if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
- if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY)
- return (EROFS);
- if ((error = hfs_chown(vp, vap->va_uid, vap->va_gid, cred, p)))
- return (error);
- }
- if (vap->va_size != VNOVAL) {
- /*
- * Disallow write attempts on read-only file systems;
- * unless the file is a socket, fifo, or a block or
- * character device resident on the file system.
- */
- switch (vp->v_type) {
- case VDIR:
- return (EISDIR);
- case VLNK:
- case VREG:
- if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY)
- return (EROFS);
- break;
- default:
- break;
+ if (VATTR_IS_ACTIVE(vap, va_acl)) {
+ /* Remember if any ACL data was set or cleared. */
+ if (vap->va_acl == NULL) {
+ /* being cleared */
+ if (cp->c_attr.ca_recflags & kHFSHasSecurityMask) {
+ cp->c_attr.ca_recflags &= ~kHFSHasSecurityMask;
+ cp->c_touch_chgtime = TRUE;
+ }
+ } else {
+ /* being set */
+ if ((cp->c_attr.ca_recflags & kHFSHasSecurityMask) == 0) {
+ cp->c_attr.ca_recflags |= kHFSHasSecurityMask;
+ cp->c_touch_chgtime = TRUE;
+ }
}
- if ((error = VOP_TRUNCATE(vp, vap->va_size, 0, cred, p)))
- return (error);
}
- cp = VTOC(vp);
- if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
- if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY)
- return (EROFS);
- if (((error = hfs_owner_rights(VTOHFS(vp), cp->c_uid, cred, p, true)) != 0) &&
- ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
- (error = VOP_ACCESS(vp, VWRITE, cred, p)))) {
- return (error);
+
+ /*
+ * Timestamp updates.
+ */
+ VATTR_SET_SUPPORTED(vap, va_create_time);
+ VATTR_SET_SUPPORTED(vap, va_access_time);
+ VATTR_SET_SUPPORTED(vap, va_modify_time);
+ VATTR_SET_SUPPORTED(vap, va_backup_time);
+ VATTR_SET_SUPPORTED(vap, va_change_time);
+ if (VATTR_IS_ACTIVE(vap, va_create_time) ||
+ VATTR_IS_ACTIVE(vap, va_access_time) ||
+ VATTR_IS_ACTIVE(vap, va_modify_time) ||
+ VATTR_IS_ACTIVE(vap, va_backup_time)) {
+ if (vnode_islnk(vp))
+ goto done;
+ if (VATTR_IS_ACTIVE(vap, va_create_time))
+ cp->c_itime = vap->va_create_time.tv_sec;
+ if (VATTR_IS_ACTIVE(vap, va_access_time)) {
+ cp->c_atime = vap->va_access_time.tv_sec;
+ cp->c_touch_acctime = FALSE;
}
- if (vap->va_atime.tv_sec != VNOVAL)
- cp->c_flag |= C_ACCESS;
- if (vap->va_mtime.tv_sec != VNOVAL) {
- cp->c_flag |= C_CHANGE | C_UPDATE;
+ if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
+ cp->c_mtime = vap->va_modify_time.tv_sec;
+ cp->c_touch_modtime = FALSE;
+ cp->c_touch_chgtime = TRUE;
+
/*
* The utimes system call can reset the modification
* time but it doesn't know about HFS create times.
- * So we need to insure that the creation time is
+ * So we need to ensure that the creation time is
* always at least as old as the modification time.
*/
if ((VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) &&
- (cp->c_cnid != kRootDirID) &&
- (vap->va_mtime.tv_sec < cp->c_itime)) {
- cp->c_itime = vap->va_mtime.tv_sec;
+ (cp->c_cnid != kHFSRootFolderID) &&
+ (cp->c_mtime < cp->c_itime)) {
+ cp->c_itime = cp->c_mtime;
}
}
- atimeval.tv_sec = vap->va_atime.tv_sec;
- atimeval.tv_usec = 0;
- mtimeval.tv_sec = vap->va_mtime.tv_sec;
- mtimeval.tv_usec = 0;
- if ((error = VOP_UPDATE(vp, &atimeval, &mtimeval, 1)))
- return (error);
+ if (VATTR_IS_ACTIVE(vap, va_backup_time))
+ cp->c_btime = vap->va_backup_time.tv_sec;
+ cp->c_flag |= C_MODIFIED;
}
- error = 0;
- if (vap->va_mode != (mode_t)VNOVAL) {
- if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY)
- return (EROFS);
- error = hfs_chmod(vp, (int)vap->va_mode, cred, p);
+
+ /*
+ * Set name encoding.
+ */
+ VATTR_SET_SUPPORTED(vap, va_encoding);
+ if (VATTR_IS_ACTIVE(vap, va_encoding)) {
+ cp->c_encoding = vap->va_encoding;
+ hfs_setencodingbits(hfsmp, cp->c_encoding);
}
+
+done:
+ if ((error = hfs_update(vp, TRUE)) != 0)
+ goto out;
HFS_KNOTE(vp, NOTE_ATTRIB);
+out:
+ if (cp)
+ hfs_unlock(cp);
return (error);
}
*/
__private_extern__
int
-hfs_chmod(vp, mode, cred, p)
- register struct vnode *vp;
- register int mode;
- register struct ucred *cred;
- struct proc *p;
+hfs_chmod(struct vnode *vp, int mode, kauth_cred_t cred, struct proc *p)
{
register struct cnode *cp = VTOC(vp);
int error;
}
#if OVERRIDE_UNKNOWN_PERMISSIONS
- if (VTOVFS(vp)->mnt_flag & MNT_UNKNOWNPERMISSIONS) {
+ if (((unsigned int)vfs_flags(VTOVFS(vp))) & MNT_UNKNOWNPERMISSIONS) {
return (0);
};
#endif
- if ((error = hfs_owner_rights(VTOHFS(vp), cp->c_uid, cred, p, true)) != 0)
- return (error);
- if (cred->cr_uid) {
- if (vp->v_type != VDIR && (mode & S_ISTXT))
- return (EFTYPE);
- if (!groupmember(cp->c_gid, cred) && (mode & S_ISGID))
- return (EPERM);
- }
cp->c_mode &= ~ALLPERMS;
cp->c_mode |= (mode & ALLPERMS);
- cp->c_flag |= C_CHANGE;
+ cp->c_touch_chgtime = TRUE;
return (0);
}
__private_extern__
int
-hfs_write_access(struct vnode *vp, struct ucred *cred, struct proc *p, Boolean considerFlags)
+hfs_write_access(struct vnode *vp, kauth_cred_t cred, struct proc *p, Boolean considerFlags)
{
struct cnode *cp = VTOC(vp);
- gid_t *gp;
int retval = 0;
- int i;
+ int is_member;
/*
* Disallow write attempts on read-only file systems;
* unless the file is a socket, fifo, or a block or
* character device resident on the file system.
*/
- switch (vp->v_type) {
+ switch (vnode_vtype(vp)) {
case VDIR:
case VLNK:
case VREG:
return (EPERM);
/* Otherwise, user id 0 always gets access. */
- if (cred->cr_uid == 0)
+ if (!suser(cred, NULL))
return (0);
/* Otherwise, check the owner. */
return ((cp->c_mode & S_IWUSR) == S_IWUSR ? 0 : EACCES);
/* Otherwise, check the groups. */
- for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) {
- if (cp->c_gid == *gp)
- return ((cp->c_mode & S_IWGRP) == S_IWGRP ? 0 : EACCES);
+ if (kauth_cred_ismember_gid(cred, cp->c_gid, &is_member) == 0 && is_member) {
+ return ((cp->c_mode & S_IWGRP) == S_IWGRP ? 0 : EACCES);
}
/* Otherwise, check everyone else. */
}
-
/*
- * Change the flags on a file or directory.
- * cnode must be locked before calling.
+ * Perform chown operation on cnode cp;
+ * code must be locked prior to call.
*/
__private_extern__
int
-hfs_chflags(vp, flags, cred, p)
- register struct vnode *vp;
- register u_long flags;
- register struct ucred *cred;
- struct proc *p;
+hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred,
+ struct proc *p)
{
register struct cnode *cp = VTOC(vp);
- int retval;
+ uid_t ouid;
+ gid_t ogid;
+ int error = 0;
+ int is_member;
+#if QUOTA
+ register int i;
+ int64_t change;
+#endif /* QUOTA */
- if (VTOVCB(vp)->vcbSigWord == kHFSSigWord) {
- if ((retval = hfs_write_access(vp, cred, p, false)) != 0) {
- return retval;
- };
- } else if ((retval = hfs_owner_rights(VTOHFS(vp), cp->c_uid, cred, p, true)) != 0) {
- return retval;
- };
+ if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord)
+ return (ENOTSUP);
- if (cred->cr_uid == 0) {
- if ((cp->c_flags & (SF_IMMUTABLE | SF_APPEND)) &&
- securelevel > 0) {
- return EPERM;
- };
- cp->c_flags = flags;
- } else {
- if (cp->c_flags & (SF_IMMUTABLE | SF_APPEND) ||
- (flags & UF_SETTABLE) != flags) {
- return EPERM;
- };
- cp->c_flags &= SF_SETTABLE;
- cp->c_flags |= (flags & UF_SETTABLE);
- }
- cp->c_flag |= C_CHANGE;
-
- return (0);
-}
-
-
-/*
- * Perform chown operation on cnode cp;
- * code must be locked prior to call.
- */
-__private_extern__
-int
-hfs_chown(vp, uid, gid, cred, p)
- register struct vnode *vp;
- uid_t uid;
- gid_t gid;
- struct ucred *cred;
- struct proc *p;
-{
- register struct cnode *cp = VTOC(vp);
- uid_t ouid;
- gid_t ogid;
- int error = 0;
-#if QUOTA
- register int i;
- int64_t change;
-#endif /* QUOTA */
-
- if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord)
- return (EOPNOTSUPP);
-
- if (VTOVFS(vp)->mnt_flag & MNT_UNKNOWNPERMISSIONS)
+ if (((unsigned int)vfs_flags(VTOVFS(vp))) & MNT_UNKNOWNPERMISSIONS)
return (0);
if (uid == (uid_t)VNOVAL)
uid = cp->c_uid;
if (gid == (gid_t)VNOVAL)
gid = cp->c_gid;
+
+#if 0 /* we are guaranteed that this is already the case */
/*
* If we don't own the file, are trying to change the owner
* of the file, or are not a member of the target group,
* the caller must be superuser or the call fails.
*/
- if ((cred->cr_uid != cp->c_uid || uid != cp->c_uid ||
- (gid != cp->c_gid && !groupmember((gid_t)gid, cred))) &&
- (error = suser(cred, &p->p_acflag)))
+ if ((kauth_cred_getuid(cred) != cp->c_uid || uid != cp->c_uid ||
+ (gid != cp->c_gid &&
+ (kauth_cred_ismember_gid(cred, gid, &is_member) || !is_member))) &&
+ (error = suser(cred, 0)))
return (error);
+#endif
ogid = cp->c_gid;
ouid = cp->c_uid;
if ((error = hfs_getinoquota(cp)))
return (error);
if (ouid == uid) {
- dqrele(vp, cp->c_dquot[USRQUOTA]);
+ dqrele(cp->c_dquot[USRQUOTA]);
cp->c_dquot[USRQUOTA] = NODQUOT;
}
if (ogid == gid) {
- dqrele(vp, cp->c_dquot[GRPQUOTA]);
+ dqrele(cp->c_dquot[GRPQUOTA]);
cp->c_dquot[GRPQUOTA] = NODQUOT;
}
/*
* Eventually need to account for (fake) a block per directory
- *if (vp->v_type == VDIR)
- *change = VTOVCB(vp)->blockSize;
- *else
+ * if (vnode_isdir(vp))
+ * change = VTOHFS(vp)->blockSize;
+ * else
*/
change = (int64_t)(cp->c_blocks) * (int64_t)VTOVCB(vp)->blockSize;
(void) hfs_chkdq(cp, -change, cred, CHOWN);
(void) hfs_chkiq(cp, -1, cred, CHOWN);
for (i = 0; i < MAXQUOTAS; i++) {
- dqrele(vp, cp->c_dquot[i]);
+ dqrele(cp->c_dquot[i]);
cp->c_dquot[i] = NODQUOT;
}
#endif /* QUOTA */
#if QUOTA
if ((error = hfs_getinoquota(cp)) == 0) {
if (ouid == uid) {
- dqrele(vp, cp->c_dquot[USRQUOTA]);
+ dqrele(cp->c_dquot[USRQUOTA]);
cp->c_dquot[USRQUOTA] = NODQUOT;
}
if (ogid == gid) {
- dqrele(vp, cp->c_dquot[GRPQUOTA]);
+ dqrele(cp->c_dquot[GRPQUOTA]);
cp->c_dquot[GRPQUOTA] = NODQUOT;
}
if ((error = hfs_chkdq(cp, change, cred, CHOWN)) == 0) {
(void) hfs_chkdq(cp, -change, cred, CHOWN|FORCE);
}
for (i = 0; i < MAXQUOTAS; i++) {
- dqrele(vp, cp->c_dquot[i]);
+ dqrele(cp->c_dquot[i]);
cp->c_dquot[i] = NODQUOT;
}
}
cp->c_uid = ouid;
if (hfs_getinoquota(cp) == 0) {
if (ouid == uid) {
- dqrele(vp, cp->c_dquot[USRQUOTA]);
+ dqrele(cp->c_dquot[USRQUOTA]);
cp->c_dquot[USRQUOTA] = NODQUOT;
}
if (ogid == gid) {
- dqrele(vp, cp->c_dquot[GRPQUOTA]);
+ dqrele(cp->c_dquot[GRPQUOTA]);
cp->c_dquot[GRPQUOTA] = NODQUOT;
}
(void) hfs_chkdq(cp, change, cred, FORCE|CHOWN);
#endif /* QUOTA */
if (ouid != uid || ogid != gid)
- cp->c_flag |= C_CHANGE;
- if (ouid != uid && cred->cr_uid != 0)
- cp->c_mode &= ~S_ISUID;
- if (ogid != gid && cred->cr_uid != 0)
- cp->c_mode &= ~S_ISGID;
+ cp->c_touch_chgtime = TRUE;
return (0);
}
/*
-#
-#% exchange fvp L L L
-#% exchange tvp L L L
-#
+ * The hfs_exchange routine swaps the fork data in two files by
+ * exchanging some of the information in the cnode. It is used
+ * to preserve the file ID when updating an existing file, in
+ * case the file is being tracked through its file ID. Typically
+ * its used after creating a new file during a safe-save.
*/
- /*
- * The hfs_exchange routine swaps the fork data in two files by
- * exchanging some of the information in the cnode. It is used
- * to preserve the file ID when updating an existing file, in
- * case the file is being tracked through its file ID. Typically
- * its used after creating a new file during a safe-save.
- */
-
static int
-hfs_exchange(ap)
- struct vop_exchange_args /* {
+hfs_vnop_exchange(ap)
+ struct vnop_exchange_args /* {
struct vnode *a_fvp;
struct vnode *a_tvp;
- struct ucred *a_cred;
- struct proc *a_p;
+ int a_options;
+ vfs_context_t a_context;
} */ *ap;
{
struct vnode *from_vp = ap->a_fvp;
struct vnode *to_vp = ap->a_tvp;
- struct cnode *from_cp = VTOC(from_vp);
- struct cnode *to_cp = VTOC(to_vp);
- struct hfsmount *hfsmp = VTOHFS(from_vp);
+ struct cnode *from_cp;
+ struct cnode *to_cp;
+ struct hfsmount *hfsmp;
struct cat_desc tempdesc;
struct cat_attr tempattr;
- int error = 0, started_tr = 0, grabbed_lock = 0;
- cat_cookie_t cookie = {0};
+ int lockflags;
+ int error = 0, started_tr = 0, got_cookie = 0;
+ cat_cookie_t cookie;
/* The files must be on the same volume. */
- if (from_vp->v_mount != to_vp->v_mount)
+ if (vnode_mount(from_vp) != vnode_mount(to_vp))
return (EXDEV);
+ if (from_vp == to_vp)
+ return (EINVAL);
+
+ 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);
+
/* Only normal files can be exchanged. */
- if ((from_vp->v_type != VREG) || (to_vp->v_type != VREG) ||
+ if (!vnode_isreg(from_vp) || !vnode_isreg(to_vp) ||
(from_cp->c_flag & C_HARDLINK) || (to_cp->c_flag & C_HARDLINK) ||
- VNODE_IS_RSRC(from_vp) || VNODE_IS_RSRC(to_vp))
- return (EINVAL);
+ VNODE_IS_RSRC(from_vp) || VNODE_IS_RSRC(to_vp)) {
+ error = EINVAL;
+ goto exit;
+ }
// XXXdbg - don't allow modification of the journal or journal_info_block
if (hfsmp->jnl) {
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) {
- return EPERM;
+ error = EPERM;
+ goto exit;
}
}
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) {
- return EPERM;
+ error = EPERM;
+ goto exit;
}
}
}
- // XXXdbg
- hfs_global_shared_lock_acquire(hfsmp);
- grabbed_lock = 1;
- if (hfsmp->jnl) {
- if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
- goto Err_Exit;
- }
- started_tr = 1;
+ if ((error = hfs_start_transaction(hfsmp)) != 0) {
+ goto exit;
}
+ started_tr = 1;
/*
* Reserve some space in the Catalog file.
*/
- if ((error = cat_preflight(hfsmp, CAT_EXCHANGE, &cookie, ap->a_p))) {
- goto Err_Exit;
+ bzero(&cookie, sizeof(cookie));
+ if ((error = cat_preflight(hfsmp, CAT_EXCHANGE, &cookie, vfs_context_proc(ap->a_context)))) {
+ goto exit;
}
-
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, ap->a_p);
- if (error) goto Err_Exit;
+ got_cookie = 1;
/* The backend code always tries to delete the virtual
* extent id for exchanging files so we neeed to lock
* the extents b-tree.
*/
- error = hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_EXCLUSIVE, ap->a_p);
- if (error) {
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, ap->a_p);
- goto Err_Exit;
- }
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);
/* Do the exchange */
- error = MacToVFSError(ExchangeFileIDs(HFSTOVCB(hfsmp),
- from_cp->c_desc.cd_nameptr, to_cp->c_desc.cd_nameptr,
- from_cp->c_parentcnid, to_cp->c_parentcnid,
- from_cp->c_hint, to_cp->c_hint));
+ error = ExchangeFileIDs(hfsmp,
+ from_cp->c_desc.cd_nameptr,
+ to_cp->c_desc.cd_nameptr,
+ from_cp->c_parentcnid,
+ to_cp->c_parentcnid,
+ from_cp->c_hint,
+ to_cp->c_hint);
+ hfs_systemfile_unlock(hfsmp, lockflags);
- (void) hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_RELEASE, ap->a_p);
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, ap->a_p);
+ /*
+ * Note that we don't need to exchange any extended attributes
+ * since the attributes are keyed by file ID.
+ */
if (error != E_NONE) {
- goto Err_Exit;
+ error = MacToVFSError(error);
+ goto exit;
}
/* Purge the vnodes from the name cache */
from_cp->c_uid = to_cp->c_uid;
from_cp->c_flags = to_cp->c_flags;
from_cp->c_mode = to_cp->c_mode;
+ 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_uid = tempattr.ca_uid;
to_cp->c_flags = tempattr.ca_flags;
to_cp->c_mode = tempattr.ca_mode;
+ to_cp->c_attr.ca_recflags = tempattr.ca_recflags;
bcopy(tempattr.ca_finderinfo, to_cp->c_finderinfo, 32);
- /* Reinsert into the cnode hash under new file IDs*/
- hfs_chashremove(from_cp);
- hfs_chashremove(to_cp);
-
- hfs_chashinsert(from_cp);
- hfs_chashinsert(to_cp);
+ /* Rehash the cnodes using their new file IDs */
+ hfs_chash_rehash(from_cp, to_cp);
/*
* When a file moves out of "Cleanup At Startup"
if ((from_cp->c_flags & UF_NODUMP) &&
(from_cp->c_parentcnid != to_cp->c_parentcnid)) {
from_cp->c_flags &= ~UF_NODUMP;
- from_cp->c_flag |= C_CHANGE;
+ from_cp->c_touch_chgtime = TRUE;
}
if ((to_cp->c_flags & UF_NODUMP) &&
(to_cp->c_parentcnid != from_cp->c_parentcnid)) {
to_cp->c_flags &= ~UF_NODUMP;
- to_cp->c_flag |= C_CHANGE;
+ to_cp->c_touch_chgtime = TRUE;
}
HFS_KNOTE(from_vp, NOTE_ATTRIB);
HFS_KNOTE(to_vp, NOTE_ATTRIB);
-Err_Exit:
- cat_postflight(hfsmp, &cookie, ap->a_p);
-
- // XXXdbg
- if (started_tr) {
- journal_end_transaction(hfsmp->jnl);
+exit:
+ if (got_cookie) {
+ cat_postflight(hfsmp, &cookie, vfs_context_proc(ap->a_context));
}
- if (grabbed_lock) {
- hfs_global_shared_lock_release(hfsmp);
+ if (started_tr) {
+ hfs_end_transaction(hfsmp);
}
+ hfs_unlockpair(from_cp, to_cp);
return (error);
}
/*
-
-#% fsync vp L L L
-#
- vop_fsync {
- IN struct vnode *vp;
- IN struct ucred *cred;
- IN int waitfor;
- IN struct proc *p;
-
- */
-static int
-hfs_fsync(ap)
- struct vop_fsync_args /* {
- struct vnode *a_vp;
- struct ucred *a_cred;
- int a_waitfor;
- struct proc *a_p;
- } */ *ap;
+ * cnode must be locked
+ */
+__private_extern__
+int
+hfs_fsync(struct vnode *vp, int waitfor, int fullsync, struct proc *p)
{
- struct vnode *vp = ap->a_vp;
struct cnode *cp = VTOC(vp);
struct filefork *fp = NULL;
int retval = 0;
- register struct buf *bp;
+ struct hfsmount *hfsmp = VTOHFS(vp);
struct timeval tv;
- struct buf *nbp;
- struct hfsmount *hfsmp = VTOHFS(ap->a_vp);
- int s;
int wait;
- int retry = 0;
+ int lockflag;
+ int took_trunc_lock = 0;
- wait = (ap->a_waitfor == MNT_WAIT);
+ wait = (waitfor == MNT_WAIT);
/* HFS directories don't have any data blocks. */
- if (vp->v_type == VDIR)
+ if (vnode_isdir(vp))
goto metasync;
/*
* For system files flush the B-tree header and
* for regular files write out any clusters
*/
- if (vp->v_flag & VSYSTEM) {
+ if (vnode_issystem(vp)) {
if (VTOF(vp)->fcbBTCBPtr != NULL) {
// XXXdbg
if (hfsmp->jnl == NULL) {
BTFlushPath(VTOF(vp));
}
}
- } else if (UBCINFOEXISTS(vp))
- (void) cluster_push(vp);
+ } else if (UBCINFOEXISTS(vp)) {
+ hfs_unlock(cp);
+ hfs_lock_truncate(cp, TRUE);
+ took_trunc_lock = 1;
+
+ /* Don't hold cnode lock when calling into cluster layer. */
+ (void) cluster_push(vp, 0);
+ hfs_lock(cp, HFS_FORCE_LOCK);
+ }
/*
* When MNT_WAIT is requested and the zero fill timeout
* has expired then we must explicitly zero out any areas
((cp->c_flags & UF_NODUMP) == 0) &&
UBCINFOEXISTS(vp) && (fp = VTOF(vp)) &&
cp->c_zftimeout != 0) {
- int devblksize;
- int was_nocache;
-
- if (time.tv_sec < cp->c_zftimeout) {
+ microuptime(&tv);
+ if (tv.tv_sec < cp->c_zftimeout) {
/* Remember that a force sync was requested. */
cp->c_flag |= C_ZFWANTSYNC;
- goto loop;
- }
- VOP_DEVBLOCKSIZE(cp->c_devvp, &devblksize);
- was_nocache = ISSET(vp->v_flag, VNOCACHE_DATA);
- SET(vp->v_flag, VNOCACHE_DATA); /* Don't cache zeros */
+ 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 end = invalid_range->rl_end;
/* The range about to be written must be validated
- * first, so that VOP_CMAP() will return the
+ * 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. */
+ hfs_unlock(cp);
(void) cluster_write(vp, (struct uio *) 0,
- fp->ff_size,
- invalid_range->rl_end + 1,
- invalid_range->rl_start,
- (off_t)0, devblksize,
- IO_HEADZEROFILL | IO_NOZERODIRTY);
+ 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;
}
- (void) cluster_push(vp);
- if (!was_nocache)
- CLR(vp->v_flag, VNOCACHE_DATA);
+ hfs_unlock(cp);
+ (void) cluster_push(vp, 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);
+
+ /*
+ * 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
+ * of a transaction). otherwise we'll just go through the normal
+ * code path and flush the buffer. note journal_active() can return
+ * -1 if the journal is invalid -- however we still need to skip any
+ * locked blocks as they get cleaned up when we finish the transaction
+ * or close the journal.
+ */
+ // if (hfsmp->jnl && journal_active(hfsmp->jnl) >= 0)
+ if (hfsmp->jnl)
+ lockflag = BUF_SKIP_LOCKED;
+ else
+ lockflag = 0;
/*
* Flush all dirty buffers associated with a vnode.
*/
-loop:
- s = splbio();
- for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
- nbp = bp->b_vnbufs.le_next;
- if ((bp->b_flags & B_BUSY))
- continue;
- if ((bp->b_flags & B_DELWRI) == 0)
- panic("hfs_fsync: bp 0x% not dirty (hfsmp 0x%x)", bp, hfsmp);
- // XXXdbg
- if (hfsmp->jnl && (bp->b_flags & B_LOCKED)) {
- if ((bp->b_flags & B_META) == 0) {
- panic("hfs: bp @ 0x%x is locked but not meta! jnl 0x%x\n",
- bp, hfsmp->jnl);
- }
- // if journal_active() returns >= 0 then the journal is ok and we
- // shouldn't do anything to this locked block (because it is part
- // of a transaction). otherwise we'll just go through the normal
- // code path and flush the buffer.
- if (journal_active(hfsmp->jnl) >= 0) {
- continue;
- }
- }
-
- bremfree(bp);
- bp->b_flags |= B_BUSY;
- /* Clear B_LOCKED, should only be set on meta files */
- bp->b_flags &= ~B_LOCKED;
-
- splx(s);
- /*
- * Wait for I/O associated with indirect blocks to complete,
- * since there is no way to quickly wait for them below.
- */
- if (bp->b_vp == vp || ap->a_waitfor == MNT_NOWAIT)
- (void) bawrite(bp);
- else
- (void) VOP_BWRITE(bp);
- goto loop;
- }
-
- if (wait) {
- while (vp->v_numoutput) {
- vp->v_flag |= VBWAIT;
- tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "hfs_fsync", 0);
- }
-
- // XXXdbg -- is checking for hfsmp->jnl == NULL the right
- // thing to do?
- if (hfsmp->jnl == NULL && vp->v_dirtyblkhd.lh_first) {
- /* still have some dirty buffers */
- if (retry++ > 10) {
- vprint("hfs_fsync: dirty", vp);
- splx(s);
- /*
- * Looks like the requests are not
- * getting queued to the driver.
- * Retrying here causes a cpu bound loop.
- * Yield to the other threads and hope
- * for the best.
- */
- (void)tsleep((caddr_t)&vp->v_numoutput,
- PRIBIO + 1, "hfs_fsync", hz/10);
- retry = 0;
- } else {
- splx(s);
- }
- /* try again */
- goto loop;
- }
- }
- splx(s);
+ buf_flushdirtyblks(vp, wait, lockflag, "hfs_fsync");
metasync:
- tv = time;
- if (vp->v_flag & VSYSTEM) {
- if (VTOF(vp)->fcbBTCBPtr != NULL)
+ if (vnode_isreg(vp) && vnode_issystem(vp)) {
+ if (VTOF(vp)->fcbBTCBPtr != NULL) {
+ microuptime(&tv);
BTSetLastSync(VTOF(vp), tv.tv_sec);
- cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_MODIFIED | C_UPDATE);
- } else /* User file */ {
- retval = VOP_UPDATE(ap->a_vp, &tv, &tv, wait);
+ }
+ cp->c_touch_acctime = FALSE;
+ cp->c_touch_chgtime = FALSE;
+ cp->c_touch_modtime = FALSE;
+ } else if ( !(vp->v_flag & VSWAP) ) /* User file */ {
+ retval = hfs_update(vp, wait);
/* When MNT_WAIT is requested push out any delayed meta data */
if ((retval == 0) && wait && cp->c_hint &&
!ISSET(cp->c_flag, C_DELETED | C_NOEXISTS)) {
- hfs_metasync(VTOHFS(vp), cp->c_hint, ap->a_p);
+ hfs_metasync(VTOHFS(vp), (daddr64_t)cp->c_hint, p);
}
// make sure that we've really been called from the user
// fsync() and if so push out any pending transactions
// that this file might is a part of (and get them on
// stable storage).
- if (vp->v_flag & VFULLFSYNC) {
+ if (fullsync || always_do_fullfsync) {
if (hfsmp->jnl) {
journal_flush(hfsmp->jnl);
} else {
- VOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, NOCRED, ap->a_p);
+ /* XXX need to pass context! */
+ VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, NULL);
}
}
}
return (retval);
}
+
/* Sync an hfs catalog b-tree node */
static int
-hfs_metasync(struct hfsmount *hfsmp, daddr_t node, struct proc *p)
+hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, struct proc *p)
{
- struct vnode *vp;
- struct buf *bp;
- struct buf *nbp;
- int s;
+ vnode_t vp;
+ buf_t bp;
+ int lockflags;
vp = HFSTOVCB(hfsmp)->catalogRefNum;
return 0;
}
- if (hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p) != 0)
- return (0);
-
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
/*
* Look for a matching node that has been delayed
* but is not part of a set (B_LOCKED).
+ *
+ * BLK_ONLYVALID causes buf_getblk to return a
+ * buf_t for the daddr64_t specified only if it's
+ * currently resident in the cache... the size
+ * parameter to buf_getblk is ignored when this flag
+ * is set
*/
- s = splbio();
- for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
- nbp = bp->b_vnbufs.le_next;
- if (bp->b_flags & B_BUSY)
- continue;
- if (bp->b_lblkno == node) {
- if (bp->b_flags & B_LOCKED)
- break;
-
- bremfree(bp);
- bp->b_flags |= B_BUSY;
- splx(s);
- (void) VOP_BWRITE(bp);
- goto exit;
- }
+ bp = buf_getblk(vp, node, 0, 0, 0, BLK_META | BLK_ONLYVALID);
+
+ if (bp) {
+ if ((buf_flags(bp) & (B_LOCKED | B_DELWRI)) == B_DELWRI)
+ (void) VNOP_BWRITE(bp);
+ else
+ buf_brelse(bp);
}
- splx(s);
-exit:
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
+
+ hfs_systemfile_unlock(hfsmp, lockflags);
return (0);
}
+
+/*ARGSUSED 1*/
+static int
+hfs_btsync_callback(struct buf *bp, void *dummy)
+{
+ buf_clearflags(bp, B_LOCKED);
+ (void) buf_bawrite(bp);
+
+ return(BUF_CLAIMED);
+}
+
+
__private_extern__
int
hfs_btsync(struct vnode *vp, int sync_transaction)
{
struct cnode *cp = VTOC(vp);
- register struct buf *bp;
struct timeval tv;
- struct buf *nbp;
- struct hfsmount *hfsmp = VTOHFS(vp);
- int s;
+ int flags = 0;
+ if (sync_transaction)
+ flags |= BUF_SKIP_NONLOCKED;
/*
* Flush all dirty buffers associated with b-tree.
*/
-loop:
- s = splbio();
-
- for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
- nbp = bp->b_vnbufs.le_next;
- if ((bp->b_flags & B_BUSY))
- continue;
- if ((bp->b_flags & B_DELWRI) == 0)
- panic("hfs_btsync: not dirty (bp 0x%x hfsmp 0x%x)", bp, hfsmp);
-
- // XXXdbg
- if (hfsmp->jnl && (bp->b_flags & B_LOCKED)) {
- if ((bp->b_flags & B_META) == 0) {
- panic("hfs: bp @ 0x%x is locked but not meta! jnl 0x%x\n",
- bp, hfsmp->jnl);
- }
- // if journal_active() returns >= 0 then the journal is ok and we
- // shouldn't do anything to this locked block (because it is part
- // of a transaction). otherwise we'll just go through the normal
- // code path and flush the buffer.
- if (journal_active(hfsmp->jnl) >= 0) {
- continue;
- }
- }
-
- if (sync_transaction && !(bp->b_flags & B_LOCKED))
- continue;
-
- bremfree(bp);
- bp->b_flags |= B_BUSY;
- bp->b_flags &= ~B_LOCKED;
-
- splx(s);
+ buf_iterate(vp, hfs_btsync_callback, flags, 0);
- (void) bawrite(bp);
-
- goto loop;
- }
- splx(s);
-
- tv = time;
- if ((vp->v_flag & VSYSTEM) && (VTOF(vp)->fcbBTCBPtr != NULL))
+ microuptime(&tv);
+ if (vnode_issystem(vp) && (VTOF(vp)->fcbBTCBPtr != NULL))
(void) BTSetLastSync(VTOF(vp), tv.tv_sec);
- cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_MODIFIED | C_UPDATE);
+ cp->c_touch_acctime = FALSE;
+ cp->c_touch_chgtime = FALSE;
+ cp->c_touch_modtime = FALSE;
return 0;
}
/*
- * Rmdir system call.
-#% rmdir dvp L U U
-#% rmdir vp L U U
-#
- vop_rmdir {
- IN WILLRELE struct vnode *dvp;
- IN WILLRELE struct vnode *vp;
- IN struct componentname *cnp;
-
+ * Remove a directory.
*/
static int
-hfs_rmdir(ap)
- struct vop_rmdir_args /* {
+hfs_vnop_rmdir(ap)
+ struct vnop_rmdir_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
+ vfs_context_t a_context;
} */ *ap;
{
- return (hfs_removedir(ap->a_dvp, ap->a_vp, ap->a_cnp, 0));
+ struct vnode *dvp = ap->a_dvp;
+ struct vnode *vp = ap->a_vp;
+ int error;
+
+ if (!vnode_isdir(vp)) {
+ return (ENOTDIR);
+ }
+ if (dvp == vp) {
+ return (EINVAL);
+ }
+ if ((error = hfs_lockpair(VTOC(dvp), VTOC(vp), HFS_EXCLUSIVE_LOCK)))
+ return (error);
+
+ error = hfs_removedir(dvp, vp, ap->a_cnp, 0);
+
+ hfs_unlockpair(VTOC(dvp), VTOC(vp));
+
+ return (error);
}
/*
- * hfs_removedir
+ * Remove a directory
+ *
+ * Both dvp and vp cnodes are locked
*/
static int
-hfs_removedir(dvp, vp, cnp, options)
- struct vnode *dvp;
- struct vnode *vp;
- struct componentname *cnp;
- int options;
+hfs_removedir(struct vnode *dvp, struct vnode *vp, struct componentname *cnp,
+ int skip_reserve)
{
- struct proc *p = cnp->cn_proc;
+ vfs_context_t ctx = cnp->cn_context;
+ struct proc *p = vfs_context_proc(ctx);
struct cnode *cp;
struct cnode *dcp;
struct hfsmount * hfsmp;
- struct timeval tv;
- cat_cookie_t cookie = {0};
- int error = 0, started_tr = 0, grabbed_lock = 0;
+ struct cat_desc desc;
+ cat_cookie_t cookie;
+ int lockflags;
+ int error = 0, started_tr = 0, got_cookie = 0;
cp = VTOC(vp);
dcp = VTOC(dvp);
hfsmp = VTOHFS(vp);
- if (dcp == cp) {
- vrele(dvp);
- vput(vp);
+ if (dcp == cp)
return (EINVAL); /* cannot remove "." */
- }
#if QUOTA
(void)hfs_getinoquota(cp);
#endif
- // XXXdbg
- hfs_global_shared_lock_acquire(hfsmp);
- grabbed_lock = 1;
- if (hfsmp->jnl) {
- if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
- goto out;
- }
- started_tr = 1;
+ if ((error = hfs_start_transaction(hfsmp)) != 0) {
+ goto out;
}
+ started_tr = 1;
- if (!(options & HFSRM_SKIP_RESERVE)) {
+ if (!skip_reserve) {
/*
* Reserve some space in the Catalog file.
*/
+ bzero(&cookie, sizeof(cookie));
if ((error = cat_preflight(hfsmp, CAT_DELETE, &cookie, p))) {
goto out;
}
+ got_cookie = 1;
}
/*
goto out;
}
+ if (cp->c_entries > 0)
+ panic("hfs_rmdir: attempting to delete a non-empty directory!");
+
/* Remove the entry from the namei cache: */
cache_purge(vp);
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
- if (error) goto out;
+ /*
+ * 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).
+ */
+ bzero(&desc, sizeof(desc));
+ desc.cd_nameptr = cnp->cn_nameptr;
+ desc.cd_namelen = cnp->cn_namelen;
+ desc.cd_parentcnid = dcp->c_cnid;
+ desc.cd_cnid = cp->c_cnid;
- if (cp->c_entries > 0)
- panic("hfs_rmdir: attempting to delete a non-empty directory!");
/* Remove entry from catalog */
- error = cat_delete(hfsmp, &cp->c_desc, &cp->c_attr);
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);
+ error = cat_delete(hfsmp, &desc, &cp->c_attr);
+ if (error == 0) {
+ /* Delete any attributes, ignore errors */
+ (void) hfs_removeallattr(hfsmp, cp->c_fileid);
+ }
+ hfs_systemfile_unlock(hfsmp, lockflags);
- /* Unlock catalog b-tree */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
- if (error) goto out;
+ if (error)
+ goto out;
#if QUOTA
(void)hfs_chkiq(cp, -1, NOCRED, 0);
dcp->c_entries--;
if (dcp->c_nlink > 0)
dcp->c_nlink--;
- dcp->c_flag |= C_CHANGE | C_UPDATE;
- tv = time;
- (void) VOP_UPDATE(dvp, &tv, &tv, 0);
+ dcp->c_touch_chgtime = TRUE;
+ dcp->c_touch_modtime = TRUE;
+
+ dcp->c_flag |= C_FORCEUPDATE; // XXXdbg - don't screw around, force this guy out
+
+ (void) hfs_update(dvp, 0);
HFS_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
hfs_volupdate(hfsmp, VOL_RMDIR, (dcp->c_cnid == kHFSRootFolderID));
cp->c_mode = 0; /* Makes the vnode go away...see inactive */
cp->c_flag |= C_NOEXISTS;
out:
- if (!(options & HFSRM_PARENT_LOCKED)) {
- vput(dvp);
- }
HFS_KNOTE(vp, NOTE_DELETE);
- vput(vp);
- if (!(options & HFSRM_SKIP_RESERVE)) {
+ if (got_cookie) {
cat_postflight(hfsmp, &cookie, p);
}
- // XXXdbg
if (started_tr) {
- journal_end_transaction(hfsmp->jnl);
- }
- if (grabbed_lock) {
- hfs_global_shared_lock_release(hfsmp);
+ hfs_end_transaction(hfsmp);
}
return (error);
}
-/*
-
-#% remove dvp L U U
-#% remove vp L U U
-#
- vop_remove {
- IN WILLRELE struct vnode *dvp;
- IN WILLRELE struct vnode *vp;
- IN struct componentname *cnp;
-
- */
+/*
+ * Remove a file or link.
+ */
static int
-hfs_remove(ap)
- struct vop_remove_args /* {
+hfs_vnop_remove(ap)
+ struct vnop_remove_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
+ int a_flags;
+ vfs_context_t a_context;
} */ *ap;
{
- return (hfs_removefile(ap->a_dvp, ap->a_vp, ap->a_cnp, 0));
+ struct vnode *dvp = ap->a_dvp;
+ struct vnode *vp = ap->a_vp;
+ int error;
+
+ if (dvp == vp) {
+ return (EINVAL);
+ }
+
+ hfs_lock_truncate(VTOC(vp), TRUE);
+
+ if ((error = hfs_lockpair(VTOC(dvp), VTOC(vp), HFS_EXCLUSIVE_LOCK)))
+ goto out;
+
+ error = hfs_removefile(dvp, vp, ap->a_cnp, ap->a_flags, 0);
+
+ hfs_unlockpair(VTOC(dvp), VTOC(vp));
+out:
+ hfs_unlock_truncate(VTOC(vp));
+ return (error);
}
+static int
+hfs_removefile_callback(struct buf *bp, void *hfsmp) {
+
+ if ( !(buf_flags(bp) & B_META))
+ panic("hfs: symlink bp @ 0x%x is not marked meta-data!\n", bp);
+ /*
+ * it's part of the current transaction, kill it.
+ */
+ journal_kill_block(((struct hfsmount *)hfsmp)->jnl, bp);
+
+ return (BUF_CLAIMED);
+}
/*
* hfs_removefile
*
- * Similar to hfs_remove except there are additional options.
+ * Similar to hfs_vnop_remove except there are additional options.
+ *
+ * Requires cnode and truncate locks to be held.
*/
static int
-hfs_removefile(dvp, vp, cnp, options)
- struct vnode *dvp;
- struct vnode *vp;
- struct componentname *cnp;
- int options;
+hfs_removefile(struct vnode *dvp, struct vnode *vp, struct componentname *cnp,
+ int flags, int skip_reserve)
{
struct vnode *rvp = NULL;
struct cnode *cp;
struct cnode *dcp;
struct hfsmount *hfsmp;
- struct proc *p = cnp->cn_proc;
+ struct cat_desc desc;
+ struct timeval tv;
+ vfs_context_t ctx = cnp->cn_context;
int dataforkbusy = 0;
int rsrcforkbusy = 0;
int truncated = 0;
- struct timeval tv;
- cat_cookie_t cookie = {0};
+ cat_cookie_t cookie;
+ int lockflags;
int error = 0;
- int started_tr = 0, grabbed_lock = 0;
- int refcount, isbigfile = 0;
+ int started_tr = 0, got_cookie = 0;
+ int isbigfile = 0;
+ cnid_t real_cnid = 0;
/* Directories should call hfs_rmdir! */
- if (vp->v_type == VDIR) {
- error = EISDIR;
- goto out;
+ if (vnode_isdir(vp)) {
+ return (EISDIR);
}
cp = VTOC(vp);
dcp = VTOC(dvp);
hfsmp = VTOHFS(vp);
+
+ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {
+ return 0;
+ }
- if (cp->c_parentcnid != dcp->c_cnid) {
+ // if it's not a hardlink, check that the parent
+ // cnid is the same as the directory cnid
+ if ( (cp->c_flag & C_HARDLINK) == 0
+ && (cp->c_parentcnid != hfsmp->hfs_privdir_desc.cd_cnid)
+ && (cp->c_parentcnid != dcp->c_cnid)) {
error = EINVAL;
goto out;
}
/* Make sure a remove is permitted */
- if ((cp->c_flags & (IMMUTABLE | APPEND)) ||
- (VTOC(dvp)->c_flags & APPEND) ||
- VNODE_IS_RSRC(vp)) {
+ if (VNODE_IS_RSRC(vp)) {
error = EPERM;
goto out;
}
/*
* Aquire a vnode for a non-empty resource fork.
- * (needed for VOP_TRUNCATE)
+ * (needed for hfs_truncate)
*/
if (cp->c_blocks - VTOF(vp)->ff_blocks) {
- error = hfs_vgetrsrc(hfsmp, vp, &rvp, p);
+ error = hfs_vgetrsrc(hfsmp, vp, &rvp, 0);
if (error)
goto out;
}
/*
* Check if this file is being used.
- *
- * The namei done for the remove took a reference on the
- * vnode (vp). And we took a ref on the resource vnode (rvp).
- * Hence set 1 in the tookref parameter of ubc_isinuse().
*/
- if (VTOC(vp)->c_flag & C_VPREFHELD) {
- refcount = 2;
- } else {
- refcount = 1;
- }
- if (UBCISVALID(vp) && ubc_isinuse(vp, refcount))
+ if (vnode_isinuse(vp, 0))
dataforkbusy = 1;
- if (rvp && UBCISVALID(rvp) && ubc_isinuse(rvp, 1))
+ if (rvp && vnode_isinuse(rvp, 0))
rsrcforkbusy = 1;
// need this to check if we have to break the deletion
/*
* Carbon semantics prohibit deleting busy files.
- * (enforced when NODELETEBUSY is requested)
+ * (enforced when VNODE_REMOVE_NODELETEBUSY is requested)
*/
- if ((dataforkbusy || rsrcforkbusy) &&
- ((cnp->cn_flags & NODELETEBUSY) ||
- (hfsmp->hfs_privdir_desc.cd_cnid == 0))) {
- error = EBUSY;
- goto out;
+ if (dataforkbusy || rsrcforkbusy) {
+ if ((flags & VNODE_REMOVE_NODELETEBUSY) ||
+ (hfsmp->hfs_privdir_desc.cd_cnid == 0)) {
+ error = EBUSY;
+ goto out;
+ }
}
#if QUOTA
(void)hfs_getinoquota(cp);
#endif /* QUOTA */
- // XXXdbg
- hfs_global_shared_lock_acquire(hfsmp);
- grabbed_lock = 1;
- if (hfsmp->jnl) {
- if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
- goto out;
+ /*
+ * We do the ubc_setsize before the hfs_truncate
+ * since we'll be inside a transaction.
+ */
+ if ((cp->c_flag & C_HARDLINK) == 0 &&
+ (!dataforkbusy || !rsrcforkbusy)) {
+ /*
+ * A ubc_setsize can cause a pagein so defer it
+ * until after the cnode lock is dropped. The
+ * cnode lock cannot be dropped/reacquired here
+ * since we might already hold the journal lock.
+ */
+ if (!dataforkbusy && cp->c_datafork->ff_blocks && !isbigfile) {
+ cp->c_flag |= C_NEED_DATA_SETSIZE;
+ }
+ if (!rsrcforkbusy && rvp) {
+ cp->c_flag |= C_NEED_RSRC_SETSIZE;
+ }
+ } else {
+ struct cat_desc cndesc;
+
+ // for hard links, re-lookup the name that was passed
+ // in so we get the correct cnid for the name (as
+ // opposed to the c_cnid in the cnode which could have
+ // been changed before this node got locked).
+ bzero(&cndesc, sizeof(cndesc));
+ cndesc.cd_nameptr = cnp->cn_nameptr;
+ cndesc.cd_namelen = cnp->cn_namelen;
+ cndesc.cd_parentcnid = VTOC(dvp)->c_cnid;
+ cndesc.cd_hint = VTOC(dvp)->c_childhint;
+
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
+
+ if (cat_lookup(hfsmp, &cndesc, 0, NULL, NULL, NULL, &real_cnid) != 0) {
+ hfs_systemfile_unlock(hfsmp, lockflags);
+ error = ENOENT;
+ goto out;
}
- started_tr = 1;
+
+ hfs_systemfile_unlock(hfsmp, lockflags);
+ }
+
+ if ((error = hfs_start_transaction(hfsmp)) != 0) {
+ goto out;
}
+ started_tr = 1;
- if (!(options & HFSRM_SKIP_RESERVE)) {
+ if (!skip_reserve) {
/*
* Reserve some space in the Catalog file.
*/
- if ((error = cat_preflight(hfsmp, CAT_DELETE, &cookie, p))) {
+ if ((error = cat_preflight(hfsmp, CAT_DELETE, &cookie, 0))) {
goto out;
}
+ got_cookie = 1;
}
/* Remove our entry from the namei cache. */
cache_purge(vp);
// XXXdbg - if we're journaled, kill any dirty symlink buffers
- if (hfsmp->jnl && vp->v_type == VLNK && vp->v_dirtyblkhd.lh_first) {
- struct buf *bp, *nbp;
-
- recheck:
- for (bp=vp->v_dirtyblkhd.lh_first; bp; bp=nbp) {
- nbp = bp->b_vnbufs.le_next;
-
- if ((bp->b_flags & B_BUSY)) {
- // if it was busy, someone else must be dealing
- // with it so just move on.
- continue;
- }
-
- if (!(bp->b_flags & B_META)) {
- panic("hfs: symlink bp @ 0x%x is not marked meta-data!\n", bp);
- }
-
- // if it's part of the current transaction, kill it.
- if (bp->b_flags & B_LOCKED) {
- bremfree(bp);
- bp->b_flags |= B_BUSY;
- journal_kill_block(hfsmp->jnl, bp);
- goto recheck;
- }
- }
- }
- // XXXdbg
+ if (hfsmp->jnl && vnode_islnk(vp))
+ buf_iterate(vp, hfs_removefile_callback, BUF_SKIP_NONLOCKED, (void *)hfsmp);
/*
* Truncate any non-busy forks. Busy forks will
* get trucated when their vnode goes inactive.
*
+ * Since we're already inside a transaction,
+ * tell hfs_truncate to skip the ubc_setsize.
+ *
* (Note: hard links are truncated in VOP_INACTIVE)
*/
if ((cp->c_flag & C_HARDLINK) == 0) {
int mode = cp->c_mode;
if (!dataforkbusy && !isbigfile && cp->c_datafork->ff_blocks != 0) {
- cp->c_mode = 0; /* Suppress VOP_UPDATES */
- error = VOP_TRUNCATE(vp, (off_t)0, IO_NDELAY, NOCRED, p);
+ cp->c_mode = 0; /* Suppress hfs_update */
+ error = hfs_truncate(vp, (off_t)0, IO_NDELAY, 1, ctx);
cp->c_mode = mode;
if (error)
goto out;
truncated = 1;
}
if (!rsrcforkbusy && rvp) {
- cp->c_mode = 0; /* Suppress VOP_UPDATES */
- error = VOP_TRUNCATE(rvp, (off_t)0, IO_NDELAY, NOCRED, p);
+ cp->c_mode = 0; /* Suppress hfs_update */
+ error = hfs_truncate(rvp, (off_t)0, IO_NDELAY, 1, ctx);
cp->c_mode = mode;
if (error)
goto out;
truncated = 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).
+ */
+ desc.cd_flags = 0;
+ desc.cd_encoding = cp->c_desc.cd_encoding;
+ desc.cd_nameptr = cnp->cn_nameptr;
+ desc.cd_namelen = cnp->cn_namelen;
+ desc.cd_parentcnid = dcp->c_cnid;
+ desc.cd_hint = cp->c_desc.cd_hint;
+ if (real_cnid) {
+ // if it was a hardlink we had to re-lookup the cnid
+ desc.cd_cnid = real_cnid;
+ } else {
+ desc.cd_cnid = cp->c_cnid;
+ }
+ microtime(&tv);
+
/*
* There are 3 remove cases to consider:
* 1. File is a hardlink ==> remove the link
*/
if (cp->c_flag & C_HARDLINK) {
- struct cat_desc desc;
-
- if ((cnp->cn_flags & HASBUF) == 0 ||
- cnp->cn_nameptr[0] == '\0') {
- error = ENOENT; /* name missing! */
- goto out;
- }
-
- /* Setup a descriptor for the link */
- bzero(&desc, sizeof(desc));
- desc.cd_nameptr = cnp->cn_nameptr;
- desc.cd_namelen = cnp->cn_namelen;
- desc.cd_parentcnid = dcp->c_cnid;
- /* XXX - if cnid is out of sync then the wrong thread rec will get deleted. */
- desc.cd_cnid = cp->c_cnid;
-
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
- if (error)
- goto out;
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
/* Delete the link record */
error = cat_delete(hfsmp, &desc, &cp->c_attr);
+ if (error == 0) {
+ /* Update the parent directory */
+ if (dcp->c_entries > 0)
+ dcp->c_entries--;
+ if (dcp->c_nlink > 0)
+ dcp->c_nlink--;
+ dcp->c_ctime = tv.tv_sec;
+ dcp->c_mtime = tv.tv_sec;
+ (void ) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);
+
+ if (--cp->c_nlink < 1) {
+ char inodename[32];
+ char delname[32];
+ struct cat_desc to_desc;
+ struct cat_desc from_desc;
- if ((error == 0) && (--cp->c_nlink < 1)) {
- char inodename[32];
- char delname[32];
- struct cat_desc to_desc;
- struct cat_desc from_desc;
-
- /*
- * This is now esentially an open deleted file.
- * Rename it to reflect this state which makes
- * orphan file cleanup easier (see hfs_remove_orphans).
- * Note: a rename failure here is not fatal.
- */
- MAKE_INODE_NAME(inodename, cp->c_rdev);
- bzero(&from_desc, sizeof(from_desc));
- from_desc.cd_nameptr = inodename;
- from_desc.cd_namelen = strlen(inodename);
- from_desc.cd_parentcnid = hfsmp->hfs_privdir_desc.cd_cnid;
- from_desc.cd_flags = 0;
- from_desc.cd_cnid = cp->c_fileid;
-
- MAKE_DELETED_NAME(delname, cp->c_fileid);
- bzero(&to_desc, sizeof(to_desc));
- to_desc.cd_nameptr = delname;
- to_desc.cd_namelen = strlen(delname);
- to_desc.cd_parentcnid = hfsmp->hfs_privdir_desc.cd_cnid;
- to_desc.cd_flags = 0;
- to_desc.cd_cnid = cp->c_fileid;
+ /*
+ * This is now esentially an open deleted file.
+ * Rename it to reflect this state which makes
+ * orphan file cleanup easier (see hfs_remove_orphans).
+ * Note: a rename failure here is not fatal.
+ */
+ MAKE_INODE_NAME(inodename, cp->c_rdev);
+ bzero(&from_desc, sizeof(from_desc));
+ from_desc.cd_nameptr = inodename;
+ from_desc.cd_namelen = strlen(inodename);
+ from_desc.cd_parentcnid = hfsmp->hfs_privdir_desc.cd_cnid;
+ from_desc.cd_flags = 0;
+ from_desc.cd_cnid = cp->c_fileid;
+
+ MAKE_DELETED_NAME(delname, cp->c_fileid);
+ bzero(&to_desc, sizeof(to_desc));
+ to_desc.cd_nameptr = delname;
+ to_desc.cd_namelen = strlen(delname);
+ to_desc.cd_parentcnid = hfsmp->hfs_privdir_desc.cd_cnid;
+ to_desc.cd_flags = 0;
+ to_desc.cd_cnid = cp->c_fileid;
- (void) cat_rename(hfsmp, &from_desc, &hfsmp->hfs_privdir_desc,
- &to_desc, (struct cat_desc *)NULL);
- cp->c_flag |= C_DELETED;
+ error = cat_rename(hfsmp, &from_desc, &hfsmp->hfs_privdir_desc,
+ &to_desc, (struct cat_desc *)NULL);
+ if (error != 0) {
+ panic("hfs_removefile: error %d from cat_rename(%s %s) cp 0x%x\n",
+ inodename, delname, cp);
+ }
+ if (error == 0) {
+ /* Update the file's state */
+ cp->c_flag |= C_DELETED;
+ cp->c_ctime = tv.tv_sec;
+ (void) cat_update(hfsmp, &to_desc, &cp->c_attr, NULL, NULL);
+ }
+ } else {
+ /* Update the file's state */
+ cp->c_ctime = tv.tv_sec;
+ (void) cat_update(hfsmp, &cp->c_desc, &cp->c_attr, NULL, NULL);
+ }
}
-
- /* Unlock the Catalog */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
-
+ hfs_systemfile_unlock(hfsmp, lockflags);
if (error != 0)
goto out;
- cp->c_flag |= C_CHANGE;
- tv = time;
- (void) VOP_UPDATE(vp, &tv, &tv, 0);
-
hfs_volupdate(hfsmp, VOL_RMFILE, (dcp->c_cnid == kHFSRootFolderID));
} else if (dataforkbusy || rsrcforkbusy || isbigfile) {
to_desc.cd_flags = 0;
to_desc.cd_cnid = cp->c_cnid;
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
- if (error)
- goto out;
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
- error = cat_rename(hfsmp, &cp->c_desc, &todir_desc,
+ error = cat_rename(hfsmp, &desc, &todir_desc,
&to_desc, (struct cat_desc *)NULL);
- // XXXdbg - only bump this count if we were successful
if (error == 0) {
hfsmp->hfs_privdir_attr.ca_entries++;
+ (void) cat_update(hfsmp, &hfsmp->hfs_privdir_desc,
+ &hfsmp->hfs_privdir_attr, NULL, NULL);
+
+ /* Update the parent directory */
+ if (dcp->c_entries > 0)
+ dcp->c_entries--;
+ if (dcp->c_nlink > 0)
+ dcp->c_nlink--;
+ dcp->c_ctime = tv.tv_sec;
+ dcp->c_mtime = tv.tv_sec;
+ (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);
+
+ /* Update the file's state */
+ cp->c_flag |= C_DELETED;
+ cp->c_ctime = tv.tv_sec;
+ --cp->c_nlink;
+ (void) cat_update(hfsmp, &to_desc, &cp->c_attr, NULL, NULL);
}
- (void)cat_update(hfsmp, &hfsmp->hfs_privdir_desc,
- &hfsmp->hfs_privdir_attr, NULL, NULL);
-
- /* Unlock the Catalog */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
- if (error) goto out;
-
- cp->c_flag |= C_CHANGE | C_DELETED | C_NOEXISTS;
- --cp->c_nlink;
- tv = time;
- (void) VOP_UPDATE(vp, &tv, &tv, 0);
+ hfs_systemfile_unlock(hfsmp, lockflags);
+ if (error)
+ goto out;
} else /* Not busy */ {
if (cp->c_blocks > 0) {
-#if 0
- panic("hfs_remove: attempting to delete a non-empty file!");
-#else
printf("hfs_remove: attempting to delete a non-empty file %s\n",
cp->c_desc.cd_nameptr);
error = EBUSY;
goto out;
-#endif
}
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
- if (error)
- goto out;
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);
- error = cat_delete(hfsmp, &cp->c_desc, &cp->c_attr);
+ 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_desc.cd_nameptr, cp->c_attr.ca_fileid, error);
}
}
-
- /* Unlock the Catalog */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
- if (error) goto out;
+ if (error == 0) {
+ /* Delete any attributes, ignore errors */
+ (void) hfs_removeallattr(hfsmp, cp->c_fileid);
+
+ /* Update the parent directory */
+ if (dcp->c_entries > 0)
+ dcp->c_entries--;
+ if (dcp->c_nlink > 0)
+ dcp->c_nlink--;
+ 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)
+ goto out;
#if QUOTA
(void)hfs_chkiq(cp, -1, NOCRED, 0);
cp->c_mode = 0;
truncated = 0; // because the catalog entry is gone
- cp->c_flag |= C_CHANGE | C_NOEXISTS;
+ cp->c_flag |= C_NOEXISTS;
+ cp->c_touch_chgtime = TRUE; /* XXX needed ? */
--cp->c_nlink;
+
hfs_volupdate(hfsmp, VOL_RMFILE, (dcp->c_cnid == kHFSRootFolderID));
}
*/
cat_releasedesc(&cp->c_desc);
- /* In all three cases the parent lost a child */
- if (dcp->c_entries > 0)
- dcp->c_entries--;
- if (dcp->c_nlink > 0)
- dcp->c_nlink--;
- dcp->c_flag |= C_CHANGE | C_UPDATE;
- tv = time;
- (void) VOP_UPDATE(dvp, &tv, &tv, 0);
HFS_KNOTE(dvp, NOTE_WRITE);
out:
- /* All done with component name... */
- if ((options & HFSRM_SAVE_NAME) == 0 &&
- (cnp != 0) &&
- (cnp->cn_flags & (HASBUF | SAVENAME)) == (HASBUF | SAVENAME)) {
- char *tmp = cnp->cn_pnbuf;
- cnp->cn_pnbuf = NULL;
- cnp->cn_flags &= ~HASBUF;
- FREE_ZONE(tmp, cnp->cn_pnlen, M_NAMEI);
- }
-
- if (!(options & HFSRM_SKIP_RESERVE)) {
- cat_postflight(hfsmp, &cookie, p);
+ if (got_cookie) {
+ cat_postflight(hfsmp, &cookie, 0);
}
/* Commit the truncation to the catalog record */
if (truncated) {
- cp->c_flag |= C_CHANGE | C_UPDATE | C_FORCEUPDATE;
- tv = time;
- (void) VOP_UPDATE(vp, &tv, &tv, 0);
+ cp->c_flag |= C_FORCEUPDATE;
+ cp->c_touch_chgtime = TRUE;
+ cp->c_touch_modtime = TRUE;
+ (void) hfs_update(vp, 0);
}
- // XXXdbg
if (started_tr) {
- journal_end_transaction(hfsmp->jnl);
- }
- if (grabbed_lock) {
- hfs_global_shared_lock_release(hfsmp);
+ hfs_end_transaction(hfsmp);
}
HFS_KNOTE(vp, NOTE_DELETE);
if (rvp) {
HFS_KNOTE(rvp, NOTE_DELETE);
- vrele(rvp);
+ /* Defer the vnode_put on rvp until the hfs_unlock(). */
+ cp->c_flag |= C_NEED_RVNODE_PUT;
};
- if (error) {
- vput(vp);
- } else {
- VOP_UNLOCK(vp, 0, p);
- // XXXdbg - try to prevent the lost ubc_info panic
- if ((cp->c_flag & C_HARDLINK) == 0 || cp->c_nlink == 0) {
- (void) ubc_uncache(vp);
- }
- vrele(vp);
- }
- if (!(options & HFSRM_PARENT_LOCKED)) {
- vput(dvp);
- }
-
return (error);
}
__private_extern__ void
replace_desc(struct cnode *cp, struct cat_desc *cdp)
{
+ if (&cp->c_desc == cdp) {
+ return;
+ }
+
/* First release allocated name buffer */
if (cp->c_desc.cd_flags & CD_HASBUF && cp->c_desc.cd_nameptr != 0) {
char *name = cp->c_desc.cd_nameptr;
cp->c_desc.cd_nameptr = 0;
cp->c_desc.cd_namelen = 0;
cp->c_desc.cd_flags &= ~CD_HASBUF;
- remove_name(name);
+ vfs_removename(name);
}
bcopy(cdp, &cp->c_desc, sizeof(cp->c_desc));
}
-/*
-#
-#% rename fdvp U U U
-#% rename fvp U U U
-#% rename tdvp L U U
-#% rename tvp X U U
-#
-*/
/*
* Rename a cnode.
*
- * The VFS layer guarantees that source and destination will
- * either both be directories, or both not be directories.
+ * The VFS layer guarantees that:
+ * - source and destination will either both be directories, or
+ * both not be directories.
+ * - all the vnodes are from the same file system
*
- * When the target is a directory, hfs_rename must ensure
- * that it is empty.
- *
- * The rename system call is responsible for freeing
- * the pathname buffers (ie no need to call VOP_ABORTOP).
+ * When the target is a directory, HFS must ensure that its empty.
*/
-
static int
-hfs_rename(ap)
- struct vop_rename_args /* {
+hfs_vnop_rename(ap)
+ struct vnop_rename_args /* {
struct vnode *a_fdvp;
struct vnode *a_fvp;
struct componentname *a_fcnp;
struct vnode *a_tdvp;
struct vnode *a_tvp;
struct componentname *a_tcnp;
+ vfs_context_t a_context;
} */ *ap;
{
struct vnode *tvp = ap->a_tvp;
struct vnode *fdvp = ap->a_fdvp;
struct componentname *tcnp = ap->a_tcnp;
struct componentname *fcnp = ap->a_fcnp;
- struct proc *p = fcnp->cn_proc;
- struct cnode *fcp = NULL;
- struct cnode *fdcp = NULL;
- struct cnode *tdcp = VTOC(tdvp);
+ struct proc *p = vfs_context_proc(ap->a_context);
+ struct cnode *fcp;
+ struct cnode *fdcp;
+ struct cnode *tdcp;
+ struct cnode *tcp;
struct cat_desc from_desc;
struct cat_desc to_desc;
struct cat_desc out_desc;
- struct hfsmount *hfsmp = NULL;
- struct timeval tv;
- cat_cookie_t cookie = {0};
- int fdvp_locked, fvp_locked, tdvp_locked, tvp_locked;
- int tvp_deleted;
- int started_tr = 0, grabbed_lock = 0;
- int error = 0;
-
+ struct hfsmount *hfsmp;
+ cat_cookie_t cookie;
+ int tvp_deleted = 0;
+ int started_tr = 0, got_cookie = 0;
+ int took_trunc_lock = 0;
+ int lockflags;
+ int error;
- /* Establish our vnode lock state. */
- tdvp_locked = 1;
- tvp_locked = (tvp != 0);
- fdvp_locked = 0;
- fvp_locked = 0;
- tvp_deleted = 0;
+ /* When tvp exist, take the truncate lock for the hfs_removefile(). */
+ if (tvp && vnode_isreg(tvp)) {
+ hfs_lock_truncate(VTOC(tvp), TRUE);
+ took_trunc_lock = 1;
+ }
- /*
- * Check for cross-device rename.
- */
- if ((fvp->v_mount != tdvp->v_mount) ||
- (tvp && (fvp->v_mount != tvp->v_mount))) {
- error = EXDEV;
- goto out;
+ error = hfs_lockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL,
+ HFS_EXCLUSIVE_LOCK);
+ if (error) {
+ if (took_trunc_lock)
+ hfs_unlock_truncate(VTOC(tvp));
+ return (error);
}
- /*
- * When fvp matches tvp they must be case variants
- * or hard links.
- *
- * In some cases tvp will be locked in other cases
- * it be unlocked with no reference. Normalize the
- * state here (unlocked with a reference) so that
- * we can exit in a known state.
- */
- if (fvp == tvp) {
- if (VOP_ISLOCKED(tvp) &&
- (VTOC(tvp)->c_lock.lk_lockholder == p->p_pid) &&
- (VTOC(tvp)->c_lock.lk_lockthread == current_thread())) {
- vput(tvp);
- }
- tvp = NULL;
- tvp_locked = 0;
+ fdcp = VTOC(fdvp);
+ fcp = VTOC(fvp);
+ tdcp = VTOC(tdvp);
+ tcp = tvp ? VTOC(tvp) : NULL;
+ hfsmp = VTOHFS(tdvp);
- /*
- * If this a hard link with different parents
- * and its not a case variant then keep tvp
- * around for removal.
- */
- if ((VTOC(fvp)->c_flag & C_HARDLINK) &&
- ((fdvp != tdvp) ||
- (hfs_namecmp(fcnp->cn_nameptr, fcnp->cn_namelen,
- tcnp->cn_nameptr, tcnp->cn_namelen) != 0))) {
- tvp = fvp;
- vref(tvp);
- }
+ /* Check for a race against unlink. */
+ if (fcp->c_flag & C_NOEXISTS) {
+ error = ENOENT;
+ goto out;
}
-
+
/*
* The following edge case is caught here:
* (to cannot be a descendent of from)
* /
* o tvp
*/
- if (tdcp->c_parentcnid == VTOC(fvp)->c_cnid) {
+ if (tdcp->c_parentcnid == fcp->c_cnid) {
error = EINVAL;
goto out;
}
* /
* o fvp
*/
- if (tvp && (tvp->v_type == VDIR) && (VTOC(tvp)->c_entries != 0)) {
+ if (tvp && vnode_isdir(tvp) && (tcp->c_entries != 0) && fvp != tvp) {
error = ENOTEMPTY;
goto out;
}
/*
* Make sure "from" vnode and its parent are changeable.
*/
- if ((VTOC(fvp)->c_flags & (IMMUTABLE | APPEND)) ||
- (VTOC(fdvp)->c_flags & APPEND)) {
+ if ((fcp->c_flags & (IMMUTABLE | APPEND)) || (fdcp->c_flags & APPEND)) {
error = EPERM;
goto out;
}
- hfsmp = VTOHFS(tdvp);
-
/*
* If the destination parent directory is "sticky", then the
* user must own the parent directory, or the destination of
* (except by root). This implements append-only directories.
*
* Note that checks for immutable and write access are done
- * by the call to VOP_REMOVE.
+ * by the call to hfs_removefile.
*/
if (tvp && (tdcp->c_mode & S_ISTXT) &&
- (tcnp->cn_cred->cr_uid != 0) &&
- (tcnp->cn_cred->cr_uid != tdcp->c_uid) &&
- (hfs_owner_rights(hfsmp, VTOC(tvp)->c_uid, tcnp->cn_cred, p, false)) ) {
+ (suser(vfs_context_ucred(tcnp->cn_context), NULL)) &&
+ (kauth_cred_getuid(vfs_context_ucred(tcnp->cn_context)) != tdcp->c_uid) &&
+ (hfs_owner_rights(hfsmp, tcp->c_uid, vfs_context_ucred(tcnp->cn_context), p, false)) ) {
error = EPERM;
goto out;
}
#if QUOTA
if (tvp)
- (void)hfs_getinoquota(VTOC(tvp));
+ (void)hfs_getinoquota(tcp);
#endif
-
- /*
- * Lock all the vnodes before starting a journal transaction.
- */
-
- /*
- * Simple case (same parent) - just lock child (fvp).
- */
- if (fdvp == tdvp) {
- if (error = vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p))
- goto out;
- fvp_locked = 1;
- goto vnlocked;
- }
-
- /*
- * If fdvp is the parent of tdvp then we'll need to
- * drop tdvp's lock before acquiring a lock on fdvp.
- *
- * fdvp
- * o
- * / \
- * / \
- * tdvp o o fvp
- * \
- * \
- * o tvp
- *
- *
- * If the parent directories are unrelated then we'll
- * need to aquire their vnode locks in vnode address
- * order. Otherwise we can race with another rename
- * call that involves the same vnodes except that to
- * and from are switched and potentially deadlock.
- * [ie rename("a/b", "c/d") vs rename("c/d", "a/b")]
- *
- * If its not either of the two above cases then we
- * can safely lock fdvp and fvp.
- */
- if ((VTOC(fdvp)->c_cnid == VTOC(tdvp)->c_parentcnid) ||
- ((VTOC(tdvp)->c_cnid != VTOC(fdvp)->c_parentcnid) &&
- (fdvp < tdvp))) {
-
- /* Drop locks on tvp and tdvp */
- if (tvp_locked) {
- VOP_UNLOCK(tvp, 0, p);
- tvp_locked = 0;
- }
- VOP_UNLOCK(tdvp, 0, p);
- tdvp_locked = 0;
-
- /* Aquire locks in correct order */
- if ((error = vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY, p)))
- goto out;
- fdvp_locked = 1;
- if ((error = vn_lock(tdvp, LK_EXCLUSIVE | LK_RETRY, p)))
- goto out;
- tdvp_locked = 1;
-
- /*
- * Now that the parents are locked only one thread
- * can continue. So the lock order of the children
- * doesn't really matter
- */
- if (tvp == fvp) {
- if ((error = vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p)))
- goto out;
- tvp_locked = 1;
- } else {
- if (tvp) {
- if ((error = vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p)))
- goto out;
- tvp_locked = 1;
- }
- if ((error = vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p)))
- goto out;
- fvp_locked = 1;
- }
-
- } else /* OK to lock fdvp and fvp */ {
- if ((error = vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY, p)))
- goto out;
- fdvp_locked = 1;
- if (error = vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p))
- goto out;
- if (tvp == fvp)
- tvp_locked = 1;
- else
- fvp_locked = 1;
- }
-
-vnlocked:
- fdcp = VTOC(fdvp);
- fcp = VTOC(fvp);
-
- /*
- * While fvp is still locked, purge it from the name cache and
- * grab it's c_cnid value. Note that the removal of tvp (below)
- * can drop fvp's lock when fvp == tvp.
- */
+ /* Preflighting done, take fvp out of the name space. */
cache_purge(fvp);
/*
* we can drop its NODUMP status.
*/
if ((fcp->c_flags & UF_NODUMP) &&
- (fvp->v_type == VREG) &&
+ vnode_isreg(fvp) &&
(fdvp != tdvp) &&
(fdcp->c_desc.cd_nameptr != NULL) &&
(strcmp(fdcp->c_desc.cd_nameptr, CARBON_TEMP_DIR_NAME) == 0)) {
fcp->c_flags &= ~UF_NODUMP;
- fcp->c_flag |= C_CHANGE;
- tv = time;
- (void) VOP_UPDATE(fvp, &tv, &tv, 0);
+ fcp->c_touch_chgtime = TRUE;
+ (void) hfs_update(fvp, 0);
}
bzero(&from_desc, sizeof(from_desc));
to_desc.cd_flags = fcp->c_desc.cd_flags & ~(CD_HASBUF | CD_DECOMPOSED);
to_desc.cd_cnid = fcp->c_cnid;
- hfs_global_shared_lock_acquire(hfsmp);
- grabbed_lock = 1;
- if (hfsmp->jnl) {
- if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
- goto out;
+ if ((error = hfs_start_transaction(hfsmp)) != 0) {
+ goto out;
+ }
+ started_tr = 1;
+
+ // if it's a hardlink then re-lookup the name so
+ // that we get the correct cnid in from_desc (see
+ // the comment in hfs_removefile for more details)
+ //
+ if (fcp->c_flag & C_HARDLINK) {
+ struct cat_desc tmpdesc;
+ cnid_t real_cnid;
+
+ bzero(&tmpdesc, sizeof(tmpdesc));
+ tmpdesc.cd_nameptr = fcnp->cn_nameptr;
+ tmpdesc.cd_namelen = fcnp->cn_namelen;
+ tmpdesc.cd_parentcnid = fdcp->c_cnid;
+ tmpdesc.cd_hint = fdcp->c_childhint;
+
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
+
+ if (cat_lookup(hfsmp, &tmpdesc, 0, NULL, NULL, NULL, &real_cnid) != 0) {
+ hfs_systemfile_unlock(hfsmp, lockflags);
+ goto out;
}
- started_tr = 1;
+
+ // use the real cnid instead of whatever happened to be there
+ from_desc.cd_cnid = real_cnid;
+ hfs_systemfile_unlock(hfsmp, lockflags);
}
/*
* Reserve some space in the Catalog file.
*/
+ bzero(&cookie, sizeof(cookie));
if ((error = cat_preflight(hfsmp, CAT_RENAME + CAT_DELETE, &cookie, p))) {
goto out;
}
+ got_cookie = 1;
/*
- * If the destination exists then it needs to be removed.
+ * If the destination exists then it may need to be removed.
*/
-
if (tvp) {
- if (tvp != fvp)
- cache_purge(tvp);
/*
- * Note that hfs_removedir and hfs_removefile
- * will keep tdvp locked with a reference.
- * But tvp will lose its lock and reference.
+ * When fvp matches tvp they must be case variants
+ * or hard links.
*/
- if (tvp->v_type == VDIR)
- error = hfs_removedir(tdvp, tvp, tcnp, HFSRM_RENAMEOPTS);
- else
- error = hfs_removefile(tdvp, tvp, tcnp, HFSRM_RENAMEOPTS);
+ if (fvp == tvp) {
+ /*
+ * If this a hard link with different parents
+ * and its not a case variant then tvp should
+ * be removed.
+ */
+ if (!((fcp->c_flag & C_HARDLINK) &&
+ ((fdvp != tdvp) ||
+ (hfs_namecmp(fcnp->cn_nameptr, fcnp->cn_namelen,
+ tcnp->cn_nameptr, tcnp->cn_namelen) != 0)))) {
+ goto skip;
+ }
+ } else {
+ cache_purge(tvp);
+ }
+
+ if (vnode_isdir(tvp))
+ error = hfs_removedir(tdvp, tvp, tcnp, HFSRM_SKIP_RESERVE);
+ else {
+ error = hfs_removefile(tdvp, tvp, tcnp, 0, HFSRM_SKIP_RESERVE);
+ }
- if (tvp == fvp)
- fvp_locked = 0;
- tvp = NULL;
- tvp_locked = 0;
- tvp_deleted = 1;
if (error)
goto out;
+ tvp_deleted = 1;
}
-
+skip:
/*
* All done with tvp and fvp
*/
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
- if (error)
- goto out;
-
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
error = cat_rename(hfsmp, &from_desc, &tdcp->c_desc, &to_desc, &out_desc);
-
- /* Unlock catalog b-tree */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
+ hfs_systemfile_unlock(hfsmp, lockflags);
if (error) {
goto out;
}
+ /* Invalidate negative cache entries in the destination directory */
+ if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)
+ cache_purge_negatives(tdvp);
+
/* Update cnode's catalog descriptor */
- if (fvp_locked) {
- replace_desc(fcp, &out_desc);
- fcp->c_parentcnid = tdcp->c_cnid;
- fcp->c_hint = 0;
- }
+ replace_desc(fcp, &out_desc);
+ fcp->c_parentcnid = tdcp->c_cnid;
+ fcp->c_hint = 0;
- hfs_volupdate(hfsmp, fvp->v_type == VDIR ? VOL_RMDIR : VOL_RMFILE,
+ hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_RMDIR : VOL_RMFILE,
(fdcp->c_cnid == kHFSRootFolderID));
- hfs_volupdate(hfsmp, fvp->v_type == VDIR ? VOL_MKDIR : VOL_MKFILE,
+ hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_MKDIR : VOL_MKFILE,
(tdcp->c_cnid == kHFSRootFolderID));
/* Update both parent directories. */
- tv = time;
if (fdvp != tdvp) {
tdcp->c_nlink++;
tdcp->c_entries++;
fdcp->c_nlink--;
if (fdcp->c_entries > 0)
fdcp->c_entries--;
- fdcp->c_flag |= C_CHANGE | C_UPDATE;
- (void) VOP_UPDATE(fdvp, &tv, &tv, 0);
+ fdcp->c_touch_chgtime = TRUE;
+ fdcp->c_touch_modtime = TRUE;
+
+ fdcp->c_flag |= C_FORCEUPDATE; // XXXdbg - force it out!
+ (void) hfs_update(fdvp, 0);
}
tdcp->c_childhint = out_desc.cd_hint; /* Cache directory's location */
- tdcp->c_flag |= C_CHANGE | C_UPDATE;
- (void) VOP_UPDATE(tdvp, &tv, &tv, 0);
+ tdcp->c_touch_chgtime = TRUE;
+ tdcp->c_touch_modtime = TRUE;
+ tdcp->c_flag |= C_FORCEUPDATE; // XXXdbg - force it out!
+ (void) hfs_update(tdvp, 0);
out:
- if (hfsmp) {
+ if (got_cookie) {
cat_postflight(hfsmp, &cookie, p);
}
if (started_tr) {
- journal_end_transaction(hfsmp->jnl);
- }
- if (grabbed_lock) {
- hfs_global_shared_lock_release(hfsmp);
+ hfs_end_transaction(hfsmp);
}
/* Note that if hfs_removedir or hfs_removefile was invoked above they will already have
HFS_KNOTE(fdvp, NOTE_WRITE);
if (tdvp != fdvp) HFS_KNOTE(tdvp, NOTE_WRITE);
};
- if (fvp_locked) {
- VOP_UNLOCK(fvp, 0, p);
- }
- if (fdvp_locked) {
- VOP_UNLOCK(fdvp, 0, p);
- }
- if (tdvp_locked) {
- VOP_UNLOCK(tdvp, 0, p);
- }
- if (tvp_locked) {
- VOP_UNLOCK(tvp, 0, p);
- }
- vrele(fvp);
- vrele(fdvp);
- if (tvp)
- vrele(tvp);
- vrele(tdvp);
+ if (took_trunc_lock)
+ hfs_unlock_truncate(VTOC(tvp));
+
+ hfs_unlockfour(fdcp, fcp, tdcp, tcp);
/* After tvp is removed the only acceptable error is EIO */
if (error && tvp_deleted)
}
-
/*
- * Mkdir system call
-#% mkdir dvp L U U
-#% mkdir vpp - L -
-#
- vop_mkdir {
- IN WILLRELE struct vnode *dvp;
- OUT struct vnode **vpp;
- IN struct componentname *cnp;
- IN struct vattr *vap;
-
- We are responsible for freeing the namei buffer,
- it is done in hfs_makenode()
-*/
-
+ * Make a directory.
+ */
static int
-hfs_mkdir(ap)
- struct vop_mkdir_args /* {
- struct vnode *a_dvp;
- struct vnode **a_vpp;
- struct componentname *a_cnp;
- struct vattr *a_vap;
- } */ *ap;
+hfs_vnop_mkdir(struct vnop_mkdir_args *ap)
{
- struct vattr *vap = ap->a_vap;
-
- return (hfs_makenode(MAKEIMODE(vap->va_type, vap->va_mode),
- ap->a_dvp, ap->a_vpp, ap->a_cnp));
+ /***** HACK ALERT ********/
+ ap->a_cnp->cn_flags |= MAKEENTRY;
+ return hfs_makenode(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap, ap->a_context);
}
/*
- * symlink -- make a symbolic link
-#% symlink dvp L U U
-#% symlink vpp - U -
-#
-# XXX - note that the return vnode has already been VRELE'ed
-# by the filesystem layer. To use it you must use vget,
-# possibly with a further namei.
-#
- vop_symlink {
- IN WILLRELE struct vnode *dvp;
- OUT WILLRELE struct vnode **vpp;
- IN struct componentname *cnp;
- IN struct vattr *vap;
- IN char *target;
-
- We are responsible for freeing the namei buffer,
- it is done in hfs_makenode().
-
-*/
-
+ * Create a symbolic link.
+ */
static int
-hfs_symlink(ap)
- struct vop_symlink_args /* {
- struct vnode *a_dvp;
- struct vnode **a_vpp;
- struct componentname *a_cnp;
- struct vattr *a_vap;
- char *a_target;
- } */ *ap;
+hfs_vnop_symlink(struct vnop_symlink_args *ap)
{
- register struct vnode *vp, **vpp = ap->a_vpp;
+ struct vnode **vpp = ap->a_vpp;
+ struct vnode *dvp = ap->a_dvp;
+ struct vnode *vp = NULL;
struct hfsmount *hfsmp;
struct filefork *fp;
- int len, error;
struct buf *bp = NULL;
+ char *datap;
+ int started_tr = 0;
+ int len, error;
/* HFS standard disks don't support symbolic links */
- if (VTOVCB(ap->a_dvp)->vcbSigWord != kHFSPlusSigWord) {
- VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
- vput(ap->a_dvp);
- return (EOPNOTSUPP);
- }
+ if (VTOVCB(dvp)->vcbSigWord != kHFSPlusSigWord)
+ return (ENOTSUP);
/* Check for empty target name */
- if (ap->a_target[0] == 0) {
- VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
- vput(ap->a_dvp);
+ if (ap->a_target[0] == 0)
return (EINVAL);
- }
-
-
- hfsmp = VTOHFS(ap->a_dvp);
/* Create the vnode */
- if ((error = hfs_makenode(S_IFLNK | ap->a_vap->va_mode,
- ap->a_dvp, vpp, ap->a_cnp))) {
- return (error);
+ ap->a_vap->va_mode |= S_IFLNK;
+ if ((error = hfs_makenode(dvp, vpp, ap->a_cnp, ap->a_vap, ap->a_context))) {
+ goto out;
}
-
vp = *vpp;
- len = strlen(ap->a_target);
+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
+ return (error);
fp = VTOF(vp);
+ hfsmp = VTOHFS(dvp);
+ len = strlen(ap->a_target);
#if QUOTA
(void)hfs_getinoquota(VTOC(vp));
#endif /* QUOTA */
- // XXXdbg
- hfs_global_shared_lock_acquire(hfsmp);
- if (hfsmp->jnl) {
- if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
- hfs_global_shared_lock_release(hfsmp);
- vput(vp);
- return error;
- }
+ if ((error = hfs_start_transaction(hfsmp)) != 0) {
+ goto out;
}
+ started_tr = 1;
- /* Allocate space for the link */
- error = VOP_TRUNCATE(vp, len, IO_NOZEROFILL,
- ap->a_cnp->cn_cred, ap->a_cnp->cn_proc);
+ /*
+ * Allocate space for the link.
+ *
+ * Since we're already inside a transaction,
+ * tell hfs_truncate to skip the ubc_setsize.
+ *
+ * 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);
if (error)
goto out; /* XXX need to remove link */
/* Write the link to disk */
- bp = getblk(vp, 0, roundup((int)fp->ff_size, VTOHFS(vp)->hfs_phys_block_size),
+ bp = buf_getblk(vp, (daddr64_t)0, roundup((int)fp->ff_size, VTOHFS(vp)->hfs_phys_block_size),
0, 0, BLK_META);
if (hfsmp->jnl) {
journal_modify_block_start(hfsmp->jnl, bp);
}
- bzero(bp->b_data, bp->b_bufsize);
- bcopy(ap->a_target, bp->b_data, len);
+ datap = (char *)buf_dataptr(bp);
+ bzero(datap, buf_size(bp));
+ bcopy(ap->a_target, datap, len);
+
if (hfsmp->jnl) {
journal_modify_block_end(hfsmp->jnl, bp);
} else {
- bawrite(bp);
+ buf_bawrite(bp);
}
+ /*
+ * We defered the ubc_setsize for hfs_truncate
+ * since we were inside a transaction.
+ *
+ * We don't need to drop the cnode lock here
+ * since this is a symlink.
+ */
+ ubc_setsize(vp, len);
out:
- if (hfsmp->jnl) {
- journal_end_transaction(hfsmp->jnl);
+ if (started_tr)
+ hfs_end_transaction(hfsmp);
+ if (vp) {
+ hfs_unlock(VTOC(vp));
}
- hfs_global_shared_lock_release(hfsmp);
- vput(vp);
return (error);
}
-/*
- * Dummy dirents to simulate the "." and ".." entries of the directory
- * in a hfs filesystem. HFS doesn't provide these on disk. Note that
- * the size of these entries is the smallest needed to represent them
- * (only 12 byte each).
- */
-static hfsdotentry rootdots[2] = {
- {
- 1, /* d_fileno */
- sizeof(struct hfsdotentry), /* d_reclen */
- DT_DIR, /* d_type */
- 1, /* d_namlen */
- "." /* d_name */
- },
- {
- 1, /* d_fileno */
- sizeof(struct hfsdotentry), /* d_reclen */
- DT_DIR, /* d_type */
- 2, /* d_namlen */
- ".." /* d_name */
- }
+/* structures to hold a "." or ".." directory entry */
+struct hfs_stddotentry {
+ u_int32_t d_fileno; /* unique file number */
+ u_int16_t d_reclen; /* length of this structure */
+ u_int8_t d_type; /* dirent file type */
+ u_int8_t d_namlen; /* len of filename */
+ char d_name[4]; /* "." or ".." */
};
-/* 4.3 Note:
-* There is some confusion as to what the semantics of uio_offset are.
-* In ufs, it represents the actual byte offset within the directory
-* "file." HFS, however, just uses it as an entry counter - essentially
-* assuming that it has no meaning except to the hfs_readdir function.
-* This approach would be more efficient here, but some callers may
-* assume the uio_offset acts like a byte offset. NFS in fact
-* monkeys around with the offset field a lot between readdir calls.
-*
-* The use of the resid uiop->uio_resid and uiop->uio_iov->iov_len
-* fields is a mess as well. The libc function readdir() returns
-* NULL (indicating the end of a directory) when either
-* the getdirentries() syscall (which calls this and returns
-* the size of the buffer passed in less the value of uiop->uio_resid)
-* returns 0, or a direct record with a d_reclen of zero.
-* nfs_server.c:rfs_readdir(), on the other hand, checks for the end
-* of the directory by testing uiop->uio_resid == 0. The solution
-* is to pad the size of the last struct direct in a given
-* block to fill the block if we are not at the end of the directory.
-*/
+struct hfs_extdotentry {
+ u_int64_t d_fileno; /* unique file number */
+ u_int64_t d_seekoff; /* seek offset (optional, used by servers) */
+ u_int16_t d_reclen; /* length of this structure */
+ u_int16_t d_namlen; /* len of filename */
+ u_int8_t d_type; /* dirent file type */
+ u_char d_name[3]; /* "." or ".." */
+};
+typedef union {
+ struct hfs_stddotentry std;
+ struct hfs_extdotentry ext;
+} hfs_dotentry_t;
/*
- * NOTE: We require a minimal buffer size of DIRBLKSIZ for two reasons. One, it is the same value
- * returned be stat() call as the block size. This is mentioned in the man page for getdirentries():
- * "Nbytes must be greater than or equal to the block size associated with the file,
- * see stat(2)". Might as well settle on the same size of ufs. Second, this makes sure there is enough
- * room for the . and .. entries that have to added manually.
+ * hfs_vnop_readdir reads directory entries into the buffer pointed
+ * to by uio, in a filesystem independent format. Up to uio_resid
+ * bytes of data can be transferred. The data in the buffer is a
+ * series of packed dirent structures where each one contains the
+ * following entries:
+ *
+ * u_int32_t d_fileno; // file number of entry
+ * u_int16_t d_reclen; // length of this record
+ * u_int8_t d_type; // file type
+ * u_int8_t d_namlen; // length of string in d_name
+ * char d_name[MAXNAMELEN+1]; // null terminated file name
+ *
+ * The current position (uio_offset) refers to the next block of
+ * entries. The offset can only be set to a value previously
+ * returned by hfs_vnop_readdir or zero. This offset does not have
+ * to match the number of bytes returned (in uio_resid).
+ *
+ * In fact, the offset used by HFS is essentially an index (26 bits)
+ * with a tag (6 bits). The tag is for associating the next request
+ * with the current request. This enables us to have multiple threads
+ * reading the directory while the directory is also being modified.
+ *
+ * Each tag/index pair is tied to a unique directory hint. The hint
+ * contains information (filename) needed to build the catalog b-tree
+ * key for finding the next set of entries.
*/
-
-/*
-#% readdir vp L L L
-#
-vop_readdir {
- IN struct vnode *vp;
- INOUT struct uio *uio;
- IN struct ucred *cred;
- INOUT int *eofflag;
- OUT int *ncookies;
- INOUT u_long **cookies;
- */
static int
-hfs_readdir(ap)
- struct vop_readdir_args /* {
- struct vnode *vp;
- struct uio *uio;
- struct ucred *cred;
- int *eofflag;
- int *ncookies;
- u_long **cookies;
+hfs_vnop_readdir(ap)
+ struct vnop_readdir_args /* {
+ vnode_t a_vp;
+ uio_t a_uio;
+ int a_flags;
+ int *a_eofflag;
+ int *a_numdirent;
+ vfs_context_t a_context;
} */ *ap;
{
- register struct uio *uio = ap->a_uio;
- struct cnode *cp = VTOC(ap->a_vp);
- struct hfsmount *hfsmp = VTOHFS(ap->a_vp);
- struct proc *p = current_proc();
- off_t off = uio->uio_offset;
- int retval = 0;
+ struct vnode *vp = ap->a_vp;
+ uio_t uio = ap->a_uio;
+ struct cnode *cp;
+ struct hfsmount *hfsmp;
+ directoryhint_t *dirhint = NULL;
+ directoryhint_t localhint;
+ off_t offset;
+ off_t startoffset;
+ int error = 0;
int eofflag = 0;
- void *user_start = NULL;
- int user_len;
+ user_addr_t user_start = 0;
+ user_size_t user_len = 0;
+ int index;
+ unsigned int tag;
+ int items;
+ 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))) {
+ return (EINVAL);
+ }
+ /* 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);
- int ncookies=0;
- u_long *cookies=NULL;
- u_long *cookiep=NULL;
-
- /* We assume it's all one big buffer... */
- if (uio->uio_iovcnt > 1 || uio->uio_resid < AVERAGE_HFSDIRENTRY_SIZE)
- return EINVAL;
+ /* Pick up cnid hint (if any). */
+ if (nfs_cookies) {
+ cnid_hint = (cnid_t)(uio_offset(uio) >> 32);
+ uio_setoffset(uio, uio_offset(uio) & 0x00000000ffffffffLL);
+ if (cnid_hint == INT_MAX) { /* searching pass the last item */
+ eofflag = 1;
+ goto out;
+ }
+ }
+ /*
+ * Synthesize entries for "." and ".."
+ */
+ if (offset == 0) {
+ hfs_dotentry_t dotentry[2];
+ size_t uiosize;
+
+ if (extended) {
+ struct hfs_extdotentry *entry = &dotentry[0].ext;
+
+ entry->d_fileno = cp->c_cnid;
+ entry->d_reclen = sizeof(struct hfs_extdotentry);
+ entry->d_type = DT_DIR;
+ entry->d_namlen = 1;
+ entry->d_name[0] = '.';
+ entry->d_name[1] = '\0';
+ entry->d_name[2] = '\0';
+ entry->d_seekoff = 1;
+
+ ++entry;
+ entry->d_fileno = cp->c_parentcnid;
+ entry->d_reclen = sizeof(struct hfs_extdotentry);
+ entry->d_type = DT_DIR;
+ entry->d_namlen = 2;
+ entry->d_name[0] = '.';
+ entry->d_name[1] = '.';
+ entry->d_name[2] = '\0';
+ entry->d_seekoff = 2;
+ uiosize = 2 * sizeof(struct hfs_extdotentry);
+ } else {
+ struct hfs_stddotentry *entry = &dotentry[0].std;
+
+ entry->d_fileno = cp->c_cnid;
+ entry->d_reclen = sizeof(struct hfs_stddotentry);
+ entry->d_type = DT_DIR;
+ entry->d_namlen = 1;
+ *(int *)&entry->d_name[0] = 0;
+ entry->d_name[0] = '.';
+
+ ++entry;
+ entry->d_fileno = cp->c_parentcnid;
+ entry->d_reclen = sizeof(struct hfs_stddotentry);
+ entry->d_type = DT_DIR;
+ entry->d_namlen = 2;
+ *(int *)&entry->d_name[0] = 0;
+ entry->d_name[0] = '.';
+ entry->d_name[1] = '.';
+ uiosize = 2 * sizeof(struct hfs_stddotentry);
+ }
+ if ((error = uiomove((caddr_t)&dotentry, uiosize, uio))) {
+ goto out;
+ }
+ offset += 2;
+ }
- // XXXdbg
+ /* If there are no real entries then we're done. */
+ if (cp->c_entries == 0) {
+ error = 0;
+ eofflag = 1;
+ uio_setoffset(uio, offset);
+ goto seekoffcalc;
+ }
+
+ //
// We have to lock the user's buffer here so that we won't
// fault on it after we've acquired a shared lock on the
// catalog file. The issue is that you can get a 3-way
// currently (10/30/02) that can fault on user data with a
// shared lock on the catalog file.
//
- if (hfsmp->jnl && uio->uio_segflg == UIO_USERSPACE) {
- user_start = uio->uio_iov->iov_base;
- user_len = uio->uio_iov->iov_len;
+ if (hfsmp->jnl && uio_isuserspace(uio)) {
+ user_start = uio_curriovbase(uio);
+ user_len = uio_curriovlen(uio);
- if ((retval = vslock(user_start, user_len)) != 0) {
- return retval;
+ if ((error = vslock(user_start, user_len)) != 0) {
+ user_start = 0;
+ goto out;
}
}
-
- /* Create the entries for . and .. */
- if (uio->uio_offset < sizeof(rootdots)) {
- caddr_t dep;
- size_t dotsize;
-
- rootdots[0].d_fileno = cp->c_cnid;
- rootdots[1].d_fileno = cp->c_parentcnid;
-
- if (uio->uio_offset == 0) {
- dep = (caddr_t) &rootdots[0];
- dotsize = 2* sizeof(struct hfsdotentry);
- } else if (uio->uio_offset == sizeof(struct hfsdotentry)) {
- dep = (caddr_t) &rootdots[1];
- dotsize = sizeof(struct hfsdotentry);
- } else {
- retval = EINVAL;
- goto Exit;
+ /* Convert offset into a catalog directory index. */
+ index = (offset & HFS_INDEX_MASK) - 2;
+ tag = offset & ~HFS_INDEX_MASK;
+
+ /* Lock catalog during cat_findname and cat_getdirentries. */
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
+
+ /* When called from NFS, try and resolve a cnid hint. */
+ if (nfs_cookies && cnid_hint != 0) {
+ if (cat_findname(hfsmp, cnid_hint, &localhint.dh_desc) == 0) {
+ if ( localhint.dh_desc.cd_parentcnid == cp->c_cnid) {
+ localhint.dh_index = index - 1;
+ localhint.dh_time = 0;
+ bzero(&localhint.dh_link, sizeof(localhint.dh_link));
+ dirhint = &localhint; /* don't forget to release the descriptor */
+ } else {
+ cat_releasedesc(&localhint.dh_desc);
+ }
}
-
- retval = uiomove(dep, dotsize, uio);
- if (retval != 0)
- goto Exit;
}
- if (ap->a_ncookies != NULL) {
- /*
- * These cookies are handles that allow NFS to restart
- * scanning through a directory. If a directory is large
- * enough, NFS will issue a successive readdir() with a
- * uio->uio_offset that is equal to one of these cookies.
- *
- * The cookies that we generate are synthesized byte-offsets.
- * The offset is where the dirent the dirent would be if the
- * directory were an array of packed dirent structs. It is
- * synthetic because that's not how directories are stored in
- * HFS but other code expects that the cookie is a byte offset.
- *
- * We have to pre-allocate the cookies because cat_getdirentries()
- * is the only one that can properly synthesize the offsets (since
- * it may have to skip over entries and only it knows the true
- * virtual offset of any particular directory entry). So we allocate
- * a cookie table here and pass it in to cat_getdirentries().
- *
- * Note that the handling of "." and ".." is mostly done here but
- * cat_getdirentries() is aware of.
- *
- * Only the NFS server uses cookies so fortunately this code is
- * not executed unless the NFS server is issuing the readdir
- * request.
- *
- * Also note that the NFS server is the one responsible for
- * free'ing the cookies even though we allocated them. Ick.
- *
- * We allocate a reasonable number of entries for the size of
- * the buffer that we're going to fill in. cat_getdirentries()
- * is smart enough to not overflow if there's more room in the
- * buffer but not enough room in the cookie table.
- */
- if (uio->uio_segflg != UIO_SYSSPACE)
- panic("hfs_readdir: unexpected uio from NFS server");
-
- ncookies = uio->uio_iov->iov_len / (AVERAGE_HFSDIRENTRY_SIZE/2);
- MALLOC(cookies, u_long *, ncookies * sizeof(u_long), M_TEMP, M_WAITOK);
+ /* Get a directory hint (cnode must be locked exclusive) */
+ if (dirhint == NULL) {
+ dirhint = hfs_getdirhint(cp, ((index - 1) & HFS_INDEX_MASK) | tag);
- *ap->a_ncookies = ncookies;
- *ap->a_cookies = cookies;
+ /* Hide tag from catalog layer. */
+ dirhint->dh_index &= HFS_INDEX_MASK;
+ if (dirhint->dh_index == HFS_INDEX_MASK) {
+ dirhint->dh_index = -1;
+ }
}
+
+ /* Pack the buffer with dirent entries. */
+ error = cat_getdirentries(hfsmp, cp->c_entries, dirhint, uio, extended, &items, &eofflag);
- /* If there are no children then we're done */
- if (cp->c_entries == 0) {
+ hfs_systemfile_unlock(hfsmp, lockflags);
+
+ if (error != 0) {
+ goto out;
+ }
+
+ /* Get index to the next item */
+ index += items;
+
+ if (items >= (int)cp->c_entries) {
eofflag = 1;
- retval = 0;
- if (cookies) {
- cookies[0] = 0;
- cookies[1] = sizeof(struct hfsdotentry);
- }
- goto Exit;
}
- /* Lock catalog b-tree */
- retval = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_SHARED, p);
- if (retval) goto Exit;
-
- retval = cat_getdirentries(hfsmp, &cp->c_desc, cp->c_entries, uio, &eofflag, cookies, ncookies);
+ /* Convert catalog directory index back into an offset. */
+ while (tag == 0)
+ tag = (++cp->c_dirhinttag) << HFS_INDEX_BITS;
+ uio_setoffset(uio, (index + 2) | tag);
+ dirhint->dh_index |= tag;
- /* Unlock catalog b-tree */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
+seekoffcalc:
+ cp->c_touch_acctime = TRUE;
- if (retval != E_NONE) {
- goto Exit;
+ if (ap->a_numdirent) {
+ if (startoffset == 0)
+ items += 2;
+ *ap->a_numdirent = items;
}
-
- /* were we already past eof ? */
- if (uio->uio_offset == off) {
- retval = E_NONE;
- goto Exit;
- }
-
- cp->c_flag |= C_ACCESS;
-Exit:;
+out:
if (hfsmp->jnl && user_start) {
vsunlock(user_start, user_len, TRUE);
}
-
- if (ap->a_eofflag)
+ /* If we didn't do anything then go ahead and dump the hint. */
+ if ((dirhint != NULL) &&
+ (dirhint != &localhint) &&
+ (uio_offset(uio) == startoffset)) {
+ hfs_reldirhint(cp, dirhint);
+ eofflag = 1;
+ }
+ if (ap->a_eofflag) {
*ap->a_eofflag = eofflag;
-
- return (retval);
+ }
+ if (dirhint == &localhint) {
+ cat_releasedesc(&localhint.dh_desc);
+ }
+ hfs_unlock(cp);
+ return (error);
}
/*
- * Return target name of a symbolic link
-#% readlink vp L L L
-#
- vop_readlink {
- IN struct vnode *vp;
- INOUT struct uio *uio;
- IN struct ucred *cred;
- */
-
+ * Read contents of a symbolic link.
+ */
static int
-hfs_readlink(ap)
- struct vop_readlink_args /* {
+hfs_vnop_readlink(ap)
+ struct vnop_readlink_args /* {
struct vnode *a_vp;
struct uio *a_uio;
- struct ucred *a_cred;
+ vfs_context_t a_context;
} */ *ap;
{
- int retval;
struct vnode *vp = ap->a_vp;
struct cnode *cp;
struct filefork *fp;
+ int error;
- if (vp->v_type != VLNK)
+ if (!vnode_islnk(vp))
return (EINVAL);
+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
+ return (error);
cp = VTOC(vp);
fp = VTOF(vp);
/* Zero length sym links are not allowed */
if (fp->ff_size == 0 || fp->ff_size > MAXPATHLEN) {
VTOVCB(vp)->vcbFlags |= kHFS_DamagedVolume;
- return (EINVAL);
+ error = EINVAL;
+ goto exit;
}
/* Cache the path so we don't waste buffer cache resources */
- if (fp->ff_symlinkptr == NULL) {
- struct buf *bp = NULL;
-
- MALLOC(fp->ff_symlinkptr, char *, fp->ff_size, M_TEMP, M_WAITOK);
- retval = meta_bread(vp, 0,
- roundup((int)fp->ff_size,
- VTOHFS(vp)->hfs_phys_block_size),
- ap->a_cred, &bp);
- if (retval) {
- if (bp)
- brelse(bp);
- if (fp->ff_symlinkptr) {
- FREE(fp->ff_symlinkptr, M_TEMP);
- fp->ff_symlinkptr = NULL;
- }
- return (retval);
- }
- bcopy(bp->b_data, fp->ff_symlinkptr, (size_t)fp->ff_size);
- if (bp) {
- if (VTOHFS(vp)->jnl && (bp->b_flags & B_LOCKED) == 0) {
- bp->b_flags |= B_INVAL; /* data no longer needed */
- }
- brelse(bp);
- }
- }
- retval = uiomove((caddr_t)fp->ff_symlinkptr, (int)fp->ff_size, ap->a_uio);
-#if 1
- /*
- * Keep track blocks read
- */
- if ((VTOHFS(vp)->hfc_stage == HFC_RECORDING) && (retval == 0)) {
-
- /*
- * If this file hasn't been seen since the start of
- * the current sampling period then start over.
- */
- if (cp->c_atime < VTOHFS(vp)->hfc_timebase)
- VTOF(vp)->ff_bytesread = fp->ff_size;
- else
- VTOF(vp)->ff_bytesread += fp->ff_size;
-
- // if (VTOF(vp)->ff_bytesread > fp->ff_size)
- // cp->c_flag |= C_ACCESS;
- }
-#endif
- return (retval);
-}
-
-/*
- * Lock an cnode. If its already locked, set the WANT bit and sleep.
-#% lock vp U L U
-#
- vop_lock {
- IN struct vnode *vp;
- IN int flags;
- IN struct proc *p;
- */
-
-static int
-hfs_lock(ap)
- struct vop_lock_args /* {
- struct vnode *a_vp;
- int a_flags;
- struct proc *a_p;
- } */ *ap;
-{
- struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
-
- return (lockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, ap->a_p));
-}
-
-/*
- * Unlock an cnode.
-#% unlock vp L U L
-#
- vop_unlock {
- IN struct vnode *vp;
- IN int flags;
- IN struct proc *p;
-
- */
-static int
-hfs_unlock(ap)
- struct vop_unlock_args /* {
- struct vnode *a_vp;
- int a_flags;
- struct proc *a_p;
- } */ *ap;
-{
- struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
-#if 0
- if (!lockstatus(&cp->c_lock)) {
- printf("hfs_unlock: vnode %s wasn't locked!\n",
- cp->c_desc.cd_nameptr ? cp->c_desc.cd_nameptr : "");
- }
-#endif
- return (lockmgr(&cp->c_lock, ap->a_flags | LK_RELEASE,
- &vp->v_interlock, ap->a_p));
-}
-
-
-/*
- * Print out the contents of a cnode.
-#% print vp = = =
-#
- vop_print {
- IN struct vnode *vp;
- */
-static int
-hfs_print(ap)
- struct vop_print_args /* {
- struct vnode *a_vp;
- } */ *ap;
-{
- struct vnode * vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
+ if (fp->ff_symlinkptr == NULL) {
+ struct buf *bp = NULL;
- printf("tag VT_HFS, cnid %d, on dev %d, %d", cp->c_cnid,
- major(cp->c_dev), minor(cp->c_dev));
-#if FIFO
- if (vp->v_type == VFIFO)
- fifo_printinfo(vp);
-#endif /* FIFO */
- lockmgr_printinfo(&cp->c_lock);
- printf("\n");
- return (0);
-}
+ MALLOC(fp->ff_symlinkptr, char *, fp->ff_size, M_TEMP, M_WAITOK);
+ error = (int)buf_meta_bread(vp, (daddr64_t)0,
+ roundup((int)fp->ff_size,
+ VTOHFS(vp)->hfs_phys_block_size),
+ vfs_context_ucred(ap->a_context), &bp);
+ if (error) {
+ if (bp)
+ buf_brelse(bp);
+ if (fp->ff_symlinkptr) {
+ FREE(fp->ff_symlinkptr, M_TEMP);
+ fp->ff_symlinkptr = NULL;
+ }
+ goto exit;
+ }
+ bcopy((char *)buf_dataptr(bp), fp->ff_symlinkptr, (size_t)fp->ff_size);
+ if (VTOHFS(vp)->jnl && (buf_flags(bp) & B_LOCKED) == 0) {
+ buf_markinvalid(bp); /* data no longer needed */
+ }
+ buf_brelse(bp);
+ }
+ error = uiomove((caddr_t)fp->ff_symlinkptr, (int)fp->ff_size, ap->a_uio);
-/*
- * Check for a locked cnode.
-#% islocked vp = = =
-#
- vop_islocked {
- IN struct vnode *vp;
+ /*
+ * Keep track blocks read
+ */
+ if ((VTOHFS(vp)->hfc_stage == HFC_RECORDING) && (error == 0)) {
+
+ /*
+ * If this file hasn't been seen since the start of
+ * the current sampling period then start over.
+ */
+ if (cp->c_atime < VTOHFS(vp)->hfc_timebase)
+ VTOF(vp)->ff_bytesread = fp->ff_size;
+ else
+ VTOF(vp)->ff_bytesread += fp->ff_size;
+
+ // if (VTOF(vp)->ff_bytesread > fp->ff_size)
+ // cp->c_touch_acctime = TRUE;
+ }
- */
-static int
-hfs_islocked(ap)
- struct vop_islocked_args /* {
- struct vnode *a_vp;
- } */ *ap;
-{
- return (lockstatus(&VTOC(ap->a_vp)->c_lock));
+exit:
+ hfs_unlock(cp);
+ return (error);
}
-/*
-
-#% pathconf vp L L L
-#
- vop_pathconf {
- IN struct vnode *vp;
- IN int name;
- OUT register_t *retval;
- */
+/*
+ * Get configurable pathname variables.
+ */
static int
-hfs_pathconf(ap)
- struct vop_pathconf_args /* {
+hfs_vnop_pathconf(ap)
+ struct vnop_pathconf_args /* {
struct vnode *a_vp;
int a_name;
int *a_retval;
+ vfs_context_t a_context;
} */ *ap;
{
- int retval = 0;
-
switch (ap->a_name) {
case _PC_LINK_MAX:
- if (VTOVCB(ap->a_vp)->vcbSigWord == kHFSPlusSigWord)
- *ap->a_retval = HFS_LINK_MAX;
- else
+ if (VTOHFS(ap->a_vp)->hfs_flags & HFS_STANDARD)
*ap->a_retval = 1;
+ else
+ *ap->a_retval = HFS_LINK_MAX;
break;
case _PC_NAME_MAX:
- *ap->a_retval = kHFSPlusMaxFileNameBytes; /* max # of characters x max utf8 representation */
+ if (VTOHFS(ap->a_vp)->hfs_flags & HFS_STANDARD)
+ *ap->a_retval = kHFSMaxFileNameChars; /* 255 */
+ else
+ *ap->a_retval = kHFSPlusMaxFileNameChars; /* 31 */
break;
case _PC_PATH_MAX:
- *ap->a_retval = PATH_MAX; /* 1024 */
+ *ap->a_retval = PATH_MAX; /* 1024 */
break;
case _PC_PIPE_BUF:
*ap->a_retval = PIPE_BUF;
*ap->a_retval = 1;
break;
default:
- retval = EINVAL;
- }
-
- return (retval);
-}
-
-
-/*
- * Advisory record locking support
-#% advlock vp U U U
-#
- vop_advlock {
- IN struct vnode *vp;
- IN caddr_t id;
- IN int op;
- IN struct flock *fl;
- IN int flags;
-
- */
-static int
-hfs_advlock(ap)
- struct vop_advlock_args /* {
- struct vnode *a_vp;
- caddr_t a_id;
- int a_op;
- struct flock *a_fl;
- int a_flags;
- } */ *ap;
-{
- struct vnode *vp = ap->a_vp;
- struct flock *fl = ap->a_fl;
- struct hfslockf *lock;
- struct filefork *fork;
- off_t start, end;
- int retval;
-
- /* Only regular files can have locks */
- if (vp->v_type != VREG)
- return (EISDIR);
-
- fork = VTOF(ap->a_vp);
- /*
- * Avoid the common case of unlocking when cnode has no locks.
- */
- if (fork->ff_lockf == (struct hfslockf *)0) {
- if (ap->a_op != F_SETLK) {
- fl->l_type = F_UNLCK;
- return (0);
- }
- }
- /*
- * Convert the flock structure into a start and end.
- */
- start = 0;
- switch (fl->l_whence) {
- case SEEK_SET:
- case SEEK_CUR:
- /*
- * Caller is responsible for adding any necessary offset
- * when SEEK_CUR is used.
- */
- start = fl->l_start;
- break;
- case SEEK_END:
- start = fork->ff_size + fl->l_start;
- break;
- default:
- return (EINVAL);
- }
-
- if (fl->l_len == 0)
- end = -1;
- else if (fl->l_len > 0)
- end = start + fl->l_len - 1;
- else { /* l_len is negative */
- end = start - 1;
- start += fl->l_len;
- }
- if (start < 0)
return (EINVAL);
-
- /*
- * Create the hfslockf structure
- */
- MALLOC(lock, struct hfslockf *, sizeof *lock, M_LOCKF, M_WAITOK);
- lock->lf_start = start;
- lock->lf_end = end;
- lock->lf_id = ap->a_id;
- lock->lf_fork = fork;
- lock->lf_type = fl->l_type;
- lock->lf_next = (struct hfslockf *)0;
- TAILQ_INIT(&lock->lf_blkhd);
- lock->lf_flags = ap->a_flags;
- /*
- * Do the requested operation.
- */
- switch(ap->a_op) {
- case F_SETLK:
- retval = hfs_setlock(lock);
- break;
- case F_UNLCK:
- retval = hfs_clearlock(lock);
- FREE(lock, M_LOCKF);
- break;
- case F_GETLK:
- retval = hfs_getlock(lock, fl);
- FREE(lock, M_LOCKF);
- break;
- default:
- retval = EINVAL;
- _FREE(lock, M_LOCKF);
- break;
}
- return (retval);
+ return (0);
}
-
/*
- * Update the access, modified, and node change times as specified
- * by the C_ACCESS, C_UPDATE, and C_CHANGE flags respectively. The
- * C_MODIFIED flag is used to specify that the node needs to be
- * updated but that the times have already been set. The access and
- * modified times are input parameters but the node change time is
- * always taken from the current time. If waitfor is set, then wait
- * for the disk write of the node to complete.
+ * Update a cnode's on-disk metadata.
+ *
+ * If waitfor is set, then wait for the disk write of
+ * the node to complete.
+ *
+ * The cnode must be locked exclusive
*/
-/*
-#% update vp L L L
- IN struct vnode *vp;
- IN struct timeval *access;
- IN struct timeval *modify;
- IN int waitfor;
-*/
-static int
-hfs_update(ap)
- struct vop_update_args /* {
- struct vnode *a_vp;
- struct timeval *a_access;
- struct timeval *a_modify;
- int a_waitfor;
- } */ *ap;
+__private_extern__
+int
+hfs_update(struct vnode *vp, __unused int waitfor)
{
- struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(ap->a_vp);
+ struct cnode *cp = VTOC(vp);
struct proc *p;
struct cat_fork *dataforkp = NULL;
struct cat_fork *rsrcforkp = NULL;
struct cat_fork datafork;
- int updateflag;
struct hfsmount *hfsmp;
+ int lockflags;
int error;
+ p = current_proc();
hfsmp = VTOHFS(vp);
- /* XXX do we really want to clear the sytem cnode flags here???? */
- if (((vp->v_flag & VSYSTEM) && (cp->c_cnid < kHFSFirstUserCatalogNodeID))||
- (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY) ||
- (cp->c_mode == 0)) {
- cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_MODIFIED | C_UPDATE);
+ if (vnode_issystem(vp) && (cp->c_cnid < kHFSFirstUserCatalogNodeID)) {
+ return (0);
+ }
+ if ((hfsmp->hfs_flags & HFS_READ_ONLY) || (cp->c_mode == 0)) {
+ cp->c_flag &= ~C_MODIFIED;
+ cp->c_touch_acctime = 0;
+ cp->c_touch_chgtime = 0;
+ cp->c_touch_modtime = 0;
return (0);
}
- updateflag = cp->c_flag & (C_ACCESS | C_CHANGE | C_MODIFIED | C_UPDATE | C_FORCEUPDATE);
+ hfs_touchtimes(hfsmp, cp);
/* Nothing to update. */
- if (updateflag == 0) {
- return (0);
- }
- /* HFS standard doesn't have access times. */
- if ((updateflag == C_ACCESS) && (VTOVCB(vp)->vcbSigWord == kHFSSigWord)) {
+ if ((cp->c_flag & (C_MODIFIED | C_FORCEUPDATE)) == 0) {
return (0);
}
- if (updateflag & C_ACCESS) {
- /*
- * When the access time is the only thing changing
- * then make sure its sufficiently newer before
- * committing it to disk.
- */
- if ((updateflag == C_ACCESS) &&
- (ap->a_access->tv_sec < (cp->c_atime + ATIME_ONDISK_ACCURACY))) {
- return (0);
- }
- cp->c_atime = ap->a_access->tv_sec;
- }
- if (updateflag & C_UPDATE) {
- cp->c_mtime = ap->a_modify->tv_sec;
- cp->c_mtime_nsec = ap->a_modify->tv_usec * 1000;
- }
- if (updateflag & C_CHANGE) {
- cp->c_ctime = time.tv_sec;
- /*
- * HFS dates that WE set must be adjusted for DST
- */
- if ((VTOVCB(vp)->vcbSigWord == kHFSSigWord) && gTimeZone.tz_dsttime) {
- cp->c_ctime += 3600;
- cp->c_mtime = cp->c_ctime;
- }
- }
if (cp->c_datafork)
dataforkp = &cp->c_datafork->ff_data;
if (cp->c_rsrcfork)
rsrcforkp = &cp->c_rsrcfork->ff_data;
- p = current_proc();
-
/*
* For delayed allocations updates are
* postponed until an fsync or the file
* we have to do the update.
*/
if (ISSET(cp->c_flag, C_FORCEUPDATE) == 0 &&
- (ISSET(cp->c_flag, C_DELETED) ||
+ (ISSET(cp->c_flag, C_DELETED) ||
(dataforkp && cp->c_datafork->ff_unallocblocks) ||
(rsrcforkp && cp->c_rsrcfork->ff_unallocblocks))) {
- if (updateflag & (C_CHANGE | C_UPDATE))
- hfs_volupdate(hfsmp, VOL_UPDATE, 0);
- cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_UPDATE);
+ // cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_UPDATE);
cp->c_flag |= C_MODIFIED;
HFS_KNOTE(vp, NOTE_ATTRIB);
return (0);
}
-
- // XXXdbg
- hfs_global_shared_lock_acquire(hfsmp);
- if (hfsmp->jnl) {
- if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
- hfs_global_shared_lock_release(hfsmp);
- return error;
- }
+ if ((error = hfs_start_transaction(hfsmp)) != 0) {
+ return error;
}
-
/*
* For files with invalid ranges (holes) the on-disk
* A shared lock is sufficient since an update doesn't change
* the tree and the lock on vp protects the cnode.
*/
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_SHARED, p);
- if (error) {
- if (hfsmp->jnl) {
- journal_end_transaction(hfsmp->jnl);
- }
- hfs_global_shared_lock_release(hfsmp);
- return (error);
- }
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
/* XXX - waitfor is not enforced */
error = cat_update(hfsmp, &cp->c_desc, &cp->c_attr, dataforkp, rsrcforkp);
- /* Unlock the Catalog b-tree file. */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
-
- if (updateflag & (C_CHANGE | C_UPDATE | C_FORCEUPDATE))
- hfs_volupdate(hfsmp, VOL_UPDATE, 0);
+ hfs_systemfile_unlock(hfsmp, lockflags);
/* After the updates are finished, clear the flags */
- cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_MODIFIED | C_UPDATE | C_FORCEUPDATE);
+ cp->c_flag &= ~(C_MODIFIED | C_FORCEUPDATE);
- // XXXdbg
- if (hfsmp->jnl) {
- journal_end_transaction(hfsmp->jnl);
- }
- hfs_global_shared_lock_release(hfsmp);
+ hfs_end_transaction(hfsmp);
HFS_KNOTE(vp, NOTE_ATTRIB);
/*
* Allocate a new node
- *
- * Upon leaving, namei buffer must be freed.
- *
*/
static int
-hfs_makenode(mode, dvp, vpp, cnp)
- int mode;
- struct vnode *dvp;
- struct vnode **vpp;
- struct componentname *cnp;
+hfs_makenode(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
+ struct vnode_attr *vap, vfs_context_t ctx)
{
- struct cnode *cp;
+ struct cnode *cp = NULL;
struct cnode *dcp;
struct vnode *tvp;
struct hfsmount *hfsmp;
- struct timeval tv;
- struct proc *p;
struct cat_desc in_desc, out_desc;
struct cat_attr attr;
- cat_cookie_t cookie = {0};
- int error, started_tr = 0, grabbed_lock = 0;
+ struct timeval tv;
+ cat_cookie_t cookie;
+ int lockflags;
+ int error, started_tr = 0, got_cookie = 0;
enum vtype vnodetype;
+ int mode;
- p = cnp->cn_proc;
+ if ((error = hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK)))
+ return (error);
dcp = VTOC(dvp);
hfsmp = VTOHFS(dvp);
*vpp = NULL;
tvp = NULL;
- bzero(&out_desc, sizeof(out_desc));
+ out_desc.cd_flags = 0;
+ out_desc.cd_nameptr = NULL;
+
+ mode = MAKEIMODE(vap->va_type, vap->va_mode);
if ((mode & S_IFMT) == 0)
mode |= S_IFREG;
vnodetype = IFTOVT(mode);
- /* Check if unmount in progress */
- if (VTOVFS(dvp)->mnt_kern_flag & MNTK_UNMOUNT) {
- error = EPERM;
- goto exit;
- }
/* Check if were out of usable disk space. */
- if ((suser(cnp->cn_cred, NULL) != 0) && (hfs_freeblks(hfsmp, 1) <= 0)) {
+ if ((hfs_freeblks(hfsmp, 1) <= 0) && (suser(vfs_context_ucred(ctx), NULL) != 0)) {
error = ENOSPC;
goto exit;
}
+ microtime(&tv);
+
/* Setup the default attributes */
bzero(&attr, sizeof(attr));
attr.ca_mode = mode;
attr.ca_nlink = vnodetype == VDIR ? 2 : 1;
- attr.ca_mtime = time.tv_sec;
- attr.ca_mtime_nsec = time.tv_usec * 1000;
+ attr.ca_mtime = tv.tv_sec;
if ((VTOVCB(dvp)->vcbSigWord == kHFSSigWord) && gTimeZone.tz_dsttime) {
attr.ca_mtime += 3600; /* Same as what hfs_update does */
}
attr.ca_atime = attr.ca_ctime = attr.ca_itime = attr.ca_mtime;
- if (VTOVFS(dvp)->mnt_flag & MNT_UNKNOWNPERMISSIONS) {
- attr.ca_uid = hfsmp->hfs_uid;
- attr.ca_gid = hfsmp->hfs_gid;
- } else {
- if (vnodetype == VLNK)
- attr.ca_uid = dcp->c_uid;
- else
- attr.ca_uid = cnp->cn_cred->cr_uid;
- attr.ca_gid = dcp->c_gid;
- }
- /*
- * Don't tag as a special file (BLK or CHR) until *after*
- * hfs_getnewvnode is called. This insures that any
- * alias checking is defered until hfs_mknod completes.
- */
- if (vnodetype == VBLK || vnodetype == VCHR)
- attr.ca_mode = (attr.ca_mode & ~S_IFMT) | S_IFREG;
+ attr.ca_atimeondisk = attr.ca_atime;
+ /* On HFS+ the ThreadExists flag must always be set for files. */
+ if (vnodetype != VDIR && (hfsmp->hfs_flags & HFS_STANDARD) == 0)
+ attr.ca_recflags = kHFSThreadExistsMask;
+
+ 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);
/* Tag symlinks with a type and creator. */
if (vnodetype == VLNK) {
fip->fdType = SWAP_BE32(kSymLinkFileType);
fip->fdCreator = SWAP_BE32(kSymLinkCreator);
}
- if ((attr.ca_mode & S_ISGID) &&
- !groupmember(dcp->c_gid, cnp->cn_cred) &&
- suser(cnp->cn_cred, NULL)) {
- attr.ca_mode &= ~S_ISGID;
- }
if (cnp->cn_flags & ISWHITEOUT)
attr.ca_flags |= UF_OPAQUE;
/* Setup the descriptor */
- bzero(&in_desc, sizeof(in_desc));
in_desc.cd_nameptr = cnp->cn_nameptr;
in_desc.cd_namelen = cnp->cn_namelen;
in_desc.cd_parentcnid = dcp->c_cnid;
in_desc.cd_flags = S_ISDIR(mode) ? CD_ISDIR : 0;
+ in_desc.cd_hint = dcp->c_childhint;
+ in_desc.cd_encoding = 0;
- // XXXdbg
- hfs_global_shared_lock_acquire(hfsmp);
- grabbed_lock = 1;
- if (hfsmp->jnl) {
- if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
- goto exit;
- }
- started_tr = 1;
+ if ((error = hfs_start_transaction(hfsmp)) != 0) {
+ goto exit;
}
+ started_tr = 1;
/*
* Reserve some space in the Catalog file.
* request can cause an hfs_inactive call to
* delete an unlinked file)
*/
- if ((error = cat_preflight(hfsmp, CAT_CREATE | CAT_DELETE, &cookie, p))) {
+ if ((error = cat_preflight(hfsmp, CAT_CREATE | CAT_DELETE, &cookie, 0))) {
goto exit;
}
+ got_cookie = 1;
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(VTOHFS(dvp), kHFSCatalogFileID, LK_EXCLUSIVE, p);
- if (error)
- goto exit;
-
+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
error = cat_create(hfsmp, &in_desc, &attr, &out_desc);
-
- /* Unlock catalog b-tree */
- (void) hfs_metafilelocking(VTOHFS(dvp), kHFSCatalogFileID, LK_RELEASE, p);
+ if (error == 0) {
+ /* Update the parent directory */
+ dcp->c_childhint = out_desc.cd_hint; /* Cache directory's location */
+ dcp->c_nlink++;
+ dcp->c_entries++;
+ 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);
+ }
+ hfs_systemfile_unlock(hfsmp, lockflags);
if (error)
goto exit;
- /* Update the parent directory */
- dcp->c_childhint = out_desc.cd_hint; /* Cache directory's location */
- dcp->c_nlink++;
- dcp->c_entries++;
- dcp->c_flag |= C_CHANGE | C_UPDATE;
- tv = time;
- (void) VOP_UPDATE(dvp, &tv, &tv, 0);
+ /* Invalidate negative cache entries in the directory */
+ if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)
+ cache_purge_negatives(dvp);
+
if (vnodetype == VDIR) {
HFS_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
} else {
// deadlock with someone on that other file system (since we could be
// holding two transaction locks as well as various vnodes and we did
// not obtain the locks on them in the proper order).
- //
+ //
// NOTE: this means that if the quota check fails or we have to update
// the change time on a block-special device that those changes
// will happen as part of independent transactions.
//
if (started_tr) {
- journal_end_transaction(hfsmp->jnl);
- started_tr = 0;
- }
- if (grabbed_lock) {
- hfs_global_shared_lock_release(hfsmp);
- grabbed_lock = 0;
+ hfs_end_transaction(hfsmp);
+ started_tr = 0;
}
- /* Create a vnode for the object just created: */
- error = hfs_getnewvnode(hfsmp, NULL, &out_desc, 0, &attr, NULL, &tvp);
+ /*
+ * Create a vnode for the object just created.
+ *
+ * The cnode is locked on successful return.
+ */
+ error = hfs_getnewvnode(hfsmp, dvp, cnp, &out_desc, 0, &attr, NULL, &tvp);
if (error)
goto exit;
// XXXdbg
- cache_enter(dvp, tvp, cnp);
+ //cache_enter(dvp, tvp, cnp);
-#if QUOTA
cp = VTOC(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
*/
- if ((error = hfs_getinoquota(cp)) ||
- (error = hfs_chkiq(cp, 1, cnp->cn_cred, FORCE))) {
- if (tvp->v_type == VDIR)
- VOP_RMDIR(dvp,tvp, cnp);
- else
- VOP_REMOVE(dvp,tvp, cnp);
-
- // because VOP_RMDIR and VOP_REMOVE already
- // have done the vput()
- dvp = NULL;
- goto exit;
- }
-#endif /* QUOTA */
-
- /*
- * restore vtype and mode for VBLK and VCHR
- */
- if (vnodetype == VBLK || vnodetype == VCHR) {
- struct cnode *cp;
-
- cp = VTOC(tvp);
- cp->c_mode = mode;
- tvp->v_type = IFTOVT(mode);
- cp->c_flag |= C_CHANGE;
- tv = time;
- if ((error = VOP_UPDATE(tvp, &tv, &tv, 1))) {
- vput(tvp);
+ if (vfs_flags(HFSTOVFS(hfsmp)) & MNT_QUOTA) {
+ 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);
+ hfs_unlock_truncate(cp);
+ }
+ /*
+ * 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;
}
}
+#endif /* QUOTA */
+ /* Remember if any ACL data was set. */
+ if (VATTR_IS_ACTIVE(vap, va_acl) &&
+ (vap->va_acl != NULL)) {
+ cp->c_attr.ca_recflags |= kHFSHasSecurityMask;
+ cp->c_touch_chgtime = TRUE;
+ (void) hfs_update(tvp, TRUE);
+ }
*vpp = tvp;
exit:
cat_releasedesc(&out_desc);
- cat_postflight(hfsmp, &cookie, p);
-
- if ((cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) {
- char *tmp = cnp->cn_pnbuf;
- cnp->cn_pnbuf = NULL;
- cnp->cn_flags &= ~HASBUF;
- FREE_ZONE(tmp, cnp->cn_pnlen, M_NAMEI);
+ if (got_cookie) {
+ cat_postflight(hfsmp, &cookie, 0);
}
/*
* Check if a file is located in the "Cleanup At Startup"
(dcp->c_desc.cd_nameptr != NULL) &&
(strcmp(dcp->c_desc.cd_nameptr, CARBON_TEMP_DIR_NAME) == 0)) {
struct vnode *ddvp;
- cnid_t parid;
- parid = dcp->c_parentcnid;
- vput(dvp);
+ hfs_unlock(dcp);
dvp = NULL;
/*
* The parent of "Cleanup At Startup" should
* have the ASCII name of the userid.
*/
- if (VFS_VGET(HFSTOVFS(hfsmp), &parid, &ddvp) == 0) {
- if (VTOC(ddvp)->c_desc.cd_nameptr &&
- (cp->c_uid == strtoul(VTOC(ddvp)->c_desc.cd_nameptr, 0, 0))) {
- cp->c_flags |= UF_NODUMP;
- cp->c_flag |= C_CHANGE;
+ if (hfs_vget(hfsmp, dcp->c_parentcnid, &ddvp, 0) == 0) {
+ if (VTOC(ddvp)->c_desc.cd_nameptr) {
+ uid_t uid;
+
+ uid = strtoul(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;
+ }
}
- vput(ddvp);
+ hfs_unlock(VTOC(ddvp));
+ vnode_put(ddvp);
}
}
- if (dvp)
- vput(dvp);
-
- if (started_tr) {
- journal_end_transaction(hfsmp->jnl);
- started_tr = 0;
+ if (dvp) {
+ hfs_unlock(dcp);
}
- if (grabbed_lock) {
- hfs_global_shared_lock_release(hfsmp);
- grabbed_lock = 0;
+ if (error == 0 && cp != NULL) {
+ hfs_unlock(cp);
+ }
+ if (started_tr) {
+ hfs_end_transaction(hfsmp);
+ started_tr = 0;
}
return (error);
}
-static int
-hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp, struct vnode **rvpp, struct proc *p)
+/*
+ * WARNING - assumes caller has cnode lock.
+ */
+__private_extern__
+int
+hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp, struct vnode **rvpp, __unused struct proc *p)
{
struct vnode *rvp;
struct cnode *cp = VTOC(vp);
int error;
+ int vid;
if ((rvp = cp->c_rsrc_vp)) {
+ vid = vnode_vid(rvp);
+
/* Use exising vnode */
- error = vget(rvp, 0, p);
+ error = vnode_getwithvid(rvp, vid);
if (error) {
char * name = VTOC(vp)->c_desc.cd_nameptr;
}
} else {
struct cat_fork rsrcfork;
+ struct componentname cn;
+ int lockflags;
- /* Lock catalog b-tree */
- error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_SHARED, p);
- if (error)
- return (error);
+ /*
+ * Make sure cnode lock is exclusive, if not upgrade it.
+ *
+ * We assume that we were called from a read-only VNOP (getattr)
+ * and that its safe to have the cnode lock dropped and reacquired.
+ */
+ if (cp->c_lockowner != current_thread()) {
+ /*
+ * If the upgrade fails we loose the lock and
+ * have to take the exclusive lock on our own.
+ */
+ if (lck_rw_lock_shared_to_exclusive(&cp->c_rwlock) != 0)
+ lck_rw_lock_exclusive(&cp->c_rwlock);
+ cp->c_lockowner = current_thread();
+ }
+
+ 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);
+ (struct cat_attr *)0, &rsrcfork, NULL);
- /* Unlock the Catalog */
- (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
+ hfs_systemfile_unlock(hfsmp, lockflags);
if (error)
return (error);
- error = hfs_getnewvnode(hfsmp, cp, &cp->c_desc, 1, &cp->c_attr,
- &rsrcfork, &rvp);
+ /*
+ * Supply hfs_getnewvnode with a component name.
+ */
+ cn.cn_pnbuf = NULL;
+ if (cp->c_desc.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_context = NULL;
+ cn.cn_pnlen = MAXPATHLEN;
+ cn.cn_nameptr = cn.cn_pnbuf;
+ cn.cn_hash = 0;
+ cn.cn_consume = 0;
+ cn.cn_namelen = sprintf(cn.cn_nameptr, "%s%s", cp->c_desc.cd_nameptr, _PATH_RSRCFORKSPEC);
+ }
+ error = hfs_getnewvnode(hfsmp, vnode_parent(vp), cn.cn_pnbuf ? &cn : NULL,
+ &cp->c_desc, 2, &cp->c_attr, &rsrcfork, &rvp);
+ if (cn.cn_pnbuf)
+ FREE_ZONE(cn.cn_pnbuf, cn.cn_pnlen, M_NAMEI);
if (error)
return (error);
}
filt_hfsdetach(struct knote *kn)
{
struct vnode *vp;
- int result;
- struct proc *p = current_proc();
vp = (struct vnode *)kn->kn_hook;
- if (1) { /* ! KNDETACH_VNLOCKED */
- result = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
- if (result) return;
- };
+ if (vnode_getwithvid(vp, kn->kn_hookid))
+ return;
- result = KNOTE_DETACH(&VTOC(vp)->c_knotes, kn);
-
- if (1) { /* ! KNDETACH_VNLOCKED */
- VOP_UNLOCK(vp, 0, p);
- };
+ 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_fp->f_data;
+ 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
return (1);
}
- kn->kn_data = VTOF(vp)->ff_size - kn->kn_fp->f_offset;
+ /* poll(2) semantics dictate always saying there is data */
+ kn->kn_data = (!(kn->kn_flags & EV_POLL)) ?
+ VTOF(vp)->ff_size - kn->kn_fp->f_fglob->fg_offset : 1;
+
+ if (dropvp)
+ vnode_put(vp);
+
return (kn->kn_data != 0);
}
static int
filt_hfswrite(struct knote *kn, long hint)
{
+ int dropvp = 0;
+
+ if (hint == 0) {
+ if ((vnode_getwithvid(kn->kn_hook, kn->kn_hookid) != 0)) {
+ hint = NOTE_REVOKE;
+ } else
+ vnode_put(kn->kn_hook);
+ }
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);
}
filt_hfsvnode(struct knote *kn, long hint)
{
+ if (hint == 0) {
+ if ((vnode_getwithvid(kn->kn_hook, kn->kn_hookid) != 0)) {
+ hint = NOTE_REVOKE;
+ } else
+ vnode_put(kn->kn_hook);
+ }
if (kn->kn_sfflags & hint)
kn->kn_fflags |= hint;
- if (hint == NOTE_REVOKE) {
- kn->kn_flags |= EV_EOF;
+ if ((hint == NOTE_REVOKE)) {
+ kn->kn_flags |= (EV_EOF | EV_ONESHOT);
return (1);
}
+
return (kn->kn_fflags != 0);
}
{ 1, NULL, filt_hfsdetach, filt_hfsvnode };
/*
- #
- #% kqfilt_add vp L L L
- #
- vop_kqfilt_add
- IN struct vnode *vp;
- IN struct knote *kn;
- IN struct proc *p;
+ * Add a kqueue filter.
*/
static int
-hfs_kqfilt_add(ap)
- struct vop_kqfilt_add_args /* {
+hfs_vnop_kqfiltadd(
+ struct vnop_kqfilt_add_args /* {
struct vnode *a_vp;
struct knote *a_kn;
struct proc *p;
- } */ *ap;
+ 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 (vp->v_type == VREG) {
+ if (vnode_isreg(vp)) {
kn->kn_fop = &hfsread_filtops;
} else {
return EINVAL;
};
break;
case EVFILT_WRITE:
- if (vp->v_type == VREG) {
+ if (vnode_isreg(vp)) {
kn->kn_fop = &hfswrite_filtops;
} else {
return EINVAL;
}
kn->kn_hook = (caddr_t)vp;
+ kn->kn_hookid = vnode_vid(vp);
- /* simple_lock(&vp->v_pollinfo.vpi_lock); */
+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK)))
+ return (error);
KNOTE_ATTACH(&VTOC(vp)->c_knotes, kn);
- /* simple_unlock(&vp->v_pollinfo.vpi_lock); */
+ hfs_unlock(VTOC(vp));
return (0);
}
/*
- #
- #% kqfilt_remove vp L L L
- #
- vop_kqfilt_remove
- IN struct vnode *vp;
- IN uintptr_t ident;
- IN struct proc *p;
+ * Remove a kqueue filter
*/
static int
-hfs_kqfilt_remove(ap)
- struct vop_kqfilt_remove_args /* {
+hfs_vnop_kqfiltremove(ap)
+ struct vnop_kqfilt_remove_args /* {
struct vnode *a_vp;
uintptr_t ident;
- struct proc *p;
+ vfs_context_t a_context;
} */ *ap;
{
- struct vnode *vp = ap->a_vp;
- uintptr_t ident = ap->a_ident;
int result;
result = ENOTSUP; /* XXX */
*/
static int
hfsspec_read(ap)
- struct vop_read_args /* {
+ struct vnop_read_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int a_ioflag;
- struct ucred *a_cred;
+ vfs_context_t a_context;
} */ *ap;
{
/*
* Set access flag.
*/
- VTOC(ap->a_vp)->c_flag |= C_ACCESS;
- return (VOCALL (spec_vnodeop_p, VOFFSET(vop_read), ap));
+ VTOC(ap->a_vp)->c_touch_acctime = TRUE;
+ return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_read), ap));
}
/*
*/
static int
hfsspec_write(ap)
- struct vop_write_args /* {
+ struct vnop_write_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int a_ioflag;
- struct ucred *a_cred;
+ vfs_context_t a_context;
} */ *ap;
{
/*
* Set update and change flags.
*/
- VTOC(ap->a_vp)->c_flag |= C_CHANGE | C_UPDATE;
- return (VOCALL (spec_vnodeop_p, VOFFSET(vop_write), ap));
+ VTOC(ap->a_vp)->c_touch_chgtime = TRUE;
+ VTOC(ap->a_vp)->c_touch_modtime = TRUE;
+ return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_write), ap));
}
/*
*/
static int
hfsspec_close(ap)
- struct vop_close_args /* {
+ struct vnop_close_args /* {
struct vnode *a_vp;
int a_fflag;
- struct ucred *a_cred;
- struct proc *a_p;
+ vfs_context_t a_context;
} */ *ap;
{
struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
+ struct cnode *cp;
- simple_lock(&vp->v_interlock);
- if (ap->a_vp->v_usecount > 1)
- CTIMES(cp, &time, &time);
- simple_unlock(&vp->v_interlock);
- return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap));
+ if (vnode_isinuse(ap->a_vp, 1)) {
+ if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) == 0) {
+ cp = VTOC(vp);
+ hfs_touchtimes(VTOHFS(vp), cp);
+ hfs_unlock(cp);
+ }
+ }
+ return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_close), ap));
}
#if FIFO
*/
static int
hfsfifo_read(ap)
- struct vop_read_args /* {
+ struct vnop_read_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int a_ioflag;
- struct ucred *a_cred;
+ vfs_context_t a_context;
} */ *ap;
{
extern int (**fifo_vnodeop_p)(void *);
/*
* Set access flag.
*/
- VTOC(ap->a_vp)->c_flag |= C_ACCESS;
- return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_read), ap));
+ VTOC(ap->a_vp)->c_touch_acctime = TRUE;
+ return (VOCALL (fifo_vnodeop_p, VOFFSET(vnop_read), ap));
}
/*
*/
static int
hfsfifo_write(ap)
- struct vop_write_args /* {
+ struct vnop_write_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int a_ioflag;
- struct ucred *a_cred;
+ vfs_context_t a_context;
} */ *ap;
{
extern int (**fifo_vnodeop_p)(void *);
/*
* Set update and change flags.
*/
- VTOC(ap->a_vp)->c_flag |= C_CHANGE | C_UPDATE;
- return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_write), ap));
+ VTOC(ap->a_vp)->c_touch_chgtime = TRUE;
+ VTOC(ap->a_vp)->c_touch_modtime = TRUE;
+ return (VOCALL (fifo_vnodeop_p, VOFFSET(vnop_write), ap));
}
/*
*/
static int
hfsfifo_close(ap)
- struct vop_close_args /* {
+ struct vnop_close_args /* {
struct vnode *a_vp;
int a_fflag;
- struct ucred *a_cred;
- struct proc *a_p;
+ vfs_context_t a_context;
} */ *ap;
{
extern int (**fifo_vnodeop_p)(void *);
struct vnode *vp = ap->a_vp;
- struct cnode *cp = VTOC(vp);
+ struct cnode *cp;
- simple_lock(&vp->v_interlock);
- if (ap->a_vp->v_usecount > 1)
- CTIMES(cp, &time, &time);
- simple_unlock(&vp->v_interlock);
- return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap));
+ if (vnode_isinuse(ap->a_vp, 1)) {
+ if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) == 0) {
+ cp = VTOC(vp);
+ hfs_touchtimes(VTOHFS(vp), cp);
+ hfs_unlock(cp);
+ }
+ }
+ return (VOCALL (fifo_vnodeop_p, VOFFSET(vnop_close), ap));
}
/*
*/
int
hfsfifo_kqfilt_add(ap)
- struct vop_kqfilt_add_args *ap;
+ struct vnop_kqfilt_add_args *ap;
{
extern int (**fifo_vnodeop_p)(void *);
int error;
- error = VOCALL(fifo_vnodeop_p, VOFFSET(vop_kqfilt_add), ap);
+ error = VOCALL(fifo_vnodeop_p, VOFFSET(vnop_kqfilt_add), ap);
if (error)
- error = hfs_kqfilt_add(ap);
+ error = hfs_vnop_kqfiltadd(ap);
return (error);
}
*/
int
hfsfifo_kqfilt_remove(ap)
- struct vop_kqfilt_remove_args *ap;
+ struct vnop_kqfilt_remove_args *ap;
{
extern int (**fifo_vnodeop_p)(void *);
int error;
- error = VOCALL(fifo_vnodeop_p, VOFFSET(vop_kqfilt_remove), ap);
+ error = VOCALL(fifo_vnodeop_p, VOFFSET(vnop_kqfilt_remove), ap);
if (error)
- error = hfs_kqfilt_remove(ap);
+ error = hfs_vnop_kqfiltremove(ap);
return (error);
}
#endif /* FIFO */
+/*
+ * Synchronize a file's in-core state with that on disk.
+ */
+static int
+hfs_vnop_fsync(ap)
+ struct vnop_fsync_args /* {
+ struct vnode *a_vp;
+ int a_waitfor;
+ vfs_context_t a_context;
+ } */ *ap;
+{
+ struct vnode* vp = ap->a_vp;
+ int error;
+
+ /*
+ * We need to allow ENOENT lock errors since unlink
+ * systenm call can call VNOP_FSYNC during vclean.
+ */
+ error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK);
+ if (error)
+ return (0);
+
+ error = hfs_fsync(vp, ap->a_waitfor, 0, vfs_context_proc(ap->a_context));
+
+ hfs_unlock(VTOC(vp));
+ return (error);
+}
/*****************************************************************************
*
* VOP Tables
*
*****************************************************************************/
-int hfs_cache_lookup(); /* in hfs_lookup.c */
-int hfs_lookup(); /* in hfs_lookup.c */
-int hfs_read(); /* in hfs_readwrite.c */
-int hfs_write(); /* in hfs_readwrite.c */
-int hfs_ioctl(); /* in hfs_readwrite.c */
-int hfs_select(); /* in hfs_readwrite.c */
-int hfs_bmap(); /* in hfs_readwrite.c */
-int hfs_strategy(); /* in hfs_readwrite.c */
-int hfs_truncate(); /* in hfs_readwrite.c */
-int hfs_allocate(); /* in hfs_readwrite.c */
-int hfs_pagein(); /* in hfs_readwrite.c */
-int hfs_pageout(); /* in hfs_readwrite.c */
-int hfs_search(); /* in hfs_search.c */
-int hfs_bwrite(); /* in hfs_readwrite.c */
-int hfs_link(); /* in hfs_link.c */
-int hfs_blktooff(); /* in hfs_readwrite.c */
-int hfs_offtoblk(); /* in hfs_readwrite.c */
-int hfs_cmap(); /* in hfs_readwrite.c */
-int hfs_getattrlist(); /* in hfs_attrlist.c */
-int hfs_setattrlist(); /* in hfs_attrlist.c */
-int hfs_readdirattr(); /* in hfs_attrlist.c */
-int hfs_inactive(); /* in hfs_cnode.c */
-int hfs_reclaim(); /* in hfs_cnode.c */
+int hfs_vnop_readdirattr(struct vnop_readdirattr_args *); /* in hfs_attrlist.c */
+int hfs_vnop_inactive(struct vnop_inactive_args *); /* in hfs_cnode.c */
+int hfs_vnop_reclaim(struct vnop_reclaim_args *); /* in hfs_cnode.c */
+int hfs_vnop_link(struct vnop_link_args *); /* in hfs_link.c */
+int hfs_vnop_lookup(struct vnop_lookup_args *); /* in hfs_lookup.c */
+int hfs_vnop_search(struct vnop_searchfs_args *); /* in hfs_search.c */
+
+int hfs_vnop_read(struct vnop_read_args *); /* in hfs_readwrite.c */
+int hfs_vnop_write(struct vnop_write_args *); /* in hfs_readwrite.c */
+int hfs_vnop_ioctl(struct vnop_ioctl_args *); /* in hfs_readwrite.c */
+int hfs_vnop_select(struct vnop_select_args *); /* in hfs_readwrite.c */
+int hfs_vnop_strategy(struct vnop_strategy_args *); /* in hfs_readwrite.c */
+int hfs_vnop_allocate(struct vnop_allocate_args *); /* in hfs_readwrite.c */
+int hfs_vnop_pagein(struct vnop_pagein_args *); /* in hfs_readwrite.c */
+int hfs_vnop_pageout(struct vnop_pageout_args *); /* in hfs_readwrite.c */
+int hfs_vnop_bwrite(struct vnop_bwrite_args *); /* in hfs_readwrite.c */
+int hfs_vnop_blktooff(struct vnop_blktooff_args *); /* in hfs_readwrite.c */
+int hfs_vnop_offtoblk(struct vnop_offtoblk_args *); /* in hfs_readwrite.c */
+int hfs_vnop_blockmap(struct vnop_blockmap_args *); /* in hfs_readwrite.c */
+int hfs_vnop_getxattr(struct vnop_getxattr_args *); /* in hfs_xattr.c */
+int hfs_vnop_setxattr(struct vnop_setxattr_args *); /* in hfs_xattr.c */
+int hfs_vnop_removexattr(struct vnop_removexattr_args *); /* in hfs_xattr.c */
+int hfs_vnop_listxattr(struct vnop_listxattr_args *); /* in hfs_xattr.c */
int (**hfs_vnodeop_p)(void *);
#define VOPFUNC int (*)(void *)
struct vnodeopv_entry_desc hfs_vnodeop_entries[] = {
- { &vop_default_desc, (VOPFUNC)vn_default_error },
- { &vop_lookup_desc, (VOPFUNC)hfs_cache_lookup }, /* lookup */
- { &vop_create_desc, (VOPFUNC)hfs_create }, /* create */
- { &vop_mknod_desc, (VOPFUNC)hfs_mknod }, /* mknod */
- { &vop_open_desc, (VOPFUNC)hfs_open }, /* open */
- { &vop_close_desc, (VOPFUNC)hfs_close }, /* close */
- { &vop_access_desc, (VOPFUNC)hfs_access }, /* access */
- { &vop_getattr_desc, (VOPFUNC)hfs_getattr }, /* getattr */
- { &vop_setattr_desc, (VOPFUNC)hfs_setattr }, /* setattr */
- { &vop_read_desc, (VOPFUNC)hfs_read }, /* read */
- { &vop_write_desc, (VOPFUNC)hfs_write }, /* write */
- { &vop_ioctl_desc, (VOPFUNC)hfs_ioctl }, /* ioctl */
- { &vop_select_desc, (VOPFUNC)hfs_select }, /* select */
- { &vop_revoke_desc, (VOPFUNC)nop_revoke }, /* revoke */
- { &vop_exchange_desc, (VOPFUNC)hfs_exchange }, /* exchange */
- { &vop_mmap_desc, (VOPFUNC)err_mmap }, /* mmap */
- { &vop_fsync_desc, (VOPFUNC)hfs_fsync }, /* fsync */
- { &vop_seek_desc, (VOPFUNC)nop_seek }, /* seek */
- { &vop_remove_desc, (VOPFUNC)hfs_remove }, /* remove */
- { &vop_link_desc, (VOPFUNC)hfs_link }, /* link */
- { &vop_rename_desc, (VOPFUNC)hfs_rename }, /* rename */
- { &vop_mkdir_desc, (VOPFUNC)hfs_mkdir }, /* mkdir */
- { &vop_rmdir_desc, (VOPFUNC)hfs_rmdir }, /* rmdir */
- { &vop_mkcomplex_desc, (VOPFUNC)err_mkcomplex }, /* mkcomplex */
- { &vop_getattrlist_desc, (VOPFUNC)hfs_getattrlist }, /* getattrlist */
- { &vop_setattrlist_desc, (VOPFUNC)hfs_setattrlist }, /* setattrlist */
- { &vop_symlink_desc, (VOPFUNC)hfs_symlink }, /* symlink */
- { &vop_readdir_desc, (VOPFUNC)hfs_readdir }, /* readdir */
- { &vop_readdirattr_desc, (VOPFUNC)hfs_readdirattr }, /* readdirattr */
- { &vop_readlink_desc, (VOPFUNC)hfs_readlink }, /* readlink */
- { &vop_abortop_desc, (VOPFUNC)nop_abortop }, /* abortop */
- { &vop_inactive_desc, (VOPFUNC)hfs_inactive }, /* inactive */
- { &vop_reclaim_desc, (VOPFUNC)hfs_reclaim }, /* reclaim */
- { &vop_lock_desc, (VOPFUNC)hfs_lock }, /* lock */
- { &vop_unlock_desc, (VOPFUNC)hfs_unlock }, /* unlock */
- { &vop_bmap_desc, (VOPFUNC)hfs_bmap }, /* bmap */
- { &vop_strategy_desc, (VOPFUNC)hfs_strategy }, /* strategy */
- { &vop_print_desc, (VOPFUNC)hfs_print }, /* print */
- { &vop_islocked_desc, (VOPFUNC)hfs_islocked }, /* islocked */
- { &vop_pathconf_desc, (VOPFUNC)hfs_pathconf }, /* pathconf */
- { &vop_advlock_desc, (VOPFUNC)hfs_advlock }, /* advlock */
- { &vop_reallocblks_desc, (VOPFUNC)err_reallocblks }, /* reallocblks */
- { &vop_truncate_desc, (VOPFUNC)hfs_truncate }, /* truncate */
- { &vop_allocate_desc, (VOPFUNC)hfs_allocate }, /* allocate */
- { &vop_update_desc, (VOPFUNC)hfs_update }, /* update */
- { &vop_searchfs_desc, (VOPFUNC)hfs_search }, /* search fs */
- { &vop_bwrite_desc, (VOPFUNC)hfs_bwrite }, /* bwrite */
- { &vop_pagein_desc, (VOPFUNC)hfs_pagein }, /* pagein */
- { &vop_pageout_desc,(VOPFUNC) hfs_pageout }, /* pageout */
- { &vop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */
- { &vop_blktooff_desc, (VOPFUNC)hfs_blktooff }, /* blktooff */
- { &vop_offtoblk_desc, (VOPFUNC)hfs_offtoblk }, /* offtoblk */
- { &vop_cmap_desc, (VOPFUNC)hfs_cmap }, /* cmap */
- { &vop_kqfilt_add_desc, (VOPFUNC)hfs_kqfilt_add }, /* kqfilt_add */
- { &vop_kqfilt_remove_desc, (VOPFUNC)hfs_kqfilt_remove }, /* kqfilt_remove */
+ { &vnop_default_desc, (VOPFUNC)vn_default_error },
+ { &vnop_lookup_desc, (VOPFUNC)hfs_vnop_lookup }, /* lookup */
+ { &vnop_create_desc, (VOPFUNC)hfs_vnop_create }, /* create */
+ { &vnop_mknod_desc, (VOPFUNC)hfs_vnop_mknod }, /* mknod */
+ { &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_vnop_setattr }, /* setattr */
+ { &vnop_read_desc, (VOPFUNC)hfs_vnop_read }, /* read */
+ { &vnop_write_desc, (VOPFUNC)hfs_vnop_write }, /* write */
+ { &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_vnop_exchange }, /* exchange */
+ { &vnop_mmap_desc, (VOPFUNC)err_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_rename_desc, (VOPFUNC)hfs_vnop_rename }, /* rename */
+ { &vnop_mkdir_desc, (VOPFUNC)hfs_vnop_mkdir }, /* mkdir */
+ { &vnop_rmdir_desc, (VOPFUNC)hfs_vnop_rmdir }, /* rmdir */
+ { &vnop_symlink_desc, (VOPFUNC)hfs_vnop_symlink }, /* symlink */
+ { &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_vnop_allocate }, /* allocate */
+ { &vnop_searchfs_desc, (VOPFUNC)hfs_vnop_search }, /* search fs */
+ { &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_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */
+ { &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},
+ { &vnop_listxattr_desc, (VOPFUNC)hfs_vnop_listxattr},
{ NULL, (VOPFUNC)NULL }
};
int (**hfs_specop_p)(void *);
struct vnodeopv_entry_desc hfs_specop_entries[] = {
- { &vop_default_desc, (VOPFUNC)vn_default_error },
- { &vop_lookup_desc, (VOPFUNC)spec_lookup }, /* lookup */
- { &vop_create_desc, (VOPFUNC)spec_create }, /* create */
- { &vop_mknod_desc, (VOPFUNC)spec_mknod }, /* mknod */
- { &vop_open_desc, (VOPFUNC)spec_open }, /* open */
- { &vop_close_desc, (VOPFUNC)hfsspec_close }, /* close */
- { &vop_access_desc, (VOPFUNC)hfs_access }, /* access */
- { &vop_getattr_desc, (VOPFUNC)hfs_getattr }, /* getattr */
- { &vop_setattr_desc, (VOPFUNC)hfs_setattr }, /* setattr */
- { &vop_read_desc, (VOPFUNC)hfsspec_read }, /* read */
- { &vop_write_desc, (VOPFUNC)hfsspec_write }, /* write */
- { &vop_lease_desc, (VOPFUNC)spec_lease_check }, /* lease */
- { &vop_ioctl_desc, (VOPFUNC)spec_ioctl }, /* ioctl */
- { &vop_select_desc, (VOPFUNC)spec_select }, /* select */
- { &vop_revoke_desc, (VOPFUNC)spec_revoke }, /* revoke */
- { &vop_mmap_desc, (VOPFUNC)spec_mmap }, /* mmap */
- { &vop_fsync_desc, (VOPFUNC)hfs_fsync }, /* fsync */
- { &vop_seek_desc, (VOPFUNC)spec_seek }, /* seek */
- { &vop_remove_desc, (VOPFUNC)spec_remove }, /* remove */
- { &vop_link_desc, (VOPFUNC)spec_link }, /* link */
- { &vop_rename_desc, (VOPFUNC)spec_rename }, /* rename */
- { &vop_mkdir_desc, (VOPFUNC)spec_mkdir }, /* mkdir */
- { &vop_rmdir_desc, (VOPFUNC)spec_rmdir }, /* rmdir */
- { &vop_getattrlist_desc, (VOPFUNC)hfs_getattrlist },
- { &vop_symlink_desc, (VOPFUNC)spec_symlink }, /* symlink */
- { &vop_readdir_desc, (VOPFUNC)spec_readdir }, /* readdir */
- { &vop_readlink_desc, (VOPFUNC)spec_readlink }, /* readlink */
- { &vop_abortop_desc, (VOPFUNC)spec_abortop }, /* abortop */
- { &vop_inactive_desc, (VOPFUNC)hfs_inactive }, /* inactive */
- { &vop_reclaim_desc, (VOPFUNC)hfs_reclaim }, /* reclaim */
- { &vop_lock_desc, (VOPFUNC)hfs_lock }, /* lock */
- { &vop_unlock_desc, (VOPFUNC)hfs_unlock }, /* unlock */
- { &vop_bmap_desc, (VOPFUNC)spec_bmap }, /* bmap */
- { &vop_strategy_desc, (VOPFUNC)spec_strategy }, /* strategy */
- { &vop_print_desc, (VOPFUNC)hfs_print }, /* print */
- { &vop_islocked_desc, (VOPFUNC)hfs_islocked }, /* islocked */
- { &vop_pathconf_desc, (VOPFUNC)spec_pathconf }, /* pathconf */
- { &vop_advlock_desc, (VOPFUNC)spec_advlock }, /* advlock */
- { &vop_blkatoff_desc, (VOPFUNC)spec_blkatoff }, /* blkatoff */
- { &vop_valloc_desc, (VOPFUNC)spec_valloc }, /* valloc */
- { &vop_reallocblks_desc, (VOPFUNC)spec_reallocblks }, /* reallocblks */
- { &vop_vfree_desc, (VOPFUNC)err_vfree }, /* vfree */
- { &vop_truncate_desc, (VOPFUNC)spec_truncate }, /* truncate */
- { &vop_update_desc, (VOPFUNC)hfs_update }, /* update */
- { &vop_bwrite_desc, (VOPFUNC)hfs_bwrite },
- { &vop_devblocksize_desc, (VOPFUNC)spec_devblocksize }, /* devblocksize */
- { &vop_pagein_desc, (VOPFUNC)hfs_pagein }, /* Pagein */
- { &vop_pageout_desc, (VOPFUNC)hfs_pageout }, /* Pageout */
- { &vop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */
- { &vop_blktooff_desc, (VOPFUNC)hfs_blktooff }, /* blktooff */
- { &vop_offtoblk_desc, (VOPFUNC)hfs_offtoblk }, /* offtoblk */
+ { &vnop_default_desc, (VOPFUNC)vn_default_error },
+ { &vnop_lookup_desc, (VOPFUNC)spec_lookup }, /* lookup */
+ { &vnop_create_desc, (VOPFUNC)spec_create }, /* create */
+ { &vnop_mknod_desc, (VOPFUNC)spec_mknod }, /* mknod */
+ { &vnop_open_desc, (VOPFUNC)spec_open }, /* open */
+ { &vnop_close_desc, (VOPFUNC)hfsspec_close }, /* close */
+ { &vnop_getattr_desc, (VOPFUNC)hfs_vnop_getattr }, /* getattr */
+ { &vnop_setattr_desc, (VOPFUNC)hfs_vnop_setattr }, /* setattr */
+ { &vnop_read_desc, (VOPFUNC)hfsspec_read }, /* read */
+ { &vnop_write_desc, (VOPFUNC)hfsspec_write }, /* write */
+ { &vnop_ioctl_desc, (VOPFUNC)spec_ioctl }, /* ioctl */
+ { &vnop_select_desc, (VOPFUNC)spec_select }, /* select */
+ { &vnop_revoke_desc, (VOPFUNC)spec_revoke }, /* revoke */
+ { &vnop_mmap_desc, (VOPFUNC)spec_mmap }, /* mmap */
+ { &vnop_fsync_desc, (VOPFUNC)hfs_vnop_fsync }, /* fsync */
+ { &vnop_remove_desc, (VOPFUNC)spec_remove }, /* remove */
+ { &vnop_link_desc, (VOPFUNC)spec_link }, /* link */
+ { &vnop_rename_desc, (VOPFUNC)spec_rename }, /* rename */
+ { &vnop_mkdir_desc, (VOPFUNC)spec_mkdir }, /* mkdir */
+ { &vnop_rmdir_desc, (VOPFUNC)spec_rmdir }, /* rmdir */
+ { &vnop_symlink_desc, (VOPFUNC)spec_symlink }, /* symlink */
+ { &vnop_readdir_desc, (VOPFUNC)spec_readdir }, /* readdir */
+ { &vnop_readlink_desc, (VOPFUNC)spec_readlink }, /* readlink */
+ { &vnop_inactive_desc, (VOPFUNC)hfs_vnop_inactive }, /* inactive */
+ { &vnop_reclaim_desc, (VOPFUNC)hfs_vnop_reclaim }, /* reclaim */
+ { &vnop_strategy_desc, (VOPFUNC)spec_strategy }, /* strategy */
+ { &vnop_pathconf_desc, (VOPFUNC)spec_pathconf }, /* pathconf */
+ { &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */
+ { &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_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */
+ { &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */
{ (struct vnodeop_desc*)NULL, (VOPFUNC)NULL }
};
struct vnodeopv_desc hfs_specop_opv_desc =
#if FIFO
int (**hfs_fifoop_p)(void *);
struct vnodeopv_entry_desc hfs_fifoop_entries[] = {
- { &vop_default_desc, (VOPFUNC)vn_default_error },
- { &vop_lookup_desc, (VOPFUNC)fifo_lookup }, /* lookup */
- { &vop_create_desc, (VOPFUNC)fifo_create }, /* create */
- { &vop_mknod_desc, (VOPFUNC)fifo_mknod }, /* mknod */
- { &vop_open_desc, (VOPFUNC)fifo_open }, /* open */
- { &vop_close_desc, (VOPFUNC)hfsfifo_close }, /* close */
- { &vop_access_desc, (VOPFUNC)hfs_access }, /* access */
- { &vop_getattr_desc, (VOPFUNC)hfs_getattr }, /* getattr */
- { &vop_setattr_desc, (VOPFUNC)hfs_setattr }, /* setattr */
- { &vop_read_desc, (VOPFUNC)hfsfifo_read }, /* read */
- { &vop_write_desc, (VOPFUNC)hfsfifo_write }, /* write */
- { &vop_lease_desc, (VOPFUNC)fifo_lease_check }, /* lease */
- { &vop_ioctl_desc, (VOPFUNC)fifo_ioctl }, /* ioctl */
- { &vop_select_desc, (VOPFUNC)fifo_select }, /* select */
- { &vop_revoke_desc, (VOPFUNC)fifo_revoke }, /* revoke */
- { &vop_mmap_desc, (VOPFUNC)fifo_mmap }, /* mmap */
- { &vop_fsync_desc, (VOPFUNC)hfs_fsync }, /* fsync */
- { &vop_seek_desc, (VOPFUNC)fifo_seek }, /* seek */
- { &vop_remove_desc, (VOPFUNC)fifo_remove }, /* remove */
- { &vop_link_desc, (VOPFUNC)fifo_link }, /* link */
- { &vop_rename_desc, (VOPFUNC)fifo_rename }, /* rename */
- { &vop_mkdir_desc, (VOPFUNC)fifo_mkdir }, /* mkdir */
- { &vop_rmdir_desc, (VOPFUNC)fifo_rmdir }, /* rmdir */
- { &vop_getattrlist_desc, (VOPFUNC)hfs_getattrlist },
- { &vop_symlink_desc, (VOPFUNC)fifo_symlink }, /* symlink */
- { &vop_readdir_desc, (VOPFUNC)fifo_readdir }, /* readdir */
- { &vop_readlink_desc, (VOPFUNC)fifo_readlink }, /* readlink */
- { &vop_abortop_desc, (VOPFUNC)fifo_abortop }, /* abortop */
- { &vop_inactive_desc, (VOPFUNC)hfs_inactive }, /* inactive */
- { &vop_reclaim_desc, (VOPFUNC)hfs_reclaim }, /* reclaim */
- { &vop_lock_desc, (VOPFUNC)hfs_lock }, /* lock */
- { &vop_unlock_desc, (VOPFUNC)hfs_unlock }, /* unlock */
- { &vop_bmap_desc, (VOPFUNC)fifo_bmap }, /* bmap */
- { &vop_strategy_desc, (VOPFUNC)fifo_strategy }, /* strategy */
- { &vop_print_desc, (VOPFUNC)hfs_print }, /* print */
- { &vop_islocked_desc, (VOPFUNC)hfs_islocked }, /* islocked */
- { &vop_pathconf_desc, (VOPFUNC)fifo_pathconf }, /* pathconf */
- { &vop_advlock_desc, (VOPFUNC)fifo_advlock }, /* advlock */
- { &vop_blkatoff_desc, (VOPFUNC)fifo_blkatoff }, /* blkatoff */
- { &vop_valloc_desc, (VOPFUNC)fifo_valloc }, /* valloc */
- { &vop_reallocblks_desc, (VOPFUNC)fifo_reallocblks }, /* reallocblks */
- { &vop_vfree_desc, (VOPFUNC)err_vfree }, /* vfree */
- { &vop_truncate_desc, (VOPFUNC)fifo_truncate }, /* truncate */
- { &vop_update_desc, (VOPFUNC)hfs_update }, /* update */
- { &vop_bwrite_desc, (VOPFUNC)hfs_bwrite },
- { &vop_pagein_desc, (VOPFUNC)hfs_pagein }, /* Pagein */
- { &vop_pageout_desc, (VOPFUNC)hfs_pageout }, /* Pageout */
- { &vop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */
- { &vop_blktooff_desc, (VOPFUNC)hfs_blktooff }, /* blktooff */
- { &vop_offtoblk_desc, (VOPFUNC)hfs_offtoblk }, /* offtoblk */
- { &vop_cmap_desc, (VOPFUNC)hfs_cmap }, /* cmap */
- { &vop_kqfilt_add_desc, (VOPFUNC)hfsfifo_kqfilt_add }, /* kqfilt_add */
- { &vop_kqfilt_remove_desc, (VOPFUNC)hfsfifo_kqfilt_remove }, /* kqfilt_remove */
+ { &vnop_default_desc, (VOPFUNC)vn_default_error },
+ { &vnop_lookup_desc, (VOPFUNC)fifo_lookup }, /* lookup */
+ { &vnop_create_desc, (VOPFUNC)fifo_create }, /* create */
+ { &vnop_mknod_desc, (VOPFUNC)fifo_mknod }, /* mknod */
+ { &vnop_open_desc, (VOPFUNC)fifo_open }, /* open */
+ { &vnop_close_desc, (VOPFUNC)hfsfifo_close }, /* close */
+ { &vnop_getattr_desc, (VOPFUNC)hfs_vnop_getattr }, /* getattr */
+ { &vnop_setattr_desc, (VOPFUNC)hfs_vnop_setattr }, /* setattr */
+ { &vnop_read_desc, (VOPFUNC)hfsfifo_read }, /* read */
+ { &vnop_write_desc, (VOPFUNC)hfsfifo_write }, /* write */
+ { &vnop_ioctl_desc, (VOPFUNC)fifo_ioctl }, /* ioctl */
+ { &vnop_select_desc, (VOPFUNC)fifo_select }, /* select */
+ { &vnop_revoke_desc, (VOPFUNC)fifo_revoke }, /* revoke */
+ { &vnop_mmap_desc, (VOPFUNC)fifo_mmap }, /* mmap */
+ { &vnop_fsync_desc, (VOPFUNC)hfs_vnop_fsync }, /* fsync */
+ { &vnop_remove_desc, (VOPFUNC)fifo_remove }, /* remove */
+ { &vnop_link_desc, (VOPFUNC)fifo_link }, /* link */
+ { &vnop_rename_desc, (VOPFUNC)fifo_rename }, /* rename */
+ { &vnop_mkdir_desc, (VOPFUNC)fifo_mkdir }, /* mkdir */
+ { &vnop_rmdir_desc, (VOPFUNC)fifo_rmdir }, /* rmdir */
+ { &vnop_symlink_desc, (VOPFUNC)fifo_symlink }, /* symlink */
+ { &vnop_readdir_desc, (VOPFUNC)fifo_readdir }, /* readdir */
+ { &vnop_readlink_desc, (VOPFUNC)fifo_readlink }, /* readlink */
+ { &vnop_inactive_desc, (VOPFUNC)hfs_vnop_inactive }, /* inactive */
+ { &vnop_reclaim_desc, (VOPFUNC)hfs_vnop_reclaim }, /* reclaim */
+ { &vnop_strategy_desc, (VOPFUNC)fifo_strategy }, /* strategy */
+ { &vnop_pathconf_desc, (VOPFUNC)fifo_pathconf }, /* pathconf */
+ { &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */
+ { &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_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