xnu-1504.9.17.tar.gz

[apple/xnu.git] / bsd / hfs / hfs_cnode.c

diff --git a/bsd/hfs/hfs_cnode.c b/bsd/hfs/hfs_cnode.c
index 913454fdf0e9f92cba5240f97720123656ccbca0..c17c8d4ddbe0ac5bf2eb1d81727ad78b824507c7 100644 (file)
--- a/bsd/hfs/hfs_cnode.c
+++ b/bsd/hfs/hfs_cnode.c
@@ -1,16 +1,19 @@
 /*
 /*

- * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2002-2008 Apple Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
- * 
- * Copyright (c) 1999-2003 Apple Computer, 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
  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in

- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * 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
  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER


@@ -20,7 +23,7 @@
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 #include <sys/param.h>
 #include <sys/systm.h>
  */
 #include <sys/param.h>
 #include <sys/systm.h>


@@ -29,8 +32,12 @@
 #include <sys/mount.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/mount.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>

+#include <sys/time.h>

 #include <sys/ubc.h>
 #include <sys/quota.h>
 #include <sys/ubc.h>
 #include <sys/quota.h>

+#include <sys/kdebug.h>
+
+#include <kern/locks.h>

 
 #include <miscfs/specfs/specdev.h>
 #include <miscfs/fifofs/fifo.h>
 
 #include <miscfs/specfs/specdev.h>
 #include <miscfs/fifofs/fifo.h>


@@ -42,8 +49,19 @@
 
 extern int prtactive;
 
 
 extern int prtactive;
 

+extern lck_attr_t *  hfs_lock_attr;
+extern lck_grp_t *  hfs_mutex_group;
+extern lck_grp_t *  hfs_rwlock_group;
+
+static int  hfs_filedone(struct vnode *vp, vfs_context_t context);

 
 

-extern void    hfs_relnamehints(struct cnode *dcp);
+static void  hfs_reclaim_cnode(struct cnode *);
+
+static int hfs_isordered(struct cnode *, struct cnode *);
+
+inline int hfs_checkdeleted (struct cnode *cp) {
+       return ((cp->c_flag & (C_DELETED | C_NOEXISTS)) ? ENOENT : 0);
+}

 
 
 /*
 
 
 /*


@@ -51,49 +69,159 @@ extern void        hfs_relnamehints(struct cnode *dcp);
  */
 __private_extern__
 int
  */
 __private_extern__
 int

