/* * Copyright (c) 2000-2014 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * * 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. The rights granted to you under the License * may not be used to create, or enable the creation or redistribution of, * unlawful or unlicensed copies of an Apple operating system, or to * circumvent, violate, or enable the circumvention or violation of, any * terms of an Apple operating system software license agreement. * * 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 * 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. * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "hfs.h" #include "hfs_catalog.h" #include "hfs_cnode.h" #include "hfs_dbg.h" #include "hfs_mount.h" #include "hfs_quota.h" #include "hfs_endian.h" #include "hfs_kdebug.h" #include "hfscommon/headers/BTreesInternal.h" #include "hfscommon/headers/FileMgrInternal.h" #define KNDETACH_VNLOCKED 0x00000001 /* 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_DECL(_vfs_generic); SYSCTL_INT (_vfs_generic, OID_AUTO, always_do_fullfsync, CTLFLAG_RW | CTLFLAG_LOCKED, &always_do_fullfsync, 0, "always F_FULLFSYNC when fsync is called"); int hfs_makenode(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vnode_attr *vap, vfs_context_t ctx); int hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, __unused struct proc *p); int hfs_metasync_all(struct hfsmount *hfsmp); int hfs_removedir(struct vnode *, struct vnode *, struct componentname *, int, int); int hfs_removefile(struct vnode *, struct vnode *, struct componentname *, int, int, int, struct vnode *, int); /* Used here and in cnode teardown -- for symlinks */ int hfs_removefile_callback(struct buf *bp, void *hfsmp); enum { HFS_MOVE_DATA_INCLUDE_RSRC = 1, }; typedef uint32_t hfs_move_data_options_t; static int hfs_move_data(cnode_t *from_cp, cnode_t *to_cp, hfs_move_data_options_t options); static int hfs_move_fork(filefork_t *srcfork, cnode_t *src, filefork_t *dstfork, cnode_t *dst); static const struct cat_fork * hfs_prepare_fork_for_update(const filefork_t *pfork, struct cat_fork *fork_buf, uint32_t block_size); #if HFS_COMPRESSION static int hfs_move_compressed(cnode_t *from_vp, cnode_t *to_vp); #endif decmpfs_cnode* hfs_lazy_init_decmpfs_cnode (struct cnode *cp); #if FIFO static int hfsfifo_read(struct vnop_read_args *); static int hfsfifo_write(struct vnop_write_args *); static int hfsfifo_close(struct vnop_close_args *); extern int (**fifo_vnodeop_p)(void *); #endif /* FIFO */ int hfs_vnop_close(struct vnop_close_args*); int hfs_vnop_create(struct vnop_create_args*); int hfs_vnop_exchange(struct vnop_exchange_args*); int hfs_vnop_fsync(struct vnop_fsync_args*); int hfs_vnop_mkdir(struct vnop_mkdir_args*); int hfs_vnop_mknod(struct vnop_mknod_args*); int hfs_vnop_getattr(struct vnop_getattr_args*); int hfs_vnop_open(struct vnop_open_args*); int hfs_vnop_readdir(struct vnop_readdir_args*); int hfs_vnop_remove(struct vnop_remove_args*); int hfs_vnop_rename(struct vnop_rename_args*); int hfs_vnop_rmdir(struct vnop_rmdir_args*); int hfs_vnop_symlink(struct vnop_symlink_args*); int hfs_vnop_setattr(struct vnop_setattr_args*); int hfs_vnop_readlink(struct vnop_readlink_args *); int hfs_vnop_pathconf(struct vnop_pathconf_args *); int hfs_vnop_mmap(struct vnop_mmap_args *ap); int hfsspec_read(struct vnop_read_args *); int hfsspec_write(struct vnop_write_args *); int hfsspec_close(struct vnop_close_args *); /* Options for hfs_removedir and hfs_removefile */ #define HFSRM_SKIP_RESERVE 0x01 /***************************************************************************** * * Common Operations on vnodes * *****************************************************************************/ /* * Is the given cnode either the .journal or .journal_info_block file on * a volume with an active journal? Many VNOPs use this to deny access * to those files. * * Note: the .journal file on a volume with an external journal still * returns true here, even though it does not actually hold the contents * of the volume's journal. */ static _Bool hfs_is_journal_file(struct hfsmount *hfsmp, struct cnode *cp) { if (hfsmp->jnl != NULL && (cp->c_fileid == hfsmp->hfs_jnlinfoblkid || cp->c_fileid == hfsmp->hfs_jnlfileid)) { return true; } else { return false; } } /* * Create a regular file. */ int hfs_vnop_create(struct vnop_create_args *ap) { /* * We leave handling of certain race conditions here to the caller * which will have a better understanding of the semantics it * requires. For example, if it turns out that the file exists, * it would be wrong of us to return a reference to the existing * file because the caller might not want that and it would be * misleading to suggest the file had been created when it hadn't * been. Note that our NFS server code does not set the * VA_EXCLUSIVE flag so you cannot assume that callers don't want * EEXIST errors if it's not set. The common case, where users * are calling open with the O_CREAT mode, is handled in VFS; when * we return EEXIST, it will loop and do the look-up again. */ return hfs_makenode(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap, ap->a_context); } /* * Make device special file. */ int hfs_vnop_mknod(struct vnop_mknod_args *ap) { 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(dvp)->vcbSigWord != kHFSPlusSigWord) { return (ENOTSUP); } /* Create the vnode */ error = hfs_makenode(dvp, vpp, ap->a_cnp, vap, ap->a_context); if (error) return (error); cp = VTOC(*vpp); 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; return (0); } #if HFS_COMPRESSION /* * hfs_ref_data_vp(): returns the data fork vnode for a given cnode. * In the (hopefully rare) case where the data fork vnode is not * present, it will use hfs_vget() to create a new vnode for the * data fork. * * NOTE: If successful and a vnode is returned, the caller is responsible * for releasing the returned vnode with vnode_rele(). */ static int hfs_ref_data_vp(struct cnode *cp, struct vnode **data_vp, int skiplock) { int vref = 0; if (!data_vp || !cp) /* sanity check incoming parameters */ return EINVAL; /* maybe we should take the hfs cnode lock here, and if so, use the skiplock parameter to tell us not to */ if (!skiplock) hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT); struct vnode *c_vp = cp->c_vp; if (c_vp) { /* we already have a data vnode */ *data_vp = c_vp; vref = vnode_ref(*data_vp); if (!skiplock) hfs_unlock(cp); if (vref == 0) { return 0; } return EINVAL; } /* no data fork vnode in the cnode, so ask hfs for one. */ if (!cp->c_rsrc_vp) { /* if we don't have either a c_vp or c_rsrc_vp, we can't really do anything useful */ *data_vp = NULL; if (!skiplock) hfs_unlock(cp); return EINVAL; } if (0 == hfs_vget(VTOHFS(cp->c_rsrc_vp), cp->c_cnid, data_vp, 1, 0) && 0 != data_vp) { vref = vnode_ref(*data_vp); vnode_put(*data_vp); if (!skiplock) hfs_unlock(cp); if (vref == 0) { return 0; } return EINVAL; } /* there was an error getting the vnode */ *data_vp = NULL; if (!skiplock) hfs_unlock(cp); return EINVAL; } /* * hfs_lazy_init_decmpfs_cnode(): returns the decmpfs_cnode for a cnode, * allocating it if necessary; returns NULL if there was an allocation error. * function is non-static so that it can be used from the FCNTL handler. */ decmpfs_cnode * hfs_lazy_init_decmpfs_cnode(struct cnode *cp) { if (!cp->c_decmp) { decmpfs_cnode *dp = NULL; MALLOC_ZONE(dp, decmpfs_cnode *, sizeof(decmpfs_cnode), M_DECMPFS_CNODE, M_WAITOK); if (!dp) { /* error allocating a decmpfs cnode */ return NULL; } decmpfs_cnode_init(dp); if (!OSCompareAndSwapPtr(NULL, dp, (void * volatile *)&cp->c_decmp)) { /* another thread got here first, so free the decmpfs_cnode we allocated */ decmpfs_cnode_destroy(dp); FREE_ZONE(dp, sizeof(*dp), M_DECMPFS_CNODE); } } return cp->c_decmp; } /* * hfs_file_is_compressed(): returns 1 if the file is compressed, and 0 (zero) if not. * if the file's compressed flag is set, makes sure that the decmpfs_cnode field * is allocated by calling hfs_lazy_init_decmpfs_cnode(), then makes sure it is populated, * or else fills it in via the decmpfs_file_is_compressed() function. */ int hfs_file_is_compressed(struct cnode *cp, int skiplock) { int ret = 0; /* fast check to see if file is compressed. If flag is clear, just answer no */ if (!(cp->c_bsdflags & UF_COMPRESSED)) { return 0; } decmpfs_cnode *dp = hfs_lazy_init_decmpfs_cnode(cp); if (!dp) { /* error allocating a decmpfs cnode, treat the file as uncompressed */ return 0; } /* flag was set, see if the decmpfs_cnode state is valid (zero == invalid) */ uint32_t decmpfs_state = decmpfs_cnode_get_vnode_state(dp); switch(decmpfs_state) { case FILE_IS_COMPRESSED: case FILE_IS_CONVERTING: /* treat decompressing files as if they are compressed */ return 1; case FILE_IS_NOT_COMPRESSED: return 0; /* otherwise the state is not cached yet */ } /* decmpfs hasn't seen this file yet, so call decmpfs_file_is_compressed() to init the decmpfs_cnode struct */ struct vnode *data_vp = NULL; if (0 == hfs_ref_data_vp(cp, &data_vp, skiplock)) { if (data_vp) { ret = decmpfs_file_is_compressed(data_vp, VTOCMP(data_vp)); // fill in decmpfs_cnode vnode_rele(data_vp); } } return ret; } /* hfs_uncompressed_size_of_compressed_file() - get the uncompressed size of the file. * if the caller has passed a valid vnode (has a ref count > 0), then hfsmp and fid are not required. * if the caller doesn't have a vnode, pass NULL in vp, and pass valid hfsmp and fid. * files size is returned in size (required) * if the indicated file is a directory (or something that doesn't have a data fork), then this call * will return an error and the caller should fall back to treating the item as an uncompressed file */ int hfs_uncompressed_size_of_compressed_file(struct hfsmount *hfsmp, struct vnode *vp, cnid_t fid, off_t *size, int skiplock) { int ret = 0; int putaway = 0; /* flag to remember if we used hfs_vget() */ if (!size) { return EINVAL; /* no place to put the file size */ } if (NULL == vp) { if (!hfsmp || !fid) { /* make sure we have the required parameters */ return EINVAL; } if (0 != hfs_vget(hfsmp, fid, &vp, skiplock, 0)) { /* vnode is null, use hfs_vget() to get it */ vp = NULL; } else { putaway = 1; /* note that hfs_vget() was used to aquire the vnode */ } } /* this double check for compression (hfs_file_is_compressed) * ensures the cached size is present in case decmpfs hasn't * encountered this node yet. */ if (vp) { if (hfs_file_is_compressed(VTOC(vp), skiplock) ) { *size = decmpfs_cnode_get_vnode_cached_size(VTOCMP(vp)); /* file info will be cached now, so get size */ } else { if (VTOCMP(vp) && VTOCMP(vp)->cmp_type >= CMP_MAX) { if (VTOCMP(vp)->cmp_type != DATALESS_CMPFS_TYPE) { // if we don't recognize this type, just use the real data fork size if (VTOC(vp)->c_datafork) { *size = VTOC(vp)->c_datafork->ff_size; ret = 0; } else { ret = EINVAL; } } else { *size = decmpfs_cnode_get_vnode_cached_size(VTOCMP(vp)); /* file info will be cached now, so get size */ ret = 0; } } else { ret = EINVAL; } } } if (putaway) { /* did we use hfs_vget() to get this vnode? */ vnode_put(vp); /* if so, release it and set it to null */ vp = NULL; } return ret; } int hfs_hides_rsrc(vfs_context_t ctx, struct cnode *cp, int skiplock) { if (ctx == decmpfs_ctx) return 0; if (!hfs_file_is_compressed(cp, skiplock)) return 0; return decmpfs_hides_rsrc(ctx, cp->c_decmp); } int hfs_hides_xattr(vfs_context_t ctx, struct cnode *cp, const char *name, int skiplock) { if (ctx == decmpfs_ctx) return 0; if (!hfs_file_is_compressed(cp, skiplock)) return 0; return decmpfs_hides_xattr(ctx, cp->c_decmp, name); } #endif /* HFS_COMPRESSION */ // // This function gets the doc_tombstone structure for the // current thread. If the thread doesn't have one, the // structure is allocated. // static struct doc_tombstone * get_uthread_doc_tombstone(void) { struct uthread *ut; ut = get_bsdthread_info(current_thread()); if (ut->t_tombstone == NULL) { ut->t_tombstone = kalloc(sizeof(struct doc_tombstone)); if (ut->t_tombstone) { memset(ut->t_tombstone, 0, sizeof(struct doc_tombstone)); } } return ut->t_tombstone; } // // This routine clears out the current tombstone for the // current thread and if necessary passes the doc-id of // the tombstone on to the dst_cnode. // // If the doc-id transfers to dst_cnode, we also generate // a doc-id changed fsevent. Unlike all the other fsevents, // doc-id changed events can only be generated here in HFS // where we have the necessary info. // static void clear_tombstone_docid(struct doc_tombstone *ut, __unused struct hfsmount *hfsmp, struct cnode *dst_cnode) { uint32_t old_id = ut->t_lastop_document_id; ut->t_lastop_document_id = 0; ut->t_lastop_parent = NULL; ut->t_lastop_parent_vid = 0; ut->t_lastop_filename[0] = '\0'; // // If the lastop item is still the same and needs to be cleared, // clear it. // if (dst_cnode && old_id && ut->t_lastop_item && vnode_vid(ut->t_lastop_item) == ut->t_lastop_item_vid) { // // clear the document_id from the file that used to have it. // XXXdbg - we need to lock the other vnode and make sure to // update it on disk. // struct cnode *ocp = VTOC(ut->t_lastop_item); struct FndrExtendedFileInfo *ofip = (struct FndrExtendedFileInfo *)((char *)&ocp->c_attr.ca_finderinfo + 16); // printf("clearing doc-id from ino %d\n", ocp->c_desc.cd_cnid); ofip->document_id = 0; ocp->c_bsdflags &= ~UF_TRACKED; ocp->c_flag |= C_MODIFIED | C_FORCEUPDATE; // mark it dirty /* cat_update(hfsmp, &ocp->c_desc, &ocp->c_attr, NULL, NULL); */ } #if CONFIG_FSE if (dst_cnode && old_id) { struct FndrExtendedFileInfo *fip = (struct FndrExtendedFileInfo *)((char *)&dst_cnode->c_attr.ca_finderinfo + 16); add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(), FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)ut->t_lastop_fileid, // src inode # FSE_ARG_INO, (ino64_t)dst_cnode->c_fileid, // dst inode # FSE_ARG_INT32, (uint32_t)fip->document_id, FSE_ARG_DONE); } #endif // last, clear these now that we're all done ut->t_lastop_item = NULL; ut->t_lastop_fileid = 0; ut->t_lastop_item_vid = 0; } // // This function is used to filter out operations on temp // filenames. We have to filter out operations on certain // temp filenames to work-around questionable application // behavior from apps like Autocad that perform unusual // sequences of file system operations for a "safe save". static int is_ignorable_temp_name(const char *nameptr, int len) { if (len == 0) { len = strlen(nameptr); } if ( strncmp(nameptr, "atmp", 4) == 0 || (len > 4 && strncmp(nameptr+len-4, ".bak", 4) == 0) || (len > 4 && strncmp(nameptr+len-4, ".tmp", 4) == 0)) { return 1; } return 0; } // // Decide if we need to save a tombstone or not. Normally we always // save a tombstone - but if there already is one and the name we're // given is an ignorable name, then we will not save a tombstone. // static int should_save_docid_tombstone(struct doc_tombstone *ut, struct vnode *vp, struct componentname *cnp) { if (cnp->cn_nameptr == NULL) { return 0; } if (ut->t_lastop_document_id && ut->t_lastop_item == vp && is_ignorable_temp_name(cnp->cn_nameptr, cnp->cn_namelen)) { return 0; } return 1; } // // This function saves a tombstone for the given vnode and name. The // tombstone represents the parent directory and name where the document // used to live and the document-id of that file. This info is recorded // in the doc_tombstone structure hanging off the uthread (which assumes // that all safe-save operations happen on the same thread). // // If later on the same parent/name combo comes back into existence then // we'll preserve the doc-id from this vnode onto the new vnode. // static void save_tombstone(struct hfsmount *hfsmp, struct vnode *dvp, struct vnode *vp, struct componentname *cnp, int for_unlink) { struct cnode *cp = VTOC(vp); struct doc_tombstone *ut; ut = get_uthread_doc_tombstone(); if (for_unlink && vp->v_type == VREG && cp->c_linkcount > 1) { // // a regular file that is being unlinked and that is also // hardlinked should not clear the UF_TRACKED state or // mess with the tombstone because somewhere else in the // file system the file is still alive. // return; } ut->t_lastop_parent = dvp; ut->t_lastop_parent_vid = vnode_vid(dvp); ut->t_lastop_fileid = cp->c_fileid; if (for_unlink) { ut->t_lastop_item = NULL; ut->t_lastop_item_vid = 0; } else { ut->t_lastop_item = vp; ut->t_lastop_item_vid = vnode_vid(vp); } strlcpy((char *)&ut->t_lastop_filename[0], cnp->cn_nameptr, sizeof(ut->t_lastop_filename)); struct FndrExtendedFileInfo *fip = (struct FndrExtendedFileInfo *)((char *)&cp->c_attr.ca_finderinfo + 16); ut->t_lastop_document_id = fip->document_id; if (for_unlink) { // clear this so it's never returned again fip->document_id = 0; cp->c_bsdflags &= ~UF_TRACKED; if (ut->t_lastop_document_id) { (void) cat_update(hfsmp, &cp->c_desc, &cp->c_attr, NULL, NULL); #if CONFIG_FSE // this event is more of a "pending-delete" add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(), FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)cp->c_fileid, // src inode # FSE_ARG_INO, (ino64_t)0, // dst inode # FSE_ARG_INT32, ut->t_lastop_document_id, // document id FSE_ARG_DONE); #endif } } } /* * Open a file/directory. */ int hfs_vnop_open(struct vnop_open_args *ap) { struct vnode *vp = ap->a_vp; struct filefork *fp; struct timeval tv; int error; static int past_bootup = 0; struct cnode *cp = VTOC(vp); struct hfsmount *hfsmp = VTOHFS(vp); #if HFS_COMPRESSION if (ap->a_mode & FWRITE) { /* open for write */ if ( hfs_file_is_compressed(cp, 1) ) { /* 1 == don't take the cnode lock */ /* opening a compressed file for write, so convert it to decompressed */ struct vnode *data_vp = NULL; error = hfs_ref_data_vp(cp, &data_vp, 1); /* 1 == don't take the cnode lock */ if (0 == error) { if (data_vp) { error = decmpfs_decompress_file(data_vp, VTOCMP(data_vp), -1, 1, 0); vnode_rele(data_vp); } else { error = EINVAL; } } if (error != 0) return error; } } else { /* open for read */ if (hfs_file_is_compressed(cp, 1) ) { /* 1 == don't take the cnode lock */ if (VNODE_IS_RSRC(vp)) { /* opening the resource fork of a compressed file, so nothing to do */ } else { /* opening a compressed file for read, make sure it validates */ error = decmpfs_validate_compressed_file(vp, VTOCMP(vp)); if (error != 0) return error; } } } #endif /* * Files marked append-only must be opened for appending. */ if ((cp->c_bsdflags & APPEND) && !vnode_isdir(vp) && (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE) return (EPERM); if (vnode_isreg(vp) && !UBCINFOEXISTS(vp)) return (EBUSY); /* file is in use by the kernel */ /* Don't allow journal to be opened externally. */ if (hfs_is_journal_file(hfsmp, cp)) return (EPERM); if ((hfsmp->hfs_flags & HFS_READ_ONLY) || (hfsmp->jnl == NULL) || #if NAMEDSTREAMS !vnode_isreg(vp) || vnode_isinuse(vp, 0) || vnode_isnamedstream(vp)) { #else !vnode_isreg(vp) || vnode_isinuse(vp, 0)) { #endif return (0); } if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) return (error); #if QUOTA /* If we're going to write to the file, initialize quotas. */ if ((ap->a_mode & FWRITE) && (hfsmp->hfs_flags & HFS_QUOTAS)) (void)hfs_getinoquota(cp); #endif /* QUOTA */ /* * On the first (non-busy) open of a fragmented * file attempt to de-frag it (if its less than 20MB). */ fp = VTOF(vp); if (fp->ff_blocks && fp->ff_extents[7].blockCount != 0 && fp->ff_size <= (20 * 1024 * 1024)) { int no_mods = 0; struct timeval now; /* * Wait until system bootup is done (3 min). * And don't relocate a file that's been modified * within the past minute -- this can lead to * system thrashing. */ if (!past_bootup) { microuptime(&tv); if (tv.tv_sec > (60*3)) { past_bootup = 1; } } microtime(&now); if ((now.tv_sec - cp->c_mtime) > 60) { no_mods = 1; } if (past_bootup && no_mods) { (void) hfs_relocate(vp, hfsmp->nextAllocation + 4096, vfs_context_ucred(ap->a_context), vfs_context_proc(ap->a_context)); } } hfs_unlock(cp); return (0); } /* * Close a file/directory. */ int hfs_vnop_close(ap) struct vnop_close_args /* { struct vnode *a_vp; int a_fflag; vfs_context_t a_context; } */ *ap; { register struct vnode *vp = ap->a_vp; register struct cnode *cp; struct proc *p = vfs_context_proc(ap->a_context); struct hfsmount *hfsmp; int busy; int tooktrunclock = 0; int knownrefs = 0; if ( hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) return (0); cp = VTOC(vp); hfsmp = VTOHFS(vp); /* * If the rsrc fork is a named stream, it can cause the data fork to * stay around, preventing de-allocation of these blocks. * Do checks for truncation on close. Purge extra extents if they exist. * Make sure the vp is not a directory, and that it has a resource fork, * and that resource fork is also a named stream. */ if ((vp->v_type == VREG) && (cp->c_rsrc_vp) && (vnode_isnamedstream(cp->c_rsrc_vp))) { uint32_t blks; blks = howmany(VTOF(vp)->ff_size, VTOVCB(vp)->blockSize); /* * If there are extra blocks and there are only 2 refs on * this vp (ourselves + rsrc fork holding ref on us), go ahead * and try to truncate. */ if ((blks < VTOF(vp)->ff_blocks) && (!vnode_isinuse(vp, 2))) { // release cnode lock; must acquire truncate lock BEFORE cnode lock hfs_unlock(cp); hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); tooktrunclock = 1; if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) { hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); // bail out if we can't re-acquire cnode lock return 0; } // now re-test to make sure it's still valid if (cp->c_rsrc_vp) { knownrefs = 1 + vnode_isnamedstream(cp->c_rsrc_vp); if (!vnode_isinuse(vp, knownrefs)){ // now we can truncate the file, if necessary blks = howmany(VTOF(vp)->ff_size, VTOVCB(vp)->blockSize); if (blks < VTOF(vp)->ff_blocks){ (void) hfs_truncate(vp, VTOF(vp)->ff_size, IO_NDELAY, 0, ap->a_context); } } } } } // if we froze the fs and we're exiting, then "thaw" the fs if (hfsmp->hfs_freeze_state == HFS_FROZEN && hfsmp->hfs_freezing_proc == p && proc_exiting(p)) { hfs_thaw(hfsmp, p); } busy = vnode_isinuse(vp, 1); 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 (tooktrunclock){ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); } hfs_unlock(cp); if (ap->a_fflag & FWASWRITTEN) { hfs_sync_ejectable(hfsmp); } return (0); } static bool hfs_should_generate_document_id(hfsmount_t *hfsmp, cnode_t *cp) { return (!ISSET(hfsmp->hfs_flags, HFS_READ_ONLY) && ISSET(cp->c_bsdflags, UF_TRACKED) && cp->c_desc.cd_cnid != kHFSRootFolderID && (S_ISDIR(cp->c_mode) || S_ISREG(cp->c_mode) || S_ISLNK(cp->c_mode))); } /* * Get basic attributes. */ int hfs_vnop_getattr(struct vnop_getattr_args *ap) { #define VNODE_ATTR_TIMES \ (VNODE_ATTR_va_access_time|VNODE_ATTR_va_change_time|VNODE_ATTR_va_modify_time) #define VNODE_ATTR_AUTH \ (VNODE_ATTR_va_mode | VNODE_ATTR_va_uid | VNODE_ATTR_va_gid | \ VNODE_ATTR_va_flags | VNODE_ATTR_va_acl) struct vnode *vp = ap->a_vp; struct vnode_attr *vap = ap->a_vap; struct vnode *rvp = NULLVP; struct hfsmount *hfsmp; struct cnode *cp; uint64_t data_size; enum vtype v_type; int error = 0; cp = VTOC(vp); #if HFS_COMPRESSION /* we need to inspect the decmpfs state of the file before we take the hfs cnode lock */ int compressed = 0; int hide_size = 0; off_t uncompressed_size = -1; if (VATTR_IS_ACTIVE(vap, va_data_size) || VATTR_IS_ACTIVE(vap, va_total_alloc) || VATTR_IS_ACTIVE(vap, va_data_alloc) || VATTR_IS_ACTIVE(vap, va_total_size)) { /* we only care about whether the file is compressed if asked for the uncompressed size */ if (VNODE_IS_RSRC(vp)) { /* if it's a resource fork, decmpfs may want us to hide the size */ hide_size = hfs_hides_rsrc(ap->a_context, cp, 0); } else { /* if it's a data fork, we need to know if it was compressed so we can report the uncompressed size */ compressed = hfs_file_is_compressed(cp, 0); } if ((VATTR_IS_ACTIVE(vap, va_data_size) || VATTR_IS_ACTIVE(vap, va_total_size))) { // if it's compressed if (compressed || (!VNODE_IS_RSRC(vp) && cp->c_decmp && cp->c_decmp->cmp_type >= CMP_MAX)) { if (0 != hfs_uncompressed_size_of_compressed_file(NULL, vp, 0, &uncompressed_size, 0)) { /* failed to get the uncompressed size, we'll check for this later */ uncompressed_size = -1; } else { // fake that it's compressed compressed = 1; } } } } #endif /* * Shortcut for vnode_authorize path. Each of the attributes * in this set is updated atomically so we don't need to take * the cnode lock to access them. */ if ((vap->va_active & ~VNODE_ATTR_AUTH) == 0) { /* Make sure file still exists. */ if (cp->c_flag & C_NOEXISTS) return (ENOENT); vap->va_uid = cp->c_uid; vap->va_gid = cp->c_gid; vap->va_mode = cp->c_mode; vap->va_flags = cp->c_bsdflags; vap->va_supported |= VNODE_ATTR_AUTH & ~VNODE_ATTR_va_acl; if ((cp->c_attr.ca_recflags & kHFSHasSecurityMask) == 0) { vap->va_acl = (kauth_acl_t) KAUTH_FILESEC_NONE; VATTR_SET_SUPPORTED(vap, va_acl); } return (0); } hfsmp = VTOHFS(vp); v_type = vnode_vtype(vp); if (VATTR_IS_ACTIVE(vap, va_document_id)) { uint32_t document_id; if (cp->c_desc.cd_cnid == kHFSRootFolderID) document_id = kHFSRootFolderID; else { /* * This is safe without a lock because we're just reading * a 32 bit aligned integer which should be atomic on all * platforms we support. */ document_id = hfs_get_document_id(cp); if (!document_id && hfs_should_generate_document_id(hfsmp, cp)) { uint32_t new_document_id; error = hfs_generate_document_id(hfsmp, &new_document_id); if (error) return error; error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); if (error) return error; bool want_docid_fsevent = false; // Need to check again now that we have the lock document_id = hfs_get_document_id(cp); if (!document_id && hfs_should_generate_document_id(hfsmp, cp)) { cp->c_attr.ca_finderextendeddirinfo.document_id = document_id = new_document_id; want_docid_fsevent = true; SET(cp->c_flag, C_MODIFIED); } hfs_unlock(cp); if (want_docid_fsevent) { #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, ap->a_context, FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)0, // src inode # FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode # FSE_ARG_INT32, document_id, FSE_ARG_DONE); if (need_fsevent(FSE_STAT_CHANGED, vp)) { add_fsevent(FSE_STAT_CHANGED, ap->a_context, FSE_ARG_VNODE, vp, FSE_ARG_DONE); } #endif } } } vap->va_document_id = document_id; VATTR_SET_SUPPORTED(vap, va_document_id); } /* * If time attributes are requested and we have cnode times * that require updating, then acquire an exclusive lock on * the cnode before updating the times. Otherwise we can * just acquire a shared lock. */ if ((vap->va_active & VNODE_ATTR_TIMES) && (cp->c_touch_acctime || cp->c_touch_chgtime || cp->c_touch_modtime)) { if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) return (error); hfs_touchtimes(hfsmp, cp); } else { if ((error = hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) return (error); } if (v_type == VDIR) { data_size = (cp->c_entries + 2) * AVERAGE_HFSDIRENTRY_SIZE; if (VATTR_IS_ACTIVE(vap, va_nlink)) { int nlink; /* * For directories, the va_nlink is esentially a count * of the ".." references to a directory plus the "." * reference and the directory itself. So for HFS+ this * becomes the sub-directory count plus two. * * In the absence of a sub-directory count we use the * directory's item count. This will be too high in * most cases since it also includes files. */ if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) && (cp->c_attr.ca_recflags & kHFSHasFolderCountMask)) nlink = cp->c_attr.ca_dircount; /* implied ".." entries */ else nlink = cp->c_entries; /* Account for ourself and our "." entry */ nlink += 2; /* Hide our private directories. */ if (cp->c_cnid == kHFSRootFolderID) { if (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid != 0) { --nlink; } if (hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid != 0) { --nlink; } } VATTR_RETURN(vap, va_nlink, (u_int64_t)nlink); } if (VATTR_IS_ACTIVE(vap, va_nchildren)) { int entries; entries = cp->c_entries; /* Hide our private files and directories. */ if (cp->c_cnid == kHFSRootFolderID) { if (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid != 0) --entries; if (hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid != 0) --entries; if (hfsmp->jnl || ((hfsmp->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY))) entries -= 2; /* hide the journal files */ } VATTR_RETURN(vap, va_nchildren, entries); } /* * The va_dirlinkcount is the count of real directory hard links. * (i.e. its not the sum of the implied "." and ".." references) */ if (VATTR_IS_ACTIVE(vap, va_dirlinkcount)) { VATTR_RETURN(vap, va_dirlinkcount, (uint32_t)cp->c_linkcount); } } else /* !VDIR */ { data_size = VCTOF(vp, cp)->ff_size; VATTR_RETURN(vap, va_nlink, (u_int64_t)cp->c_linkcount); if (VATTR_IS_ACTIVE(vap, va_data_alloc)) { u_int64_t blocks; #if HFS_COMPRESSION if (hide_size) { VATTR_RETURN(vap, va_data_alloc, 0); } else if (compressed) { /* for compressed files, we report all allocated blocks as belonging to the data fork */ blocks = cp->c_blocks; VATTR_RETURN(vap, va_data_alloc, blocks * (u_int64_t)hfsmp->blockSize); } else #endif { blocks = VCTOF(vp, cp)->ff_blocks; VATTR_RETURN(vap, va_data_alloc, blocks * (u_int64_t)hfsmp->blockSize); } } } /* 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_entries + 2) * AVERAGE_HFSDIRENTRY_SIZE); } else { u_int64_t total_size = ~0ULL; struct cnode *rcp; #if HFS_COMPRESSION if (hide_size) { /* we're hiding the size of this file, so just return 0 */ total_size = 0; } else if (compressed) { if (uncompressed_size == -1) { /* * We failed to get the uncompressed size above, * so we'll fall back to the standard path below * since total_size is still -1 */ } else { /* use the uncompressed size we fetched above */ total_size = uncompressed_size; } } #endif if (total_size == ~0ULL) { if (cp->c_datafork) { total_size = cp->c_datafork->ff_size; } if (cp->c_blocks - VTOF(vp)->ff_blocks) { /* We deal with rsrc fork vnode iocount at the end of the function */ error = hfs_vgetrsrc(hfsmp, vp, &rvp); if (error) { /* * Note that we call hfs_vgetrsrc with error_on_unlinked * set to FALSE. This is because we may be invoked via * fstat() on an open-unlinked file descriptor and we must * continue to support access to the rsrc fork until it disappears. * The code at the end of this function will be * responsible for releasing the iocount generated by * hfs_vgetrsrc. This is because we can't drop the iocount * without unlocking the cnode first. */ goto out; } rcp = VTOC(rvp); if (rcp && rcp->c_rsrcfork) { total_size += rcp->c_rsrcfork->ff_size; } } } VATTR_RETURN(vap, va_total_size, total_size); } } 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, (u_int64_t)cp->c_blocks * (u_int64_t)hfsmp->blockSize); } } /* * 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 (VATTR_IS_ACTIVE(vap, va_acl)) { if ((cp->c_attr.ca_recflags & kHFSHasSecurityMask) == 0) { vap->va_acl = (kauth_acl_t) KAUTH_FILESEC_NONE; VATTR_SET_SUPPORTED(vap, va_acl); } } if (VATTR_IS_ACTIVE(vap, va_access_time)) { /* Access times are lazily 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_create_time.tv_sec = cp->c_itime; vap->va_create_time.tv_nsec = 0; vap->va_modify_time.tv_sec = cp->c_mtime; vap->va_modify_time.tv_nsec = 0; vap->va_change_time.tv_sec = cp->c_ctime; vap->va_change_time.tv_nsec = 0; vap->va_backup_time.tv_sec = cp->c_btime; vap->va_backup_time.tv_nsec = 0; /* See if we need to emit the date added field to the user */ if (VATTR_IS_ACTIVE(vap, va_addedtime)) { u_int32_t dateadded = hfs_get_dateadded (cp); if (dateadded) { vap->va_addedtime.tv_sec = dateadded; vap->va_addedtime.tv_nsec = 0; VATTR_SET_SUPPORTED (vap, va_addedtime); } } /* XXX is this really a good 'optimal I/O size'? */ vap->va_iosize = hfsmp->hfs_logBlockSize; vap->va_uid = cp->c_uid; vap->va_gid = cp->c_gid; vap->va_mode = cp->c_mode; vap->va_flags = cp->c_bsdflags; /* * Exporting file IDs from HFS Plus: * * For "normal" files the c_fileid is the same value as the * c_cnid. But for hard link files, they are different - the * 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) uses va_fileid and the Carbon APIs, * which are hardlink-ignorant, will ask for va_linkid. */ vap->va_fileid = (u_int64_t)cp->c_fileid; /* * We need to use the origin cache for both hardlinked files * and directories. Hardlinked directories have multiple cnids * and parents (one per link). Hardlinked files also have their * own parents and link IDs separate from the indirect inode number. * If we don't use the cache, we could end up vending the wrong ID * because the cnode will only reflect the link that was looked up most recently. */ if (cp->c_flag & C_HARDLINK) { vap->va_linkid = (u_int64_t)hfs_currentcnid(cp); vap->va_parentid = (u_int64_t)hfs_currentparent(cp); } else { vap->va_linkid = (u_int64_t)cp->c_cnid; vap->va_parentid = (u_int64_t)cp->c_parentcnid; } vap->va_fsid = hfsmp->hfs_raw_dev; vap->va_filerev = 0; vap->va_encoding = cp->c_encoding; vap->va_rdev = (v_type == VBLK || v_type == VCHR) ? cp->c_rdev : 0; #if HFS_COMPRESSION if (VATTR_IS_ACTIVE(vap, va_data_size)) { if (hide_size) vap->va_data_size = 0; else if (compressed) { if (uncompressed_size == -1) { /* failed to get the uncompressed size above, so just return data_size */ vap->va_data_size = data_size; } else { /* use the uncompressed size we fetched above */ vap->va_data_size = uncompressed_size; } } else vap->va_data_size = data_size; // vap->va_supported |= VNODE_ATTR_va_data_size; VATTR_SET_SUPPORTED(vap, va_data_size); } #else vap->va_data_size = data_size; vap->va_supported |= VNODE_ATTR_va_data_size; #endif #if CONFIG_PROTECT if (VATTR_IS_ACTIVE(vap, va_dataprotect_class)) { vap->va_dataprotect_class = cp->c_cpentry ? cp->c_cpentry->cp_pclass : 0; VATTR_SET_SUPPORTED(vap, va_dataprotect_class); } #endif if (VATTR_IS_ACTIVE(vap, va_write_gencount)) { if (ubc_is_mapped_writable(vp)) { /* * Return 0 to the caller to indicate the file may be * changing. There is no need for us to increment the * generation counter here because it gets done as part of * page-out and also when the file is unmapped (to account * for changes we might not have seen). */ vap->va_write_gencount = 0; } else { vap->va_write_gencount = hfs_get_gencount(cp); } VATTR_SET_SUPPORTED(vap, va_write_gencount); } /* Mark them all at once instead of individual VATTR_SET_SUPPORTED calls. */ vap->va_supported |= VNODE_ATTR_va_create_time | VNODE_ATTR_va_modify_time | VNODE_ATTR_va_change_time| VNODE_ATTR_va_backup_time | VNODE_ATTR_va_iosize | VNODE_ATTR_va_uid | VNODE_ATTR_va_gid | VNODE_ATTR_va_mode | VNODE_ATTR_va_flags |VNODE_ATTR_va_fileid | VNODE_ATTR_va_linkid | VNODE_ATTR_va_parentid | VNODE_ATTR_va_fsid | VNODE_ATTR_va_filerev | VNODE_ATTR_va_encoding | VNODE_ATTR_va_rdev; /* If this is the root, let VFS to find out the mount name, which * may be different from the real name. Otherwise, we need to take care * for hardlinked files, which need to be looked up, if necessary */ if (VATTR_IS_ACTIVE(vap, va_name) && (cp->c_cnid != kHFSRootFolderID)) { struct cat_desc linkdesc; int lockflags; int uselinkdesc = 0; cnid_t nextlinkid = 0; cnid_t prevlinkid = 0; /* Get the name for ATTR_CMN_NAME. We need to take special care for hardlinks * here because the info. for the link ID requested by getattrlist may be * different than what's currently in the cnode. This is because the cnode * will be filled in with the information for the most recent link ID that went * through namei/lookup(). If there are competing lookups for hardlinks that point * to the same inode, one (or more) getattrlists could be vended incorrect name information. * Also, we need to beware of open-unlinked files which could have a namelen of 0. */ if ((cp->c_flag & C_HARDLINK) && ((cp->c_desc.cd_namelen == 0) || (vap->va_linkid != cp->c_cnid))) { /* * If we have no name and our link ID is the raw inode number, then we may * have an open-unlinked file. Go to the next link in this case. */ if ((cp->c_desc.cd_namelen == 0) && (vap->va_linkid == cp->c_fileid)) { if ((error = hfs_lookup_siblinglinks(hfsmp, vap->va_linkid, &prevlinkid, &nextlinkid))){ goto out; } } else { /* just use link obtained from vap above */ nextlinkid = vap->va_linkid; } /* We need to probe the catalog for the descriptor corresponding to the link ID * stored in nextlinkid. Note that we don't know if we have the exclusive lock * for the cnode here, so we can't just update the descriptor. Instead, * we should just store the descriptor's value locally and then use it to pass * out the name value as needed below. */ if (nextlinkid){ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK); error = cat_findname(hfsmp, nextlinkid, &linkdesc); hfs_systemfile_unlock(hfsmp, lockflags); if (error == 0) { uselinkdesc = 1; } } } /* By this point, we've either patched up the name above and the c_desc * points to the correct data, or it already did, in which case we just proceed * by copying the name into the vap. Note that we will never set va_name to * supported if nextlinkid is never initialized. This could happen in the degenerate * case above involving the raw inode number, where it has no nextlinkid. In this case * we will simply not mark the name bit as supported. */ if (uselinkdesc) { strlcpy(vap->va_name, (const char*) linkdesc.cd_nameptr, MAXPATHLEN); VATTR_SET_SUPPORTED(vap, va_name); cat_releasedesc(&linkdesc); } else if (cp->c_desc.cd_namelen) { strlcpy(vap->va_name, (const char*) cp->c_desc.cd_nameptr, MAXPATHLEN); VATTR_SET_SUPPORTED(vap, va_name); } } out: hfs_unlock(cp); /* * We need to vnode_put the rsrc fork vnode only *after* we've released * the cnode lock, since vnode_put can trigger an inactive call, which * will go back into HFS and try to acquire a cnode lock. */ if (rvp) { vnode_put (rvp); } return (error); } int hfs_vnop_setattr(ap) struct vnop_setattr_args /* { struct vnode *a_vp; struct vnode_attr *a_vap; vfs_context_t a_context; } */ *ap; { struct vnode_attr *vap = ap->a_vap; struct vnode *vp = ap->a_vp; 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; time_t orig_ctime; orig_ctime = VTOC(vp)->c_ctime; #if HFS_COMPRESSION int decmpfs_reset_state = 0; /* we call decmpfs_update_attributes even if the file is not compressed because we want to update the incoming flags if the xattrs are invalid */ error = decmpfs_update_attributes(vp, vap); if (error) return error; #endif // // if this is not a size-changing setattr and it is not just // an atime update, then check for a snapshot. // if (!VATTR_IS_ACTIVE(vap, va_data_size) && !(vap->va_active == VNODE_ATTR_va_access_time)) { check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_METADATA_MOD, NSPACE_REARM_NO_ARG); } #if CONFIG_PROTECT if ((error = cp_handle_vnop(vp, CP_WRITE_ACCESS, 0)) != 0) { return (error); } #endif /* CONFIG_PROTECT */ hfsmp = VTOHFS(vp); /* Don't allow modification of the journal. */ if (hfs_is_journal_file(hfsmp, VTOC(vp))) { return (EPERM); } // // Check if we'll need a document_id and if so, get it before we lock the // the cnode to avoid any possible deadlock with the root vnode which has // to get locked to get the document id // u_int32_t document_id=0; if (VATTR_IS_ACTIVE(vap, va_flags) && (vap->va_flags & UF_TRACKED) && !(VTOC(vp)->c_bsdflags & UF_TRACKED)) { struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&(VTOC(vp)->c_attr.ca_finderinfo) + 16); // // If the document_id is not set, get a new one. It will be set // on the file down below once we hold the cnode lock. // if (fip->document_id == 0) { if (hfs_generate_document_id(hfsmp, &document_id) != 0) { document_id = 0; } } } /* * File size change request. * We are guaranteed that this is not a directory, and that * the filesystem object is writeable. * * NOTE: HFS COMPRESSION depends on the data_size being set *before* the bsd flags are updated */ VATTR_SET_SUPPORTED(vap, va_data_size); if (VATTR_IS_ACTIVE(vap, va_data_size) && !vnode_islnk(vp)) { #if HFS_COMPRESSION /* keep the compressed state locked until we're done truncating the file */ decmpfs_cnode *dp = VTOCMP(vp); if (!dp) { /* * call hfs_lazy_init_decmpfs_cnode() to make sure that the decmpfs_cnode * is filled in; we need a decmpfs_cnode to lock out decmpfs state changes * on this file while it's truncating */ dp = hfs_lazy_init_decmpfs_cnode(VTOC(vp)); if (!dp) { /* failed to allocate a decmpfs_cnode */ return ENOMEM; /* what should this be? */ } } check_for_tracked_file(vp, orig_ctime, vap->va_data_size == 0 ? NAMESPACE_HANDLER_TRUNCATE_OP|NAMESPACE_HANDLER_DELETE_OP : NAMESPACE_HANDLER_TRUNCATE_OP, NULL); decmpfs_lock_compressed_data(dp, 1); if (hfs_file_is_compressed(VTOC(vp), 1)) { error = decmpfs_decompress_file(vp, dp, -1/*vap->va_data_size*/, 0, 1); if (error != 0) { decmpfs_unlock_compressed_data(dp, 1); return error; } } #endif // Take truncate lock hfs_lock_truncate(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); // hfs_truncate will deal with the cnode lock error = hfs_truncate(vp, vap->va_data_size, vap->va_vaflags & 0xffff, 0, ap->a_context); hfs_unlock_truncate(VTOC(vp), HFS_LOCK_DEFAULT); #if HFS_COMPRESSION decmpfs_unlock_compressed_data(dp, 1); #endif if (error) return error; } if (cp == NULL) { if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) return (error); cp = VTOC(vp); } /* * If it is just an access time update request by itself * we know the request is from kernel level code, and we * can delay it without being as worried about consistency. * This change speeds up mmaps, in the rare case that they * get caught behind a sync. */ if (vap->va_active == VNODE_ATTR_va_access_time) { cp->c_touch_acctime=TRUE; goto out; } /* * 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; /* * 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; /* * 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)) { u_int16_t *fdFlags; #if HFS_COMPRESSION if ((cp->c_bsdflags ^ vap->va_flags) & UF_COMPRESSED) { /* * the UF_COMPRESSED was toggled, so reset our cached compressed state * but we don't want to actually do the update until we've released the cnode lock down below * NOTE: turning the flag off doesn't actually decompress the file, so that we can * turn off the flag and look at the "raw" file for debugging purposes */ decmpfs_reset_state = 1; } #endif if ((vap->va_flags & UF_TRACKED) && !(cp->c_bsdflags & UF_TRACKED)) { struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16); // // we're marking this item UF_TRACKED. if the document_id is // not set, get a new one and put it on the file. // if (fip->document_id == 0) { if (document_id != 0) { // printf("SETATTR: assigning doc-id %d to %s (ino %d)\n", document_id, vp->v_name, cp->c_desc.cd_cnid); fip->document_id = (uint32_t)document_id; #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, ap->a_context, FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)0, // src inode # FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode # FSE_ARG_INT32, document_id, FSE_ARG_DONE); #endif } else { // printf("hfs: could not acquire a new document_id for %s (ino %d)\n", vp->v_name, cp->c_desc.cd_cnid); } } } else if (!(vap->va_flags & UF_TRACKED) && (cp->c_bsdflags & UF_TRACKED)) { // // UF_TRACKED is being cleared so clear the document_id // struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16); if (fip->document_id) { // printf("SETATTR: clearing doc-id %d from %s (ino %d)\n", fip->document_id, vp->v_name, cp->c_desc.cd_cnid); #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, ap->a_context, FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)cp->c_fileid, // src inode # FSE_ARG_INO, (ino64_t)0, // dst inode # FSE_ARG_INT32, fip->document_id, // document id FSE_ARG_DONE); #endif fip->document_id = 0; cp->c_bsdflags &= ~UF_TRACKED; } } cp->c_bsdflags = vap->va_flags; cp->c_touch_chgtime = TRUE; /* * Mirror the UF_HIDDEN flag to the invisible bit of the Finder Info. * * The fdFlags for files and frFlags for folders are both 8 bytes * into the userInfo (the first 16 bytes of the Finder Info). They * are both 16-bit fields. */ fdFlags = (u_int16_t *) &cp->c_finderinfo[8]; if (vap->va_flags & UF_HIDDEN) *fdFlags |= OSSwapHostToBigConstInt16(kFinderInvisibleMask); else *fdFlags &= ~OSSwapHostToBigConstInt16(kFinderInvisibleMask); } /* * 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 (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 (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; hfs_clear_might_be_dirty_flag(cp); /* * The utimes system call can reset the modification * time but it doesn't know about HFS create times. * 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 != kHFSRootFolderID) && (cp->c_mtime < cp->c_itime)) { cp->c_itime = cp->c_mtime; } } if (VATTR_IS_ACTIVE(vap, va_backup_time)) cp->c_btime = vap->va_backup_time.tv_sec; cp->c_flag |= C_MODIFIED; } /* * 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); } if ((error = hfs_update(vp, TRUE)) != 0) goto out; out: if (cp) { /* Purge origin cache for cnode, since caller now has correct link ID for it * We purge it here since it was acquired for us during lookup, and we no longer need it. */ if ((cp->c_flag & C_HARDLINK) && (vp->v_type != VDIR)){ hfs_relorigin(cp, 0); } hfs_unlock(cp); #if HFS_COMPRESSION if (decmpfs_reset_state) { /* * we've changed the UF_COMPRESSED flag, so reset the decmpfs state for this cnode * but don't do it while holding the hfs cnode lock */ decmpfs_cnode *dp = VTOCMP(vp); if (!dp) { /* * call hfs_lazy_init_decmpfs_cnode() to make sure that the decmpfs_cnode * is filled in; we need a decmpfs_cnode to prevent decmpfs state changes * on this file if it's locked */ dp = hfs_lazy_init_decmpfs_cnode(VTOC(vp)); if (!dp) { /* failed to allocate a decmpfs_cnode */ return ENOMEM; /* what should this be? */ } } decmpfs_cnode_set_vnode_state(dp, FILE_TYPE_UNKNOWN, 0); } #endif } return (error); } /* * Change the mode on a file. * cnode must be locked before calling. */ int hfs_chmod(struct vnode *vp, int mode, __unused kauth_cred_t cred, __unused struct proc *p) { register struct cnode *cp = VTOC(vp); if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord) return (0); // Don't allow modification of the journal or journal_info_block if (hfs_is_journal_file(VTOHFS(vp), cp)) { return EPERM; } #if OVERRIDE_UNKNOWN_PERMISSIONS if (((unsigned int)vfs_flags(VTOVFS(vp))) & MNT_UNKNOWNPERMISSIONS) { return (0); }; #endif cp->c_mode &= ~ALLPERMS; cp->c_mode |= (mode & ALLPERMS); cp->c_touch_chgtime = TRUE; return (0); } int hfs_write_access(struct vnode *vp, kauth_cred_t cred, struct proc *p, Boolean considerFlags) { struct cnode *cp = VTOC(vp); int retval = 0; 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 (vnode_vtype(vp)) { case VDIR: case VLNK: case VREG: if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY) return (EROFS); break; default: break; } /* If immutable bit set, nobody gets to write it. */ if (considerFlags && (cp->c_bsdflags & IMMUTABLE)) return (EPERM); /* Otherwise, user id 0 always gets access. */ if (!suser(cred, NULL)) return (0); /* Otherwise, check the owner. */ if ((retval = hfs_owner_rights(VTOHFS(vp), cp->c_uid, cred, p, false)) == 0) return ((cp->c_mode & S_IWUSR) == S_IWUSR ? 0 : EACCES); /* Otherwise, check the groups. */ 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. */ return ((cp->c_mode & S_IWOTH) == S_IWOTH ? 0 : EACCES); } /* * Perform chown operation on cnode cp; * code must be locked prior to call. */ int #if !QUOTA hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, __unused kauth_cred_t cred, __unused struct proc *p) #else hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred, __unused struct proc *p) #endif { register struct cnode *cp = VTOC(vp); uid_t ouid; gid_t ogid; #if QUOTA int error = 0; register int i; int64_t change; #endif /* QUOTA */ if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord) return (ENOTSUP); 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 ((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 QUOTA if ((error = hfs_getinoquota(cp))) return (error); if (ouid == uid) { dqrele(cp->c_dquot[USRQUOTA]); cp->c_dquot[USRQUOTA] = NODQUOT; } if (ogid == gid) { dqrele(cp->c_dquot[GRPQUOTA]); cp->c_dquot[GRPQUOTA] = NODQUOT; } /* * Eventually need to account for (fake) a block per directory * 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(cp->c_dquot[i]); cp->c_dquot[i] = NODQUOT; } #endif /* QUOTA */ cp->c_gid = gid; cp->c_uid = uid; #if QUOTA if ((error = hfs_getinoquota(cp)) == 0) { if (ouid == uid) { dqrele(cp->c_dquot[USRQUOTA]); cp->c_dquot[USRQUOTA] = NODQUOT; } if (ogid == gid) { dqrele(cp->c_dquot[GRPQUOTA]); cp->c_dquot[GRPQUOTA] = NODQUOT; } if ((error = hfs_chkdq(cp, change, cred, CHOWN)) == 0) { if ((error = hfs_chkiq(cp, 1, cred, CHOWN)) == 0) goto good; else (void) hfs_chkdq(cp, -change, cred, CHOWN|FORCE); } for (i = 0; i < MAXQUOTAS; i++) { dqrele(cp->c_dquot[i]); cp->c_dquot[i] = NODQUOT; } } cp->c_gid = ogid; cp->c_uid = ouid; if (hfs_getinoquota(cp) == 0) { if (ouid == uid) { dqrele(cp->c_dquot[USRQUOTA]); cp->c_dquot[USRQUOTA] = NODQUOT; } if (ogid == gid) { dqrele(cp->c_dquot[GRPQUOTA]); cp->c_dquot[GRPQUOTA] = NODQUOT; } (void) hfs_chkdq(cp, change, cred, FORCE|CHOWN); (void) hfs_chkiq(cp, 1, cred, FORCE|CHOWN); (void) hfs_getinoquota(cp); } return (error); good: if (hfs_getinoquota(cp)) panic("hfs_chown: lost quota"); #endif /* QUOTA */ /* According to the SUSv3 Standard, chown() shall mark for update the st_ctime field of the file. (No exceptions mentioned) */ cp->c_touch_chgtime = TRUE; return (0); } #if HFS_COMPRESSION /* * Flush the resource fork if it exists. vp is the data fork and has * an iocount. */ static int hfs_flush_rsrc(vnode_t vp, vfs_context_t ctx) { cnode_t *cp = VTOC(vp); hfs_lock(cp, HFS_SHARED_LOCK, 0); vnode_t rvp = cp->c_rsrc_vp; if (!rvp) { hfs_unlock(cp); return 0; } int vid = vnode_vid(rvp); hfs_unlock(cp); int error = vnode_getwithvid(rvp, vid); if (error) return error == ENOENT ? 0 : error; hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, 0); hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK); hfs_filedone(rvp, ctx, HFS_FILE_DONE_NO_SYNC); hfs_unlock(cp); hfs_unlock_truncate(cp, 0); error = ubc_msync(rvp, 0, ubc_getsize(rvp), NULL, UBC_PUSHALL | UBC_SYNC); vnode_put(rvp); return error; } #endif // HFS_COMPRESSION /* * hfs_vnop_exchange: * * Inputs: * 'from' vnode/cnode * 'to' vnode/cnode * options flag bits * vfs_context * * Discussion: * hfs_vnop_exchange is used to service the exchangedata(2) system call. * Per the requirements of that system call, this function "swaps" some * of the information that lives in one catalog record for some that * lives in another. Note that not everything is swapped; in particular, * the extent information stored in each cnode is kept local to that * cnode. This allows existing file descriptor references to continue * to operate on the same content, regardless of the location in the * namespace that the file may have moved to. See inline comments * in the function for more information. */ int hfs_vnop_exchange(ap) struct vnop_exchange_args /* { struct vnode *a_fvp; struct vnode *a_tvp; 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; struct cnode *to_cp; struct hfsmount *hfsmp; struct cat_desc tempdesc; struct cat_attr tempattr; const unsigned char *from_nameptr; const unsigned char *to_nameptr; char from_iname[32]; char to_iname[32]; uint32_t to_flag_special; uint32_t from_flag_special; cnid_t from_parid; cnid_t to_parid; int lockflags; int error = 0, started_tr = 0, got_cookie = 0; cat_cookie_t cookie; time_t orig_from_ctime, orig_to_ctime; bool have_cnode_locks = false, have_from_trunc_lock = false, have_to_trunc_lock = false; /* * VFS does the following checks: * 1. Validate that both are files. * 2. Validate that both are on the same mount. * 3. Validate that they're not the same vnode. */ from_cp = VTOC(from_vp); to_cp = VTOC(to_vp); hfsmp = VTOHFS(from_vp); orig_from_ctime = from_cp->c_ctime; orig_to_ctime = to_cp->c_ctime; #if CONFIG_PROTECT /* * Do not allow exchangedata/F_MOVEDATAEXTENTS on data-protected filesystems * because the EAs will not be swapped. As a result, the persistent keys would not * match and the files will be garbage. */ if (cp_fs_protected (vnode_mount(from_vp))) { return EINVAL; } #endif #if HFS_COMPRESSION if (!ISSET(ap->a_options, FSOPT_EXCHANGE_DATA_ONLY)) { if ( hfs_file_is_compressed(from_cp, 0) ) { if ( 0 != ( error = decmpfs_decompress_file(from_vp, VTOCMP(from_vp), -1, 0, 1) ) ) { return error; } } if ( hfs_file_is_compressed(to_cp, 0) ) { if ( 0 != ( error = decmpfs_decompress_file(to_vp, VTOCMP(to_vp), -1, 0, 1) ) ) { return error; } } } #endif // HFS_COMPRESSION // Resource forks cannot be exchanged. if (VNODE_IS_RSRC(from_vp) || VNODE_IS_RSRC(to_vp)) return EINVAL; /* * Normally, we want to notify the user handlers about the event, * except if it's a handler driving the event. */ if ((ap->a_options & FSOPT_EXCHANGE_DATA_ONLY) == 0) { check_for_tracked_file(from_vp, orig_from_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL); check_for_tracked_file(to_vp, orig_to_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL); } else { /* * This is currently used by mtmd so we should tidy up the * file now because the data won't be used again in the * destination file. */ hfs_lock_truncate(from_cp, HFS_EXCLUSIVE_LOCK, 0); hfs_lock_always(from_cp, HFS_EXCLUSIVE_LOCK); hfs_filedone(from_vp, ap->a_context, HFS_FILE_DONE_NO_SYNC); hfs_unlock(from_cp); hfs_unlock_truncate(from_cp, 0); // Flush all the data from the source file error = ubc_msync(from_vp, 0, ubc_getsize(from_vp), NULL, UBC_PUSHALL | UBC_SYNC); if (error) goto exit; #if HFS_COMPRESSION /* * If this is a compressed file, we need to do the same for * the resource fork. */ if (ISSET(from_cp->c_bsdflags, UF_COMPRESSED)) { error = hfs_flush_rsrc(from_vp, ap->a_context); if (error) goto exit; } #endif /* * We're doing a data-swap so we need to take the truncate * lock exclusively. We need an exclusive lock because we * will be completely truncating the source file and we must * make sure nobody else sneaks in and trys to issue I/O * whilst we don't have the cnode lock. * * After taking the truncate lock we do a quick check to * verify there are no other references (including mmap * references), but we must remember that this does not stop * anybody coming in later and taking a reference. We will * have the truncate lock exclusively so that will prevent * them from issuing any I/O. */ if (to_cp < from_cp) { hfs_lock_truncate(to_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); have_to_trunc_lock = true; } hfs_lock_truncate(from_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); have_from_trunc_lock = true; /* * Do an early check to verify the source is not in use by * anyone. We should be called from an FD opened as F_EVTONLY * so that doesn't count as a reference. */ if (vnode_isinuse(from_vp, 0)) { error = EBUSY; goto exit; } if (to_cp >= from_cp) { hfs_lock_truncate(to_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); have_to_trunc_lock = true; } } if ((error = hfs_lockpair(from_cp, to_cp, HFS_EXCLUSIVE_LOCK))) goto exit; have_cnode_locks = true; // Don't allow modification of the journal or journal_info_block if (hfs_is_journal_file(hfsmp, from_cp) || hfs_is_journal_file(hfsmp, to_cp)) { error = EPERM; goto exit; } /* * Ok, now that all of the pre-flighting is done, call the underlying * function if needed. */ if (ISSET(ap->a_options, FSOPT_EXCHANGE_DATA_ONLY)) { #if HFS_COMPRESSION if (ISSET(from_cp->c_bsdflags, UF_COMPRESSED)) { error = hfs_move_compressed(from_cp, to_cp); goto exit; } #endif error = hfs_move_data(from_cp, to_cp, 0); goto exit; } 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, vfs_context_proc(ap->a_context)))) { goto exit; } got_cookie = 1; /* The backend code always tries to delete the virtual * extent id for exchanging files so we need to lock * the extents b-tree. */ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK); /* Account for the location of the catalog objects. */ if (from_cp->c_flag & C_HARDLINK) { MAKE_INODE_NAME(from_iname, sizeof(from_iname), from_cp->c_attr.ca_linkref); from_nameptr = (unsigned char *)from_iname; from_parid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid; from_cp->c_hint = 0; } else { from_nameptr = from_cp->c_desc.cd_nameptr; from_parid = from_cp->c_parentcnid; } if (to_cp->c_flag & C_HARDLINK) { MAKE_INODE_NAME(to_iname, sizeof(to_iname), to_cp->c_attr.ca_linkref); to_nameptr = (unsigned char *)to_iname; to_parid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid; to_cp->c_hint = 0; } else { to_nameptr = to_cp->c_desc.cd_nameptr; to_parid = to_cp->c_parentcnid; } /* * ExchangeFileIDs swaps the on-disk, or in-BTree extent information * attached to two different file IDs. It also swaps the extent * information that may live in the extents-overflow B-Tree. * * We do this in a transaction as this may require a lot of B-Tree nodes * to do completely, particularly if one of the files in question * has a lot of extents. * * For example, assume "file1" has fileID 50, and "file2" has fileID 52. * For the on-disk records, which are assumed to be synced, we will * first swap the resident inline-8 extents as part of the catalog records. * Then we will swap any extents overflow records for each file. * * When ExchangeFileIDs returns successfully, "file1" will have fileID 52, * and "file2" will have fileID 50. However, note that this is only * approximately half of the work that exchangedata(2) will need to * accomplish. In other words, we swap "too much" of the information * because if we only called ExchangeFileIDs, both the fileID and extent * information would be the invariants of this operation. We don't * actually want that; we want to conclude with "file1" having * file ID 50, and "file2" having fileID 52. * * The remainder of hfs_vnop_exchange will swap the file ID and other cnode * data back to the proper ownership, while still allowing the cnode to remain * pointing at the same set of extents that it did originally. */ error = ExchangeFileIDs(hfsmp, from_nameptr, to_nameptr, from_parid, to_parid, from_cp->c_hint, to_cp->c_hint); hfs_systemfile_unlock(hfsmp, lockflags); /* * Note that we don't need to exchange any extended attributes * since the attributes are keyed by file ID. */ if (error != E_NONE) { error = MacToVFSError(error); goto exit; } /* Purge the vnodes from the name cache */ if (from_vp) cache_purge(from_vp); if (to_vp) cache_purge(to_vp); /* Bump both source and destination write counts before any swaps. */ { hfs_incr_gencount (from_cp); hfs_incr_gencount (to_cp); } /* Save a copy of "from" attributes before swapping. */ bcopy(&from_cp->c_desc, &tempdesc, sizeof(struct cat_desc)); bcopy(&from_cp->c_attr, &tempattr, sizeof(struct cat_attr)); /* Save whether or not each cnode is a hardlink or has EAs */ from_flag_special = from_cp->c_flag & (C_HARDLINK | C_HASXATTRS); to_flag_special = to_cp->c_flag & (C_HARDLINK | C_HASXATTRS); /* Drop the special bits from each cnode */ from_cp->c_flag &= ~(C_HARDLINK | C_HASXATTRS); to_cp->c_flag &= ~(C_HARDLINK | C_HASXATTRS); /* * Now complete the in-memory portion of the copy. * * ExchangeFileIDs swaps the on-disk records involved. We complete the * operation by swapping the in-memory contents of the two files here. * We swap the cnode descriptors, which contain name, BSD attributes, * timestamps, etc, about the file. * * NOTE: We do *NOT* swap the fileforks of the two cnodes. We have * already swapped the on-disk extent information. As long as we swap the * IDs, the in-line resident 8 extents that live in the filefork data * structure will point to the right data for the new file ID if we leave * them alone. * * As a result, any file descriptor that points to a particular * vnode (even though it should change names), will continue * to point to the same content. */ /* Copy the "to" -> "from" cnode */ bcopy(&to_cp->c_desc, &from_cp->c_desc, sizeof(struct cat_desc)); from_cp->c_hint = 0; /* * If 'to' was a hardlink, then we copied over its link ID/CNID/(namespace ID) * when we bcopy'd the descriptor above. However, the cnode attributes * are not bcopied. As a result, make sure to swap the file IDs of each item. * * Further, other hardlink attributes must be moved along in this swap: * the linkcount, the linkref, and the firstlink all need to move * along with the file IDs. See note below regarding the flags and * what moves vs. what does not. * * For Reference: * linkcount == total # of hardlinks. * linkref == the indirect inode pointer. * firstlink == the first hardlink in the chain (written to the raw inode). * These three are tied to the fileID and must move along with the rest of the data. */ from_cp->c_fileid = to_cp->c_attr.ca_fileid; from_cp->c_itime = to_cp->c_itime; from_cp->c_btime = to_cp->c_btime; from_cp->c_atime = to_cp->c_atime; from_cp->c_ctime = to_cp->c_ctime; from_cp->c_gid = to_cp->c_gid; from_cp->c_uid = to_cp->c_uid; from_cp->c_bsdflags = to_cp->c_bsdflags; from_cp->c_mode = to_cp->c_mode; from_cp->c_linkcount = to_cp->c_linkcount; from_cp->c_attr.ca_linkref = to_cp->c_attr.ca_linkref; from_cp->c_attr.ca_firstlink = to_cp->c_attr.ca_firstlink; /* * The cnode flags need to stay with the cnode and not get transferred * over along with everything else because they describe the content; they are * not attributes that reflect changes specific to the file ID. In general, * fields that are tied to the file ID are the ones that will move. * * This reflects the fact that the file may have borrowed blocks, dirty metadata, * or other extents, which may not yet have been written to the catalog. If * they were, they would have been transferred above in the ExchangeFileIDs call above... * * The flags that are special are: * C_HARDLINK, C_HASXATTRS * * These flags move with the item and file ID in the namespace since their * state is tied to that of the file ID. * * So to transfer the flags, we have to take the following steps * 1) Store in a localvar whether or not the special bits are set. * 2) Drop the special bits from the current flags * 3) swap the special flag bits to their destination */ from_cp->c_flag |= to_flag_special; from_cp->c_attr.ca_recflags = to_cp->c_attr.ca_recflags; bcopy(to_cp->c_finderinfo, from_cp->c_finderinfo, 32); /* Copy the "from" -> "to" cnode */ bcopy(&tempdesc, &to_cp->c_desc, sizeof(struct cat_desc)); to_cp->c_hint = 0; /* * Pull the file ID from the tempattr we copied above. We can't assume * it is the same as the CNID. */ to_cp->c_fileid = tempattr.ca_fileid; to_cp->c_itime = tempattr.ca_itime; to_cp->c_btime = tempattr.ca_btime; to_cp->c_atime = tempattr.ca_atime; to_cp->c_ctime = tempattr.ca_ctime; to_cp->c_gid = tempattr.ca_gid; to_cp->c_uid = tempattr.ca_uid; to_cp->c_bsdflags = tempattr.ca_flags; to_cp->c_mode = tempattr.ca_mode; to_cp->c_linkcount = tempattr.ca_linkcount; to_cp->c_attr.ca_linkref = tempattr.ca_linkref; to_cp->c_attr.ca_firstlink = tempattr.ca_firstlink; /* * Only OR in the "from" flags into our cnode flags below. * Leave the rest of the flags alone. */ to_cp->c_flag |= from_flag_special; to_cp->c_attr.ca_recflags = tempattr.ca_recflags; bcopy(tempattr.ca_finderinfo, to_cp->c_finderinfo, 32); /* Rehash the cnodes using their new file IDs */ hfs_chash_rehash(hfsmp, from_cp, to_cp); /* * When a file moves out of "Cleanup At Startup" * we can drop its NODUMP status. */ if ((from_cp->c_bsdflags & UF_NODUMP) && (from_cp->c_parentcnid != to_cp->c_parentcnid)) { from_cp->c_bsdflags &= ~UF_NODUMP; from_cp->c_touch_chgtime = TRUE; } if ((to_cp->c_bsdflags & UF_NODUMP) && (to_cp->c_parentcnid != from_cp->c_parentcnid)) { to_cp->c_bsdflags &= ~UF_NODUMP; to_cp->c_touch_chgtime = TRUE; } exit: if (got_cookie) { cat_postflight(hfsmp, &cookie, vfs_context_proc(ap->a_context)); } if (started_tr) { hfs_end_transaction(hfsmp); } if (have_from_trunc_lock) hfs_unlock_truncate(from_cp, 0); if (have_to_trunc_lock) hfs_unlock_truncate(to_cp, 0); if (have_cnode_locks) hfs_unlockpair(from_cp, to_cp); return (error); } #if HFS_COMPRESSION /* * This function is used specifically for the case when a namespace * handler is trying to steal data before it's deleted. Note that we * don't bother deleting the xattr from the source because it will get * deleted a short time later anyway. * * cnodes must be locked */ static int hfs_move_compressed(cnode_t *from_cp, cnode_t *to_cp) { int ret; void *data = NULL; CLR(from_cp->c_bsdflags, UF_COMPRESSED); SET(from_cp->c_flag, C_MODIFIED); ret = hfs_move_data(from_cp, to_cp, HFS_MOVE_DATA_INCLUDE_RSRC); if (ret) goto exit; /* * Transfer the xattr that decmpfs uses. Ideally, this code * should be with the other decmpfs code but it's file system * agnostic and this path is currently, and likely to remain, HFS+ * specific. It's easier and more performant if we implement it * here. */ size_t size = MAX_DECMPFS_XATTR_SIZE; MALLOC(data, void *, size, M_TEMP, M_WAITOK); ret = hfs_xattr_read(from_cp->c_vp, DECMPFS_XATTR_NAME, data, &size); if (ret) goto exit; ret = hfs_xattr_write(to_cp->c_vp, DECMPFS_XATTR_NAME, data, size); if (ret) goto exit; SET(to_cp->c_bsdflags, UF_COMPRESSED); SET(to_cp->c_flag, C_MODIFIED); exit: if (data) FREE(data, M_TEMP); return ret; } #endif // HFS_COMPRESSION int hfs_vnop_mmap(struct vnop_mmap_args *ap) { struct vnode *vp = ap->a_vp; cnode_t *cp = VTOC(vp); int error; if (VNODE_IS_RSRC(vp)) { /* allow pageins of the resource fork */ } else { int compressed = hfs_file_is_compressed(cp, 1); /* 1 == don't take the cnode lock */ time_t orig_ctime = cp->c_ctime; if (!compressed && (cp->c_bsdflags & UF_COMPRESSED)) { error = check_for_dataless_file(vp, NAMESPACE_HANDLER_READ_OP); if (error != 0) { return error; } } if (ap->a_fflags & PROT_WRITE) { check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL); } } // // NOTE: we return ENOTSUP because we want the cluster layer // to actually do all the real work. // return (ENOTSUP); } static errno_t hfs_vnop_mnomap(struct vnop_mnomap_args *ap) { vnode_t vp = ap->a_vp; /* * Whilst the file was mapped, there may not have been any * page-outs so we need to increment the generation counter now. * Unfortunately this may lead to a change in the generation * counter when no actual change has been made, but there is * little we can do about that with our current architecture. */ if (ubc_is_mapped_writable(vp)) { cnode_t *cp = VTOC(vp); hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS); hfs_incr_gencount(cp); /* * We don't want to set the modification time here since a * change to that is not acceptable if no changes were made. * Instead we set a flag so that if we get any page-outs we * know to update the modification time. It's possible that * they weren't actually because of changes made whilst the * file was mapped but that's not easy to fix now. */ SET(cp->c_flag, C_MIGHT_BE_DIRTY_FROM_MAPPING); hfs_unlock(cp); } return 0; } /* * Mark the resource fork as needing a ubc_setsize when we drop the * cnode lock later. */ static void hfs_rsrc_setsize(cnode_t *cp) { /* * We need to take an iocount if we don't have one. vnode_get * will return ENOENT if the vnode is terminating which is what we * want as it's not safe to call ubc_setsize in that case. */ if (cp->c_rsrc_vp && !vnode_get(cp->c_rsrc_vp)) { // Shouldn't happen, but better safe... if (ISSET(cp->c_flag, C_NEED_RVNODE_PUT)) vnode_put(cp->c_rsrc_vp); SET(cp->c_flag, C_NEED_RVNODE_PUT | C_NEED_RSRC_SETSIZE); } } /* * hfs_move_data * * This is a non-symmetric variant of exchangedata. In this function, * the contents of the data fork (and optionally the resource fork) * are moved from from_cp to to_cp. * * The cnodes must be locked. * * The cnode pointed to by 'to_cp' *must* be empty prior to invoking * this function. We impose this restriction because we may not be * able to fully delete the entire file's contents in a single * transaction, particularly if it has a lot of extents. In the * normal file deletion codepath, the file is screened for two * conditions: 1) bigger than 400MB, and 2) more than 8 extents. If * so, the file is relocated to the hidden directory and the deletion * is broken up into multiple truncates. We can't do that here * because both files need to exist in the namespace. The main reason * this is imposed is that we may have to touch a whole lot of bitmap * blocks if there are many extents. * * Any data written to 'from_cp' after this call completes is not * guaranteed to be moved. * * Arguments: * cnode_t *from_cp : source file * cnode_t *to_cp : destination file; must be empty * * Returns: * * EBUSY - File has been deleted or is in use * EFBIG - Destination file was not empty * EIO - An I/O error * 0 - success * other - Other errors that can be returned from called functions */ int hfs_move_data(cnode_t *from_cp, cnode_t *to_cp, hfs_move_data_options_t options) { hfsmount_t *hfsmp = VTOHFS(from_cp->c_vp); int error = 0; int lockflags = 0; bool return_EIO_on_error = false; const bool include_rsrc = ISSET(options, HFS_MOVE_DATA_INCLUDE_RSRC); /* Verify that neither source/dest file is open-unlinked */ if (ISSET(from_cp->c_flag, C_DELETED | C_NOEXISTS) || ISSET(to_cp->c_flag, C_DELETED | C_NOEXISTS)) { return EBUSY; } /* * Verify the source file is not in use by anyone besides us. * * This function is typically invoked by a namespace handler * process responding to a temporarily stalled system call. * The FD that it is working off of is opened O_EVTONLY, so * it really has no active usecounts (the kusecount from O_EVTONLY * is subtracted from the total usecounts). * * As a result, we shouldn't have any active usecounts against * this vnode when we go to check it below. */ if (vnode_isinuse(from_cp->c_vp, 0)) return EBUSY; if (include_rsrc && from_cp->c_rsrc_vp) { if (vnode_isinuse(from_cp->c_rsrc_vp, 0)) return EBUSY; /* * In the code below, if the destination file doesn't have a * c_rsrcfork then we don't create it which means we we cannot * transfer the ff_invalidranges and cf_vblocks fields. These * shouldn't be set because we flush the resource fork before * calling this function but there is a tiny window when we * did not have any locks... */ if (!to_cp->c_rsrcfork && (!TAILQ_EMPTY(&from_cp->c_rsrcfork->ff_invalidranges) || from_cp->c_rsrcfork->ff_unallocblocks)) { /* * The file isn't really busy now but something did slip * in and tinker with the file while we didn't have any * locks, so this is the most meaningful return code for * the caller. */ return EBUSY; } } // Check the destination file is empty if (to_cp->c_datafork->ff_blocks || to_cp->c_datafork->ff_size || (include_rsrc && (to_cp->c_blocks || (to_cp->c_rsrcfork && to_cp->c_rsrcfork->ff_size)))) { return EFBIG; } if ((error = hfs_start_transaction (hfsmp))) return error; lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK); // filefork_t is 128 bytes which should be OK filefork_t rfork_buf, *from_rfork = NULL; if (include_rsrc) { from_rfork = from_cp->c_rsrcfork; /* * Creating resource fork vnodes is expensive, so just get get * the fork data if we need it. */ if (!from_rfork && hfs_has_rsrc(from_cp)) { from_rfork = &rfork_buf; from_rfork->ff_cp = from_cp; TAILQ_INIT(&from_rfork->ff_invalidranges); error = cat_idlookup(hfsmp, from_cp->c_fileid, 0, 1, NULL, NULL, &from_rfork->ff_data); if (error) goto exit; } } /* * From here on, any failures mean that we might be leaving things * in a weird or inconsistent state. Ideally, we should back out * all the changes, but to do that properly we need to fix * MoveData. We'll save fixing that for another time. For now, * just return EIO in all cases to the caller so that they know. */ return_EIO_on_error = true; bool data_overflow_extents = overflow_extents(from_cp->c_datafork); // Move the data fork if ((error = hfs_move_fork (from_cp->c_datafork, from_cp, to_cp->c_datafork, to_cp))) { goto exit; } SET(from_cp->c_flag, C_NEED_DATA_SETSIZE); SET(to_cp->c_flag, C_NEED_DATA_SETSIZE); // We move the resource fork later /* * Note that because all we're doing is moving the extents around, * we can probably do this in a single transaction: Each extent * record (group of 8) is 64 bytes. A extent overflow B-Tree node * is typically 4k. This means each node can hold roughly ~60 * extent records == (480 extents). * * If a file was massively fragmented and had 20k extents, this * means we'd roughly touch 20k/480 == 41 to 42 nodes, plus the * index nodes, for half of the operation. (inserting or * deleting). So if we're manipulating 80-100 nodes, this is * basically 320k of data to write to the journal in a bad case. */ if (data_overflow_extents) { if ((error = MoveData(hfsmp, from_cp->c_cnid, to_cp->c_cnid, 0))) goto exit; } if (from_rfork && overflow_extents(from_rfork)) { if ((error = MoveData(hfsmp, from_cp->c_cnid, to_cp->c_cnid, 1))) goto exit; } // Touch times from_cp->c_touch_acctime = TRUE; from_cp->c_touch_chgtime = TRUE; from_cp->c_touch_modtime = TRUE; hfs_touchtimes(hfsmp, from_cp); to_cp->c_touch_acctime = TRUE; to_cp->c_touch_chgtime = TRUE; to_cp->c_touch_modtime = TRUE; hfs_touchtimes(hfsmp, to_cp); struct cat_fork dfork_buf; const struct cat_fork *dfork, *rfork; dfork = hfs_prepare_fork_for_update(to_cp->c_datafork, &dfork_buf, hfsmp->blockSize); rfork = hfs_prepare_fork_for_update(from_rfork, &rfork_buf.ff_data, hfsmp->blockSize); // Update the catalog nodes, to_cp first if ((error = cat_update(hfsmp, &to_cp->c_desc, &to_cp->c_attr, dfork, rfork))) { goto exit; } CLR(to_cp->c_flag, C_MODIFIED); // Update in-memory resource fork data here if (from_rfork) { // Update c_blocks uint32_t moving = from_rfork->ff_blocks + from_rfork->ff_unallocblocks; from_cp->c_blocks -= moving; to_cp->c_blocks += moving; // Update to_cp's resource data if it has it filefork_t *to_rfork = to_cp->c_rsrcfork; if (to_rfork) { to_rfork->ff_invalidranges = from_rfork->ff_invalidranges; to_rfork->ff_data = from_rfork->ff_data; // Deal with ubc_setsize hfs_rsrc_setsize(to_cp); } // Wipe out the resource fork in from_cp rl_init(&from_rfork->ff_invalidranges); bzero(&from_rfork->ff_data, sizeof(from_rfork->ff_data)); // Deal with ubc_setsize hfs_rsrc_setsize(from_cp); } // Currently unnecessary, but might be useful in future... dfork = hfs_prepare_fork_for_update(from_cp->c_datafork, &dfork_buf, hfsmp->blockSize); rfork = hfs_prepare_fork_for_update(from_rfork, &rfork_buf.ff_data, hfsmp->blockSize); // Update from_cp if ((error = cat_update(hfsmp, &from_cp->c_desc, &from_cp->c_attr, dfork, rfork))) { goto exit; } CLR(from_cp->c_flag, C_MODIFIED); exit: if (lockflags) { hfs_systemfile_unlock(hfsmp, lockflags); hfs_end_transaction(hfsmp); } if (error && error != EIO && return_EIO_on_error) { printf("hfs_move_data: encountered error %d\n", error); error = EIO; } return error; } /* * Move all of the catalog and runtime data in srcfork to dstfork. * * This allows us to maintain the invalid ranges across the move data * operation so we don't need to force all of the pending IO right * now. In addition, we move all non overflow-extent extents into the * destination here. * * The destination fork must be empty and should have been checked * prior to calling this. */ static int hfs_move_fork(filefork_t *srcfork, cnode_t *src_cp, filefork_t *dstfork, cnode_t *dst_cp) { // Move the invalid ranges dstfork->ff_invalidranges = srcfork->ff_invalidranges; rl_init(&srcfork->ff_invalidranges); // Move the fork data (copy whole structure) dstfork->ff_data = srcfork->ff_data; bzero(&srcfork->ff_data, sizeof(srcfork->ff_data)); // Update c_blocks src_cp->c_blocks -= dstfork->ff_blocks + dstfork->ff_unallocblocks; dst_cp->c_blocks += dstfork->ff_blocks + dstfork->ff_unallocblocks; return 0; } #include struct hfs_fsync_panic_hook { panic_hook_t hook; struct cnode *cp; }; static void hfs_fsync_panic_hook(panic_hook_t *hook_) { struct hfs_fsync_panic_hook *hook = (struct hfs_fsync_panic_hook *)hook_; extern int kdb_log(const char *fmt, ...); // Get the physical region just before cp panic_phys_range_t range; uint64_t phys; if (panic_phys_range_before(hook->cp, &phys, &range)) { kdb_log("cp = %p, phys = %p, prev (%p: %p-%p)\n", hook->cp, phys, range.type, range.phys_start, range.phys_start + range.len); } else kdb_log("cp = %p, phys = %p, prev (!)\n", hook->cp, phys); panic_dump_mem((void *)(((vm_offset_t)hook->cp - 4096) & ~4095), 12288); kdb_log("\n"); } /* * cnode must be locked */ int hfs_fsync(struct vnode *vp, int waitfor, int fullsync, struct proc *p) { struct cnode *cp = VTOC(vp); struct filefork *fp = NULL; int retval = 0; struct hfsmount *hfsmp = VTOHFS(vp); struct rl_entry *invalid_range; struct timeval tv; int waitdata; /* attributes necessary for data retrieval */ int wait; /* all other attributes (e.g. atime, etc.) */ int lockflag; int took_trunc_lock = 0; int locked_buffers = 0; /* * Applications which only care about data integrity rather than full * file integrity may opt out of (delay) expensive metadata update * operations as a performance optimization. */ wait = (waitfor == MNT_WAIT); waitdata = (waitfor == MNT_DWAIT) | wait; if (always_do_fullfsync) fullsync = 1; /* HFS directories don't have any data blocks. */ if (vnode_isdir(vp)) goto metasync; fp = VTOF(vp); /* * For system files flush the B-tree header and * for regular files write out any clusters */ if (vnode_issystem(vp)) { if (VTOF(vp)->fcbBTCBPtr != NULL) { // XXXdbg if (hfsmp->jnl == NULL) { BTFlushPath(VTOF(vp)); } } } else if (UBCINFOEXISTS(vp)) { hfs_unlock(cp); hfs_lock_truncate(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT); took_trunc_lock = 1; struct hfs_fsync_panic_hook hook; hook.cp = cp; panic_hook(&hook.hook, hfs_fsync_panic_hook); if (fp->ff_unallocblocks != 0) { hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); } panic_unhook(&hook.hook); /* Don't hold cnode lock when calling into cluster layer. */ (void) cluster_push(vp, waitdata ? IO_SYNC : 0); hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS); } /* * When MNT_WAIT is requested and the zero fill timeout * has expired then we must explicitly zero out any areas * that are currently marked invalid (holes). * * Files with NODUMP can bypass zero filling here. */ if (fp && (((cp->c_flag & C_ALWAYS_ZEROFILL) && !TAILQ_EMPTY(&fp->ff_invalidranges)) || ((wait || (cp->c_flag & C_ZFWANTSYNC)) && ((cp->c_bsdflags & UF_NODUMP) == 0) && UBCINFOEXISTS(vp) && (vnode_issystem(vp) ==0) && cp->c_zftimeout != 0))) { microuptime(&tv); if ((cp->c_flag & C_ALWAYS_ZEROFILL) == 0 && !fullsync && tv.tv_sec < (long)cp->c_zftimeout) { /* Remember that a force sync was requested. */ cp->c_flag |= C_ZFWANTSYNC; goto datasync; } if (!TAILQ_EMPTY(&fp->ff_invalidranges)) { if (!took_trunc_lock || (cp->c_truncatelockowner == HFS_SHARED_OWNER)) { hfs_unlock(cp); if (took_trunc_lock) { hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); } hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS); took_trunc_lock = 1; } while ((invalid_range = TAILQ_FIRST(&fp->ff_invalidranges))) { off_t start = invalid_range->rl_start; off_t end = invalid_range->rl_end; /* The range about to be written must be validated * first, so that VNOP_BLOCKMAP() will return the * appropriate mapping for the cluster code: */ rl_remove(start, end, &fp->ff_invalidranges); /* Don't hold cnode lock when calling into cluster layer. */ hfs_unlock(cp); (void) cluster_write(vp, (struct uio *) 0, fp->ff_size, end + 1, start, (off_t)0, IO_HEADZEROFILL | IO_NOZERODIRTY | IO_NOCACHE); hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS); cp->c_flag |= C_MODIFIED; } hfs_unlock(cp); (void) cluster_push(vp, waitdata ? IO_SYNC : 0); hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS); } cp->c_flag &= ~C_ZFWANTSYNC; cp->c_zftimeout = 0; } datasync: if (took_trunc_lock) { hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); took_trunc_lock = 0; } /* * if we have a journal and if journal_active() returns != 0 then the * we shouldn't do anything to a locked block (because it is part * 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. * Record how many of them were dirty AND locked (if necessary). */ locked_buffers = buf_flushdirtyblks_skipinfo(vp, waitdata, lockflag, "hfs_fsync"); if ((lockflag & BUF_SKIP_LOCKED) && (locked_buffers) && (vnode_vtype(vp) == VLNK)) { /* * If there are dirty symlink buffers, then we may need to take action * to prevent issues later on if we are journaled. If we're fsyncing a * symlink vnode then we are in one of three cases: * * 1) automatic sync has fired. In this case, we don't want the behavior to change. * * 2) Someone has opened the FD for the symlink (not what it points to) * and has issued an fsync against it. This should be rare, and we don't * want the behavior to change. * * 3) We are being called by a vclean which is trying to reclaim this * symlink vnode. If this is the case, then allowing this fsync to * proceed WITHOUT flushing the journal could result in the vclean * invalidating the buffer's blocks before the journal transaction is * written to disk. To prevent this, we force a journal flush * if the vnode is in the middle of a recycle (VL_TERMINATE or VL_DEAD is set). */ if (vnode_isrecycled(vp)) { fullsync = 1; } } metasync: if (vnode_isreg(vp) && vnode_issystem(vp)) { if (VTOF(vp)->fcbBTCBPtr != NULL) { microuptime(&tv); BTSetLastSync(VTOF(vp), tv.tv_sec); } 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 the catalog record for * this file. If they asked for a full fsync, we can skip this * because the journal_flush or hfs_metasync_all will push out * all of the metadata changes. */ if ((retval == 0) && wait && !fullsync && cp->c_hint && !ISSET(cp->c_flag, C_DELETED | C_NOEXISTS)) { hfs_metasync(VTOHFS(vp), (daddr64_t)cp->c_hint, p); } /* * If this was a full fsync, make sure all metadata * changes get to stable storage. */ if (fullsync) { if (hfsmp->jnl) { hfs_journal_flush(hfsmp, FALSE); if (journal_uses_fua(hfsmp->jnl)) { /* * the journal_flush did NOT issue a sync track cache command, * and the fullsync indicates we are supposed to flush all cached * data to the media, so issue the sync track cache command * explicitly */ VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, NULL); } } else { retval = hfs_metasync_all(hfsmp); /* XXX need to pass context! */ VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, NULL); } } } return (retval); } /* Sync an hfs catalog b-tree node */ int hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, __unused struct proc *p) { vnode_t vp; buf_t bp; int lockflags; vp = HFSTOVCB(hfsmp)->catalogRefNum; // XXXdbg - don't need to do this on a journaled volume if (hfsmp->jnl) { 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 */ 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); } hfs_systemfile_unlock(hfsmp, lockflags); return (0); } /* * Sync all hfs B-trees. Use this instead of journal_flush for a volume * without a journal. Note that the volume bitmap does not get written; * we rely on fsck_hfs to fix that up (which it can do without any loss * of data). */ int hfs_metasync_all(struct hfsmount *hfsmp) { int lockflags; /* Lock all of the B-trees so we get a mutually consistent state */ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG|SFL_EXTENTS|SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK); /* Sync each of the B-trees */ if (hfsmp->hfs_catalog_vp) hfs_btsync(hfsmp->hfs_catalog_vp, 0); if (hfsmp->hfs_extents_vp) hfs_btsync(hfsmp->hfs_extents_vp, 0); if (hfsmp->hfs_attribute_vp) hfs_btsync(hfsmp->hfs_attribute_vp, 0); /* Wait for all of the writes to complete */ if (hfsmp->hfs_catalog_vp) vnode_waitforwrites(hfsmp->hfs_catalog_vp, 0, 0, 0, "hfs_metasync_all"); if (hfsmp->hfs_extents_vp) vnode_waitforwrites(hfsmp->hfs_extents_vp, 0, 0, 0, "hfs_metasync_all"); if (hfsmp->hfs_attribute_vp) vnode_waitforwrites(hfsmp->hfs_attribute_vp, 0, 0, 0, "hfs_metasync_all"); hfs_systemfile_unlock(hfsmp, lockflags); return 0; } /*ARGSUSED 1*/ static int hfs_btsync_callback(struct buf *bp, __unused void *dummy) { buf_clearflags(bp, B_LOCKED); (void) buf_bawrite(bp); return(BUF_CLAIMED); } int hfs_btsync(struct vnode *vp, int sync_transaction) { struct cnode *cp = VTOC(vp); struct timeval tv; int flags = 0; if (sync_transaction) flags |= BUF_SKIP_NONLOCKED; /* * Flush all dirty buffers associated with b-tree. */ buf_iterate(vp, hfs_btsync_callback, flags, 0); microuptime(&tv); if (vnode_issystem(vp) && (VTOF(vp)->fcbBTCBPtr != NULL)) (void) BTSetLastSync(VTOF(vp), tv.tv_sec); cp->c_touch_acctime = FALSE; cp->c_touch_chgtime = FALSE; cp->c_touch_modtime = FALSE; return 0; } /* * Remove a directory. */ int 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; { struct vnode *dvp = ap->a_dvp; struct vnode *vp = ap->a_vp; struct cnode *dcp = VTOC(dvp); struct cnode *cp = VTOC(vp); int error; time_t orig_ctime; orig_ctime = VTOC(vp)->c_ctime; if (!S_ISDIR(cp->c_mode)) { return (ENOTDIR); } if (dvp == vp) { return (EINVAL); } check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL); cp = VTOC(vp); if ((error = hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK))) { return (error); } /* Check for a race with rmdir on the parent directory */ if (dcp->c_flag & (C_DELETED | C_NOEXISTS)) { hfs_unlockpair (dcp, cp); return ENOENT; } // // if the item is tracked but doesn't have a document_id, assign one and generate an fsevent for it // if ((cp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id == 0) { uint32_t newid; hfs_unlockpair(dcp, cp); if (hfs_generate_document_id(VTOHFS(vp), &newid) == 0) { hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK); ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id = newid; #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(), FSE_ARG_DEV, VTOHFS(vp)->hfs_raw_dev, FSE_ARG_INO, (ino64_t)0, // src inode # FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode # FSE_ARG_INT32, newid, FSE_ARG_DONE); #endif } else { // XXXdbg - couldn't get a new docid... what to do? can't really fail the rm... hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK); } } error = hfs_removedir(dvp, vp, ap->a_cnp, 0, 0); hfs_unlockpair(dcp, cp); return (error); } /* * Remove a directory * * Both dvp and vp cnodes are locked */ int hfs_removedir(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, int skip_reserve, int only_unlink) { struct cnode *cp; struct cnode *dcp; struct hfsmount * hfsmp; struct cat_desc desc; int lockflags; int error = 0, started_tr = 0; cp = VTOC(vp); dcp = VTOC(dvp); hfsmp = VTOHFS(vp); if (dcp == cp) { return (EINVAL); /* cannot remove "." */ } if (cp->c_flag & (C_NOEXISTS | C_DELETED)) { return (0); } if (cp->c_entries != 0) { return (ENOTEMPTY); } /* * If the directory is open or in use (e.g. opendir() or current working * directory for some process); wait for inactive/reclaim to actually * remove cnode from the catalog. Both inactive and reclaim codepaths are capable * of removing open-unlinked directories from the catalog, as well as getting rid * of EAs still on the element. So change only_unlink to true, so that it will get * cleaned up below. * * Otherwise, we can get into a weird old mess where the directory has C_DELETED, * but it really means C_NOEXISTS because the item was actually removed from the * catalog. Then when we try to remove the entry from the catalog later on, it won't * really be there anymore. */ if (vnode_isinuse(vp, 0)) { only_unlink = 1; } /* Deal with directory hardlinks */ if (cp->c_flag & C_HARDLINK) { /* * Note that if we have a directory which was a hardlink at any point, * its actual directory data is stored in the directory inode in the hidden * directory rather than the leaf element(s) present in the namespace. * * If there are still other hardlinks to this directory, * then we'll just eliminate this particular link and the vnode will still exist. * If this is the last link to an empty directory, then we'll open-unlink the * directory and it will be only tagged with C_DELETED (as opposed to C_NOEXISTS). * * We could also return EBUSY here. */ return hfs_unlink(hfsmp, dvp, vp, cnp, skip_reserve); } /* * In a few cases, we may want to allow the directory to persist in an * open-unlinked state. If the directory is being open-unlinked (still has usecount * references), or if it has EAs, or if it was being deleted as part of a rename, * then we go ahead and move it to the hidden directory. * * If the directory is being open-unlinked, then we want to keep the catalog entry * alive so that future EA calls and fchmod/fstat etc. do not cause issues later. * * If the directory had EAs, then we want to use the open-unlink trick so that the * EA removal is not done in one giant transaction. Otherwise, it could cause a panic * due to overflowing the journal. * * Finally, if it was deleted as part of a rename, we move it to the hidden directory * in order to maintain rename atomicity. * * Note that the allow_dirs argument to hfs_removefile specifies that it is * supposed to handle directories for this case. */ if (((hfsmp->hfs_attribute_vp != NULL) && ((cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0)) || (only_unlink != 0)) { int ret = hfs_removefile(dvp, vp, cnp, 0, 0, 1, NULL, only_unlink); /* * Even though hfs_vnop_rename calls vnode_recycle for us on tvp we call * it here just in case we were invoked by rmdir() on a directory that had * EAs. To ensure that we start reclaiming the space as soon as possible, * we call vnode_recycle on the directory. */ vnode_recycle(vp); return ret; } dcp->c_flag |= C_DIR_MODIFICATION; #if QUOTA if (hfsmp->hfs_flags & HFS_QUOTAS) (void)hfs_getinoquota(cp); #endif if ((error = hfs_start_transaction(hfsmp)) != 0) { goto out; } started_tr = 1; /* * Verify the directory is empty (and valid). * (Rmdir ".." won't be valid since * ".." will contain a reference to * the current directory and thus be * non-empty.) */ if ((dcp->c_bsdflags & APPEND) || (cp->c_bsdflags & (IMMUTABLE | APPEND))) { error = EPERM; goto out; } /* Remove the entry from the namei cache: */ cache_purge(vp); /* * 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_nameptr = (const u_int8_t *)cnp->cn_nameptr; desc.cd_namelen = cnp->cn_namelen; desc.cd_parentcnid = dcp->c_fileid; desc.cd_cnid = cp->c_cnid; desc.cd_flags = CD_ISDIR; desc.cd_encoding = cp->c_encoding; desc.cd_hint = 0; if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid, NULL, &error)) { error = 0; goto out; } /* Remove entry from catalog */ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK); if (!skip_reserve) { /* * Reserve some space in the Catalog file. */ if ((error = cat_preflight(hfsmp, CAT_DELETE, NULL, 0))) { hfs_systemfile_unlock(hfsmp, lockflags); goto out; } } error = cat_delete(hfsmp, &desc, &cp->c_attr); if (!error) { // // if skip_reserve == 1 then we're being called from hfs_vnop_rename() and thus // we don't need to touch the document_id as it's handled by the rename code. // otherwise it's a normal remove and we need to save the document id in the // per thread struct and clear it from the cnode. // struct doc_tombstone *ut; ut = get_uthread_doc_tombstone(); if (!skip_reserve && (cp->c_bsdflags & UF_TRACKED) && should_save_docid_tombstone(ut, vp, cnp)) { if (ut->t_lastop_document_id) { clear_tombstone_docid(ut, hfsmp, NULL); } save_tombstone(hfsmp, dvp, vp, cnp, 1); } /* The parent lost a child */ if (dcp->c_entries > 0) dcp->c_entries--; DEC_FOLDERCOUNT(hfsmp, dcp->c_attr); dcp->c_dirchangecnt++; hfs_incr_gencount(dcp); dcp->c_touch_chgtime = TRUE; dcp->c_touch_modtime = TRUE; hfs_touchtimes(hfsmp, cp); (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL); cp->c_flag &= ~(C_MODIFIED | C_FORCEUPDATE); } hfs_systemfile_unlock(hfsmp, lockflags); if (error) goto out; #if QUOTA if (hfsmp->hfs_flags & HFS_QUOTAS) (void)hfs_chkiq(cp, -1, NOCRED, 0); #endif /* QUOTA */ hfs_volupdate(hfsmp, VOL_RMDIR, (dcp->c_cnid == kHFSRootFolderID)); /* Mark C_NOEXISTS since the catalog entry is now gone */ cp->c_flag |= C_NOEXISTS; out: dcp->c_flag &= ~C_DIR_MODIFICATION; wakeup((caddr_t)&dcp->c_flag); if (started_tr) { hfs_end_transaction(hfsmp); } return (error); } /* * Remove a file or link. */ int 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; { struct vnode *dvp = ap->a_dvp; struct vnode *vp = ap->a_vp; struct cnode *dcp = VTOC(dvp); struct cnode *cp; struct vnode *rvp = NULL; int error=0, recycle_rsrc=0; int recycle_vnode = 0; uint32_t rsrc_vid = 0; time_t orig_ctime; if (dvp == vp) { return (EINVAL); } orig_ctime = VTOC(vp)->c_ctime; if (!vnode_isnamedstream(vp) && ((ap->a_flags & VNODE_REMOVE_SKIP_NAMESPACE_EVENT) == 0)) { error = check_for_tracked_file(vp, orig_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL); if (error) { // XXXdbg - decide on a policy for handling namespace handler failures! // for now we just let them proceed. } } error = 0; cp = VTOC(vp); relock: hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); if ((error = hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK))) { hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); if (rvp) { vnode_put (rvp); } return (error); } // // if the item is tracked but doesn't have a document_id, assign one and generate an fsevent for it // if ((cp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id == 0) { uint32_t newid; hfs_unlockpair(dcp, cp); if (hfs_generate_document_id(VTOHFS(vp), &newid) == 0) { hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK); ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id = newid; #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(), FSE_ARG_DEV, VTOHFS(vp)->hfs_raw_dev, FSE_ARG_INO, (ino64_t)0, // src inode # FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode # FSE_ARG_INT32, newid, FSE_ARG_DONE); #endif } else { // XXXdbg - couldn't get a new docid... what to do? can't really fail the rm... hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK); } } /* * Lazily respond to determining if there is a valid resource fork * vnode attached to 'cp' if it is a regular file or symlink. * If the vnode does not exist, then we may proceed without having to * create it. * * If, however, it does exist, then we need to acquire an iocount on the * vnode after acquiring its vid. This ensures that if we have to do I/O * against it, it can't get recycled from underneath us in the middle * of this call. * * Note: this function may be invoked for directory hardlinks, so just skip these * steps if 'vp' is a directory. */ if ((vp->v_type == VLNK) || (vp->v_type == VREG)) { if ((cp->c_rsrc_vp) && (rvp == NULL)) { /* We need to acquire the rsrc vnode */ rvp = cp->c_rsrc_vp; rsrc_vid = vnode_vid (rvp); /* Unlock everything to acquire iocount on the rsrc vnode */ hfs_unlock_truncate (cp, HFS_LOCK_DEFAULT); hfs_unlockpair (dcp, cp); /* Use the vid to maintain identity on rvp */ if (vnode_getwithvid(rvp, rsrc_vid)) { /* * If this fails, then it was recycled or * reclaimed in the interim. Reset fields and * start over. */ rvp = NULL; rsrc_vid = 0; } goto relock; } } /* * Check to see if we raced rmdir for the parent directory * hfs_removefile already checks for a race on vp/cp */ if (dcp->c_flag & (C_DELETED | C_NOEXISTS)) { error = ENOENT; goto rm_done; } error = hfs_removefile(dvp, vp, ap->a_cnp, ap->a_flags, 0, 0, NULL, 0); /* * If the remove succeeded in deleting the file, then we may need to mark * the resource fork for recycle so that it is reclaimed as quickly * as possible. If it were not recycled quickly, then this resource fork * vnode could keep a v_parent reference on the data fork, which prevents it * from going through reclaim (by giving it extra usecounts), except in the force- * unmount case. * * However, a caveat: we need to continue to supply resource fork * access to open-unlinked files even if the resource fork is not open. This is * a requirement for the compressed files work. Luckily, hfs_vgetrsrc will handle * this already if the data fork has been re-parented to the hidden directory. * * As a result, all we really need to do here is mark the resource fork vnode * for recycle. If it goes out of core, it can be brought in again if needed. * If the cnode was instead marked C_NOEXISTS, then there wouldn't be any * more work. */ if (error == 0) { if (rvp) { recycle_rsrc = 1; } /* * If the target was actually removed from the catalog schedule it for * full reclamation/inactivation. We hold an iocount on it so it should just * get marked with MARKTERM */ if (cp->c_flag & C_NOEXISTS) { recycle_vnode = 1; } } /* * Drop the truncate lock before unlocking the cnode * (which can potentially perform a vnode_put and * recycle the vnode which in turn might require the * truncate lock) */ rm_done: hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); hfs_unlockpair(dcp, cp); if (recycle_rsrc) { /* inactive or reclaim on rvp will clean up the blocks from the rsrc fork */ vnode_recycle(rvp); } if (recycle_vnode) { vnode_recycle (vp); } if (rvp) { /* drop iocount on rsrc fork, was obtained at beginning of fxn */ vnode_put(rvp); } return (error); } int hfs_removefile_callback(struct buf *bp, void *hfsmp) { if ( !(buf_flags(bp) & B_META)) panic("hfs: symlink bp @ %p 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_vnop_remove except there are additional options. * This function may be used to remove directories if they have * lots of EA's -- note the 'allow_dirs' argument. * * This function is able to delete blocks & fork data for the resource * fork even if it does not exist in core (and have a backing vnode). * It should infer the correct behavior based on the number of blocks * in the cnode and whether or not the resource fork pointer exists or * not. As a result, one only need pass in the 'vp' corresponding to the * data fork of this file (or main vnode in the case of a directory). * Passing in a resource fork will result in an error. * * Because we do not create any vnodes in this function, we are not at * risk of deadlocking against ourselves by double-locking. * * Requires cnode and truncate locks to be held. */ int hfs_removefile(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, int flags, int skip_reserve, int allow_dirs, __unused struct vnode *rvp, int only_unlink) { struct cnode *cp; struct cnode *dcp; struct vnode *rsrc_vp = NULL; struct hfsmount *hfsmp; struct cat_desc desc; struct timeval tv; int dataforkbusy = 0; int rsrcforkbusy = 0; int lockflags; int error = 0; int started_tr = 0; int isbigfile = 0, defer_remove=0, isdir=0; int update_vh = 0; cp = VTOC(vp); dcp = VTOC(dvp); hfsmp = VTOHFS(vp); /* Check if we lost a race post lookup. */ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) { return (0); } if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid, NULL, &error)) { return 0; } /* Make sure a remove is permitted */ if (VNODE_IS_RSRC(vp)) { return (EPERM); } else { /* * We know it's a data fork. * Probe the cnode to see if we have a valid resource fork * in hand or not. */ rsrc_vp = cp->c_rsrc_vp; } /* Don't allow deleting the journal or journal_info_block. */ if (hfs_is_journal_file(hfsmp, cp)) { return (EPERM); } /* * If removing a symlink, then we need to ensure that the * data blocks for the symlink are not still in-flight or pending. * If so, we will unlink the symlink here, making its blocks * available for re-allocation by a subsequent transaction. That is OK, but * then the I/O for the data blocks could then go out before the journal * transaction that created it was flushed, leading to I/O ordering issues. */ if (vp->v_type == VLNK) { /* * This will block if the asynchronous journal flush is in progress. * If this symlink is not being renamed over and doesn't have any open FDs, * then we'll remove it from the journal's bufs below in kill_block. */ buf_wait_for_shadow_io (vp, 0); } /* * Hard links require special handling. */ if (cp->c_flag & C_HARDLINK) { if ((flags & VNODE_REMOVE_NODELETEBUSY) && vnode_isinuse(vp, 0)) { return (EBUSY); } else { /* A directory hard link with a link count of one is * treated as a regular directory. Therefore it should * only be removed using rmdir(). */ if ((vnode_isdir(vp) == 1) && (cp->c_linkcount == 1) && (allow_dirs == 0)) { return (EPERM); } return hfs_unlink(hfsmp, dvp, vp, cnp, skip_reserve); } } /* Directories should call hfs_rmdir! (unless they have a lot of attributes) */ if (vnode_isdir(vp)) { if (allow_dirs == 0) return (EPERM); /* POSIX */ isdir = 1; } /* Sanity check the parent ids. */ if ((cp->c_parentcnid != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) && (cp->c_parentcnid != dcp->c_fileid)) { return (EINVAL); } dcp->c_flag |= C_DIR_MODIFICATION; // this guy is going away so mark him as such cp->c_flag |= C_DELETED; /* Remove our entry from the namei cache. */ cache_purge(vp); /* * If the caller was operating on a file (as opposed to a * directory with EAs), then we need to figure out * whether or not it has a valid resource fork vnode. * * If there was a valid resource fork vnode, then we need * to use hfs_truncate to eliminate its data. If there is * no vnode, then we hold the cnode lock which would * prevent it from being created. As a result, * we can use the data deletion functions which do not * require that a cnode/vnode pair exist. */ /* Check if this file is being used. */ if (isdir == 0) { dataforkbusy = vnode_isinuse(vp, 0); /* * At this point, we know that 'vp' points to the * a data fork because we checked it up front. And if * there is no rsrc fork, rsrc_vp will be NULL. */ if (rsrc_vp && (cp->c_blocks - VTOF(vp)->ff_blocks)) { rsrcforkbusy = vnode_isinuse(rsrc_vp, 0); } } /* Check if we have to break the deletion into multiple pieces. */ if (isdir == 0) isbigfile = cp->c_datafork->ff_size >= HFS_BIGFILE_SIZE; /* Check if the file has xattrs. If it does we'll have to delete them in individual transactions in case there are too many */ if ((hfsmp->hfs_attribute_vp != NULL) && (cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0) { defer_remove = 1; } /* If we are explicitly told to only unlink item and move to hidden dir, then do it */ if (only_unlink) { defer_remove = 1; } /* * Carbon semantics prohibit deleting busy files. * (enforced when VNODE_REMOVE_NODELETEBUSY is requested) */ if (dataforkbusy || rsrcforkbusy) { if ((flags & VNODE_REMOVE_NODELETEBUSY) || (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid == 0)) { error = EBUSY; goto out; } } #if QUOTA if (hfsmp->hfs_flags & HFS_QUOTAS) (void)hfs_getinoquota(cp); #endif /* QUOTA */ /* * Do a ubc_setsize to indicate we need to wipe contents if: * 1) item is a regular file. * 2) Neither fork is busy AND we are not told to unlink this. * * We need to check for the defer_remove since it can be set without * having a busy data or rsrc fork */ if (isdir == 0 && (!dataforkbusy || !rsrcforkbusy) && (defer_remove == 0)) { /* * A ubc_setsize can cause a pagein so defer it * until after the cnode lock is dropped. The * 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 && rsrc_vp) { cp->c_flag |= C_NEED_RSRC_SETSIZE; } } if ((error = hfs_start_transaction(hfsmp)) != 0) { goto out; } started_tr = 1; // XXXdbg - if we're journaled, kill any dirty symlink buffers if (hfsmp->jnl && vnode_islnk(vp) && (defer_remove == 0)) { buf_iterate(vp, hfs_removefile_callback, BUF_SKIP_NONLOCKED, (void *)hfsmp); } /* * Prepare to truncate any non-busy forks. Busy forks will * get truncated when their vnode goes inactive. * Note that we will only enter this region if we * can avoid creating an open-unlinked file. If * either region is busy, we will have to create an open * unlinked file. * * Since we are deleting the file, we need to stagger the runtime * modifications to do things in such a way that a crash won't * result in us getting overlapped extents or any other * bad inconsistencies. As such, we call prepare_release_storage * which updates the UBC, updates quota information, and releases * any loaned blocks that belong to this file. No actual * truncation or bitmap manipulation is done until *AFTER* * the catalog record is removed. */ if (isdir == 0 && (!dataforkbusy && !rsrcforkbusy) && (only_unlink == 0)) { if (!dataforkbusy && !isbigfile && cp->c_datafork->ff_blocks != 0) { error = hfs_prepare_release_storage (hfsmp, vp); if (error) { goto out; } update_vh = 1; } /* * If the resource fork vnode does not exist, we can skip this step. */ if (!rsrcforkbusy && rsrc_vp) { error = hfs_prepare_release_storage (hfsmp, rsrc_vp); if (error) { goto out; } update_vh = 1; } } /* * Protect against a race with rename by using the component * name passed in and parent id from dvp (instead of using * the cp->c_desc which may have changed). Also, be aware that * because we allow directories to be passed in, we need to special case * this temporary descriptor in case we were handed a directory. */ if (isdir) { desc.cd_flags = CD_ISDIR; } else { desc.cd_flags = 0; } desc.cd_encoding = cp->c_desc.cd_encoding; desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr; desc.cd_namelen = cnp->cn_namelen; desc.cd_parentcnid = dcp->c_fileid; desc.cd_hint = cp->c_desc.cd_hint; desc.cd_cnid = cp->c_cnid; microtime(&tv); /* * There are two cases to consider: * 1. File/Dir is busy/big/defer_remove ==> move/rename the file/dir * 2. File is not in use ==> remove the file * * We can get a directory in case 1 because it may have had lots of attributes, * which need to get removed here. */ if (dataforkbusy || rsrcforkbusy || isbigfile || defer_remove) { char delname[32]; struct cat_desc to_desc; struct cat_desc todir_desc; /* * Orphan this file or directory (move to hidden directory). * Again, we need to take care that we treat directories as directories, * and files as files. Because directories with attributes can be passed in * check to make sure that we have a directory or a file before filling in the * temporary descriptor's flags. We keep orphaned directories AND files in * the FILE_HARDLINKS private directory since we're generalizing over all * orphaned filesystem objects. */ bzero(&todir_desc, sizeof(todir_desc)); todir_desc.cd_parentcnid = 2; MAKE_DELETED_NAME(delname, sizeof(delname), cp->c_fileid); bzero(&to_desc, sizeof(to_desc)); to_desc.cd_nameptr = (const u_int8_t *)delname; to_desc.cd_namelen = strlen(delname); to_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid; if (isdir) { to_desc.cd_flags = CD_ISDIR; } else { to_desc.cd_flags = 0; } to_desc.cd_cnid = cp->c_cnid; lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK); if (!skip_reserve) { if ((error = cat_preflight(hfsmp, CAT_RENAME, NULL, 0))) { hfs_systemfile_unlock(hfsmp, lockflags); goto out; } } error = cat_rename(hfsmp, &desc, &todir_desc, &to_desc, (struct cat_desc *)NULL); if (error == 0) { hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries++; if (isdir == 1) { INC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[FILE_HARDLINKS]); } (void) cat_update(hfsmp, &hfsmp->hfs_private_desc[FILE_HARDLINKS], &hfsmp->hfs_private_attr[FILE_HARDLINKS], NULL, NULL); /* Update the parent directory */ if (dcp->c_entries > 0) dcp->c_entries--; if (isdir == 1) { DEC_FOLDERCOUNT(hfsmp, dcp->c_attr); } dcp->c_dirchangecnt++; hfs_incr_gencount(dcp); 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 or directory's state */ cp->c_flag |= C_DELETED; cp->c_ctime = tv.tv_sec; --cp->c_linkcount; (void) cat_update(hfsmp, &to_desc, &cp->c_attr, NULL, NULL); } hfs_systemfile_unlock(hfsmp, lockflags); if (error) goto out; } else { /* * Nobody is using this item; we can safely remove everything. */ struct filefork *temp_rsrc_fork = NULL; #if QUOTA off_t savedbytes; int blksize = hfsmp->blockSize; #endif u_int32_t fileid = cp->c_fileid; /* * Figure out if we need to read the resource fork data into * core before wiping out the catalog record. * * 1) Must not be a directory * 2) cnode's c_rsrcfork ptr must be NULL. * 3) rsrc fork must have actual blocks */ if ((isdir == 0) && (cp->c_rsrcfork == NULL) && (cp->c_blocks - VTOF(vp)->ff_blocks)) { /* * The resource fork vnode & filefork did not exist. * Create a temporary one for use in this function only. */ MALLOC_ZONE (temp_rsrc_fork, struct filefork *, sizeof (struct filefork), M_HFSFORK, M_WAITOK); bzero(temp_rsrc_fork, sizeof(struct filefork)); temp_rsrc_fork->ff_cp = cp; rl_init(&temp_rsrc_fork->ff_invalidranges); } lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK); /* Look up the resource fork first, if necessary */ if (temp_rsrc_fork) { error = cat_lookup (hfsmp, &desc, 1, 0, (struct cat_desc*) NULL, (struct cat_attr*) NULL, &temp_rsrc_fork->ff_data, NULL); if (error) { FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK); hfs_systemfile_unlock (hfsmp, lockflags); goto out; } } if (!skip_reserve) { if ((error = cat_preflight(hfsmp, CAT_DELETE, NULL, 0))) { if (temp_rsrc_fork) { FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK); } hfs_systemfile_unlock(hfsmp, lockflags); goto out; } } error = cat_delete(hfsmp, &desc, &cp->c_attr); if (error && error != ENXIO && error != ENOENT) { printf("hfs_removefile: deleting file %s (id=%d) vol=%s err=%d\n", cp->c_desc.cd_nameptr, cp->c_attr.ca_fileid, hfsmp->vcbVN, error); } if (error == 0) { /* Update the parent directory */ if (dcp->c_entries > 0) dcp->c_entries--; dcp->c_dirchangecnt++; hfs_incr_gencount(dcp); dcp->c_ctime = tv.tv_sec; dcp->c_mtime = tv.tv_sec; (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL); } hfs_systemfile_unlock(hfsmp, lockflags); if (error) { if (temp_rsrc_fork) { FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK); } goto out; } /* * Now that we've wiped out the catalog record, the file effectively doesn't * exist anymore. So update the quota records to reflect the loss of the * data fork and the resource fork. */ #if QUOTA if (cp->c_datafork->ff_blocks > 0) { savedbytes = ((off_t)cp->c_datafork->ff_blocks * (off_t)blksize); (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0); } /* * We may have just deleted the catalog record for a resource fork even * though it did not exist in core as a vnode. However, just because there * was a resource fork pointer in the cnode does not mean that it had any blocks. */ if (temp_rsrc_fork || cp->c_rsrcfork) { if (cp->c_rsrcfork) { if (cp->c_rsrcfork->ff_blocks > 0) { savedbytes = ((off_t)cp->c_rsrcfork->ff_blocks * (off_t)blksize); (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0); } } else { /* we must have used a temporary fork */ savedbytes = ((off_t)temp_rsrc_fork->ff_blocks * (off_t)blksize); (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0); } } if (hfsmp->hfs_flags & HFS_QUOTAS) { (void)hfs_chkiq(cp, -1, NOCRED, 0); } #endif /* * If we didn't get any errors deleting the catalog entry, then go ahead * and release the backing store now. The filefork pointers are still valid. */ if (temp_rsrc_fork) { error = hfs_release_storage (hfsmp, cp->c_datafork, temp_rsrc_fork, fileid); } else { /* if cp->c_rsrcfork == NULL, hfs_release_storage will skip over it. */ error = hfs_release_storage (hfsmp, cp->c_datafork, cp->c_rsrcfork, fileid); } if (error) { /* * If we encountered an error updating the extents and bitmap, * mark the volume inconsistent. At this point, the catalog record has * already been deleted, so we can't recover it at this point. We need * to proceed and update the volume header and mark the cnode C_NOEXISTS. * The subsequent fsck should be able to recover the free space for us. */ hfs_mark_inconsistent(hfsmp, HFS_OP_INCOMPLETE); } else { /* reset update_vh to 0, since hfs_release_storage should have done it for us */ update_vh = 0; } /* Get rid of the temporary rsrc fork */ if (temp_rsrc_fork) { FREE_ZONE (temp_rsrc_fork, sizeof(struct filefork), M_HFSFORK); } cp->c_flag |= C_NOEXISTS; cp->c_flag &= ~C_DELETED; cp->c_touch_chgtime = TRUE; /* XXX needed ? */ --cp->c_linkcount; /* * We must never get a directory if we're in this else block. We could * accidentally drop the number of files in the volume header if we did. */ hfs_volupdate(hfsmp, VOL_RMFILE, (dcp->c_cnid == kHFSRootFolderID)); } // // if skip_reserve == 1 then we're being called from hfs_vnop_rename() and thus // we don't need to touch the document_id as it's handled by the rename code. // otherwise it's a normal remove and we need to save the document id in the // per thread struct and clear it from the cnode. // struct doc_tombstone *ut; ut = get_uthread_doc_tombstone(); if (!error && !skip_reserve && (cp->c_bsdflags & UF_TRACKED) && should_save_docid_tombstone(ut, vp, cnp)) { if (ut->t_lastop_document_id) { clear_tombstone_docid(ut, hfsmp, NULL); } save_tombstone(hfsmp, dvp, vp, cnp, 1); } /* * All done with this cnode's descriptor... * * Note: all future catalog calls for this cnode must be by * fileid only. This is OK for HFS (which doesn't have file * thread records) since HFS doesn't support the removal of * busy files. */ cat_releasedesc(&cp->c_desc); out: if (error) { cp->c_flag &= ~C_DELETED; } if (update_vh) { /* * If we bailed out earlier, we may need to update the volume header * to deal with the borrowed blocks accounting. */ hfs_volupdate (hfsmp, VOL_UPDATE, 0); } if (started_tr) { hfs_end_transaction(hfsmp); } dcp->c_flag &= ~C_DIR_MODIFICATION; wakeup((caddr_t)&dcp->c_flag); return (error); } __private_extern__ void replace_desc(struct cnode *cp, struct cat_desc *cdp) { // fixes 4348457 and 4463138 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) { const u_int8_t *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; vfs_removename((const char *)name); } bcopy(cdp, &cp->c_desc, sizeof(cp->c_desc)); /* Cnode now owns the name buffer */ cdp->cd_nameptr = 0; cdp->cd_namelen = 0; cdp->cd_flags &= ~CD_HASBUF; } /* * Rename a cnode. * * 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 must ensure that its empty. * * Note that this function requires up to 6 vnodes in order to work properly * if it is operating on files (and not on directories). This is because only * files can have resource forks, and we now require iocounts to be held on the * vnodes corresponding to the resource forks (if applicable) as well as * the files or directories undergoing rename. The problem with not holding * iocounts on the resource fork vnodes is that it can lead to a deadlock * situation: The rsrc fork of the source file may be recycled and reclaimed * in order to provide a vnode for the destination file's rsrc fork. Since * data and rsrc forks share the same cnode, we'd eventually try to lock the * source file's cnode in order to sync its rsrc fork to disk, but it's already * been locked. By taking the rsrc fork vnodes up front we ensure that they * cannot be recycled, and that the situation mentioned above cannot happen. */ int 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 *tdvp = ap->a_tdvp; struct vnode *fvp = ap->a_fvp; struct vnode *fdvp = ap->a_fdvp; /* * Note that we only need locals for the target/destination's * resource fork vnode (and only if necessary). We don't care if the * source has a resource fork vnode or not. */ struct vnode *tvp_rsrc = NULLVP; uint32_t tvp_rsrc_vid = 0; struct componentname *tcnp = ap->a_tcnp; struct componentname *fcnp = ap->a_fcnp; struct proc *p = vfs_context_proc(ap->a_context); struct cnode *fcp; struct cnode *fdcp; struct cnode *tdcp; struct cnode *tcp; struct cnode *error_cnode; struct cat_desc from_desc; struct cat_desc to_desc; struct cat_desc out_desc; 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; time_t orig_from_ctime, orig_to_ctime; int emit_rename = 1; int emit_delete = 1; int is_tracked = 0; int unlocked; orig_from_ctime = VTOC(fvp)->c_ctime; if (tvp && VTOC(tvp)) { orig_to_ctime = VTOC(tvp)->c_ctime; } else { orig_to_ctime = ~0; } hfsmp = VTOHFS(tdvp); /* * Do special case checks here. If fvp == tvp then we need to check the * cnode with locks held. */ if (fvp == tvp) { int is_hardlink = 0; /* * In this case, we do *NOT* ever emit a DELETE event. * We may not necessarily emit a RENAME event */ emit_delete = 0; if ((error = hfs_lock(VTOC(fvp), HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) { return error; } /* Check to see if the item is a hardlink or not */ is_hardlink = (VTOC(fvp)->c_flag & C_HARDLINK); hfs_unlock (VTOC(fvp)); /* * If the item is not a hardlink, then case sensitivity must be off, otherwise * two names should not resolve to the same cnode unless they were case variants. */ if (is_hardlink) { emit_rename = 0; /* * Hardlinks are a little trickier. We only want to emit a rename event * if the item is a hardlink, the parent directories are the same, case sensitivity * is off, and the case folded names are the same. See the fvp == tvp case below for more * info. */ if ((fdvp == tdvp) && ((hfsmp->hfs_flags & HFS_CASE_SENSITIVE) == 0)) { if (hfs_namecmp((const u_int8_t *)fcnp->cn_nameptr, fcnp->cn_namelen, (const u_int8_t *)tcnp->cn_nameptr, tcnp->cn_namelen) == 0) { /* Then in this case only it is ok to emit a rename */ emit_rename = 1; } } } } if (emit_rename) { /* c_bsdflags should only be assessed while holding the cnode lock. * This is not done consistently throughout the code and can result * in race. This will be fixed via rdar://12181064 */ if (VTOC(fvp)->c_bsdflags & UF_TRACKED) { is_tracked = 1; } check_for_tracked_file(fvp, orig_from_ctime, NAMESPACE_HANDLER_RENAME_OP, NULL); } if (tvp && VTOC(tvp)) { if (emit_delete) { check_for_tracked_file(tvp, orig_to_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL); } } retry: /* When tvp exists, take the truncate lock for hfs_removefile(). */ if (tvp && (vnode_isreg(tvp) || vnode_islnk(tvp))) { hfs_lock_truncate(VTOC(tvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); took_trunc_lock = 1; } relock: error = hfs_lockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL, HFS_EXCLUSIVE_LOCK, &error_cnode); if (error) { if (took_trunc_lock) { hfs_unlock_truncate(VTOC(tvp), HFS_LOCK_DEFAULT); took_trunc_lock = 0; } /* * We hit an error path. If we were trying to re-acquire the locks * after coming through here once, we might have already obtained * an iocount on tvp's resource fork vnode. Drop that before dealing * with the failure. Note this is safe -- since we are in an * error handling path, we can't be holding the cnode locks. */ if (tvp_rsrc) { vnode_put (tvp_rsrc); tvp_rsrc_vid = 0; tvp_rsrc = NULL; } /* * tvp might no longer exist. If the cause of the lock failure * was tvp, then we can try again with tvp/tcp set to NULL. * This is ok because the vfs syscall will vnode_put the vnodes * after we return from hfs_vnop_rename. */ if ((error == ENOENT) && (tvp != NULL) && (error_cnode == VTOC(tvp))) { tcp = NULL; tvp = NULL; goto retry; } /* If we want to reintroduce notifications for failed renames, this is the place to do it. */ return (error); } fdcp = VTOC(fdvp); fcp = VTOC(fvp); tdcp = VTOC(tdvp); tcp = tvp ? VTOC(tvp) : NULL; // // if the item is tracked but doesn't have a document_id, assign one and generate an fsevent for it // unlocked = 0; if ((fcp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16))->document_id == 0) { uint32_t newid; hfs_unlockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL); unlocked = 1; if (hfs_generate_document_id(hfsmp, &newid) == 0) { hfs_lock(fcp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); ((struct FndrExtendedDirInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16))->document_id = newid; #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(), FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)0, // src inode # FSE_ARG_INO, (ino64_t)fcp->c_fileid, // dst inode # FSE_ARG_INT32, newid, FSE_ARG_DONE); #endif hfs_unlock(fcp); } else { // XXXdbg - couldn't get a new docid... what to do? can't really fail the rename... } // // check if we're going to need to fix tcp as well. if we aren't, go back relock // everything. otherwise continue on and fix up tcp as well before relocking. // if (tcp == NULL || !(tcp->c_bsdflags & UF_TRACKED) || ((struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16))->document_id != 0) { goto relock; } } // // same thing for tcp if it's set // if (tcp && (tcp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16))->document_id == 0) { uint32_t newid; if (!unlocked) { hfs_unlockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL); unlocked = 1; } if (hfs_generate_document_id(hfsmp, &newid) == 0) { hfs_lock(tcp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); ((struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16))->document_id = newid; #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(), FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)0, // src inode # FSE_ARG_INO, (ino64_t)tcp->c_fileid, // dst inode # FSE_ARG_INT32, newid, FSE_ARG_DONE); #endif hfs_unlock(tcp); } else { // XXXdbg - couldn't get a new docid... what to do? can't really fail the rename... } // go back up and relock everything. next time through the if statement won't be true // and we'll skip over this block of code. goto relock; } /* * Acquire iocounts on the destination's resource fork vnode * if necessary. If dst/src are files and the dst has a resource * fork vnode, then we need to try and acquire an iocount on the rsrc vnode. * If it does not exist, then we don't care and can skip it. */ if ((vnode_isreg(fvp)) || (vnode_islnk(fvp))) { if ((tvp) && (tcp->c_rsrc_vp) && (tvp_rsrc == NULL)) { tvp_rsrc = tcp->c_rsrc_vp; /* * We can look at the vid here because we're holding the * cnode lock on the underlying cnode for this rsrc vnode. */ tvp_rsrc_vid = vnode_vid (tvp_rsrc); /* Unlock everything to acquire iocount on this rsrc vnode */ if (took_trunc_lock) { hfs_unlock_truncate (VTOC(tvp), HFS_LOCK_DEFAULT); took_trunc_lock = 0; } hfs_unlockfour(fdcp, fcp, tdcp, tcp); if (vnode_getwithvid (tvp_rsrc, tvp_rsrc_vid)) { /* iocount acquisition failed. Reset fields and start over.. */ tvp_rsrc_vid = 0; tvp_rsrc = NULL; } goto retry; } } /* Ensure we didn't race src or dst parent directories with rmdir. */ if (fdcp->c_flag & (C_NOEXISTS | C_DELETED)) { error = ENOENT; goto out; } if (tdcp->c_flag & (C_NOEXISTS | C_DELETED)) { error = ENOENT; goto out; } /* Check for a race against unlink. The hfs_valid_cnode checks validate * the parent/child relationship with fdcp and tdcp, as well as the * component name of the target cnodes. */ if ((fcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, fdvp, fcnp, fcp->c_fileid, NULL, &error)) { error = ENOENT; goto out; } if (tcp && ((tcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, tdvp, tcnp, tcp->c_fileid, NULL, &error))) { // // hmm, the destination vnode isn't valid any more. // in this case we can just drop him and pretend he // never existed in the first place. // if (took_trunc_lock) { hfs_unlock_truncate(VTOC(tvp), HFS_LOCK_DEFAULT); took_trunc_lock = 0; } error = 0; hfs_unlockfour(fdcp, fcp, tdcp, tcp); tcp = NULL; tvp = NULL; // retry the locking with tvp null'ed out goto retry; } fdcp->c_flag |= C_DIR_MODIFICATION; if (fdvp != tdvp) { tdcp->c_flag |= C_DIR_MODIFICATION; } /* * Disallow renaming of a directory hard link if the source and * destination parent directories are different, or a directory whose * descendant is a directory hard link and the one of the ancestors * of the destination directory is a directory hard link. */ if (vnode_isdir(fvp) && (fdvp != tdvp)) { if (fcp->c_flag & C_HARDLINK) { error = EPERM; goto out; } if (fcp->c_attr.ca_recflags & kHFSHasChildLinkMask) { lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK); if (cat_check_link_ancestry(hfsmp, tdcp->c_fileid, 0)) { error = EPERM; hfs_systemfile_unlock(hfsmp, lockflags); goto out; } hfs_systemfile_unlock(hfsmp, lockflags); } } /* * The following edge case is caught here: * (to cannot be a descendent of from) * * o fdvp * / * / * o fvp * \ * \ * o tdvp * / * / * o tvp */ if (tdcp->c_parentcnid == fcp->c_fileid) { error = EINVAL; goto out; } /* * The following two edge cases are caught here: * (note tvp is not empty) * * o tdvp o tdvp * / / * / / * o tvp tvp o fdvp * \ \ * \ \ * o fdvp o fvp * / * / * o fvp */ if (tvp && vnode_isdir(tvp) && (tcp->c_entries != 0) && fvp != tvp) { error = ENOTEMPTY; goto out; } /* * The following edge case is caught here: * (the from child and parent are the same) * * o tdvp * / * / * fdvp o fvp */ if (fdvp == fvp) { error = EINVAL; goto out; } /* * Make sure "from" vnode and its parent are changeable. */ if ((fcp->c_bsdflags & (IMMUTABLE | APPEND)) || (fdcp->c_bsdflags & APPEND)) { error = EPERM; goto out; } /* * If the destination parent directory is "sticky", then the * user must own the parent directory, or the destination of * the rename, otherwise the destination may not be changed * (except by root). This implements append-only directories. * * Note that checks for immutable and write access are done * by the call to hfs_removefile. */ if (tvp && (tdcp->c_mode & S_ISTXT) && (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; } /* Don't allow modification of the journal or journal_info_block */ if (hfs_is_journal_file(hfsmp, fcp) || (tcp && hfs_is_journal_file(hfsmp, tcp))) { error = EPERM; goto out; } #if QUOTA if (tvp) (void)hfs_getinoquota(tcp); #endif /* Preflighting done, take fvp out of the name space. */ cache_purge(fvp); #if CONFIG_SECLUDED_RENAME /* * Check for "secure" rename that imposes additional restrictions on the * source vnode. We wait until here to check in order to prevent a race * with other threads that manage to look up fvp, but their open or link * is blocked by our locks. At this point, with fvp out of the name cache, * and holding the lock on fdvp, no other thread can find fvp. * * TODO: Do we need to limit these checks to regular files only? */ if (fcnp->cn_flags & CN_SECLUDE_RENAME) { if (vnode_isdir(fvp)) { error = EISDIR; goto out; } /* * Neither fork of source may be open or memory mapped. * We also don't want it in use by any other system call. * The file must not have hard links. * * We can't simply use vnode_isinuse() because that does not * count opens with O_EVTONLY. We don't want a malicious * process using O_EVTONLY to subvert a secluded rename. */ if (fcp->c_linkcount != 1) { error = EMLINK; goto out; } if (fcp->c_rsrc_vp && (fcp->c_rsrc_vp->v_usecount > 0 || fcp->c_rsrc_vp->v_iocount > 0)) { /* Resource fork is in use (including O_EVTONLY) */ error = EBUSY; goto out; } if (fcp->c_vp && (fcp->c_vp->v_usecount > (fcp->c_rsrc_vp ? 1 : 0) || fcp->c_vp->v_iocount > 1)) { /* * Data fork is in use, including O_EVTONLY, but not * including a reference from the resource fork. */ error = EBUSY; goto out; } } #endif bzero(&from_desc, sizeof(from_desc)); from_desc.cd_nameptr = (const u_int8_t *)fcnp->cn_nameptr; from_desc.cd_namelen = fcnp->cn_namelen; from_desc.cd_parentcnid = fdcp->c_fileid; from_desc.cd_flags = fcp->c_desc.cd_flags & ~(CD_HASBUF | CD_DECOMPOSED); from_desc.cd_cnid = fcp->c_cnid; bzero(&to_desc, sizeof(to_desc)); to_desc.cd_nameptr = (const u_int8_t *)tcnp->cn_nameptr; to_desc.cd_namelen = tcnp->cn_namelen; to_desc.cd_parentcnid = tdcp->c_fileid; to_desc.cd_flags = fcp->c_desc.cd_flags & ~(CD_HASBUF | CD_DECOMPOSED); to_desc.cd_cnid = fcp->c_cnid; if ((error = hfs_start_transaction(hfsmp)) != 0) { goto out; } started_tr = 1; /* hfs_vnop_link() and hfs_vnop_rename() set kHFSHasChildLinkMask * inside a journal transaction and without holding a cnode lock. * As setting of this bit depends on being in journal transaction for * concurrency, check this bit again after we start journal transaction for rename * to ensure that this directory does not have any descendant that * is a directory hard link. */ if (vnode_isdir(fvp) && (fdvp != tdvp)) { if (fcp->c_attr.ca_recflags & kHFSHasChildLinkMask) { lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK); if (cat_check_link_ancestry(hfsmp, tdcp->c_fileid, 0)) { error = EPERM; hfs_systemfile_unlock(hfsmp, lockflags); goto out; } hfs_systemfile_unlock(hfsmp, lockflags); } } // 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; tmpdesc.cd_nameptr = (const u_int8_t *)fcnp->cn_nameptr; tmpdesc.cd_namelen = fcnp->cn_namelen; tmpdesc.cd_parentcnid = fdcp->c_fileid; tmpdesc.cd_hint = fdcp->c_childhint; tmpdesc.cd_flags = fcp->c_desc.cd_flags & CD_ISDIR; tmpdesc.cd_encoding = 0; lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK); if (cat_lookup(hfsmp, &tmpdesc, 0, 0, NULL, NULL, NULL, &real_cnid) != 0) { hfs_systemfile_unlock(hfsmp, lockflags); goto out; } // 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. */ if ((error = cat_preflight(hfsmp, CAT_RENAME + CAT_DELETE, &cookie, p))) { goto out; } got_cookie = 1; /* * If the destination exists then it may need to be removed. * * Due to HFS's locking system, we should always move the * existing 'tvp' element to the hidden directory in hfs_vnop_rename. * Because the VNOP_LOOKUP call enters and exits the filesystem independently * of the actual vnop that it was trying to do (stat, link, readlink), * we must release the cnode lock of that element during the interim to * do MAC checking, vnode authorization, and other calls. In that time, * the item can be deleted (or renamed over). However, only in the rename * case is it inappropriate to return ENOENT from any of those calls. Either * the call should return information about the old element (stale), or get * information about the newer element that we are about to write in its place. * * HFS lookup has been modified to detect a rename and re-drive its * lookup internally. For other calls that have already succeeded in * their lookup call and are waiting to acquire the cnode lock in order * to proceed, that cnode lock will not fail due to the cnode being marked * C_NOEXISTS, because it won't have been marked as such. It will only * have C_DELETED. Thus, they will simply act on the stale open-unlinked * element. All future callers will get the new element. * * To implement this behavior, we pass the "only_unlink" argument to * hfs_removefile and hfs_removedir. This will result in the vnode acting * as though it is open-unlinked. Additionally, when we are done moving the * element to the hidden directory, we vnode_recycle the target so that it is * reclaimed as soon as possible. Reclaim and inactive are both * capable of clearing out unused blocks for an open-unlinked file or dir. */ if (tvp) { // // if the destination has a document id, we need to preserve it // if (fvp != tvp) { uint32_t document_id; struct FndrExtendedDirInfo *ffip = (struct FndrExtendedDirInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16); struct FndrExtendedDirInfo *tfip = (struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16); if (ffip->document_id && tfip->document_id) { // both documents are tracked. only save a tombstone from tcp and do nothing else. save_tombstone(hfsmp, tdvp, tvp, tcnp, 0); } else { struct doc_tombstone *ut; ut = get_uthread_doc_tombstone(); document_id = tfip->document_id; tfip->document_id = 0; if (document_id != 0) { // clear UF_TRACKED as well since tcp is now no longer tracked tcp->c_bsdflags &= ~UF_TRACKED; (void) cat_update(hfsmp, &tcp->c_desc, &tcp->c_attr, NULL, NULL); } if (ffip->document_id == 0 && document_id != 0) { // printf("RENAME: preserving doc-id %d onto %s (from ino %d, to ino %d)\n", document_id, tcp->c_desc.cd_nameptr, tcp->c_desc.cd_cnid, fcp->c_desc.cd_cnid); fcp->c_bsdflags |= UF_TRACKED; ffip->document_id = document_id; (void) cat_update(hfsmp, &fcp->c_desc, &fcp->c_attr, NULL, NULL); #if CONFIG_FSE add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(), FSE_ARG_DEV, hfsmp->hfs_raw_dev, FSE_ARG_INO, (ino64_t)tcp->c_fileid, // src inode # FSE_ARG_INO, (ino64_t)fcp->c_fileid, // dst inode # FSE_ARG_INT32, (uint32_t)ffip->document_id, FSE_ARG_DONE); #endif } else if ((fcp->c_bsdflags & UF_TRACKED) && should_save_docid_tombstone(ut, fvp, fcnp)) { if (ut->t_lastop_document_id) { clear_tombstone_docid(ut, hfsmp, NULL); } save_tombstone(hfsmp, fdvp, fvp, fcnp, 0); //printf("RENAME: (dest-exists): saving tombstone doc-id %lld @ %s (ino %d)\n", // ut->t_lastop_document_id, ut->t_lastop_filename, fcp->c_desc.cd_cnid); } } } /* * When fvp matches tvp they could be case variants * or matching hard links. */ if (fvp == tvp) { if (!(fcp->c_flag & C_HARDLINK)) { /* * If they're not hardlinks, then fvp == tvp must mean we * are using case-insensitive HFS because case-sensitive would * not use the same vnode for both. In this case we just update * the catalog for: a -> A */ goto skip_rm; /* simple case variant */ } /* For all cases below, we must be using hardlinks */ else if ((fdvp != tdvp) || (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)) { /* * If the parent directories are not the same, AND the two items * are hardlinks, posix says to do nothing: * dir1/fred <-> dir2/bob and the op was mv dir1/fred -> dir2/bob * We just return 0 in this case. * * If case sensitivity is on, and we are using hardlinks * then renaming is supposed to do nothing. * dir1/fred <-> dir2/FRED, and op == mv dir1/fred -> dir2/FRED */ goto out; /* matching hardlinks, nothing to do */ } else if (hfs_namecmp((const u_int8_t *)fcnp->cn_nameptr, fcnp->cn_namelen, (const u_int8_t *)tcnp->cn_nameptr, tcnp->cn_namelen) == 0) { /* * If we get here, then the following must be true: * a) We are running case-insensitive HFS+. * b) Both paths 'fvp' and 'tvp' are in the same parent directory. * c) the two names are case-variants of each other. * * In this case, we are really only dealing with a single catalog record * whose name is being updated. * * op is dir1/fred -> dir1/FRED * * We need to special case the name matching, because if * dir1/fred <-> dir1/bob were the two links, and the * op was dir1/fred -> dir1/bob * That would fail/do nothing. */ goto skip_rm; /* case-variant hardlink in the same dir */ } else { goto out; /* matching hardlink, nothing to do */ } } if (vnode_isdir(tvp)) { /* * hfs_removedir will eventually call hfs_removefile on the directory * we're working on, because only hfs_removefile does the renaming of the * item to the hidden directory. The directory will stay around in the * hidden directory with C_DELETED until it gets an inactive or a reclaim. * That way, we can destroy all of the EAs as needed and allow new ones to be * written. */ error = hfs_removedir(tdvp, tvp, tcnp, HFSRM_SKIP_RESERVE, 1); } else { error = hfs_removefile(tdvp, tvp, tcnp, 0, HFSRM_SKIP_RESERVE, 0, NULL, 1); /* * If the destination file had a resource fork vnode, then we need to get rid of * its blocks when there are no more references to it. Because the call to * hfs_removefile above always open-unlinks things, we need to force an inactive/reclaim * on the resource fork vnode, in order to prevent block leaks. Otherwise, * the resource fork vnode could prevent the data fork vnode from going out of scope * because it holds a v_parent reference on it. So we mark it for termination * with a call to vnode_recycle. hfs_vnop_reclaim has been modified so that it * can clean up the blocks of open-unlinked files and resource forks. * * We can safely call vnode_recycle on the resource fork because we took an iocount * reference on it at the beginning of the function. */ if ((error == 0) && (tcp->c_flag & C_DELETED) && (tvp_rsrc)) { vnode_recycle(tvp_rsrc); } } if (error) { goto out; } tvp_deleted = 1; /* Mark 'tcp' as being deleted due to a rename */ tcp->c_flag |= C_RENAMED; /* * Aggressively mark tvp/tcp for termination to ensure that we recover all blocks * as quickly as possible. */ vnode_recycle(tvp); } else { struct doc_tombstone *ut; ut = get_uthread_doc_tombstone(); // // There is nothing at the destination. If the file being renamed is // tracked, save a "tombstone" of the document_id. If the file is // not a tracked file, then see if it needs to inherit a tombstone. // // NOTE: we do not save a tombstone if the file being renamed begins // with "atmp" which is done to work-around AutoCad's bizarre // 5-step un-safe save behavior // if (fcp->c_bsdflags & UF_TRACKED) { if (should_save_docid_tombstone(ut, fvp, fcnp)) { save_tombstone(hfsmp, fdvp, fvp, fcnp, 0); //printf("RENAME: (no dest): saving tombstone doc-id %lld @ %s (ino %d)\n", // ut->t_lastop_document_id, ut->t_lastop_filename, fcp->c_desc.cd_cnid); } else { // intentionally do nothing } } else if ( ut->t_lastop_document_id != 0 && tdvp == ut->t_lastop_parent && vnode_vid(tdvp) == ut->t_lastop_parent_vid && strcmp((char *)ut->t_lastop_filename, (char *)tcnp->cn_nameptr) == 0) { //printf("RENAME: %s (ino %d) inheriting doc-id %lld\n", tcnp->cn_nameptr, fcp->c_desc.cd_cnid, ut->t_lastop_document_id); struct FndrExtendedFileInfo *fip = (struct FndrExtendedFileInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16); fcp->c_bsdflags |= UF_TRACKED; fip->document_id = ut->t_lastop_document_id; cat_update(hfsmp, &fcp->c_desc, &fcp->c_attr, NULL, NULL); clear_tombstone_docid(ut, hfsmp, fcp); // will send the docid-changed fsevent } else if (ut->t_lastop_document_id && should_save_docid_tombstone(ut, fvp, fcnp) && should_save_docid_tombstone(ut, tvp, tcnp)) { // no match, clear the tombstone //printf("RENAME: clearing the tombstone %lld @ %s\n", ut->t_lastop_document_id, ut->t_lastop_filename); clear_tombstone_docid(ut, hfsmp, NULL); } } skip_rm: /* * All done with tvp and fvp. * * We also jump to this point if there was no destination observed during lookup and namei. * However, because only iocounts are held at the VFS layer, there is nothing preventing a * competing thread from racing us and creating a file or dir at the destination of this rename * operation. If this occurs, it may cause us to get a spurious EEXIST out of the cat_rename * call below. To preserve rename's atomicity, we need to signal VFS to re-drive the * namei/lookup and restart the rename operation. EEXIST is an allowable errno to be bubbled * out of the rename syscall, but not for this reason, since it is a synonym errno for ENOTEMPTY. * To signal VFS, we return ERECYCLE (which is also used for lookup restarts). This errno * will be swallowed and it will restart the operation. */ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK); error = cat_rename(hfsmp, &from_desc, &tdcp->c_desc, &to_desc, &out_desc); hfs_systemfile_unlock(hfsmp, lockflags); if (error) { if (error == EEXIST) { error = ERECYCLE; } goto out; } /* Invalidate negative cache entries in the destination directory */ if (tdcp->c_flag & C_NEG_ENTRIES) { cache_purge_negatives(tdvp); tdcp->c_flag &= ~C_NEG_ENTRIES; } /* Update cnode's catalog descriptor */ replace_desc(fcp, &out_desc); fcp->c_parentcnid = tdcp->c_fileid; fcp->c_hint = 0; /* Now indicate this cnode needs to have date-added written to the finderinfo */ fcp->c_flag |= C_NEEDS_DATEADDED; (void) hfs_update (fvp, 0); hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_RMDIR : VOL_RMFILE, (fdcp->c_cnid == kHFSRootFolderID)); hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_MKDIR : VOL_MKFILE, (tdcp->c_cnid == kHFSRootFolderID)); /* Update both parent directories. */ if (fdvp != tdvp) { if (vnode_isdir(fvp)) { /* If the source directory has directory hard link * descendants, set the kHFSHasChildLinkBit in the * destination parent hierarchy */ if ((fcp->c_attr.ca_recflags & kHFSHasChildLinkMask) && !(tdcp->c_attr.ca_recflags & kHFSHasChildLinkMask)) { tdcp->c_attr.ca_recflags |= kHFSHasChildLinkMask; error = cat_set_childlinkbit(hfsmp, tdcp->c_parentcnid); if (error) { printf ("hfs_vnop_rename: error updating parent chain for %u\n", tdcp->c_cnid); error = 0; } } INC_FOLDERCOUNT(hfsmp, tdcp->c_attr); DEC_FOLDERCOUNT(hfsmp, fdcp->c_attr); } tdcp->c_entries++; tdcp->c_dirchangecnt++; hfs_incr_gencount(tdcp); if (fdcp->c_entries > 0) fdcp->c_entries--; fdcp->c_dirchangecnt++; fdcp->c_touch_chgtime = TRUE; fdcp->c_touch_modtime = TRUE; fdcp->c_flag |= C_FORCEUPDATE; // XXXdbg - force it out! (void) hfs_update(fdvp, 0); } hfs_incr_gencount(fdcp); tdcp->c_childhint = out_desc.cd_hint; /* Cache directory's location */ tdcp->c_touch_chgtime = TRUE; tdcp->c_touch_modtime = TRUE; tdcp->c_flag |= C_FORCEUPDATE; // XXXdbg - force it out! (void) hfs_update(tdvp, 0); /* Update the vnode's name now that the rename has completed. */ vnode_update_identity(fvp, tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_hash, (VNODE_UPDATE_PARENT | VNODE_UPDATE_NAME)); /* * At this point, we may have a resource fork vnode attached to the * 'from' vnode. If it exists, we will want to update its name, because * it contains the old name + _PATH_RSRCFORKSPEC. ("/..namedfork/rsrc"). * * Note that the only thing we need to update here is the name attached to * the vnode, since a resource fork vnode does not have a separate resource * cnode -- it's still 'fcp'. */ if (fcp->c_rsrc_vp) { char* rsrc_path = NULL; int len; /* Create a new temporary buffer that's going to hold the new name */ MALLOC_ZONE (rsrc_path, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK); len = snprintf (rsrc_path, MAXPATHLEN, "%s%s", tcnp->cn_nameptr, _PATH_RSRCFORKSPEC); len = MIN(len, MAXPATHLEN); /* * vnode_update_identity will do the following for us: * 1) release reference on the existing rsrc vnode's name. * 2) copy/insert new name into the name cache * 3) attach the new name to the resource vnode * 4) update the vnode's vid */ vnode_update_identity (fcp->c_rsrc_vp, fvp, rsrc_path, len, 0, (VNODE_UPDATE_NAME | VNODE_UPDATE_CACHE)); /* Free the memory associated with the resource fork's name */ FREE_ZONE (rsrc_path, MAXPATHLEN, M_NAMEI); } out: if (got_cookie) { cat_postflight(hfsmp, &cookie, p); } if (started_tr) { hfs_end_transaction(hfsmp); } fdcp->c_flag &= ~C_DIR_MODIFICATION; wakeup((caddr_t)&fdcp->c_flag); if (fdvp != tdvp) { tdcp->c_flag &= ~C_DIR_MODIFICATION; wakeup((caddr_t)&tdcp->c_flag); } if (took_trunc_lock) { hfs_unlock_truncate(VTOC(tvp), HFS_LOCK_DEFAULT); } hfs_unlockfour(fdcp, fcp, tdcp, tcp); /* Now vnode_put the resource forks vnodes if necessary */ if (tvp_rsrc) { vnode_put(tvp_rsrc); tvp_rsrc = NULL; } /* After tvp is removed the only acceptable error is EIO */ if (error && tvp_deleted) error = EIO; /* If we want to reintroduce notifications for renames, this is the place to do it. */ return (error); } /* * Make a directory. */ int hfs_vnop_mkdir(struct vnop_mkdir_args *ap) { /***** 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); } /* * Create a symbolic link. */ int hfs_vnop_symlink(struct vnop_symlink_args *ap) { struct vnode **vpp = ap->a_vpp; struct vnode *dvp = ap->a_dvp; struct vnode *vp = NULL; struct cnode *cp = NULL; struct hfsmount *hfsmp; struct filefork *fp; struct buf *bp = NULL; char *datap; int started_tr = 0; u_int32_t len; int error; /* HFS standard disks don't support symbolic links */ if (VTOVCB(dvp)->vcbSigWord != kHFSPlusSigWord) return (ENOTSUP); /* Check for empty target name */ if (ap->a_target[0] == 0) return (EINVAL); hfsmp = VTOHFS(dvp); len = strlen(ap->a_target); /* Check for free space */ if (((u_int64_t)hfs_freeblks(hfsmp, 0) * (u_int64_t)hfsmp->blockSize) < len) { return (ENOSPC); } /* Create the vnode */ 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; if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) { goto out; } cp = VTOC(vp); fp = VTOF(vp); if (cp->c_flag & (C_NOEXISTS | C_DELETED)) { goto out; } #if QUOTA (void)hfs_getinoquota(cp); #endif /* QUOTA */ if ((error = hfs_start_transaction(hfsmp)) != 0) { goto out; } started_tr = 1; /* * Allocate space for the link. * * Since we're already inside a transaction, * * Don't need truncate lock since a symlink is treated as a system file. */ error = hfs_truncate(vp, len, IO_NOZEROFILL, 0, ap->a_context); /* On errors, remove the symlink file */ if (error) { /* * End the transaction so we don't re-take the cnode lock * below while inside a transaction (lock order violation). */ hfs_end_transaction(hfsmp); /* hfs_removefile() requires holding the truncate lock */ hfs_unlock(cp); hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS); if (hfs_start_transaction(hfsmp) != 0) { started_tr = 0; hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); goto out; } (void) hfs_removefile(dvp, vp, ap->a_cnp, 0, 0, 0, NULL, 0); hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT); goto out; } /* Write the link to disk */ bp = buf_getblk(vp, (daddr64_t)0, roundup((int)fp->ff_size, hfsmp->hfs_physical_block_size), 0, 0, BLK_META); if (hfsmp->jnl) { journal_modify_block_start(hfsmp->jnl, bp); } 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, NULL, NULL); } else { buf_bawrite(bp); } out: if (started_tr) hfs_end_transaction(hfsmp); if ((cp != NULL) && (vp != NULL)) { hfs_unlock(cp); } if (error) { if (vp) { vnode_put(vp); } *vpp = NULL; } return (error); } /* 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 ".." */ }; 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; /* * 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. * * If the directory is marked as deleted-but-in-use (cp->c_flag & C_DELETED), * do NOT synthesize entries for "." and "..". */ int 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; { 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; 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; cnid_t cnid_hint = 0; int bump_valence = 0; items = 0; startoffset = offset = uio_offset(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) return (EINVAL); if (VTOC(vp)->c_bsdflags & UF_COMPRESSED) { int compressed = hfs_file_is_compressed(VTOC(vp), 0); /* 0 == take the cnode lock */ if (VTOCMP(vp) != NULL && !compressed) { error = check_for_dataless_file(vp, NAMESPACE_HANDLER_READ_OP); if (error) { return error; } } } cp = VTOC(vp); hfsmp = VTOHFS(vp); /* Note that the dirhint calls require an exclusive lock. */ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) return (error); /* 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 "..", unless the directory has * been deleted, but not closed yet (lazy delete in progress). */ if (offset == 0 && !(cp->c_flag & C_DELETED)) { 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; } /* * Intentionally avoid checking the valence here. If we * have FS corruption that reports the valence is 0, even though it * has contents, we might artificially skip over iterating * this directory. */ // // 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 // deadlock if someone else starts a transaction and then // tries to lock the catalog file but can't because we're // here and we can't service our page fault because VM is // blocked trying to start a transaction as a result of // trying to free up pages for our page fault. It's messy // but it does happen on dual-processors that are paging // heavily (see radar 3082639 for more info). By locking // the buffer up-front we prevent ourselves from faulting // while holding the shared catalog file lock. // // Fortunately this and hfs_search() are the only two places // currently (10/30/02) that can fault on user data with a // shared lock on the catalog file. // if (hfsmp->jnl && uio_isuserspace(uio)) { user_start = uio_curriovbase(uio); user_len = uio_curriovlen(uio); if ((error = vslock(user_start, user_len)) != 0) { user_start = 0; goto out; } } /* 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_fileid) { 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); } } } /* Get a directory hint (cnode must be locked exclusive) */ if (dirhint == NULL) { dirhint = hfs_getdirhint(cp, ((index - 1) & HFS_INDEX_MASK) | tag, 0); /* Hide tag from catalog layer. */ dirhint->dh_index &= HFS_INDEX_MASK; if (dirhint->dh_index == HFS_INDEX_MASK) { dirhint->dh_index = -1; } } if (index == 0) { dirhint->dh_threadhint = cp->c_dirthreadhint; } else { /* * If we have a non-zero index, there is a possibility that during the last * call to hfs_vnop_readdir we hit EOF for this directory. If that is the case * then we don't want to return any new entries for the caller. Just return 0 * items, mark the eofflag, and bail out. Because we won't have done any work, the * code at the end of the function will release the dirhint for us. * * Don't forget to unlock the catalog lock on the way out, too. */ if (dirhint->dh_desc.cd_flags & CD_EOF) { error = 0; eofflag = 1; uio_setoffset(uio, startoffset); hfs_systemfile_unlock (hfsmp, lockflags); goto seekoffcalc; } } /* Pack the buffer with dirent entries. */ error = cat_getdirentries(hfsmp, cp->c_entries, dirhint, uio, ap->a_flags, &items, &eofflag); if (index == 0 && error == 0) { cp->c_dirthreadhint = dirhint->dh_threadhint; } 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; } /* * Detect valence FS corruption. * * We are holding the cnode lock exclusive, so there should not be * anybody modifying the valence field of this cnode. If we enter * this block, that means we observed filesystem corruption, because * this directory reported a valence of 0, yet we found at least one * item. In this case, we need to minimally self-heal this * directory to prevent userland from tripping over a directory * that appears empty (getattr of valence reports 0), but actually * has contents. * * We'll force the cnode update at the end of the function after * completing all of the normal getdirentries steps. */ if ((cp->c_entries == 0) && (items > 0)) { /* disk corruption */ cp->c_entries++; /* Mark the cnode as dirty. */ cp->c_flag |= (C_MODIFIED | C_FORCEUPDATE); printf("hfs_vnop_readdir: repairing valence to non-zero! \n"); bump_valence++; } /* 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; seekoffcalc: cp->c_touch_acctime = TRUE; if (ap->a_numdirent) { if (startoffset == 0) items += 2; *ap->a_numdirent = items; } out: if (user_start) { vsunlock(user_start, user_len, TRUE); } /* 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; } if (dirhint == &localhint) { cat_releasedesc(&localhint.dh_desc); } if (bump_valence) { /* force the update before dropping the cnode lock*/ hfs_update(vp, 0); } hfs_unlock(cp); return (error); } /* * Read contents of a symbolic link. */ int hfs_vnop_readlink(ap) struct vnop_readlink_args /* { struct vnode *a_vp; struct uio *a_uio; vfs_context_t a_context; } */ *ap; { struct vnode *vp = ap->a_vp; struct cnode *cp; struct filefork *fp; int error; if (!vnode_islnk(vp)) return (EINVAL); if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) return (error); cp = VTOC(vp); fp = VTOF(vp); /* Zero length sym links are not allowed */ if (fp->ff_size == 0 || fp->ff_size > MAXPATHLEN) { 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); if (fp->ff_symlinkptr == NULL) { error = ENOMEM; goto exit; } error = (int)buf_meta_bread(vp, (daddr64_t)0, roundup((int)fp->ff_size, VTOHFS(vp)->hfs_physical_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); /* * 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; } exit: hfs_unlock(cp); return (error); } /* * Get configurable pathname variables. */ int 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 std_hfs = (VTOHFS(ap->a_vp)->hfs_flags & HFS_STANDARD); switch (ap->a_name) { case _PC_LINK_MAX: if (std_hfs == 0){ *ap->a_retval = HFS_LINK_MAX; } #if CONFIG_HFS_STD else { *ap->a_retval = 1; } #endif break; case _PC_NAME_MAX: if (std_hfs == 0) { *ap->a_retval = kHFSPlusMaxFileNameChars; /* 255 */ } #if CONFIG_HFS_STD else { *ap->a_retval = kHFSMaxFileNameChars; /* 31 */ } #endif break; case _PC_PATH_MAX: *ap->a_retval = PATH_MAX; /* 1024 */ break; case _PC_PIPE_BUF: *ap->a_retval = PIPE_BUF; break; case _PC_CHOWN_RESTRICTED: *ap->a_retval = 200112; /* _POSIX_CHOWN_RESTRICTED */ break; case _PC_NO_TRUNC: *ap->a_retval = 200112; /* _POSIX_NO_TRUNC */ break; case _PC_NAME_CHARS_MAX: if (std_hfs == 0) { *ap->a_retval = kHFSPlusMaxFileNameChars; /* 255 */ } #if CONFIG_HFS_STD else { *ap->a_retval = kHFSMaxFileNameChars; /* 31 */ } #endif break; case _PC_CASE_SENSITIVE: if (VTOHFS(ap->a_vp)->hfs_flags & HFS_CASE_SENSITIVE) *ap->a_retval = 1; else *ap->a_retval = 0; break; case _PC_CASE_PRESERVING: *ap->a_retval = 1; break; case _PC_FILESIZEBITS: /* number of bits to store max file size */ if (std_hfs == 0) { *ap->a_retval = 64; } #if CONFIG_HFS_STD else { *ap->a_retval = 32; } #endif break; case _PC_XATTR_SIZE_BITS: /* Number of bits to store maximum extended attribute size */ *ap->a_retval = HFS_XATTR_SIZE_BITS; break; default: return (EINVAL); } return (0); } /* * Prepares a fork for cat_update by making sure ff_size and ff_blocks * are no bigger than the valid data on disk thus reducing the chance * of exposing unitialised data in the event of a non clean unmount. * fork_buf is where to put the temporary copy if required. (It can * be inside pfork.) */ static const struct cat_fork * hfs_prepare_fork_for_update(const filefork_t *pfork, struct cat_fork *fork_buf, uint32_t block_size) { if (!pfork) return NULL; off_t max_size = pfork->ff_size; // Check first invalid range if (!TAILQ_EMPTY(&pfork->ff_invalidranges)) max_size = TAILQ_FIRST(&pfork->ff_invalidranges)->rl_start; if (!pfork->ff_unallocblocks && pfork->ff_size <= max_size) return &pfork->ff_data; // Nothing to do if (pfork->ff_blocks < pfork->ff_unallocblocks) { panic("hfs: ff_blocks %d is less than unalloc blocks %d\n", pfork->ff_blocks, pfork->ff_unallocblocks); } struct cat_fork *out = fork_buf; if (out != &pfork->ff_data) bcopy(&pfork->ff_data, out, sizeof(*out)); // Adjust cf_blocks for cf_vblocks out->cf_blocks -= out->cf_vblocks; /* * We have to trim the size with the updated cf_blocks. You might * think that this is unnecessary because the invalid ranges * should catch this, but we update invalid ranges *before* we do * I/O whereas cf_vblocks is updated later in hfs_vnop_blockmap. * There might still be a chance that we will be exposing * unitialised data because the metadata takes a different path to * data but the window should be tiny (if it exists at all). */ off_t alloc_bytes = hfs_blk_to_bytes(out->cf_blocks, block_size); if (out->cf_size > alloc_bytes) out->cf_size = alloc_bytes; // Trim cf_size to first invalid range if (out->cf_size > max_size) out->cf_size = max_size; return out; } /* * 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 */ int hfs_update(struct vnode *vp, __unused int waitfor) { struct cnode *cp = VTOC(vp); struct proc *p; const struct cat_fork *dataforkp = NULL; const struct cat_fork *rsrcforkp = NULL; struct cat_fork datafork; struct cat_fork rsrcfork; struct hfsmount *hfsmp; int lockflags; int error; uint32_t tstate = 0; p = current_proc(); hfsmp = VTOHFS(vp); if (((vnode_issystem(vp) && (cp->c_cnid < kHFSFirstUserCatalogNodeID))) || hfsmp->hfs_catalog_vp == NULL){ 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); } if (kdebug_enable) { if (cp->c_touch_acctime) tstate |= DBG_HFS_UPDATE_ACCTIME; if (cp->c_touch_modtime) tstate |= DBG_HFS_UPDATE_MODTIME; if (cp->c_touch_chgtime) tstate |= DBG_HFS_UPDATE_CHGTIME; if (cp->c_flag & C_MODIFIED) tstate |= DBG_HFS_UPDATE_MODIFIED; if (cp->c_flag & C_FORCEUPDATE) tstate |= DBG_HFS_UPDATE_FORCE; if (cp->c_flag & C_NEEDS_DATEADDED) tstate |= DBG_HFS_UPDATE_DATEADDED; } hfs_touchtimes(hfsmp, cp); /* Nothing to update. */ if ((cp->c_flag & (C_MODIFIED | C_FORCEUPDATE)) == 0) { return (0); } if (cp->c_datafork) dataforkp = &cp->c_datafork->ff_data; if (cp->c_rsrcfork) rsrcforkp = &cp->c_rsrcfork->ff_data; /* * For delayed allocations updates are * postponed until an fsync or the file * gets written to disk. * * Deleted files can defer meta data updates until inactive. * * If we're ever called with the C_FORCEUPDATE flag though * we have to do the update. */ if (ISSET(cp->c_flag, C_FORCEUPDATE) == 0 && (ISSET(cp->c_flag, C_DELETED) || (dataforkp && cp->c_datafork->ff_unallocblocks) || (rsrcforkp && cp->c_rsrcfork->ff_unallocblocks))) { // cp->c_flag &= ~(C_ACCESS | C_CHANGE | C_UPDATE); cp->c_flag |= C_MODIFIED; return (0); } KERNEL_DEBUG_CONSTANT(HFSDBG_UPDATE | DBG_FUNC_START, VM_KERNEL_ADDRPERM(vp), tstate, 0, 0, 0); if ((error = hfs_start_transaction(hfsmp)) != 0) { KERNEL_DEBUG_CONSTANT(HFSDBG_UPDATE | DBG_FUNC_END, VM_KERNEL_ADDRPERM(vp), tstate, error, -1, 0); return error; } /* * Modify the values passed to cat_update based on whether or not * the file has invalid ranges or borrowed blocks. */ dataforkp = hfs_prepare_fork_for_update(cp->c_datafork, &datafork, hfsmp->blockSize); rsrcforkp = hfs_prepare_fork_for_update(cp->c_rsrcfork, &rsrcfork, hfsmp->blockSize); if (kdebug_enable) { long dbg_parms[NUMPARMS]; int dbg_namelen; dbg_namelen = NUMPARMS * sizeof(long); vn_getpath(vp, (char *)dbg_parms, &dbg_namelen); if (dbg_namelen < (int)sizeof(dbg_parms)) memset((char *)dbg_parms + dbg_namelen, 0, sizeof(dbg_parms) - dbg_namelen); kdebug_lookup_gen_events(dbg_parms, dbg_namelen, (void *)vp, TRUE); } /* * Lock the Catalog b-tree file. */ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK); /* XXX - waitfor is not enforced */ error = cat_update(hfsmp, &cp->c_desc, &cp->c_attr, dataforkp, rsrcforkp); hfs_systemfile_unlock(hfsmp, lockflags); /* After the updates are finished, clear the flags */ cp->c_flag &= ~(C_MODIFIED | C_FORCEUPDATE); hfs_end_transaction(hfsmp); KERNEL_DEBUG_CONSTANT(HFSDBG_UPDATE | DBG_FUNC_END, VM_KERNEL_ADDRPERM(vp), tstate, error, 0, 0); return (error); } /* * Allocate a new node */ int hfs_makenode(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vnode_attr *vap, vfs_context_t ctx) { struct cnode *cp = NULL; struct cnode *dcp = NULL; struct vnode *tvp; struct hfsmount *hfsmp; struct cat_desc in_desc, out_desc; struct cat_attr attr; struct timeval tv; int lockflags; int error, started_tr = 0; enum vtype vnodetype; int mode; int newvnode_flags = 0; u_int32_t gnv_flags = 0; int protectable_target = 0; int nocache = 0; #if CONFIG_PROTECT struct cprotect *entry = NULL; int32_t cp_class = -1; /* * By default, it's OK for AKS to overrride our target class preferences. */ uint32_t keywrap_flags = CP_KEYWRAP_DIFFCLASS; if (VATTR_IS_ACTIVE(vap, va_dataprotect_class)) { cp_class = (int32_t)vap->va_dataprotect_class; /* * Since the user specifically requested this target class be used, * we want to fail this creation operation if we cannot wrap to their * target class. The CP_KEYWRAP_DIFFCLASS bit says that it is OK to * use a different class than the one specified, so we turn that off * now. */ keywrap_flags &= ~CP_KEYWRAP_DIFFCLASS; } int protected_mount = 0; #endif if ((error = hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) return (error); /* set the cnode pointer only after successfully acquiring lock */ dcp = VTOC(dvp); /* Don't allow creation of new entries in open-unlinked directories */ if ((error = hfs_checkdeleted(dcp))) { hfs_unlock(dcp); return error; } dcp->c_flag |= C_DIR_MODIFICATION; hfsmp = VTOHFS(dvp); *vpp = NULL; tvp = NULL; out_desc.cd_flags = 0; out_desc.cd_nameptr = NULL; vnodetype = vap->va_type; if (vnodetype == VNON) vnodetype = VREG; mode = MAKEIMODE(vnodetype, vap->va_mode); if (S_ISDIR (mode) || S_ISREG (mode)) { protectable_target = 1; } /* Check if were out of usable disk space. */ if ((hfs_freeblks(hfsmp, 1) == 0) && (vfs_context_suser(ctx) != 0)) { error = ENOSPC; goto exit; } microtime(&tv); /* Setup the default attributes */ bzero(&attr, sizeof(attr)); attr.ca_mode = mode; attr.ca_linkcount = 1; if (VATTR_IS_ACTIVE(vap, va_rdev)) { attr.ca_rdev = vap->va_rdev; } if (VATTR_IS_ACTIVE(vap, va_create_time)) { VATTR_SET_SUPPORTED(vap, va_create_time); attr.ca_itime = vap->va_create_time.tv_sec; } else { attr.ca_itime = tv.tv_sec; } #if CONFIG_HFS_STD if ((hfsmp->hfs_flags & HFS_STANDARD) && gTimeZone.tz_dsttime) { attr.ca_itime += 3600; /* Same as what hfs_update does */ } #endif attr.ca_atime = attr.ca_ctime = attr.ca_mtime = attr.ca_itime; attr.ca_atimeondisk = attr.ca_atime; if (VATTR_IS_ACTIVE(vap, va_flags)) { VATTR_SET_SUPPORTED(vap, va_flags); attr.ca_flags = vap->va_flags; } /* * HFS+ only: all files get ThreadExists * HFSX only: dirs get HasFolderCount */ if (!(hfsmp->hfs_flags & HFS_STANDARD)) { if (vnodetype == VDIR) { if (hfsmp->hfs_flags & HFS_FOLDERCOUNT) attr.ca_recflags = kHFSHasFolderCountMask; } else { attr.ca_recflags = kHFSThreadExistsMask; } } #if CONFIG_PROTECT if (cp_fs_protected(hfsmp->hfs_mp)) { protected_mount = 1; } /* * On a content-protected HFS+/HFSX filesystem, files and directories * cannot be created without atomically setting/creating the EA that * contains the protection class metadata and keys at the same time, in * the same transaction. As a result, pre-set the "EAs exist" flag * on the cat_attr for protectable catalog record creations. This will * cause the cnode creation routine in hfs_getnewvnode to mark the cnode * as having EAs. */ if ((protected_mount) && (protectable_target)) { attr.ca_recflags |= kHFSHasAttributesMask; /* delay entering in the namecache */ nocache = 1; } #endif /* * Add the date added to the item. See above, as * all of the dates are set to the itime. */ hfs_write_dateadded (&attr, attr.ca_atime); /* Initialize the gen counter to 1 */ hfs_write_gencount(&attr, (uint32_t)1); attr.ca_uid = vap->va_uid; attr.ca_gid = vap->va_gid; VATTR_SET_SUPPORTED(vap, va_mode); VATTR_SET_SUPPORTED(vap, va_uid); VATTR_SET_SUPPORTED(vap, va_gid); #if QUOTA /* check to see if this node's creation would cause us to go over * quota. If so, abort this operation. */ if (hfsmp->hfs_flags & HFS_QUOTAS) { if ((error = hfs_quotacheck(hfsmp, 1, attr.ca_uid, attr.ca_gid, vfs_context_ucred(ctx)))) { goto exit; } } #endif /* Tag symlinks with a type and creator. */ if (vnodetype == VLNK) { struct FndrFileInfo *fip; fip = (struct FndrFileInfo *)&attr.ca_finderinfo; fip->fdType = SWAP_BE32(kSymLinkFileType); fip->fdCreator = SWAP_BE32(kSymLinkCreator); } /* Setup the descriptor */ in_desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr; in_desc.cd_namelen = cnp->cn_namelen; in_desc.cd_parentcnid = dcp->c_fileid; in_desc.cd_flags = S_ISDIR(mode) ? CD_ISDIR : 0; in_desc.cd_hint = dcp->c_childhint; in_desc.cd_encoding = 0; #if CONFIG_PROTECT /* * To preserve file creation atomicity with regards to the content protection EA, * we must create the file in the catalog and then write out its EA in the same * transaction. * * We only denote the target class in this EA; key generation is not completed * until the file has been inserted into the catalog and will be done * in a separate transaction. */ if ((protected_mount) && (protectable_target)) { error = cp_setup_newentry(hfsmp, dcp, cp_class, attr.ca_mode, &entry); if (error) { goto exit; } } #endif if ((error = hfs_start_transaction(hfsmp)) != 0) { goto exit; } started_tr = 1; // have to also lock the attribute file because cat_create() needs // to check that any fileID it wants to use does not have orphaned // attributes in it. lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK); cnid_t new_id; /* Reserve some space in the Catalog file. */ if ((error = cat_preflight(hfsmp, CAT_CREATE, NULL, 0))) { hfs_systemfile_unlock(hfsmp, lockflags); goto exit; } if ((error = cat_acquire_cnid(hfsmp, &new_id))) { hfs_systemfile_unlock (hfsmp, lockflags); goto exit; } error = cat_create(hfsmp, new_id, &in_desc, &attr, &out_desc); if (error == 0) { /* Update the parent directory */ dcp->c_childhint = out_desc.cd_hint; /* Cache directory's location */ dcp->c_entries++; if (vnodetype == VDIR) { INC_FOLDERCOUNT(hfsmp, dcp->c_attr); } dcp->c_dirchangecnt++; hfs_incr_gencount(dcp); 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 CONFIG_PROTECT /* * If we are creating a content protected file, now is when * we create the EA. We must create it in the same transaction * that creates the file. We can also guarantee that the file * MUST exist because we are still holding the catalog lock * at this point. */ if ((attr.ca_fileid != 0) && (protected_mount) && (protectable_target)) { error = cp_setxattr (NULL, entry, hfsmp, attr.ca_fileid, XATTR_CREATE); if (error) { int delete_err; /* * If we fail the EA creation, then we need to delete the file. * Luckily, we are still holding all of the right locks. */ delete_err = cat_delete (hfsmp, &out_desc, &attr); if (delete_err == 0) { /* Update the parent directory */ if (dcp->c_entries > 0) dcp->c_entries--; dcp->c_dirchangecnt++; dcp->c_ctime = tv.tv_sec; dcp->c_mtime = tv.tv_sec; (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL); } /* Emit EINVAL if we fail to create EA*/ error = EINVAL; } } #endif } hfs_systemfile_unlock(hfsmp, lockflags); if (error) goto exit; /* Invalidate negative cache entries in the directory */ if (dcp->c_flag & C_NEG_ENTRIES) { cache_purge_negatives(dvp); dcp->c_flag &= ~C_NEG_ENTRIES; } hfs_volupdate(hfsmp, vnodetype == VDIR ? VOL_MKDIR : VOL_MKFILE, (dcp->c_cnid == kHFSRootFolderID)); // XXXdbg // have to end the transaction here before we call hfs_getnewvnode() // because that can cause us to try and reclaim a vnode on a different // file system which could cause us to start a transaction which can // 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) { hfs_end_transaction(hfsmp); started_tr = 0; } #if CONFIG_PROTECT /* * At this point, we must have encountered success with writing the EA. * Destroy our temporary cprotect (which had no keys). */ if ((attr.ca_fileid != 0) && (protected_mount) && (protectable_target)) { cp_entry_destroy (entry); entry = NULL; } #endif gnv_flags |= GNV_CREATE; if (nocache) { gnv_flags |= GNV_NOCACHE; } /* * Create a vnode for the object just created. * * NOTE: Maintaining the cnode lock on the parent directory is important, * as it prevents race conditions where other threads want to look up entries * in the directory and/or add things as we are in the process of creating * the vnode below. However, this has the potential for causing a * double lock panic when dealing with shadow files on a HFS boot partition. * The panic could occur if we are not cleaning up after ourselves properly * when done with a shadow file or in the error cases. The error would occur if we * try to create a new vnode, and then end up reclaiming another shadow vnode to * create the new one. However, if everything is working properly, this should * be a non-issue as we would never enter that reclaim codepath. * * The cnode is locked on successful return. */ error = hfs_getnewvnode(hfsmp, dvp, cnp, &out_desc, gnv_flags, &attr, NULL, &tvp, &newvnode_flags); if (error) goto exit; cp = VTOC(tvp); struct doc_tombstone *ut; ut = get_uthread_doc_tombstone(); if ( ut->t_lastop_document_id != 0 && ut->t_lastop_parent == dvp && ut->t_lastop_parent_vid == vnode_vid(dvp) && strcmp((char *)ut->t_lastop_filename, (char *)cp->c_desc.cd_nameptr) == 0) { struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16); //printf("CREATE: preserving doc-id %lld on %s\n", ut->t_lastop_document_id, ut->t_lastop_filename); fip->document_id = (uint32_t)(ut->t_lastop_document_id & 0xffffffff); cp->c_bsdflags |= UF_TRACKED; // mark the cnode dirty cp->c_flag |= C_MODIFIED | C_FORCEUPDATE; if ((error = hfs_start_transaction(hfsmp)) == 0) { lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK); (void) cat_update(hfsmp, &cp->c_desc, &cp->c_attr, NULL, NULL); hfs_systemfile_unlock (hfsmp, lockflags); (void) hfs_end_transaction(hfsmp); } clear_tombstone_docid(ut, hfsmp, cp); // will send the docid-changed fsevent } else if (ut->t_lastop_document_id != 0) { int len = cnp->cn_namelen; if (len == 0) { len = strlen(cnp->cn_nameptr); } if (is_ignorable_temp_name(cnp->cn_nameptr, cnp->cn_namelen)) { // printf("CREATE: not clearing tombstone because %s is a temp name.\n", cnp->cn_nameptr); } else { // Clear the tombstone because the thread is not recreating the same path // printf("CREATE: clearing tombstone because %s is NOT a temp name.\n", cnp->cn_nameptr); clear_tombstone_docid(ut, hfsmp, NULL); } } *vpp = tvp; #if CONFIG_PROTECT /* * Now that we have a vnode-in-hand, generate keys for this namespace item. * If we fail to create the keys, then attempt to delete the item from the * namespace. If we can't delete the item, that's not desirable but also not fatal.. * All of the places which deal with restoring/unwrapping keys must also be * prepared to encounter an entry that does not have keys. */ if ((protectable_target) && (protected_mount)) { struct cprotect *keyed_entry = NULL; if (cp->c_cpentry == NULL) { panic ("hfs_makenode: no cpentry for cnode (%p)", cp); } error = cp_generate_keys (hfsmp, cp, CP_CLASS(cp->c_cpentry->cp_pclass), keywrap_flags, &keyed_entry); if (error == 0) { /* * Upon success, the keys were generated and written out. * Update the cp pointer in the cnode. */ cp_replace_entry (cp, keyed_entry); if (nocache) { cache_enter (dvp, tvp, cnp); } } else { /* If key creation OR the setxattr failed, emit EPERM to userland */ error = EPERM; /* * Beware! This slightly violates the lock ordering for the * cnode/vnode 'tvp'. Ordinarily, you must acquire the truncate lock * which guards file size changes before acquiring the normal cnode lock * and calling hfs_removefile on an item. * * However, in this case, we are still holding the directory lock so * 'tvp' is not lookup-able and it was a newly created vnode so it * cannot have any content yet. The only reason we are initiating * the removefile is because we could not generate content protection keys * for this namespace item. Note also that we pass a '1' in the allow_dirs * argument for hfs_removefile because we may be creating a directory here. * * All this to say that while it is technically a violation it is * impossible to race with another thread for this cnode so it is safe. */ int err = hfs_removefile (dvp, tvp, cnp, 0, 0, 1, NULL, 0); if (err) { printf("hfs_makenode: removefile failed (%d) for CP entry %p\n", err, tvp); } /* Release the cnode lock and mark the vnode for termination */ hfs_unlock (cp); err = vnode_recycle (tvp); if (err) { printf("hfs_makenode: vnode_recycle failed (%d) for CP entry %p\n", err, tvp); } /* Drop the iocount on the new vnode to force reclamation/recycling */ vnode_put (tvp); cp = NULL; *vpp = NULL; } } #endif #if QUOTA /* * Once we create this vnode, we need to initialize its quota data * structures, if necessary. We know that it is OK to just go ahead and * initialize because we've already validated earlier (through the hfs_quotacheck * function) to see if creating this cnode/vnode would cause us to go over quota. */ if (hfsmp->hfs_flags & HFS_QUOTAS) { if (cp) { /* cp could have been zeroed earlier */ (void) hfs_getinoquota(cp); } } #endif exit: cat_releasedesc(&out_desc); #if CONFIG_PROTECT /* * We may have jumped here in error-handling various situations above. * If we haven't already dumped the temporary CP used to initialize * the file atomically, then free it now. cp_entry_destroy should null * out the pointer if it was called already. */ if (entry) { cp_entry_destroy (entry); entry = NULL; } #endif /* * Make sure we release cnode lock on dcp. */ if (dcp) { dcp->c_flag &= ~C_DIR_MODIFICATION; wakeup((caddr_t)&dcp->c_flag); hfs_unlock(dcp); } if (error == 0 && cp != NULL) { hfs_unlock(cp); } if (started_tr) { hfs_end_transaction(hfsmp); started_tr = 0; } return (error); } /* * hfs_vgetrsrc acquires a resource fork vnode corresponding to the * cnode that is found in 'vp'. The cnode should be locked upon entry * and will be returned locked, but it may be dropped temporarily. * * On success, *rvpp wlll hold the resource fork vnode with an * iocount. *Don't* forget the vnode_put. */ int hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp, struct vnode **rvpp) { struct vnode *rvp; struct vnode *dvp = NULLVP; struct cnode *cp = VTOC(vp); int error; int vid; if (vnode_vtype(vp) == VDIR) { return EINVAL; } restart: /* Attempt to use existing vnode */ if ((rvp = cp->c_rsrc_vp)) { vid = vnode_vid(rvp); // vnode_getwithvid can block so we need to drop the cnode lock hfs_unlock(cp); error = vnode_getwithvid(rvp, vid); hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK); /* * When our lock was relinquished, the resource fork * could have been recycled. Check for this and try * again. */ if (error == ENOENT) goto restart; if (error) { const char * name = (const char *)VTOC(vp)->c_desc.cd_nameptr; if (name) printf("hfs_vgetrsrc: couldn't get resource" " fork for %s, vol=%s, err=%d\n", name, hfsmp->vcbVN, error); return (error); } } else { struct cat_fork rsrcfork; struct componentname cn; struct cat_desc *descptr = NULL; struct cat_desc to_desc; char delname[32]; int lockflags; int newvnode_flags = 0; /* * Make sure cnode lock is exclusive, if not upgrade it. * * 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 lose the lock and * have to take the exclusive lock on our own. */ if (lck_rw_lock_shared_to_exclusive(&cp->c_rwlock) == FALSE) lck_rw_lock_exclusive(&cp->c_rwlock); cp->c_lockowner = current_thread(); } /* * hfs_vgetsrc may be invoked for a cnode that has already been marked * C_DELETED. This is because we need to continue to provide rsrc * fork access to open-unlinked files. In this case, build a fake descriptor * like in hfs_removefile. If we don't do this, buildkey will fail in * cat_lookup because this cnode has no name in its descriptor. */ if ((cp->c_flag & C_DELETED ) && (cp->c_desc.cd_namelen == 0)) { bzero (&to_desc, sizeof(to_desc)); bzero (delname, 32); MAKE_DELETED_NAME(delname, sizeof(delname), cp->c_fileid); to_desc.cd_nameptr = (const u_int8_t*) delname; to_desc.cd_namelen = strlen(delname); to_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid; to_desc.cd_flags = 0; to_desc.cd_cnid = cp->c_cnid; descptr = &to_desc; } else { descptr = &cp->c_desc; } lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK); /* * We call cat_idlookup (instead of cat_lookup) below because we can't * trust the descriptor in the provided cnode for lookups at this point. * Between the time of the original lookup of this vnode and now, the * descriptor could have gotten swapped or replaced. If this occurred, * the parent/name combo originally desired may not necessarily be provided * if we use the descriptor. Even worse, if the vnode represents * a hardlink, we could have removed one of the links from the namespace * but left the descriptor alone, since hfs_unlink does not invalidate * the descriptor in the cnode if other links still point to the inode. * * Consider the following (slightly contrived) scenario: * /tmp/a <--> /tmp/b (hardlinks). * 1. Thread A: open rsrc fork on /tmp/b. * 1a. Thread A: does lookup, goes out to lunch right before calling getnamedstream. * 2. Thread B does 'mv /foo/b /tmp/b' * 2. Thread B succeeds. * 3. Thread A comes back and wants rsrc fork info for /tmp/b. * * Even though the hardlink backing /tmp/b is now eliminated, the descriptor * is not removed/updated during the unlink process. So, if you were to * do a lookup on /tmp/b, you'd acquire an entirely different record's resource * fork. * * As a result, we use the fileid, which should be invariant for the lifetime * of the cnode (possibly barring calls to exchangedata). * * Addendum: We can't do the above for HFS standard since we aren't guaranteed to * have thread records for files. They were only required for directories. So * we need to do the lookup with the catalog name. This is OK since hardlinks were * never allowed on HFS standard. */ /* Get resource fork data */ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0) { error = cat_idlookup (hfsmp, cp->c_fileid, 0, 1, NULL, NULL, &rsrcfork); } #if CONFIG_HFS_STD else { /* * HFS standard only: * * Get the resource fork for this item with a cat_lookup call, but do not * force a case lookup since HFS standard is case-insensitive only. We * don't want the descriptor; just the fork data here. If we tried to * do a ID lookup (via thread record -> catalog record), then we might fail * prematurely since, as noted above, thread records were not strictly required * on files in HFS. */ error = cat_lookup (hfsmp, descptr, 1, 0, (struct cat_desc*)NULL, (struct cat_attr*)NULL, &rsrcfork, NULL); } #endif hfs_systemfile_unlock(hfsmp, lockflags); if (error) { return (error); } /* * Supply hfs_getnewvnode with a component name. */ cn.cn_pnbuf = NULL; if (descptr->cd_nameptr) { MALLOC_ZONE(cn.cn_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK); cn.cn_nameiop = LOOKUP; cn.cn_flags = ISLASTCN | HASBUF; cn.cn_context = NULL; cn.cn_pnlen = MAXPATHLEN; cn.cn_nameptr = cn.cn_pnbuf; cn.cn_hash = 0; cn.cn_consume = 0; cn.cn_namelen = snprintf(cn.cn_nameptr, MAXPATHLEN, "%s%s", descptr->cd_nameptr, _PATH_RSRCFORKSPEC); // Should never happen because cn.cn_nameptr won't ever be long... if (cn.cn_namelen >= MAXPATHLEN) { FREE_ZONE(cn.cn_pnbuf, cn.cn_pnlen, M_NAMEI); return ENAMETOOLONG; } } dvp = vnode_getparent(vp); error = hfs_getnewvnode(hfsmp, dvp, cn.cn_pnbuf ? &cn : NULL, descptr, GNV_WANTRSRC | GNV_SKIPLOCK, &cp->c_attr, &rsrcfork, &rvp, &newvnode_flags); if (dvp) vnode_put(dvp); if (cn.cn_pnbuf) FREE_ZONE(cn.cn_pnbuf, cn.cn_pnlen, M_NAMEI); if (error) return (error); } *rvpp = rvp; return (0); } /* * Wrapper for special device reads */ int hfsspec_read(ap) struct vnop_read_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; vfs_context_t a_context; } */ *ap; { /* * Set access flag. */ VTOC(ap->a_vp)->c_touch_acctime = TRUE; return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_read), ap)); } /* * Wrapper for special device writes */ int hfsspec_write(ap) struct vnop_write_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; vfs_context_t a_context; } */ *ap; { /* * Set update and change flags. */ 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)); } /* * Wrapper for special device close * * Update the times on the cnode then do device close. */ int hfsspec_close(ap) struct vnop_close_args /* { struct vnode *a_vp; int a_fflag; vfs_context_t a_context; } */ *ap; { struct vnode *vp = ap->a_vp; struct cnode *cp; if (vnode_isinuse(ap->a_vp, 0)) { if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) == 0) { cp = VTOC(vp); hfs_touchtimes(VTOHFS(vp), cp); hfs_unlock(cp); } } return (VOCALL (spec_vnodeop_p, VOFFSET(vnop_close), ap)); } #if FIFO /* * Wrapper for fifo reads */ static int hfsfifo_read(ap) struct vnop_read_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; vfs_context_t a_context; } */ *ap; { /* * Set access flag. */ VTOC(ap->a_vp)->c_touch_acctime = TRUE; return (VOCALL (fifo_vnodeop_p, VOFFSET(vnop_read), ap)); } /* * Wrapper for fifo writes */ static int hfsfifo_write(ap) struct vnop_write_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; vfs_context_t a_context; } */ *ap; { /* * Set update and change flags. */ 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)); } /* * Wrapper for fifo close * * Update the times on the cnode then do device close. */ static int hfsfifo_close(ap) struct vnop_close_args /* { struct vnode *a_vp; int a_fflag; vfs_context_t a_context; } */ *ap; { struct vnode *vp = ap->a_vp; struct cnode *cp; if (vnode_isinuse(ap->a_vp, 1)) { if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) == 0) { cp = VTOC(vp); hfs_touchtimes(VTOHFS(vp), cp); hfs_unlock(cp); } } return (VOCALL (fifo_vnodeop_p, VOFFSET(vnop_close), ap)); } #endif /* FIFO */ /* * Getter for the document_id * the document_id is stored in FndrExtendedFileInfo/FndrExtendedDirInfo */ static u_int32_t hfs_get_document_id_internal(const uint8_t *finderinfo, mode_t mode) { u_int8_t *finfo = NULL; u_int32_t doc_id = 0; /* overlay the FinderInfo to the correct pointer, and advance */ finfo = ((uint8_t *)finderinfo) + 16; if (S_ISDIR(mode) || S_ISREG(mode)) { struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo; doc_id = extinfo->document_id; } else if (S_ISDIR(mode)) { struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)((u_int8_t*)finderinfo + 16); doc_id = extinfo->document_id; } return doc_id; } /* getter(s) for document id */ u_int32_t hfs_get_document_id(struct cnode *cp) { return (hfs_get_document_id_internal((u_int8_t*)cp->c_finderinfo, cp->c_attr.ca_mode)); } /* If you have finderinfo and mode, you can use this */ u_int32_t hfs_get_document_id_from_blob(const uint8_t *finderinfo, mode_t mode) { return (hfs_get_document_id_internal(finderinfo, mode)); } /* * Synchronize a file's in-core state with that on disk. */ 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; /* Note: We check hfs flags instead of vfs mount flag because during * read-write update, hfs marks itself read-write much earlier than * the vfs, and hence won't result in skipping of certain writes like * zero'ing out of unused nodes, creation of hotfiles btree, etc. */ if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY) { return 0; } /* * No need to call cp_handle_vnop to resolve fsync(). Any dirty data * should have caused the keys to be unwrapped at the time the data was * put into the UBC, either at mmap/pagein/read-write. If we did manage * to let this by, then strategy will auto-resolve for us. * * We also need to allow ENOENT lock errors since unlink * system call can call VNOP_FSYNC during vclean. */ error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT); if (error) return (0); error = hfs_fsync(vp, ap->a_waitfor, 0, vfs_context_proc(ap->a_context)); hfs_unlock(VTOC(vp)); return (error); } int (**hfs_vnodeop_p)(void *); #define VOPFUNC int (*)(void *) #if CONFIG_HFS_STD int (**hfs_std_vnodeop_p) (void *); static int hfs_readonly_op (__unused void* ap) { return (EROFS); } /* * In 10.6 and forward, HFS Standard is read-only and deprecated. The vnop table below * is for use with HFS standard to block out operations that would modify the file system */ struct vnodeopv_entry_desc hfs_standard_vnodeop_entries[] = { { &vnop_default_desc, (VOPFUNC)vn_default_error }, { &vnop_lookup_desc, (VOPFUNC)hfs_vnop_lookup }, /* lookup */ { &vnop_create_desc, (VOPFUNC)hfs_readonly_op }, /* create (READONLY) */ { &vnop_mknod_desc, (VOPFUNC)hfs_readonly_op }, /* mknod (READONLY) */ { &vnop_open_desc, (VOPFUNC)hfs_vnop_open }, /* open */ { &vnop_close_desc, (VOPFUNC)hfs_vnop_close }, /* close */ { &vnop_getattr_desc, (VOPFUNC)hfs_vnop_getattr }, /* getattr */ { &vnop_setattr_desc, (VOPFUNC)hfs_readonly_op }, /* setattr */ { &vnop_read_desc, (VOPFUNC)hfs_vnop_read }, /* read */ { &vnop_write_desc, (VOPFUNC)hfs_readonly_op }, /* write (READONLY) */ { &vnop_ioctl_desc, (VOPFUNC)hfs_vnop_ioctl }, /* ioctl */ { &vnop_select_desc, (VOPFUNC)hfs_vnop_select }, /* select */ { &vnop_revoke_desc, (VOPFUNC)nop_revoke }, /* revoke */ { &vnop_exchange_desc, (VOPFUNC)hfs_readonly_op }, /* exchange (READONLY)*/ { &vnop_mmap_desc, (VOPFUNC)err_mmap }, /* mmap */ { &vnop_fsync_desc, (VOPFUNC)hfs_readonly_op}, /* fsync (READONLY) */ { &vnop_remove_desc, (VOPFUNC)hfs_readonly_op }, /* remove (READONLY) */ { &vnop_link_desc, (VOPFUNC)hfs_readonly_op }, /* link ( READONLLY) */ { &vnop_rename_desc, (VOPFUNC)hfs_readonly_op }, /* rename (READONLY)*/ { &vnop_mkdir_desc, (VOPFUNC)hfs_readonly_op }, /* mkdir (READONLY) */ { &vnop_rmdir_desc, (VOPFUNC)hfs_readonly_op }, /* rmdir (READONLY) */ { &vnop_symlink_desc, (VOPFUNC)hfs_readonly_op }, /* symlink (READONLY) */ { &vnop_readdir_desc, (VOPFUNC)hfs_vnop_readdir }, /* readdir */ { &vnop_readdirattr_desc, (VOPFUNC)hfs_vnop_readdirattr }, /* readdirattr */ { &vnop_readlink_desc, (VOPFUNC)hfs_vnop_readlink }, /* readlink */ { &vnop_inactive_desc, (VOPFUNC)hfs_vnop_inactive }, /* inactive */ { &vnop_reclaim_desc, (VOPFUNC)hfs_vnop_reclaim }, /* reclaim */ { &vnop_strategy_desc, (VOPFUNC)hfs_vnop_strategy }, /* strategy */ { &vnop_pathconf_desc, (VOPFUNC)hfs_vnop_pathconf }, /* pathconf */ { &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */ { &vnop_allocate_desc, (VOPFUNC)hfs_readonly_op }, /* allocate (READONLY) */ #if CONFIG_SEARCHFS { &vnop_searchfs_desc, (VOPFUNC)hfs_vnop_search }, /* search fs */ #else { &vnop_searchfs_desc, (VOPFUNC)err_searchfs }, /* search fs */ #endif { &vnop_bwrite_desc, (VOPFUNC)hfs_readonly_op }, /* bwrite (READONLY) */ { &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* pagein */ { &vnop_pageout_desc,(VOPFUNC) hfs_readonly_op }, /* pageout (READONLY) */ { &vnop_copyfile_desc, (VOPFUNC)hfs_readonly_op }, /* copyfile (READONLY)*/ { &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */ { &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */ { &vnop_blockmap_desc, (VOPFUNC)hfs_vnop_blockmap }, /* blockmap */ { &vnop_getxattr_desc, (VOPFUNC)hfs_vnop_getxattr}, { &vnop_setxattr_desc, (VOPFUNC)hfs_readonly_op}, /* set xattr (READONLY) */ { &vnop_removexattr_desc, (VOPFUNC)hfs_readonly_op}, /* remove xattr (READONLY) */ { &vnop_listxattr_desc, (VOPFUNC)hfs_vnop_listxattr}, #if NAMEDSTREAMS { &vnop_getnamedstream_desc, (VOPFUNC)hfs_vnop_getnamedstream }, { &vnop_makenamedstream_desc, (VOPFUNC)hfs_readonly_op }, { &vnop_removenamedstream_desc, (VOPFUNC)hfs_readonly_op }, #endif { &vnop_getattrlistbulk_desc, (VOPFUNC)hfs_vnop_getattrlistbulk }, /* getattrlistbulk */ { NULL, (VOPFUNC)NULL } }; struct vnodeopv_desc hfs_std_vnodeop_opv_desc = { &hfs_std_vnodeop_p, hfs_standard_vnodeop_entries }; #endif /* VNOP table for HFS+ */ struct vnodeopv_entry_desc hfs_vnodeop_entries[] = { { &vnop_default_desc, (VOPFUNC)vn_default_error }, { &vnop_lookup_desc, (VOPFUNC)hfs_vnop_lookup }, /* lookup */ { &vnop_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)hfs_vnop_mmap }, /* mmap */ { &vnop_fsync_desc, (VOPFUNC)hfs_vnop_fsync }, /* fsync */ { &vnop_remove_desc, (VOPFUNC)hfs_vnop_remove }, /* remove */ { &vnop_link_desc, (VOPFUNC)hfs_vnop_link }, /* link */ { &vnop_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 */ #if CONFIG_SEARCHFS { &vnop_searchfs_desc, (VOPFUNC)hfs_vnop_search }, /* search fs */ #else { &vnop_searchfs_desc, (VOPFUNC)err_searchfs }, /* search fs */ #endif { &vnop_bwrite_desc, (VOPFUNC)hfs_vnop_bwrite }, /* bwrite */ { &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* pagein */ { &vnop_pageout_desc,(VOPFUNC) hfs_vnop_pageout }, /* pageout */ { &vnop_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_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}, #if NAMEDSTREAMS { &vnop_getnamedstream_desc, (VOPFUNC)hfs_vnop_getnamedstream }, { &vnop_makenamedstream_desc, (VOPFUNC)hfs_vnop_makenamedstream }, { &vnop_removenamedstream_desc, (VOPFUNC)hfs_vnop_removenamedstream }, #endif { &vnop_getattrlistbulk_desc, (VOPFUNC)hfs_vnop_getattrlistbulk }, /* getattrlistbulk */ { &vnop_mnomap_desc, (VOPFUNC)hfs_vnop_mnomap }, { NULL, (VOPFUNC)NULL } }; struct vnodeopv_desc hfs_vnodeop_opv_desc = { &hfs_vnodeop_p, hfs_vnodeop_entries }; /* Spec Op vnop table for HFS+ */ int (**hfs_specop_p)(void *); struct vnodeopv_entry_desc hfs_specop_entries[] = { { &vnop_default_desc, (VOPFUNC)vn_default_error }, { &vnop_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 */ { &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}, { (struct vnodeop_desc*)NULL, (VOPFUNC)NULL } }; struct vnodeopv_desc hfs_specop_opv_desc = { &hfs_specop_p, hfs_specop_entries }; #if FIFO /* HFS+ FIFO VNOP table */ int (**hfs_fifoop_p)(void *); struct vnodeopv_entry_desc hfs_fifoop_entries[] = { { &vnop_default_desc, (VOPFUNC)vn_default_error }, { &vnop_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_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}, { (struct vnodeop_desc*)NULL, (VOPFUNC)NULL } }; struct vnodeopv_desc hfs_fifoop_opv_desc = { &hfs_fifoop_p, hfs_fifoop_entries }; #endif /* FIFO */