-hfs_inactive(ap)
-       struct vop_inactive_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
+hfs_vnop_inactive(struct vnop_inactive_args *ap)

 {
        struct vnode *vp = ap->a_vp;
 {
        struct vnode *vp = ap->a_vp;

-       struct cnode *cp = VTOC(vp);
+       struct cnode *cp;

        struct hfsmount *hfsmp = VTOHFS(vp);
        struct hfsmount *hfsmp = VTOHFS(vp);

-       struct proc *p = ap->a_p;
-       struct timeval tv;
+       struct proc *p = vfs_context_proc(ap->a_context);

        int error = 0;
        int recycle = 0;
        int forkcount = 0;
        int truncated = 0;
        int error = 0;
        int recycle = 0;
        int forkcount = 0;
        int truncated = 0;

-       int started_tr = 0, grabbed_lock = 0;
-
-       if (prtactive && vp->v_usecount != 0)
-               vprint("hfs_inactive: pushing active", vp);
+       int started_tr = 0;
+       int took_trunc_lock = 0;
+       cat_cookie_t cookie;
+       int cat_reserve = 0;
+       int lockflags;
+       enum vtype v_type;
+
+       v_type = vnode_vtype(vp);
+       cp = VTOC(vp);
+
+       if ((hfsmp->hfs_flags & HFS_READ_ONLY) || vnode_issystem(vp) ||
+           (hfsmp->hfs_freezing_proc == p)) {
+               return (0);
+       }

 
        /*
         * Ignore nodes related to stale file handles.
 
        /*
         * Ignore nodes related to stale file handles.

+        * We are peeking at the cnode flag without the lock, but if C_NOEXISTS
+        * is set, that means the cnode doesn't have any backing store in the 
+        * catalog anymore, and is otherwise safe to force a recycle

         */
         */

-       if (cp->c_mode == 0)
-               goto out;
+       
+       if (cp->c_flag & C_NOEXISTS) {
+               vnode_recycle(vp);
+               return (0);
+       }

 
 

-       if (vp->v_mount->mnt_flag & MNT_RDONLY)
-               goto out;
+       if ((v_type == VREG || v_type == VLNK)) {
+               hfs_lock_truncate(cp, TRUE);
+               took_trunc_lock = 1;
+       }
+
+       (void) hfs_lock(cp, HFS_FORCE_LOCK);

 
        if (cp->c_datafork)
                ++forkcount;
        if (cp->c_rsrcfork)
                ++forkcount;
 
 
        if (cp->c_datafork)
                ++forkcount;
        if (cp->c_rsrcfork)
                ++forkcount;
 

-       /* If needed, get rid of any fork's data for a deleted file */
-       if ((cp->c_flag & C_DELETED) &&
-           vp->v_type == VREG &&
-           (VTOF(vp)->ff_blocks != 0)) {                       
-               error = VOP_TRUNCATE(vp, (off_t)0, IO_NDELAY, NOCRED, p);
-               truncated = 1;
-               // have to do this to prevent the lost ubc_info panic
-               SET(cp->c_flag, C_TRANSIT);
-               recycle = 1;
-               if (error) goto out;
+       /*
+        * We should lock cnode before checking the flags in the 
+        * condition below and should unlock the cnode before calling 
+        * ubc_setsize() as cluster code can call other HFS vnops which
+        * will try to acquire the same cnode lock and cause deadlock.
+        * Only call ubc_setsize to 0 if we are the last fork.
+        */
+       if ((v_type == VREG || v_type == VLNK) &&
+                       (cp->c_flag & C_DELETED) &&
+                       (VTOF(vp)->ff_blocks != 0) && (forkcount == 1)) {
+               hfs_unlock(cp); 
+               ubc_setsize(vp, 0);
+               (void) hfs_lock(cp, HFS_FORCE_LOCK);
+       }
+
+       if (v_type == VREG && !ISSET(cp->c_flag, C_DELETED) && VTOF(vp)->ff_blocks) {
+               hfs_filedone(vp, ap->a_context);
+       }
+       /* 
+        * Remove any directory hints or cached origins
+        */
+       if (v_type == VDIR) {
+               hfs_reldirhints(cp, 0);
+       }
+       if (cp->c_flag & C_HARDLINK) {
+               hfs_relorigins(cp);
+       }
+
+       /* Hurry the recycling process along if we're an open-unlinked file */
+       if((v_type == VREG || v_type == VLNK) && (cp->c_flag & C_DELETED)) {
+               recycle = 1;    
+       }
+
+       /*
+        * This check is slightly complicated.  We should only truncate data 
+        * in very specific cases for open-unlinked files.  This is because
+        * we want to ensure that the resource fork continues to be available
+        * if the caller has the data fork open.  However, this is not symmetric; 
+        * someone who has the resource fork open need not be able to access the data
+        * fork once the data fork has gone inactive.
+        * 
+        * If we're the last fork, then we have cleaning up to do.
+        * 
+        * A) last fork, and vp == c_vp
+        *      Truncate away own fork dat. If rsrc fork is not in core, truncate it too.
+        *
+        * B) last fork, and vp == c_rsrc_vp
+        *      Truncate ourselves, assume data fork has been cleaned due to C).
+        *
+        * If we're not the last fork, then things are a little different:
+        *
+        * C) not the last fork, vp == c_vp
+        *      Truncate ourselves.  Once the file has gone out of the namespace,
+        *      it cannot be further opened.  Further access to the rsrc fork may 
+        *      continue, however.
+        *
+        * D) not the last fork, vp == c_rsrc_vp
+        *      Don't enter the block below, just clean up vnode and push it out of core.
+        */
+
+       if ((v_type == VREG || v_type == VLNK) && (cp->c_flag & C_DELETED) &&
+                       ((forkcount == 1) || (!VNODE_IS_RSRC(vp)))) {
+               if (VTOF(vp)->ff_blocks != 0) {
+                       /*
+                        * Since we're already inside a transaction,
+                        * tell hfs_truncate to skip the ubc_setsize.
+                        */
+                       error = hfs_truncate(vp, (off_t)0, IO_NDELAY, 1, 0, ap->a_context);
+                       if (error)
+                               goto out;
+                       truncated = 1;
+               }
+
+               /* 
+                * If c_blocks > 0 and we are the last fork (data fork), then
+                * we can go and and truncate away the rsrc fork blocks if
+                * they were not in core.
+                */
+               if ((cp->c_blocks > 0) && (forkcount == 1) && (vp != cp->c_rsrc_vp)) {
+                       struct vnode *rvp = NULLVP;
+
+                       error = hfs_vgetrsrc(hfsmp, vp, &rvp, FALSE, FALSE);
+                       if (error)
+                               goto out;
+                       /*
+                        * Defer the vnode_put and ubc_setsize on rvp until hfs_unlock().
+                        */
+                       cp->c_flag |= C_NEED_RVNODE_PUT | C_NEED_RSRC_SETSIZE;
+                       error = hfs_truncate(rvp, (off_t)0, IO_NDELAY, 1, 0, ap->a_context);
+                       if (error)
+                               goto out;
+                       vnode_recycle(rvp);  /* all done with this vnode */
+               }
+       }
+
+       // If needed, get rid of any xattrs that this file (or directory) may have.
+       // Note that this must happen outside of any other transactions
+       // because it starts/ends its own transactions and grabs its
+       // own locks.  This is to prevent a file with a lot of attributes
+       // from creating a transaction that is too large (which panics).
+       //
+       if ((cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0 && 
+                       (cp->c_flag & C_DELETED) && (forkcount <= 1)) {
+               hfs_removeallattr(hfsmp, cp->c_fileid);

        }
 
        /*
        }
 
        /*


@@ -102,31 +230,52 @@ hfs_inactive(ap)
         */
        if ((cp->c_flag & C_DELETED) && (forkcount <= 1)) {                     
                /*
         */
        if ((cp->c_flag & C_DELETED) && (forkcount <= 1)) {                     
                /*

-                * Mark cnode in transit so that one can get this 
+                * Mark cnode in transit so that no one can get this 

                 * cnode from cnode hash.
                 */
                 * cnode from cnode hash.
                 */

-               SET(cp->c_flag, C_TRANSIT);
-               cp->c_flag &= ~C_DELETED;
+               // hfs_chash_mark_in_transit(hfsmp, cp);
+               // XXXdbg - remove the cnode from the hash table since it's deleted
+               //          otherwise someone could go to sleep on the cnode and not
+               //          be woken up until this vnode gets recycled which could be
+               //          a very long time...
+               hfs_chashremove(hfsmp, cp);
+
+               cp->c_flag |= C_NOEXISTS;   // XXXdbg

                cp->c_rdev = 0;
                cp->c_rdev = 0;

-               
-               // XXXdbg
-               hfs_global_shared_lock_acquire(hfsmp);
-               grabbed_lock = 1;
-               if (hfsmp->jnl) {
-                   if (journal_start_transaction(hfsmp->jnl) != 0) {
-                               error = EINVAL;
-                               goto out;
+
+               if (started_tr == 0) {
+                   if (hfs_start_transaction(hfsmp) != 0) {
+                       error = EINVAL;
+                       goto out;

                    }
                    started_tr = 1;
                }
                    }
                    started_tr = 1;
                }

+               
+               /*
+                * Reserve some space in the Catalog file.
+                */
+               if ((error = cat_preflight(hfsmp, CAT_DELETE, &cookie, p))) {
+                       goto out;
+               }
+               cat_reserve = 1;

 
 

-               /* Lock catalog b-tree */
-               error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
-               if (error) goto out;
+               lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);

 
 

-               if (cp->c_blocks > 0)
-                       printf("hfs_inactive: attempting to delete a non-empty file!");
+               if (cp->c_blocks > 0) {
+                       printf("hfs_inactive: deleting non-empty%sfile %d, "
+                              "blks %d\n", VNODE_IS_RSRC(vp) ? " rsrc " : " ",
+                              (int)cp->c_fileid, (int)cp->c_blocks);
+               }

 
 

+               //
+               // release the name pointer in the descriptor so that
+               // cat_delete() will use the file-id to do the deletion.
+               // in the case of hard links this is imperative (in the
+               // case of regular files the fileid and cnid are the
+               // same so it doesn't matter).
+               //
+               cat_releasedesc(&cp->c_desc);
+               

                /*
                 * The descriptor name may be zero,
                 * in which case the fileid is used.
                /*
                 * The descriptor name may be zero,
                 * in which case the fileid is used.


@@ -138,462 +287,421 @@ hfs_inactive(ap)
 
                /* Update HFS Private Data dir */
                if (error == 0) {
 
                /* Update HFS Private Data dir */
                if (error == 0) {

-                       hfsmp->hfs_privdir_attr.ca_entries--;
-                       (void)cat_update(hfsmp, &hfsmp->hfs_privdir_desc,
-                               &hfsmp->hfs_privdir_attr, NULL, NULL);
+                       hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries--;
+                       if (vnode_isdir(vp)) {
+                               DEC_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);

                }
 
                }
 

-               /* Unlock catalog b-tree */
-               (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
-               if (error) goto out;
+               hfs_systemfile_unlock(hfsmp, lockflags);
+
+               if (error)
+                       goto out;

 
 #if QUOTA
 
 #if QUOTA

-               (void)hfs_chkiq(cp, -1, NOCRED, 0);
+               if (hfsmp->hfs_flags & HFS_QUOTAS)
+                       (void)hfs_chkiq(cp, -1, NOCRED, 0);

 #endif /* QUOTA */
 #endif /* QUOTA */

-
-               cp->c_mode = 0;
-               cp->c_flag |= C_NOEXISTS | C_CHANGE | C_UPDATE;
+               
+               /* Already set C_NOEXISTS at the beginning of this block */
+               cp->c_flag &= ~C_DELETED;
+               cp->c_touch_chgtime = TRUE;
+               cp->c_touch_modtime = TRUE;

 
                if (error == 0)
 
                if (error == 0)

-                       hfs_volupdate(hfsmp, VOL_RMFILE, 0);
-       }
-
-       /* Push any defered access times to disk */
-       if (cp->c_flag & C_ATIMEMOD) {
-               cp->c_flag &= ~C_ATIMEMOD;
-               if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSPlusSigWord)
-                       cp->c_flag |= C_MODIFIED;
+                       hfs_volupdate(hfsmp, (v_type == VDIR) ? VOL_RMDIR : VOL_RMFILE, 0);

        }
 
        }
 

-       if (cp->c_flag & (C_ACCESS | C_CHANGE | C_MODIFIED | C_UPDATE)) {
-               tv = time;
-               VOP_UPDATE(vp, &tv, &tv, 0);
+       /*
+        * A file may have had delayed allocations, in which case hfs_update
+        * would not have updated the catalog record (cat_update).  We need
+        * to do that now, before we lose our fork data.  We also need to
+        * force the update, or hfs_update will again skip the cat_update.
+        */
+       if ((cp->c_flag & C_MODIFIED) ||
+           cp->c_touch_acctime || cp->c_touch_chgtime || cp->c_touch_modtime) {
+           if ((cp->c_flag & C_MODIFIED) || cp->c_touch_modtime){
+                       cp->c_flag |= C_FORCEUPDATE;
+               }       
+               hfs_update(vp, 0);

        }
 out:
        }
 out:

+       if (cat_reserve)
+               cat_postflight(hfsmp, &cookie, p);
+

        // XXXdbg - have to do this because a goto could have come here
        if (started_tr) {
        // XXXdbg - have to do this because a goto could have come here
        if (started_tr) {

-           journal_end_transaction(hfsmp->jnl);
+           hfs_end_transaction(hfsmp);

            started_tr = 0;
        }
            started_tr = 0;
        }

-       if (grabbed_lock) {
-               hfs_global_shared_lock_release(hfsmp);
-       }
+       /* 
+        * This has been removed from the namespace and has no backing store
+        * in the catalog, so we should force a reclaim as soon as possible.
+        * Also, we want to check the flag while we still have the cnode lock.
+        */
+       if (cp->c_flag & C_NOEXISTS) 
+               recycle = 1;
+
+       hfs_unlock(cp);
+
+       if (took_trunc_lock)
+           hfs_unlock_truncate(cp, TRUE);

 
 

-       VOP_UNLOCK(vp, 0, p);

        /*
         * If we are done with the vnode, reclaim it
         * so that it can be reused immediately.
         */
        /*
         * If we are done with the vnode, reclaim it
         * so that it can be reused immediately.
         */

-       if (cp->c_mode == 0 || recycle)
-               vrecycle(vp, (struct slock *)0, p);
+       if (recycle)
+               vnode_recycle(vp);

 
        return (error);
 }
 
 
        return (error);
 }
 

+/*
+ * File clean-up (zero fill and shrink peof).
+ */
+static int
+hfs_filedone(struct vnode *vp, vfs_context_t context)
+{
+       struct cnode *cp;
+       struct filefork *fp;
+       struct hfsmount *hfsmp;
+       struct rl_entry *invalid_range;
+       off_t leof;
+       u_int32_t blks, blocksize;
+
+       cp = VTOC(vp);
+       fp = VTOF(vp);
+       hfsmp = VTOHFS(vp);
+       leof = fp->ff_size;
+
+       if ((hfsmp->hfs_flags & HFS_READ_ONLY) || (fp->ff_blocks == 0))
+               return (0);
+
+       hfs_unlock(cp);
+       (void) cluster_push(vp, IO_CLOSE);
+       hfs_lock(cp, HFS_FORCE_LOCK);
+
+       /*
+        * Explicitly zero out the areas of file
+        * that are currently marked invalid.
+        */
+       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);
+
+               hfs_unlock(cp);
+               (void) cluster_write(vp, (struct uio *) 0,
+                                    leof, end + 1, start, (off_t)0,
+                                    IO_HEADZEROFILL | IO_NOZERODIRTY | IO_NOCACHE);
+               hfs_lock(cp, HFS_FORCE_LOCK);
+               cp->c_flag |= C_MODIFIED;
+       }
+       cp->c_flag &= ~C_ZFWANTSYNC;
+       cp->c_zftimeout = 0;
+       blocksize = VTOVCB(vp)->blockSize;
+       blks = leof / blocksize;
+       if (((off_t)blks * (off_t)blocksize) != leof)
+               blks++;
+       /*
+        * Shrink the peof to the smallest size neccessary to contain the leof.
+        */
+       if (blks < fp->ff_blocks)
+               (void) hfs_truncate(vp, leof, IO_NDELAY, 0, 0, context);
+       hfs_unlock(cp);
+       (void) cluster_push(vp, IO_CLOSE);
+       hfs_lock(cp, HFS_FORCE_LOCK);
+       
+       /*
+        * If the hfs_truncate didn't happen to flush the vnode's
+        * information out to disk, force it to be updated now that
+        * all invalid ranges have been zero-filled and validated:
+        */
+       if (cp->c_flag & C_MODIFIED) {
+               hfs_update(vp, 0);
+       }
+       return (0);
+}
+

 
 /*
  * Reclaim a cnode so that it can be used for other purposes.
  */
 __private_extern__
 int
 
 /*
  * Reclaim a cnode so that it can be used for other purposes.
  */
 __private_extern__
 int

-hfs_reclaim(ap)
-       struct vop_reclaim_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
+hfs_vnop_reclaim(struct vnop_reclaim_args *ap)

 {
        struct vnode *vp = ap->a_vp;
 {
        struct vnode *vp = ap->a_vp;

-       struct cnode *cp = VTOC(vp);
-       struct vnode *devvp = NULL;
+       struct cnode *cp;

        struct filefork *fp = NULL;
        struct filefork *altfp = NULL;
        struct filefork *fp = NULL;
        struct filefork *altfp = NULL;

-       int i;
+       struct hfsmount *hfsmp = VTOHFS(vp);
+       int reclaim_cnode = 0;

 
 

-       if (prtactive && vp->v_usecount != 0)
-               vprint("hfs_reclaim(): pushing active", vp);
+       (void) hfs_lock(VTOC(vp), HFS_FORCE_LOCK);
+       cp = VTOC(vp);
+       
+       /*
+        * A file may have had delayed allocations, in which case hfs_update
+        * would not have updated the catalog record (cat_update).  We need
+        * to do that now, before we lose our fork data.  We also need to
+        * force the update, or hfs_update will again skip the cat_update.
+        */
+       if ((cp->c_flag & C_MODIFIED) ||
+           cp->c_touch_acctime || cp->c_touch_chgtime || cp->c_touch_modtime) {
+           if ((cp->c_flag & C_MODIFIED) || cp->c_touch_modtime){
+                       cp->c_flag |= C_FORCEUPDATE;
+               }
+               hfs_update(vp, 0);
+       }

 
 

-       devvp = cp->c_devvp;            /* For later releasing */
+       /*
+        * Keep track of an inactive hot file.
+        */
+       if (!vnode_isdir(vp) &&
+           !vnode_issystem(vp) &&
+           !(cp->c_flag & (C_DELETED | C_NOEXISTS)) ) {
+               (void) hfs_addhotfile(vp);
+       }
+       vnode_removefsref(vp);

 
        /*
         * Find file fork for this vnode (if any)
         * Also check if another fork is active
         */
 
        /*
         * Find file fork for this vnode (if any)
         * Also check if another fork is active
         */

-       if ((fp = cp->c_datafork) && (cp->c_vp == vp)) {
+       if (cp->c_vp == vp) {
+               fp = cp->c_datafork;
+               altfp = cp->c_rsrcfork;
+

                cp->c_datafork = NULL;
                cp->c_vp = NULL;
                cp->c_datafork = NULL;
                cp->c_vp = NULL;

-               altfp = cp->c_rsrcfork;
-       } else if ((fp = cp->c_rsrcfork) && (cp->c_rsrc_vp == vp)) {
+       } else if (cp->c_rsrc_vp == vp) {
+               fp = cp->c_rsrcfork;
+               altfp = cp->c_datafork;
+

                cp->c_rsrcfork = NULL;
                cp->c_rsrc_vp = NULL;
                cp->c_rsrcfork = NULL;
                cp->c_rsrc_vp = NULL;

-               altfp = cp->c_datafork;

        } else {
        } else {

-               cp->c_vp = NULL;
-               fp = NULL;
-               altfp = NULL;
+               panic("hfs_vnop_reclaim: vp points to wrong cnode (vp=%p cp->c_vp=%p cp->c_rsrc_vp=%p)\n", vp, cp->c_vp, cp->c_rsrc_vp);

        }
        }

-

        /*
         * On the last fork, remove the cnode from its hash chain.
         */
        /*
         * On the last fork, remove the cnode from its hash chain.
         */

-       if (altfp == NULL)
-               hfs_chashremove(cp);
-
-       /* Release the file fork and related data (can block) */
+       if (altfp == NULL) {
+               /* If we can't remove it then the cnode must persist! */
+               if (hfs_chashremove(hfsmp, cp) == 0)
+                       reclaim_cnode = 1;
+               /* 
+                * Remove any directory hints
+                */
+               if (vnode_isdir(vp)) {
+                       hfs_reldirhints(cp, 0);
+               }
+               
+               if(cp->c_flag & C_HARDLINK) {
+                       hfs_relorigins(cp);
+               }
+       }
+       /* Release the file fork and related data */

        if (fp) {
        if (fp) {

-               fp->ff_cp = NULL;

                /* Dump cached symlink data */
                /* Dump cached symlink data */

-               if ((vp->v_type == VLNK) && (fp->ff_symlinkptr != NULL)) {
+               if (vnode_islnk(vp) && (fp->ff_symlinkptr != NULL)) {

                        FREE(fp->ff_symlinkptr, M_TEMP);
                        FREE(fp->ff_symlinkptr, M_TEMP);

-                       fp->ff_symlinkptr = NULL;
-               }
+               }               

                FREE_ZONE(fp, sizeof(struct filefork), M_HFSFORK);
                FREE_ZONE(fp, sizeof(struct filefork), M_HFSFORK);

-               fp = NULL;
-       }
-
-       /*
-        * Purge old data structures associated with the cnode.
-        */
-       cache_purge(vp);
-       if (devvp && altfp == NULL) {
-               cp->c_devvp = NULL;
-               vrele(devvp);

        }
 
        }
 

-       vp->v_data = NULL;
-

        /* 
         * If there was only one active fork then we can release the cnode.
         */
        /* 
         * If there was only one active fork then we can release the cnode.
         */

-       if (altfp == NULL) {
-#if QUOTA
-               for (i = 0; i < MAXQUOTAS; i++) {
-                       if (cp->c_dquot[i] != NODQUOT) {
-                               dqreclaim(vp, cp->c_dquot[i]);
-                               cp->c_dquot[i] = NODQUOT;
-                       }
-               }
-#endif /* QUOTA */
-               /* 
-                * Free any left over directory indices
-                */
-               if (vp->v_type == VDIR)
-                       hfs_relnamehints(cp);
-
-               /* 
-                * If the descriptor has a name then release it
-                */
-               if (cp->c_desc.cd_flags & CD_HASBUF) {
-                       char *nameptr;
-
-                       nameptr = cp->c_desc.cd_nameptr;
-                       cp->c_desc.cd_nameptr = 0;
-                       cp->c_desc.cd_flags &= ~CD_HASBUF;
-                       cp->c_desc.cd_namelen = 0;
-                       FREE(nameptr, M_TEMP);
-               }
-               CLR(cp->c_flag, (C_ALLOC | C_TRANSIT));
-               if (ISSET(cp->c_flag, C_WALLOC) || ISSET(cp->c_flag, C_WTRANSIT))
-                       wakeup(cp);
-               FREE_ZONE(cp, sizeof(struct cnode), M_HFSNODE);
-
+       if (reclaim_cnode) {
+               hfs_chashwakeup(hfsmp, cp, H_ALLOC | H_TRANSIT);
+               hfs_reclaim_cnode(cp);
+       } else /* cnode in use */ {
+               hfs_unlock(cp);

        }
 
        }
 

+       vnode_clearfsnode(vp);

        return (0);
 }
 
 
        return (0);
 }
 
 

-/*
- * get a cnode
- *
- * called by hfs_lookup and hfs_vget (descp == NULL)
- *
- * returns a locked vnode for cnode for given cnid/fileid
- */
-__private_extern__
-int
-hfs_getcnode(struct hfsmount *hfsmp, cnid_t cnid, struct cat_desc *descp, int wantrsrc,
-                  struct cat_attr *attrp, struct cat_fork *forkp, struct vnode **vpp)
-{
-       dev_t dev = hfsmp->hfs_raw_dev;
-       struct vnode *vp = NULL;
-       struct vnode *rvp = NULL;
-       struct vnode *new_vp = NULL;
-       struct cnode *cp = NULL;
-       struct proc *p = current_proc();
-       int retval = E_NONE;
-
-       /* Check if unmount in progress */
-       if (HFSTOVFS(hfsmp)->mnt_kern_flag & MNTK_UNMOUNT) {
-               *vpp = NULL;
-               return (EPERM);
-       }
-
-       /*
-        * Check the hash for an active cnode
-        */
-       cp = hfs_chashget(dev, cnid, wantrsrc, &vp, &rvp);
-       if (cp != NULL) {
-               /* hide open files that have been deleted */
-               if ((hfsmp->hfs_private_metadata_dir != 0)
-               &&  (cp->c_parentcnid == hfsmp->hfs_private_metadata_dir)
-               &&  (cp->c_nlink == 0)) {
-                       retval = ENOENT;
-                       goto exit;
-               }
-
-               /* Hide private journal files */
-               if (hfsmp->jnl &&
-                       (cp->c_parentcnid == kRootDirID) &&
-                       ((cp->c_cnid == hfsmp->hfs_jnlfileid) ||
-                       (cp->c_cnid == hfsmp->hfs_jnlinfoblkid))) {
-                   retval = ENOENT;
-                       goto exit;
-               }
-        
-               if (wantrsrc && rvp != NULL) {
-                       vp = rvp;
-                       rvp = NULL;
-                       goto done;
-               }
-               if (!wantrsrc && vp != NULL) {
-                       /* Hardlinks need an updated catalog descriptor */
-                       if (descp && cp->c_flag & C_HARDLINK) {
-                               replace_desc(cp, descp);
-                       }
-                       /* We have a vnode so we're done. */
-                       goto done;
-               }
-       }
-
-       /*
-        * There was no active vnode so get a new one.
-        * Use the existing cnode (if any).
-        */
-       if (descp != NULL) {
-               /*
-                * hfs_lookup case, use descp, attrp and forkp
-                */
-               retval = hfs_getnewvnode(hfsmp, cp, descp, wantrsrc, attrp,
-                               forkp, &new_vp);
-       } else {
-               struct cat_desc cndesc = {0};
-               struct cat_attr cnattr = {0};
-               struct cat_fork cnfork = {0};
-
-               /*
-                * hfs_vget case, need to lookup entry (by file id)
-                */
-               if (cnid == kRootParID) {
-                       static char hfs_rootname[] = "/";
-
-                       cndesc.cd_nameptr = &hfs_rootname[0];
-                       cndesc.cd_namelen = 1;
-                       cndesc.cd_parentcnid = kRootParID;
-                       cndesc.cd_cnid = kRootParID;
-                       cndesc.cd_flags = CD_ISDIR;
-       
-                       cnattr.ca_fileid = kRootParID;
-                       cnattr.ca_nlink = 2;
-                       cnattr.ca_mode = (S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO);
-               } else {
-                       /* Lock catalog b-tree */
-                       retval = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_SHARED, p);
-                       if (retval)
-                               goto exit;
-       
-                       retval = cat_idlookup(hfsmp, cnid, &cndesc, &cnattr, &cnfork);
-       
-                       /* Unlock catalog b-tree */
-                       (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
-                       if (retval)
-                               goto exit;
-       
-                       /* Hide open files that have been deleted */
-                       if ((hfsmp->hfs_private_metadata_dir != 0) &&
-                               (cndesc.cd_parentcnid == hfsmp->hfs_private_metadata_dir)) {
-                               cat_releasedesc(&cndesc);
-                               retval = ENOENT;
-                               goto exit;
-                       }
-               }
-               
-               retval = hfs_getnewvnode(hfsmp, cp, &cndesc, 0, &cnattr, &cnfork, &new_vp);
-
-               /* Hardlinks may need an updated catalog descriptor */
-               if (retval == 0
-               &&  new_vp
-               &&  (VTOC(new_vp)->c_flag & C_HARDLINK)
-               &&  cndesc.cd_nameptr
-               &&  cndesc.cd_namelen > 0) {
-                       replace_desc(VTOC(new_vp), &cndesc);
-               }
-               cat_releasedesc(&cndesc);
-       }
-exit:
-       /* Release reference taken on opposite vnode (if any). */
-       if (vp)
-               vput(vp);
-       else if (rvp)
-               vput(rvp);
-
-       if (retval) {
-               *vpp = NULL;
-               return (retval);
-       }
-       vp = new_vp;
-done:
-       /* The cnode's vnode should be in vp. */
-       if (vp == NULL)
-               panic("hfs_getcnode: missing vp!");
-
-       UBCINFOCHECK("hfs_getcnode", vp);
-       *vpp = vp;
-       return (0);
-}
-
+extern int (**hfs_vnodeop_p) (void *);
+extern int (**hfs_std_vnodeop_p) (void *);
+extern int (**hfs_specop_p)  (void *);
+#if FIFO
+extern int (**hfs_fifoop_p)  (void *);
+#endif

 
 /*
  * hfs_getnewvnode - get new default vnode
  *
 
 /*
  * hfs_getnewvnode - get new default vnode
  *

- * the vnode is returned locked
+ * The vnode is returned with an iocount and the cnode locked

  */
  */

-extern int (**hfs_vnodeop_p) (void *);
-extern int (**hfs_specop_p)  (void *);
-extern int (**hfs_fifoop_p)  (void *);
-

 __private_extern__
 int
 __private_extern__
 int

-hfs_getnewvnode(struct hfsmount *hfsmp, struct cnode *cp,
-       struct cat_desc *descp, int wantrsrc,
-       struct cat_attr *attrp, struct cat_fork *forkp,
+hfs_getnewvnode(
+       struct hfsmount *hfsmp,
+       struct vnode *dvp,
+       struct componentname *cnp,
+       struct cat_desc *descp,
+       int flags,
+       struct cat_attr *attrp,
+       struct cat_fork *forkp,

        struct vnode **vpp)
 {
        struct mount *mp = HFSTOVFS(hfsmp);
        struct vnode *vp = NULL;
        struct vnode **vpp)
 {
        struct mount *mp = HFSTOVFS(hfsmp);
        struct vnode *vp = NULL;

-       struct vnode *rvp = NULL;
-       struct vnode *new_vp = NULL;
-       struct cnode *cp2 = NULL;
+       struct vnode **cvpp;
+       struct vnode *tvp = NULLVP;
+       struct cnode *cp = NULL;

        struct filefork *fp = NULL;
        struct filefork *fp = NULL;

-       int allocated = 0;
-       int i;
+       int hfs_standard = 0;

        int retval;
        int retval;

-       dev_t dev;
-       struct proc *p = current_proc();
+       int issystemfile;
+       int wantrsrc;
+       struct vnode_fsparam vfsp;
+       enum vtype vtype;
+#if QUOTA
+       int i;
+#endif /* QUOTA */
+
+       hfs_standard = (hfsmp->hfs_flags & HFS_STANDARD);

 
 

-       /* Bail when unmount is in progress */
-       if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
+       if (attrp->ca_fileid == 0) {

                *vpp = NULL;
                *vpp = NULL;

-               return (EPERM);
+               return (ENOENT);

        }
 
 #if !FIFO
        if (IFTOVT(attrp->ca_mode) == VFIFO) {
                *vpp = NULL;
        }
 
 #if !FIFO
        if (IFTOVT(attrp->ca_mode) == VFIFO) {
                *vpp = NULL;

-               return (EOPNOTSUPP);
+               return (ENOTSUP);

        }
        }

-#endif
-       dev = hfsmp->hfs_raw_dev;
+#endif /* !FIFO */
+       vtype = IFTOVT(attrp->ca_mode);
+       issystemfile = (descp->cd_flags & CD_ISMETA) && (vtype == VREG);
+       wantrsrc = flags & GNV_WANTRSRC;
+
+#ifdef HFS_CHECK_LOCK_ORDER
+       /*
+        * The only case were its permissible to hold the parent cnode
+        * lock is during a create operation (hfs_makenode) or when
+        * we don't need the cnode lock (GNV_SKIPLOCK).
+        */
+       if ((dvp != NULL) &&
+           (flags & (GNV_CREATE | GNV_SKIPLOCK)) == 0 &&
+           VTOC(dvp)->c_lockowner == current_thread()) {
+               panic("hfs_getnewvnode: unexpected hold of parent cnode %p", VTOC(dvp));
+       }
+#endif /* HFS_CHECK_LOCK_ORDER */
+
+       /*
+        * Get a cnode (new or existing)
+        */
+       cp = hfs_chash_getcnode(hfsmp, attrp->ca_fileid, vpp, wantrsrc, (flags & GNV_SKIPLOCK));

 
 

-       /* If no cnode was passed in then create one */
+       /*
+        * If the id is no longer valid for lookups we'll get back a NULL cp.
+        */

        if (cp == NULL) {
        if (cp == NULL) {

-               MALLOC_ZONE(cp2, struct cnode *, sizeof(struct cnode),
-                       M_HFSNODE, M_WAITOK);
-               bzero(cp2, sizeof(struct cnode));
-               allocated = 1;
-               SET(cp2->c_flag, C_ALLOC);
-               cp2->c_cnid = descp->cd_cnid;
-               cp2->c_fileid = attrp->ca_fileid;
-               cp2->c_dev = dev;
-               lockinit(&cp2->c_lock, PINOD, "cnode", 0, 0);
-               (void) lockmgr(&cp2->c_lock, LK_EXCLUSIVE, (struct slock *)0, p);
-               /*
-                * There were several blocking points since we first
-                * checked the hash. Now that we're through blocking,
-                * check the hash again in case we're racing for the
-                * same cnode.
-                */
-               cp = hfs_chashget(dev, attrp->ca_fileid, wantrsrc, &vp, &rvp);
-               if (cp != NULL) {
-                       /* We lost the race - use the winner's cnode */
-                       FREE_ZONE(cp2, sizeof(struct cnode), M_HFSNODE);
-                       allocated = 0;
-                       if (wantrsrc && rvp != NULL) {
-                               *vpp = rvp;
-                               return (0);
-                       }
-                       if (!wantrsrc && vp != NULL) {
-                               *vpp = vp;
-                               return (0);
-                       }
-               } else /* allocated */ {
-                       cp = cp2;
-                       hfs_chashinsert(cp);
-               }
+               return (ENOENT);

        }
 
        }
 

-       /* Allocate a new vnode. If unsuccesful, leave after freeing memory */
-       if ((retval = getnewvnode(VT_HFS, mp, hfs_vnodeop_p, &new_vp))) {
-               if (allocated) {
-                       hfs_chashremove(cp);
-                       if (ISSET(cp->c_flag, C_WALLOC)) {
-                               CLR(cp->c_flag, C_WALLOC);
-                               wakeup(cp);
-                       }
-                       FREE_ZONE(cp2, sizeof(struct cnode), M_HFSNODE);
-                       allocated = 0;
-               } else if (rvp) {
-                       vput(rvp);
-               } else if (vp) {
-                       vput(vp);
+       /* 
+        * Hardlinks may need an updated catalog descriptor.  However, if
+        * the cnode has already been marked as open-unlinked (C_DELETED), then don't
+        * replace its descriptor. 
+        */
+       if (!(hfs_checkdeleted(cp))) {
+               if ((cp->c_flag & C_HARDLINK) && descp->cd_nameptr && descp->cd_namelen > 0) {
+                       replace_desc(cp, descp);

                }
                }

-               *vpp = NULL;
-               return (retval);

        }
        }

-       if (allocated) {
-               bcopy(attrp, &cp->c_attr, sizeof(struct cat_attr));
-               bcopy(descp, &cp->c_desc, sizeof(struct cat_desc));
-       }
-       new_vp->v_data = cp;
-       if (wantrsrc && S_ISREG(cp->c_mode))
-               cp->c_rsrc_vp = new_vp;
-       else
-               cp->c_vp = new_vp;
-
-       /* Release reference taken on opposite vnode (if any). */
-       if (rvp)
-               vput(rvp);
-       if (vp)
-               vput(vp);
-
-       vp = new_vp;
-       vp->v_ubcinfo = UBC_NOINFO;
+       /* Check if we found a matching vnode */
+       if (*vpp != NULL)
+               return (0);

 
        /*
 
        /*

-        * If this is a new cnode then initialize it using descp and attrp...
+        * If this is a new cnode then initialize it.

         */
         */

-       if (allocated) {
+       if (ISSET(cp->c_hflag, H_ALLOC)) {
+               lck_rw_init(&cp->c_truncatelock, hfs_rwlock_group, hfs_lock_attr);
+#if HFS_COMPRESSION
+               cp->c_decmp = NULL;
+#endif
+
+               /* Make sure its still valid (ie exists on disk). */
+               if (!(flags & GNV_CREATE) &&
+                   !hfs_valid_cnode(hfsmp, dvp, (wantrsrc ? NULL : cnp), cp->c_fileid)) {
+                       hfs_chash_abort(hfsmp, cp);
+                       hfs_reclaim_cnode(cp);
+                       *vpp = NULL;
+                       return (ENOENT);
+               }
+               bcopy(attrp, &cp->c_attr, sizeof(struct cat_attr));
+               bcopy(descp, &cp->c_desc, sizeof(struct cat_desc));
+

                /* The name was inherited so clear descriptor state... */
                descp->cd_namelen = 0;
                descp->cd_nameptr = NULL;
                descp->cd_flags &= ~CD_HASBUF;
 
                /* Tag hardlinks */
                /* The name was inherited so clear descriptor state... */
                descp->cd_namelen = 0;
                descp->cd_nameptr = NULL;
                descp->cd_flags &= ~CD_HASBUF;
 
                /* Tag hardlinks */

-               if (IFTOVT(cp->c_mode) == VREG &&
-                   (descp->cd_cnid != attrp->ca_fileid)) {
+               if ((vtype == VREG || vtype == VDIR) &&
+                   ((descp->cd_cnid != attrp->ca_fileid) ||
+                    (attrp->ca_recflags & kHFSHasLinkChainMask))) {

                        cp->c_flag |= C_HARDLINK;
                }
                        cp->c_flag |= C_HARDLINK;
                }

-
-               /* Take one dev reference for each non-directory cnode */
-               if (IFTOVT(cp->c_mode) != VDIR) {
-                       cp->c_devvp = hfsmp->hfs_devvp;
-                       VREF(cp->c_devvp);
+               /*
+                * Fix-up dir link counts.
+                *
+                * Earlier versions of Leopard used ca_linkcount for posix
+                * nlink support (effectively the sub-directory count + 2).
+                * That is now accomplished using the ca_dircount field with
+                * the corresponding kHFSHasFolderCountMask flag.
+                *
+                * For directories the ca_linkcount is the true link count,
+                * tracking the number of actual hardlinks to a directory.
+                *
+                * We only do this if the mount has HFS_FOLDERCOUNT set;
+                * at the moment, we only set that for HFSX volumes.
+                */
+               if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) && 
+                   (vtype == VDIR) &&
+                   !(attrp->ca_recflags & kHFSHasFolderCountMask) &&
+                   (cp->c_attr.ca_linkcount > 1)) {
+                       if (cp->c_attr.ca_entries == 0)
+                               cp->c_attr.ca_dircount = 0;
+                       else
+                               cp->c_attr.ca_dircount = cp->c_attr.ca_linkcount - 2;
+
+                       cp->c_attr.ca_linkcount = 1;
+                       cp->c_attr.ca_recflags |= kHFSHasFolderCountMask;
+                       if ( !(hfsmp->hfs_flags & HFS_READ_ONLY) )
+                               cp->c_flag |= C_MODIFIED;

                }
 #if QUOTA
                }
 #if QUOTA

-               for (i = 0; i < MAXQUOTAS; i++)
-                       cp->c_dquot[i] = NODQUOT;
+               if (hfsmp->hfs_flags & HFS_QUOTAS) {
+                       for (i = 0; i < MAXQUOTAS; i++)
+                               cp->c_dquot[i] = NODQUOT;
+               }

 #endif /* QUOTA */
        }
 
 #endif /* QUOTA */
        }
 

-       if (IFTOVT(cp->c_mode) != VDIR) {
+       if (vtype == VDIR) {
+               if (cp->c_vp != NULL)
+                       panic("hfs_getnewvnode: orphaned vnode (data)");
+               cvpp = &cp->c_vp;
+       } else {

                if (forkp && attrp->ca_blocks < forkp->cf_blocks)
                        panic("hfs_getnewvnode: bad ca_blocks (too small)");
                /*
                if (forkp && attrp->ca_blocks < forkp->cf_blocks)
                        panic("hfs_getnewvnode: bad ca_blocks (too small)");
                /*


@@ -601,86 +709,683 @@ hfs_getnewvnode(struct hfsmount *hfsmp, struct cnode *cp,
                 */
                MALLOC_ZONE(fp, struct filefork *, sizeof(struct filefork),
                        M_HFSFORK, M_WAITOK);
                 */
                MALLOC_ZONE(fp, struct filefork *, sizeof(struct filefork),
                        M_HFSFORK, M_WAITOK);

-               bzero(fp, sizeof(struct filefork));

                fp->ff_cp = cp;
                if (forkp)
                fp->ff_cp = cp;
                if (forkp)

-                       bcopy(forkp, &fp->ff_data, sizeof(HFSPlusForkData));
-               if (fp->ff_clumpsize == 0)
-                       fp->ff_clumpsize = HFSTOVCB(hfsmp)->vcbClpSiz;
+                       bcopy(forkp, &fp->ff_data, sizeof(struct cat_fork));
+               else
+                       bzero(&fp->ff_data, sizeof(struct cat_fork));

                rl_init(&fp->ff_invalidranges);
                rl_init(&fp->ff_invalidranges);

+               fp->ff_sysfileinfo = 0;
+

                if (wantrsrc) {
                        if (cp->c_rsrcfork != NULL)
                if (wantrsrc) {
                        if (cp->c_rsrcfork != NULL)

-                               panic("stale rsrc fork");
+                               panic("hfs_getnewvnode: orphaned rsrc fork");
+                       if (cp->c_rsrc_vp != NULL)
+                               panic("hfs_getnewvnode: orphaned vnode (rsrc)");

                        cp->c_rsrcfork = fp;
                        cp->c_rsrcfork = fp;

+                       cvpp = &cp->c_rsrc_vp;
+                       if ( (tvp = cp->c_vp) != NULLVP )
+                               cp->c_flag |= C_NEED_DVNODE_PUT;

                } else {
                        if (cp->c_datafork != NULL)
                } else {
                        if (cp->c_datafork != NULL)

-                               panic("stale data fork");
+                               panic("hfs_getnewvnode: orphaned data fork");
+                       if (cp->c_vp != NULL)
+                               panic("hfs_getnewvnode: orphaned vnode (data)");

                        cp->c_datafork = fp;
                        cp->c_datafork = fp;

+                       cvpp = &cp->c_vp;
+                       if ( (tvp = cp->c_rsrc_vp) != NULLVP)
+                               cp->c_flag |= C_NEED_RVNODE_PUT;

                }
        }
                }
        }

+       if (tvp != NULLVP) {
+               /*
+                * grab an iocount on the vnode we weren't
+                * interested in (i.e. we want the resource fork
+                * but the cnode already has the data fork)
+                * to prevent it from being
+                * recycled by us when we call vnode_create
+                * which will result in a deadlock when we
+                * try to take the cnode lock in hfs_vnop_fsync or
+                * hfs_vnop_reclaim... vnode_get can be called here
+                * because we already hold the cnode lock which will
+                * prevent the vnode from changing identity until
+                * we drop it.. vnode_get will not block waiting for
+                * a change of state... however, it will return an
+                * error if the current iocount == 0 and we've already
+                * started to terminate the vnode... we don't need/want to
+                * grab an iocount in the case since we can't cause
+                * the fileystem to be re-entered on this thread for this vp
+                *
+                * the matching vnode_put will happen in hfs_unlock
+                * after we've dropped the cnode lock
+                */
+               if ( vnode_get(tvp) != 0)
+                       cp->c_flag &= ~(C_NEED_RVNODE_PUT | C_NEED_DVNODE_PUT);
+       }
+       vfsp.vnfs_mp = mp;
+       vfsp.vnfs_vtype = vtype;
+       vfsp.vnfs_str = "hfs";
+       if ((cp->c_flag & C_HARDLINK) && (vtype == VDIR)) {
+               vfsp.vnfs_dvp = NULL;  /* no parent for me! */
+               vfsp.vnfs_cnp = NULL;  /* no name for me! */
+       } else {
+               vfsp.vnfs_dvp = dvp;
+               vfsp.vnfs_cnp = cnp;
+       }
+       vfsp.vnfs_fsnode = cp;

 
        /*
 
        /*

-        * Finish vnode initialization.
-        * Setting the v_type 'stamps' the vnode as 'complete',
-        * so should be done almost last. 
-        * 
-        * At this point the vnode should be locked and fully
-        * allocated. And ready to be used or accessed. (though
-        * having it locked prevents most of this, it can still
-        * be accessed through lists and hashes).
+        * Special Case HFS Standard VNOPs from HFS+, since
+        * HFS standard is readonly/deprecated as of 10.6 

         */
         */

-       vp->v_type = IFTOVT(cp->c_mode);
+
+#if FIFO
+       if (vtype == VFIFO ) 
+               vfsp.vnfs_vops = hfs_fifoop_p;
+       else
+#endif
+       if (vtype == VBLK || vtype == VCHR)
+               vfsp.vnfs_vops = hfs_specop_p;
+       else if (hfs_standard)
+               vfsp.vnfs_vops = hfs_std_vnodeop_p;
+       else 
+               vfsp.vnfs_vops = hfs_vnodeop_p;
+
+       if (vtype == VBLK || vtype == VCHR)
+               vfsp.vnfs_rdev = attrp->ca_rdev;
+       else
+               vfsp.vnfs_rdev = 0;
+
+       if (forkp) 
+               vfsp.vnfs_filesize = forkp->cf_size;
+       else
+               vfsp.vnfs_filesize = 0;
+
+       vfsp.vnfs_flags = VNFS_ADDFSREF;
+       if (dvp == NULLVP || cnp == NULL || !(cnp->cn_flags & MAKEENTRY))
+               vfsp.vnfs_flags |= VNFS_NOCACHE;

 
        /* Tag system files */
 
        /* Tag system files */

-       if ((descp->cd_cnid < kHFSFirstUserCatalogNodeID) && (vp->v_type == VREG))
-               vp->v_flag |= VSYSTEM;
+       vfsp.vnfs_marksystem = issystemfile;
+

        /* Tag root directory */
        /* Tag root directory */

-       if (cp->c_cnid == kRootDirID)
-                vp->v_flag |= VROOT;
+       if (descp->cd_cnid == kHFSRootFolderID)
+               vfsp.vnfs_markroot = 1;
+       else    
+               vfsp.vnfs_markroot = 0;
+
+       if ((retval = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, cvpp))) {
+               if (fp) {
+                       if (fp == cp->c_datafork)
+                               cp->c_datafork = NULL;
+                       else
+                               cp->c_rsrcfork = NULL;
+
+                       FREE_ZONE(fp, sizeof(struct filefork), M_HFSFORK);
+               }
+               /*
+                * If this is a newly created cnode or a vnode reclaim
+                * occurred during the attachment, then cleanup the cnode.
+                */
+               if ((cp->c_vp == NULL) && (cp->c_rsrc_vp == NULL)) {
+                       hfs_chash_abort(hfsmp, cp);
+                       hfs_reclaim_cnode(cp);
+               } 
+               else {
+                       hfs_chashwakeup(hfsmp, cp, H_ALLOC | H_ATTACH);
+                       if ((flags & GNV_SKIPLOCK) == 0){
+                               hfs_unlock(cp);
+                       }
+               }
+               *vpp = NULL;
+               return (retval);
+       }
+       vp = *cvpp;
+       vnode_settag(vp, VT_HFS);
+       if (cp->c_flag & C_HARDLINK) {
+               vnode_setmultipath(vp);
+       }
+       /*
+        * Tag resource fork vnodes as needing an VNOP_INACTIVE
+        * so that any deferred removes (open unlinked files)
+        * have the chance to process the resource fork.
+        */
+       if (VNODE_IS_RSRC(vp)) {
+               int err;
+               KERNEL_DEBUG_CONSTANT((FSDBG_CODE(DBG_FSRW, 37)), cp->c_vp, cp->c_rsrc_vp, 0, 0, 0);
+
+               /* Force VL_NEEDINACTIVE on this vnode */
+               err = vnode_ref(vp);
+               if (err == 0) {
+                       vnode_rele(vp);
+               }
+       }
+       hfs_chashwakeup(hfsmp, cp, H_ALLOC | H_ATTACH);
+
+       /*
+        * Stop tracking an active hot file.
+        */
+       if (!(flags & GNV_CREATE) && (vtype != VDIR) && !issystemfile) {
+               (void) hfs_removehotfile(vp);
+       }
+
+       *vpp = vp;
+       return (0);
+}
+
+
+static void
+hfs_reclaim_cnode(struct cnode *cp)
+{
+#if QUOTA
+       int i;
+
+       for (i = 0; i < MAXQUOTAS; i++) {
+               if (cp->c_dquot[i] != NODQUOT) {
+                       dqreclaim(cp->c_dquot[i]);
+                       cp->c_dquot[i] = NODQUOT;
+               }
+       }
+#endif /* QUOTA */
+
+       /* 
+        * If the descriptor has a name then release it
+        */
+       if ((cp->c_desc.cd_flags & CD_HASBUF) && (cp->c_desc.cd_nameptr != 0)) {
+               const char *nameptr;
+
+               nameptr = (const char *) cp->c_desc.cd_nameptr;
+               cp->c_desc.cd_nameptr = 0;
+               cp->c_desc.cd_flags &= ~CD_HASBUF;
+               cp->c_desc.cd_namelen = 0;
+               vfs_removename(nameptr);
+       }
+
+       lck_rw_destroy(&cp->c_rwlock, hfs_rwlock_group);
+       lck_rw_destroy(&cp->c_truncatelock, hfs_rwlock_group);
+#if HFS_COMPRESSION
+       if (cp->c_decmp) {
+               decmpfs_cnode_destroy(cp->c_decmp);
+               FREE_ZONE(cp->c_decmp, sizeof(*(cp->c_decmp)), M_DECMPFS_CNODE);
+       }
+#endif
+       bzero(cp, sizeof(struct cnode));
+       FREE_ZONE(cp, sizeof(struct cnode), M_HFSNODE);
+}
+

 
 

-       if ((vp->v_type == VREG) && !(vp->v_flag & VSYSTEM)
-           && (UBCINFOMISSING(vp) || UBCINFORECLAIMED(vp))) {
-               ubc_info_init(vp);
+__private_extern__
+int
+hfs_valid_cnode(struct hfsmount *hfsmp, struct vnode *dvp, struct componentname *cnp, cnid_t cnid)
+{
+       struct cat_attr attr;
+       struct cat_desc cndesc;
+       int stillvalid = 0;
+       int lockflags;
+
+       /* System files are always valid */
+       if (cnid < kHFSFirstUserCatalogNodeID)
+               return (1);
+
+       /* XXX optimization:  check write count in dvp */
+
+       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
+
+       if (dvp && cnp) {
+               bzero(&cndesc, sizeof(cndesc));
+               cndesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;
+               cndesc.cd_namelen = cnp->cn_namelen;
+               cndesc.cd_parentcnid = VTOC(dvp)->c_fileid;
+               cndesc.cd_hint = VTOC(dvp)->c_childhint;
+
+               if ((cat_lookup(hfsmp, &cndesc, 0, NULL, &attr, NULL, NULL) == 0) &&
+                   (cnid == attr.ca_fileid)) {
+                       stillvalid = 1;
+               }

        } else {
        } else {

-               vp->v_ubcinfo = UBC_NOINFO;
+               if (cat_idlookup(hfsmp, cnid, 0, NULL, NULL, NULL) == 0) {
+                       stillvalid = 1;
+               }

        }
        }

+       hfs_systemfile_unlock(hfsmp, lockflags);

 
 

-       if (vp->v_type == VCHR || vp->v_type == VBLK) {
-               struct vnode *nvp;
+       return (stillvalid);
+}

 
 

-               vp->v_op = hfs_specop_p;
-               if ((nvp = checkalias(vp, cp->c_rdev, mp))) {
+/*
+ * Touch cnode times based on c_touch_xxx flags
+ *
+ * cnode must be locked exclusive
+ *
+ * This will also update the volume modify time
+ */
+__private_extern__
+void
+hfs_touchtimes(struct hfsmount *hfsmp, struct cnode* cp)
+{
+       /* don't modify times if volume is read-only */
+       if (hfsmp->hfs_flags & HFS_READ_ONLY) {
+               cp->c_touch_acctime = FALSE;
+               cp->c_touch_chgtime = FALSE;
+               cp->c_touch_modtime = FALSE;
+       }
+       else if (hfsmp->hfs_flags & HFS_STANDARD) {
+       /* HFS Standard doesn't support access times */
+               cp->c_touch_acctime = FALSE;
+       }
+
+       /*
+        * Skip access time updates if:
+        *      . MNT_NOATIME is set
+        *      . a file system freeze is in progress
+        *      . a file system resize is in progress
+        *      . the vnode associated with this cnode is marked for rapid aging
+        */
+       if (cp->c_touch_acctime) {
+               if ((vfs_flags(hfsmp->hfs_mp) & MNT_NOATIME) ||
+                   (hfsmp->hfs_freezing_proc != NULL) ||
+                   (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) ||
+                   (cp->c_vp && vnode_israge(cp->c_vp)))
+                       cp->c_touch_acctime = FALSE;
+       }
+       if (cp->c_touch_acctime || cp->c_touch_chgtime || cp->c_touch_modtime) {
+               struct timeval tv;
+               int touchvol = 0;
+
+               microtime(&tv);
+                   
+               if (cp->c_touch_acctime) {
+                       cp->c_atime = tv.tv_sec;

                        /*
                        /*

-                        * Discard unneeded vnode, but save its cnode.
-                        * Note that the lock is carried over in the
-                        * cnode to the replacement vnode.
+                        * When the access time is the only thing changing
+                        * then make sure its sufficiently newer before
+                        * committing it to disk.

                         */
                         */

-                       nvp->v_data = vp->v_data;
-                       vp->v_data = NULL;
-                       vp->v_op = spec_vnodeop_p;
-                       vrele(vp);
-                       vgone(vp);
+                       if ((((u_int32_t)cp->c_atime - (u_int32_t)(cp)->c_attr.ca_atimeondisk) >
+                             ATIME_ONDISK_ACCURACY)) {
+                               cp->c_flag |= C_MODIFIED;
+                       }
+                       cp->c_touch_acctime = FALSE;
+               }
+               if (cp->c_touch_modtime) {
+                       cp->c_mtime = tv.tv_sec;
+                       cp->c_touch_modtime = FALSE;
+                       cp->c_flag |= C_MODIFIED;
+                       touchvol = 1;
+#if 1

                        /*
                        /*

-                        * Reinitialize aliased cnode.
-                        * Assume its not a resource fork.
+                        * HFS dates that WE set must be adjusted for DST

                         */
                         */

-                       cp->c_vp = nvp;                         
-                       vp = nvp;
-               }
-       } else if (vp->v_type == VFIFO) {
-#if FIFO
-               vp->v_op = hfs_fifoop_p;
+                       if ((hfsmp->hfs_flags & HFS_STANDARD) && gTimeZone.tz_dsttime) {
+                               cp->c_mtime += 3600;
+                       }

 #endif
 #endif

+               }
+               if (cp->c_touch_chgtime) {
+                       cp->c_ctime = tv.tv_sec;
+                       cp->c_touch_chgtime = FALSE;
+                       cp->c_flag |= C_MODIFIED;
+                       touchvol = 1;
+               }
+
+               /* Touch the volume modtime if needed */
+               if (touchvol) {
+                       MarkVCBDirty(hfsmp);
+                       HFSTOVCB(hfsmp)->vcbLsMod = tv.tv_sec;
+               }

        }
        }

+}

 
 

-       /* Vnode is now initialized - see if anyone was waiting for it. */
-       CLR(cp->c_flag, C_ALLOC);
-       if (ISSET(cp->c_flag, C_WALLOC)) {
-               CLR(cp->c_flag, C_WALLOC);
-               wakeup((caddr_t)cp);
+/*
+ * Lock a cnode.
+ */
+__private_extern__
+int
+hfs_lock(struct cnode *cp, enum hfslocktype locktype)
+{
+       void * thread = current_thread();
+
+       if (cp->c_lockowner == thread) {
+               /*
+                * Only the extents and bitmap file's support lock recursion.
+                */
+               if ((cp->c_fileid == kHFSExtentsFileID) ||
+                   (cp->c_fileid == kHFSAllocationFileID)) {
+                       cp->c_syslockcount++;
+               } else {
+                       panic("hfs_lock: locking against myself!");
+               }
+       } else if (locktype == HFS_SHARED_LOCK) {
+               lck_rw_lock_shared(&cp->c_rwlock);
+               cp->c_lockowner = HFS_SHARED_OWNER;
+
+       } else /* HFS_EXCLUSIVE_LOCK */ {
+               lck_rw_lock_exclusive(&cp->c_rwlock);
+               cp->c_lockowner = thread;
+
+               /*
+                * Only the extents and bitmap file's support lock recursion.
+                */
+               if ((cp->c_fileid == kHFSExtentsFileID) ||
+                   (cp->c_fileid == kHFSAllocationFileID)) {
+                       cp->c_syslockcount = 1;
+               }

        }
 
        }
 

-       *vpp = vp;
+#ifdef HFS_CHECK_LOCK_ORDER
+       /*
+        * Regular cnodes (non-system files) cannot be locked
+        * while holding the journal lock or a system file lock.
+        */
+       if (!(cp->c_desc.cd_flags & CD_ISMETA) &&
+            ((cp->c_fileid > kHFSFirstUserCatalogNodeID) || (cp->c_fileid == kHFSRootFolderID))) {
+               vnode_t vp = NULLVP;
+
+               /* Find corresponding vnode. */
+               if (cp->c_vp != NULLVP && VTOC(cp->c_vp) == cp) {
+                       vp = cp->c_vp;
+               } else if (cp->c_rsrc_vp != NULLVP && VTOC(cp->c_rsrc_vp) == cp) {
+                       vp = cp->c_rsrc_vp;
+               }
+               if (vp != NULLVP) {
+                       struct hfsmount *hfsmp = VTOHFS(vp);
+
+                       if (hfsmp->jnl && (journal_owner(hfsmp->jnl) == thread)) {
+                               /* This will eventually be a panic here. */
+                               printf("hfs_lock: bad lock order (cnode after journal)\n");
+                       }
+                       if (hfsmp->hfs_catalog_cp && hfsmp->hfs_catalog_cp->c_lockowner == thread) {
+                               panic("hfs_lock: bad lock order (cnode after catalog)");
+                       }
+                       if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == thread) {
+                               panic("hfs_lock: bad lock order (cnode after attribute)");
+                       }
+                       if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == thread) {
+                               panic("hfs_lock: bad lock order (cnode after extents)");
+                       }
+               }
+       }
+#endif /* HFS_CHECK_LOCK_ORDER */
+       
+       /*
+        * Skip cnodes that no longer exist (were deleted).
+        */
+       if ((locktype != HFS_FORCE_LOCK) &&
+           ((cp->c_desc.cd_flags & CD_ISMETA) == 0) &&
+           (cp->c_flag & C_NOEXISTS)) {
+               hfs_unlock(cp);
+               return (ENOENT);
+       }
+       return (0);
+}
+
+/*
+ * Lock a pair of cnodes.
+ */
+__private_extern__
+int
+hfs_lockpair(struct cnode *cp1, struct cnode *cp2, enum hfslocktype locktype)
+{
+       struct cnode *first, *last;
+       int error;
+
+       /*
+        * If cnodes match then just lock one.
+        */
+       if (cp1 == cp2) {
+               return hfs_lock(cp1, locktype);
+       }
+
+       /*
+        * Lock in cnode address order.
+        */
+       if (cp1 < cp2) {
+               first = cp1;
+               last = cp2;
+       } else {
+               first = cp2;
+               last = cp1;
+       }
+
+       if ( (error = hfs_lock(first, locktype))) {
+               return (error);
+       }
+       if ( (error = hfs_lock(last, locktype))) {
+               hfs_unlock(first);
+               return (error);
+       }
+       return (0);
+}
+
+/*
+ * Check ordering of two cnodes. Return true if they are are in-order.
+ */
+static int
+hfs_isordered(struct cnode *cp1, struct cnode *cp2)
+{
+       if (cp1 == cp2)
+               return (0);
+       if (cp1 == NULL || cp2 == (struct cnode *)0xffffffff)
+               return (1);
+       if (cp2 == NULL || cp1 == (struct cnode *)0xffffffff)
+               return (0);
+       /*
+        * Locking order is cnode address order.
+        */
+       return (cp1 < cp2);
+}
+
+/*
+ * Acquire 4 cnode locks.
+ *   - locked in cnode address order (lesser address first).
+ *   - all or none of the locks are taken
+ *   - only one lock taken per cnode (dup cnodes are skipped)
+ *   - some of the cnode pointers may be null
+ */
+__private_extern__
+int
+hfs_lockfour(struct cnode *cp1, struct cnode *cp2, struct cnode *cp3,
+             struct cnode *cp4, enum hfslocktype locktype, struct cnode **error_cnode)
+{
+       struct cnode * a[3];
+       struct cnode * b[3];
+       struct cnode * list[4];
+       struct cnode * tmp;
+       int i, j, k;
+       int error;
+       if (error_cnode) {
+               *error_cnode = NULL;
+       }
+
+       if (hfs_isordered(cp1, cp2)) {
+               a[0] = cp1; a[1] = cp2;
+       } else {
+               a[0] = cp2; a[1] = cp1;
+       }
+       if (hfs_isordered(cp3, cp4)) {
+               b[0] = cp3; b[1] = cp4;
+       } else {
+               b[0] = cp4; b[1] = cp3;
+       }
+       a[2] = (struct cnode *)0xffffffff;  /* sentinel value */
+       b[2] = (struct cnode *)0xffffffff;  /* sentinel value */
+
+       /*
+        * Build the lock list, skipping over duplicates
+        */
+       for (i = 0, j = 0, k = 0; (i < 2 || j < 2); ) {
+               tmp = hfs_isordered(a[i], b[j]) ? a[i++] : b[j++];
+               if (k == 0 || tmp != list[k-1])
+                       list[k++] = tmp;
+       }
+
+       /*
+        * Now we can lock using list[0 - k].
+        * Skip over NULL entries.
+        */
+       for (i = 0; i < k; ++i) {
+               if (list[i])
+                       if ((error = hfs_lock(list[i], locktype))) {
+                               /* Only stuff error_cnode if requested */
+                               if (error_cnode) {
+                                       *error_cnode = list[i];
+                               }
+                               /* Drop any locks we acquired. */
+                               while (--i >= 0) {
+                                       if (list[i])
+                                               hfs_unlock(list[i]);
+                               }
+                               return (error);
+                       }
+       }

        return (0);
 }
 
        return (0);
 }
 

+
+/*
+ * Unlock a cnode.
+ */
+__private_extern__
+void
+hfs_unlock(struct cnode *cp)
+{
+        vnode_t rvp = NULLVP;
+        vnode_t vp = NULLVP;
+        u_int32_t c_flag;
+       void *lockowner;
+
+       /*
+        * Only the extents and bitmap file's support lock recursion.
+        */
+       if ((cp->c_fileid == kHFSExtentsFileID) ||
+           (cp->c_fileid == kHFSAllocationFileID)) {
+               if (--cp->c_syslockcount > 0) {
+                       return;
+               }
+       }
+       c_flag = cp->c_flag;
+       cp->c_flag &= ~(C_NEED_DVNODE_PUT | C_NEED_RVNODE_PUT | C_NEED_DATA_SETSIZE | C_NEED_RSRC_SETSIZE);
+
+       if (c_flag & (C_NEED_DVNODE_PUT | C_NEED_DATA_SETSIZE)) {
+               vp = cp->c_vp;
+       }
+       if (c_flag & (C_NEED_RVNODE_PUT | C_NEED_RSRC_SETSIZE)) {
+               rvp = cp->c_rsrc_vp;
+       }
+
+       lockowner = cp->c_lockowner;
+       if (lockowner == current_thread()) {
+           cp->c_lockowner = NULL;
+           lck_rw_unlock_exclusive(&cp->c_rwlock);
+       } else {
+           lck_rw_unlock_shared(&cp->c_rwlock);
+       }
+
+       /* Perform any vnode post processing after cnode lock is dropped. */
+       if (vp) {
+               if (c_flag & C_NEED_DATA_SETSIZE)
+                       ubc_setsize(vp, 0);
+               if (c_flag & C_NEED_DVNODE_PUT)
+                       vnode_put(vp);
+       }
+       if (rvp) {
+               if (c_flag & C_NEED_RSRC_SETSIZE)
+                       ubc_setsize(rvp, 0);
+               if (c_flag & C_NEED_RVNODE_PUT)
+                       vnode_put(rvp);
+       }
+}
+
+/*
+ * Unlock a pair of cnodes.
+ */
+__private_extern__
+void
+hfs_unlockpair(struct cnode *cp1, struct cnode *cp2)
+{
+       hfs_unlock(cp1);
+       if (cp2 != cp1)
+               hfs_unlock(cp2);
+}
+
+/*
+ * Unlock a group of cnodes.
+ */
+__private_extern__
+void
+hfs_unlockfour(struct cnode *cp1, struct cnode *cp2, struct cnode *cp3, struct cnode *cp4)
+{
+       struct cnode * list[4];
+       int i, k = 0;
+
+       if (cp1) {
+               hfs_unlock(cp1);
+               list[k++] = cp1;
+       }
+       if (cp2) {
+               for (i = 0; i < k; ++i) {
+                       if (list[i] == cp2)
+                               goto skip1;
+               }
+               hfs_unlock(cp2);
+               list[k++] = cp2;
+       }
+skip1:
+       if (cp3) {
+               for (i = 0; i < k; ++i) {
+                       if (list[i] == cp3)
+                               goto skip2;
+               }
+               hfs_unlock(cp3);
+               list[k++] = cp3;
+       }
+skip2:
+       if (cp4) {
+               for (i = 0; i < k; ++i) {
+                       if (list[i] == cp4)
+                               return;
+               }
+               hfs_unlock(cp4);
+       }
+}
+
+
+/*
+ * Protect a cnode against a truncation.
+ *
+ * Used mainly by read/write since they don't hold the
+ * cnode lock across calls to the cluster layer.
+ *
+ * The process doing a truncation must take the lock
+ * exclusive. The read/write processes can take it
+ * non-exclusive.
+ */
+__private_extern__
+void
+hfs_lock_truncate(struct cnode *cp, int exclusive)
+{
+#ifdef HFS_CHECK_LOCK_ORDER
+       if (cp->c_lockowner == current_thread())
+               panic("hfs_lock_truncate: cnode %p locked!", cp);
+#endif /* HFS_CHECK_LOCK_ORDER */
+
+       if (exclusive)
+               lck_rw_lock_exclusive(&cp->c_truncatelock);
+       else
+               lck_rw_lock_shared(&cp->c_truncatelock);
+}
+
+__private_extern__
+void
+hfs_unlock_truncate(struct cnode *cp, int exclusive)
+{
+    if (exclusive) {
+       lck_rw_unlock_exclusive(&cp->c_truncatelock);
+    } else {
+       lck_rw_unlock_shared(&cp->c_truncatelock);
+    }
+}
+
+
+
+