xnu-1456.1.26.tar.gz

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

diff --git a/bsd/hfs/hfs_vfsutils.c b/bsd/hfs/hfs_vfsutils.c
index 4eed699c9223f227dbd622a98f4b71a0cdc0c1c8..2485c73f6a283b7a74e4747954346c3d8b1d274a 100644 (file)
--- a/bsd/hfs/hfs_vfsutils.c
+++ b/bsd/hfs/hfs_vfsutils.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2009 Apple Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. 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.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * 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,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * 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_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*     @(#)hfs_vfsutils.c      4.0
 *
  */
 /*     @(#)hfs_vfsutils.c      4.0
 *


@@ -32,11 +38,18 @@
 #include <sys/malloc.h>
 #include <sys/stat.h>
 #include <sys/mount.h>
 #include <sys/malloc.h>
 #include <sys/stat.h>
 #include <sys/mount.h>

+#include <sys/mount_internal.h>

 #include <sys/buf.h>
 #include <sys/buf.h>

+#include <sys/buf_internal.h>

 #include <sys/ubc.h>
 #include <sys/unistd.h>
 #include <sys/utfconv.h>
 #include <sys/kauth.h>
 #include <sys/ubc.h>
 #include <sys/unistd.h>
 #include <sys/utfconv.h>
 #include <sys/kauth.h>

+#include <sys/fcntl.h>
+#include <sys/vnode_internal.h>
+#include <kern/clock.h>
+
+#include <libkern/OSAtomic.h>

 
 #include "hfs.h"
 #include "hfs_catalog.h"
 
 #include "hfs.h"
 #include "hfs_catalog.h"


@@ -44,15 +57,12 @@
 #include "hfs_mount.h"
 #include "hfs_endian.h"
 #include "hfs_cnode.h"
 #include "hfs_mount.h"
 #include "hfs_endian.h"
 #include "hfs_cnode.h"

+#include "hfs_fsctl.h"

 
 #include "hfscommon/headers/FileMgrInternal.h"
 #include "hfscommon/headers/BTreesInternal.h"
 #include "hfscommon/headers/HFSUnicodeWrappers.h"
 
 
 #include "hfscommon/headers/FileMgrInternal.h"
 #include "hfscommon/headers/BTreesInternal.h"
 #include "hfscommon/headers/HFSUnicodeWrappers.h"
 

-
-extern int count_lock_queue(void);
-
-

 static void ReleaseMetaFileVNode(struct vnode *vp);
 static int  hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args);
 
 static void ReleaseMetaFileVNode(struct vnode *vp);
 static int  hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args);
 


@@ -60,12 +70,6 @@ static void hfs_metadatazone_init(struct hfsmount *);
 static u_int32_t hfs_hotfile_freeblocks(struct hfsmount *);
 
 
 static u_int32_t hfs_hotfile_freeblocks(struct hfsmount *);
 
 

-
-u_int32_t GetLogicalBlockSize(struct vnode *vp);
-
-extern int hfs_attrkeycompare(HFSPlusAttrKey *searchKey, HFSPlusAttrKey *trialKey);
-
-

 //*******************************************************************************
 // Note: Finder information in the HFS/HFS+ metadata are considered opaque and
 //       hence are not in the right byte order on little endian machines. It is
 //*******************************************************************************
 // Note: Finder information in the HFS/HFS+ metadata are considered opaque and
 //       hence are not in the right byte order on little endian machines. It is


@@ -77,17 +81,16 @@ extern int hfs_attrkeycompare(HFSPlusAttrKey *searchKey, HFSPlusAttrKey *trialKe
 //
 //
 //*******************************************************************************
 //
 //
 //*******************************************************************************

-char hfs_catname[] = "Catalog B-tree";
-char hfs_extname[] = "Extents B-tree";
-char hfs_vbmname[] = "Volume Bitmap";
-char hfs_attrname[] = "Attribute B-tree";
+unsigned char hfs_catname[] = "Catalog B-tree";
+unsigned char hfs_extname[] = "Extents B-tree";
+unsigned char hfs_vbmname[] = "Volume Bitmap";
+unsigned char hfs_attrname[] = "Attribute B-tree";
+unsigned char hfs_startupname[] = "Startup File";

 
 

-char hfs_privdirname[] =
-       "\xE2\x90\x80\xE2\x90\x80\xE2\x90\x80\xE2\x90\x80HFS+ Private Data";

 
 __private_extern__
 OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
 
 __private_extern__
 OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,

-               struct proc *p)
+               __unused struct proc *p)

 {
        ExtendedVCB *vcb = HFSTOVCB(hfsmp);
        int error;
 {
        ExtendedVCB *vcb = HFSTOVCB(hfsmp);
        int error;


@@ -121,6 +124,7 @@ OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
        vcb->vcbVBMSt           = SWAP_BE16 (mdb->drVBMSt);
        vcb->nextAllocation     = SWAP_BE16 (mdb->drAllocPtr);
        vcb->totalBlocks        = SWAP_BE16 (mdb->drNmAlBlks);
        vcb->vcbVBMSt           = SWAP_BE16 (mdb->drVBMSt);
        vcb->nextAllocation     = SWAP_BE16 (mdb->drAllocPtr);
        vcb->totalBlocks        = SWAP_BE16 (mdb->drNmAlBlks);

+       vcb->allocLimit         = vcb->totalBlocks;

        vcb->blockSize          = SWAP_BE32 (mdb->drAlBlkSiz);
        vcb->vcbClpSiz          = SWAP_BE32 (mdb->drClpSiz);
        vcb->vcbAlBlSt          = SWAP_BE16 (mdb->drAlBlSt);
        vcb->blockSize          = SWAP_BE32 (mdb->drAlBlkSiz);
        vcb->vcbClpSiz          = SWAP_BE32 (mdb->drClpSiz);
        vcb->vcbAlBlSt          = SWAP_BE16 (mdb->drAlBlSt);


@@ -144,17 +148,17 @@ OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
        if (error || (utf8chars == 0))
                (void) mac_roman_to_utf8(mdb->drVN, NAME_MAX, &utf8chars, vcb->vcbVN);
 
        if (error || (utf8chars == 0))
                (void) mac_roman_to_utf8(mdb->drVN, NAME_MAX, &utf8chars, vcb->vcbVN);
 

-       hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_phys_block_size);
+       hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_logical_block_size);

        vcb->vcbVBMIOSize = kHFSBlockSize;
 
        vcb->vcbVBMIOSize = kHFSBlockSize;
 

-       hfsmp->hfs_alt_id_sector = HFS_ALT_SECTOR(hfsmp->hfs_phys_block_size,
-                                                 hfsmp->hfs_phys_block_count);
+       hfsmp->hfs_alt_id_sector = HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size,
+                                                 hfsmp->hfs_logical_block_count);

 
        bzero(&cndesc, sizeof(cndesc));
        cndesc.cd_parentcnid = kHFSRootParentID;
        cndesc.cd_flags |= CD_ISMETA;
        bzero(&cnattr, sizeof(cnattr));
 
        bzero(&cndesc, sizeof(cndesc));
        cndesc.cd_parentcnid = kHFSRootParentID;
        cndesc.cd_flags |= CD_ISMETA;
        bzero(&cnattr, sizeof(cnattr));

-       cnattr.ca_nlink = 1;
+       cnattr.ca_linkcount = 1;

        cnattr.ca_mode = S_IFREG;
        bzero(&fork, sizeof(fork));
 
        cnattr.ca_mode = S_IFREG;
        bzero(&fork, sizeof(fork));
 


@@ -162,7 +166,7 @@ OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
         * Set up Extents B-tree vnode
         */
        cndesc.cd_nameptr = hfs_extname;
         * Set up Extents B-tree vnode
         */
        cndesc.cd_nameptr = hfs_extname;

-       cndesc.cd_namelen = strlen(hfs_extname);
+       cndesc.cd_namelen = strlen((char *)hfs_extname);

        cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;
        fork.cf_size = SWAP_BE32(mdb->drXTFlSize);
        fork.cf_blocks = fork.cf_size / vcb->blockSize;
        cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;
        fork.cf_size = SWAP_BE32(mdb->drXTFlSize);
        fork.cf_blocks = fork.cf_size / vcb->blockSize;


@@ -185,12 +189,13 @@ OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
                hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
                goto MtVolErr;
        }
                hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
                goto MtVolErr;
        }

+       hfsmp->hfs_extents_cp = VTOC(hfsmp->hfs_extents_vp);

 
        /*
         * Set up Catalog B-tree vnode...
         */ 
        cndesc.cd_nameptr = hfs_catname;
 
        /*
         * Set up Catalog B-tree vnode...
         */ 
        cndesc.cd_nameptr = hfs_catname;

-       cndesc.cd_namelen = strlen(hfs_catname);
+       cndesc.cd_namelen = strlen((char *)hfs_catname);

        cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;
        fork.cf_size = SWAP_BE32(mdb->drCTFlSize);
        fork.cf_blocks = fork.cf_size / vcb->blockSize;
        cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;
        fork.cf_size = SWAP_BE32(mdb->drCTFlSize);
        fork.cf_blocks = fork.cf_size / vcb->blockSize;


@@ -217,12 +222,13 @@ OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
                hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
                goto MtVolErr;
        }
                hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
                goto MtVolErr;
        }

+       hfsmp->hfs_catalog_cp = VTOC(hfsmp->hfs_catalog_vp);

 
        /*
         * Set up dummy Allocation file vnode (used only for locking bitmap)
         */  
        cndesc.cd_nameptr = hfs_vbmname;
 
        /*
         * Set up dummy Allocation file vnode (used only for locking bitmap)
         */  
        cndesc.cd_nameptr = hfs_vbmname;

-       cndesc.cd_namelen = strlen(hfs_vbmname);
+       cndesc.cd_namelen = strlen((char *)hfs_vbmname);

        cndesc.cd_cnid = cnattr.ca_fileid = kHFSAllocationFileID;
        bzero(&fork, sizeof(fork));
        cnattr.ca_blocks = 0;
        cndesc.cd_cnid = cnattr.ca_fileid = kHFSAllocationFileID;
        bzero(&fork, sizeof(fork));
        cnattr.ca_blocks = 0;


@@ -234,16 +240,15 @@ OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
                hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
                goto MtVolErr;
        }
                hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
                goto MtVolErr;
        }

+       hfsmp->hfs_allocation_cp = VTOC(hfsmp->hfs_allocation_vp);

 
        /* mark the volume dirty (clear clean unmount bit) */
        vcb->vcbAtrb &= ~kHFSVolumeUnmountedMask;
 
 
        /* mark the volume dirty (clear clean unmount bit) */
        vcb->vcbAtrb &= ~kHFSVolumeUnmountedMask;
 

-       /*
-        * all done with system files so we can unlock now...
-        */
-       hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
-       hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
-       hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
+    if (error == noErr)
+      {
+               error = cat_idlookup(hfsmp, kHFSRootFolderID, 0, NULL, NULL, NULL);
+      }

 
     if ( error == noErr )
       {
 
     if ( error == noErr )
       {


@@ -252,6 +257,14 @@ OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
             MarkVCBDirty( vcb );                                                               //      mark VCB dirty so it will be written
           }
       }
             MarkVCBDirty( vcb );                                                               //      mark VCB dirty so it will be written
           }
       }

+
+       /*
+        * all done with system files so we can unlock now...
+        */
+       hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
+       hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
+       hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
+

     goto       CmdDone;
 
     //--       Release any resources allocated so far before exiting with an error:
     goto       CmdDone;
 
     //--       Release any resources allocated so far before exiting with an error:


@@ -271,31 +284,31 @@ CmdDone:
 
 __private_extern__
 OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
 
 __private_extern__
 OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,

-       off_t embeddedOffset, u_int64_t disksize, struct proc *p, void *args, kauth_cred_t cred)
+       off_t embeddedOffset, u_int64_t disksize, __unused struct proc *p, void *args, kauth_cred_t cred)

 {
        register ExtendedVCB *vcb;
        struct cat_desc cndesc;
        struct cat_attr cnattr;
        struct cat_fork cfork;
 {
        register ExtendedVCB *vcb;
        struct cat_desc cndesc;
        struct cat_attr cnattr;
        struct cat_fork cfork;

-       UInt32 blockSize;
+       u_int32_t blockSize;

        daddr64_t spare_sectors;
        struct BTreeInfoRec btinfo;
        u_int16_t  signature;
        daddr64_t spare_sectors;
        struct BTreeInfoRec btinfo;
        u_int16_t  signature;

-       u_int16_t  version;
+       u_int16_t  hfs_version;

        int  i;
        OSErr retval;
 
        signature = SWAP_BE16(vhp->signature);
        int  i;
        OSErr retval;
 
        signature = SWAP_BE16(vhp->signature);

-       version = SWAP_BE16(vhp->version);
+       hfs_version = SWAP_BE16(vhp->version);

 
        if (signature == kHFSPlusSigWord) {
 
        if (signature == kHFSPlusSigWord) {

-               if (version != kHFSPlusVersion) {
-                       printf("hfs_mount: invalid HFS+ version: %d\n", version);
+               if (hfs_version != kHFSPlusVersion) {
+                       printf("hfs_mount: invalid HFS+ version: %d\n", hfs_version);

                        return (EINVAL);
                }
        } else if (signature == kHFSXSigWord) {
                        return (EINVAL);
                }
        } else if (signature == kHFSXSigWord) {

-               if (version != kHFSXVersion) {
-                       printf("hfs_mount: invalid HFSX version: %d\n", version);
+               if (hfs_version != kHFSXVersion) {
+                       printf("hfs_mount: invalid HFSX version: %d\n", hfs_version);

                        return (EINVAL);
                }
                /* The in-memory signature is always 'H+'. */
                        return (EINVAL);
                }
                /* The in-memory signature is always 'H+'. */


@@ -319,11 +332,25 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                return (EINVAL);
 
        /* Make sure we can live with the physical block size. */
                return (EINVAL);
 
        /* Make sure we can live with the physical block size. */

-       if ((disksize & (hfsmp->hfs_phys_block_size - 1)) ||
-           (embeddedOffset & (hfsmp->hfs_phys_block_size - 1)) ||
-           (blockSize < hfsmp->hfs_phys_block_size)) {
+       if ((disksize & (hfsmp->hfs_logical_block_size - 1)) ||
+           (embeddedOffset & (hfsmp->hfs_logical_block_size - 1)) ||
+           (blockSize < hfsmp->hfs_logical_block_size)) {

                return (ENXIO);
        }
                return (ENXIO);
        }

+
+       /* If allocation block size is less than the physical 
+        * block size, we assume that the physical block size 
+        * is same as logical block size.  The physical block 
+        * size value is used to round down the offsets for 
+        * reading and writing the primary and alternate volume 
+        * headers at physical block boundary and will cause 
+        * problems if it is less than the block size.
+        */
+       if (blockSize < hfsmp->hfs_physical_block_size) {
+               hfsmp->hfs_physical_block_size = hfsmp->hfs_logical_block_size;
+               hfsmp->hfs_log_per_phys = 1;
+       }
+

        /*
         * The VolumeHeader seems OK: transfer info from it into VCB
         * Note - the VCB starts out clear (all zeros)
        /*
         * The VolumeHeader seems OK: transfer info from it into VCB
         * Note - the VCB starts out clear (all zeros)


@@ -351,6 +378,7 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
        /* Now fill in the Extended VCB info */
        vcb->nextAllocation     = SWAP_BE32(vhp->nextAllocation);
        vcb->totalBlocks        = SWAP_BE32(vhp->totalBlocks);
        /* Now fill in the Extended VCB info */
        vcb->nextAllocation     = SWAP_BE32(vhp->nextAllocation);
        vcb->totalBlocks        = SWAP_BE32(vhp->totalBlocks);

+       vcb->allocLimit         = vcb->totalBlocks;

        vcb->freeBlocks         = SWAP_BE32(vhp->freeBlocks);
        vcb->blockSize          = blockSize;
        vcb->encodingsBitmap    = SWAP_BE64(vhp->encodingsBitmap);
        vcb->freeBlocks         = SWAP_BE32(vhp->freeBlocks);
        vcb->blockSize          = blockSize;
        vcb->encodingsBitmap    = SWAP_BE64(vhp->encodingsBitmap);


@@ -366,39 +394,40 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
         * (currently set up from the wrapper MDB) using the
         * new blocksize value:
         */
         * (currently set up from the wrapper MDB) using the
         * new blocksize value:
         */

-       hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_phys_block_size);
+       hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_logical_block_size);

        vcb->vcbVBMIOSize = min(vcb->blockSize, MAXPHYSIO);
 
        /*
         * Validate and initialize the location of the alternate volume header.
         */
        vcb->vcbVBMIOSize = min(vcb->blockSize, MAXPHYSIO);
 
        /*
         * Validate and initialize the location of the alternate volume header.
         */

-       spare_sectors = hfsmp->hfs_phys_block_count -
+       spare_sectors = hfsmp->hfs_logical_block_count -

                        (((daddr64_t)vcb->totalBlocks * blockSize) /
                        (((daddr64_t)vcb->totalBlocks * blockSize) /

-                          hfsmp->hfs_phys_block_size);
+                          hfsmp->hfs_logical_block_size);

 
 

-       if (spare_sectors > (blockSize / hfsmp->hfs_phys_block_size)) {
+       if (spare_sectors > (daddr64_t)(blockSize / hfsmp->hfs_logical_block_size)) {

                hfsmp->hfs_alt_id_sector = 0;  /* partition has grown! */
        } else {
                hfsmp->hfs_alt_id_sector = 0;  /* partition has grown! */
        } else {

-               hfsmp->hfs_alt_id_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_phys_block_size) +
-                                          HFS_ALT_SECTOR(hfsmp->hfs_phys_block_size,
-                                                         hfsmp->hfs_phys_block_count);
+               hfsmp->hfs_alt_id_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) +
+                                          HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size,
+                                                         hfsmp->hfs_logical_block_count);

        }
 
        bzero(&cndesc, sizeof(cndesc));
        cndesc.cd_parentcnid = kHFSRootParentID;
        cndesc.cd_flags |= CD_ISMETA;
        bzero(&cnattr, sizeof(cnattr));
        }
 
        bzero(&cndesc, sizeof(cndesc));
        cndesc.cd_parentcnid = kHFSRootParentID;
        cndesc.cd_flags |= CD_ISMETA;
        bzero(&cnattr, sizeof(cnattr));

-       cnattr.ca_nlink = 1;
+       cnattr.ca_linkcount = 1;

        cnattr.ca_mode = S_IFREG;
 
        /*
         * Set up Extents B-tree vnode
         */
        cndesc.cd_nameptr = hfs_extname;
        cnattr.ca_mode = S_IFREG;
 
        /*
         * Set up Extents B-tree vnode
         */
        cndesc.cd_nameptr = hfs_extname;

-       cndesc.cd_namelen = strlen(hfs_extname);
+       cndesc.cd_namelen = strlen((char *)hfs_extname);

        cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;
 
        cfork.cf_size    = SWAP_BE64 (vhp->extentsFile.logicalSize);
        cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;
 
        cfork.cf_size    = SWAP_BE64 (vhp->extentsFile.logicalSize);

+       cfork.cf_new_size= 0;

        cfork.cf_clump   = SWAP_BE32 (vhp->extentsFile.clumpSize);
        cfork.cf_blocks  = SWAP_BE32 (vhp->extentsFile.totalBlocks);
        cfork.cf_vblocks = 0;
        cfork.cf_clump   = SWAP_BE32 (vhp->extentsFile.clumpSize);
        cfork.cf_blocks  = SWAP_BE32 (vhp->extentsFile.totalBlocks);
        cfork.cf_vblocks = 0;


@@ -411,20 +440,24 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
        }
        retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                 &hfsmp->hfs_extents_vp);
        }
        retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                 &hfsmp->hfs_extents_vp);

+       if (retval)
+       {
+               goto ErrorExit;
+       }
+       hfsmp->hfs_extents_cp = VTOC(hfsmp->hfs_extents_vp);
+       hfs_unlock(hfsmp->hfs_extents_cp);

 
 

-       if (retval) goto ErrorExit;

        retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_extents_vp),
                                          (KeyCompareProcPtr) CompareExtentKeysPlus));
        retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_extents_vp),
                                          (KeyCompareProcPtr) CompareExtentKeysPlus));

-       if (retval) {
-               hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
+       if (retval)
+       {

                goto ErrorExit;
        }
                goto ErrorExit;
        }

-

        /*
         * Set up Catalog B-tree vnode
         */ 
        cndesc.cd_nameptr = hfs_catname;
        /*
         * Set up Catalog B-tree vnode
         */ 
        cndesc.cd_nameptr = hfs_catname;

-       cndesc.cd_namelen = strlen(hfs_catname);
+       cndesc.cd_namelen = strlen((char *)hfs_catname);

        cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;
 
        cfork.cf_size    = SWAP_BE64 (vhp->catalogFile.logicalSize);
        cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;
 
        cfork.cf_size    = SWAP_BE64 (vhp->catalogFile.logicalSize);


@@ -441,14 +474,14 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
        retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                 &hfsmp->hfs_catalog_vp);
        if (retval) {
        retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                 &hfsmp->hfs_catalog_vp);
        if (retval) {

-               hfs_unlock(VTOC(hfsmp->hfs_extents_vp));

                goto ErrorExit;
        }
                goto ErrorExit;
        }

+       hfsmp->hfs_catalog_cp = VTOC(hfsmp->hfs_catalog_vp);
+       hfs_unlock(hfsmp->hfs_catalog_cp);
+

        retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_catalog_vp),
                                          (KeyCompareProcPtr) CompareExtendedCatalogKeys));
        if (retval) {
        retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_catalog_vp),
                                          (KeyCompareProcPtr) CompareExtendedCatalogKeys));
        if (retval) {

-               hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
-               hfs_unlock(VTOC(hfsmp->hfs_extents_vp));

                goto ErrorExit;
        }
        if ((hfsmp->hfs_flags & HFS_X) &&
                goto ErrorExit;
        }
        if ((hfsmp->hfs_flags & HFS_X) &&


@@ -465,7 +498,7 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
         * Set up Allocation file vnode
         */  
        cndesc.cd_nameptr = hfs_vbmname;
         * Set up Allocation file vnode
         */  
        cndesc.cd_nameptr = hfs_vbmname;

-       cndesc.cd_namelen = strlen(hfs_vbmname);
+       cndesc.cd_namelen = strlen((char *)hfs_vbmname);

        cndesc.cd_cnid = cnattr.ca_fileid = kHFSAllocationFileID;
 
        cfork.cf_size    = SWAP_BE64 (vhp->allocationFile.logicalSize);
        cndesc.cd_cnid = cnattr.ca_fileid = kHFSAllocationFileID;
 
        cfork.cf_size    = SWAP_BE64 (vhp->allocationFile.logicalSize);


@@ -482,17 +515,17 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
        retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                 &hfsmp->hfs_allocation_vp);
        if (retval) {
        retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                 &hfsmp->hfs_allocation_vp);
        if (retval) {

-               hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
-               hfs_unlock(VTOC(hfsmp->hfs_extents_vp));

                goto ErrorExit;
        }
                goto ErrorExit;
        }

+       hfsmp->hfs_allocation_cp = VTOC(hfsmp->hfs_allocation_vp);
+       hfs_unlock(hfsmp->hfs_allocation_cp);

 
        /*
         * Set up Attribute B-tree vnode
         */
        if (vhp->attributesFile.totalBlocks != 0) {
                cndesc.cd_nameptr = hfs_attrname;
 
        /*
         * Set up Attribute B-tree vnode
         */
        if (vhp->attributesFile.totalBlocks != 0) {
                cndesc.cd_nameptr = hfs_attrname;

-               cndesc.cd_namelen = strlen(hfs_attrname);
+               cndesc.cd_namelen = strlen((char *)hfs_attrname);

                cndesc.cd_cnid = cnattr.ca_fileid = kHFSAttributesFileID;
        
                cfork.cf_size    = SWAP_BE64 (vhp->attributesFile.logicalSize);
                cndesc.cd_cnid = cnattr.ca_fileid = kHFSAttributesFileID;
        
                cfork.cf_size    = SWAP_BE64 (vhp->attributesFile.logicalSize);


@@ -509,29 +542,48 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                         &hfsmp->hfs_attribute_vp);
                if (retval) {
                retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
                                         &hfsmp->hfs_attribute_vp);
                if (retval) {

-                       hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
-                       hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
-                       hfs_unlock(VTOC(hfsmp->hfs_extents_vp));

                        goto ErrorExit;
                }
                        goto ErrorExit;
                }

+               hfsmp->hfs_attribute_cp = VTOC(hfsmp->hfs_attribute_vp);
+               hfs_unlock(hfsmp->hfs_attribute_cp);

                retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_attribute_vp),
                                                  (KeyCompareProcPtr) hfs_attrkeycompare));
                if (retval) {
                retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_attribute_vp),
                                                  (KeyCompareProcPtr) hfs_attrkeycompare));
                if (retval) {

-                       hfs_unlock(VTOC(hfsmp->hfs_attribute_vp));
-                       hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
-                       hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
-                       hfs_unlock(VTOC(hfsmp->hfs_extents_vp));

                        goto ErrorExit;
                }
        }
 
                        goto ErrorExit;
                }
        }
 

-
+       /*
+        * Set up Startup file vnode
+        */
+       if (vhp->startupFile.totalBlocks != 0) {
+               cndesc.cd_nameptr = hfs_startupname;
+               cndesc.cd_namelen = strlen((char *)hfs_startupname);
+               cndesc.cd_cnid = cnattr.ca_fileid = kHFSStartupFileID;
+       
+               cfork.cf_size    = SWAP_BE64 (vhp->startupFile.logicalSize);
+               cfork.cf_clump   = SWAP_BE32 (vhp->startupFile.clumpSize);
+               cfork.cf_blocks  = SWAP_BE32 (vhp->startupFile.totalBlocks);
+               cfork.cf_vblocks = 0;
+               cnattr.ca_blocks = cfork.cf_blocks;
+               for (i = 0; i < kHFSPlusExtentDensity; i++) {
+                       cfork.cf_extents[i].startBlock =
+                                       SWAP_BE32 (vhp->startupFile.extents[i].startBlock);
+                       cfork.cf_extents[i].blockCount =
+                                       SWAP_BE32 (vhp->startupFile.extents[i].blockCount);
+               }
+               retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,
+                                        &hfsmp->hfs_startup_vp);
+               if (retval) {
+                       goto ErrorExit;
+               }
+               hfsmp->hfs_startup_cp = VTOC(hfsmp->hfs_startup_vp);
+               hfs_unlock(hfsmp->hfs_startup_cp);
+       }
+       

        /* Pick up volume name and create date */
        /* Pick up volume name and create date */

-       retval = cat_idlookup(hfsmp, kHFSRootFolderID, &cndesc, &cnattr, NULL);
+       retval = cat_idlookup(hfsmp, kHFSRootFolderID, 0, &cndesc, &cnattr, NULL);

        if (retval) {
        if (retval) {

-               hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
-               hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
-               hfs_unlock(VTOC(hfsmp->hfs_extents_vp));

                goto ErrorExit;
        }
        vcb->vcbCrDate = cnattr.ca_itime;
                goto ErrorExit;
        }
        vcb->vcbCrDate = cnattr.ca_itime;


@@ -545,14 +597,10 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                hfs_flushvolumeheader(hfsmp, TRUE, 0);
        }
 
                hfs_flushvolumeheader(hfsmp, TRUE, 0);
        }
 

-       /*
-        * all done with metadata files so we can unlock now...
-        */
-       if (hfsmp->hfs_attribute_vp)
-               hfs_unlock(VTOC(hfsmp->hfs_attribute_vp));
-       hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
-       hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
-       hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
+       /* kHFSHasFolderCount is only supported/updated on HFSX volumes */
+       if ((hfsmp->hfs_flags & HFS_X) != 0) {
+               hfsmp->hfs_flags |= HFS_FOLDERCOUNT;
+       }

 
        //
        // Check if we need to do late journal initialization.  This only
 
        //
        // Check if we need to do late journal initialization.  This only


@@ -566,6 +614,14 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
 
                retval = hfs_late_journal_init(hfsmp, vhp, args);
                if (retval != 0) {
 
                retval = hfs_late_journal_init(hfsmp, vhp, args);
                if (retval != 0) {

+                       if (retval == EROFS) {
+                               // EROFS is a special error code that means the volume has an external
+                               // journal which we couldn't find.  in that case we do not want to
+                               // rewrite the volume header - we'll just refuse to mount the volume.
+                               retval = EINVAL;
+                               goto ErrorExit;
+                       }
+

                        hfsmp->jnl = NULL;
                        
                        // if the journal failed to open, then set the lastMountedVersion
                        hfsmp->jnl = NULL;
                        
                        // if the journal failed to open, then set the lastMountedVersion


@@ -580,9 +636,12 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                                    
                                mdb_offset = (daddr64_t)((embeddedOffset / blockSize) + HFS_PRI_SECTOR(blockSize));
 
                                    
                                mdb_offset = (daddr64_t)((embeddedOffset / blockSize) + HFS_PRI_SECTOR(blockSize));
 

-                               retval = (int)buf_meta_bread(hfsmp->hfs_devvp, mdb_offset, blockSize, cred, &bp);
+                               bp = NULL;
+                               retval = (int)buf_meta_bread(hfsmp->hfs_devvp, 
+                                               HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
+                                               hfsmp->hfs_physical_block_size, cred, &bp);

                                if (retval == 0) {
                                if (retval == 0) {

-                                       jvhp = (HFSPlusVolumeHeader *)(buf_dataptr(bp) + HFS_PRI_OFFSET(blockSize));
+                                       jvhp = (HFSPlusVolumeHeader *)(buf_dataptr(bp) + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));

                                            
                                        if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord) {
                                                printf ("hfs(3): Journal replay fail.  Writing lastMountVersion as FSK!\n");
                                            
                                        if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord) {
                                                printf ("hfs(3): Journal replay fail.  Writing lastMountVersion as FSK!\n");


@@ -602,11 +661,15 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                        retval = EINVAL;
                        goto ErrorExit;
                } else if (hfsmp->jnl) {
                        retval = EINVAL;
                        goto ErrorExit;
                } else if (hfsmp->jnl) {

-                       vfs_setflags(hfsmp->hfs_mp, (uint64_t)((unsigned int)MNT_JOURNALED));
+                       vfs_setflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));

                }
                }

-       } else if (hfsmp->jnl) {
+       } else if (hfsmp->jnl || ((vcb->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY))) {

                struct cat_attr jinfo_attr, jnl_attr;
                
                struct cat_attr jinfo_attr, jnl_attr;
                

+               if (hfsmp->hfs_flags & HFS_READ_ONLY) {
+                   vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
+               }
+

                // if we're here we need to fill in the fileid's for the
                // journal and journal_info_block.
                hfsmp->hfs_jnlinfoblkid = GetFileInfo(vcb, kRootDirID, ".journal_info_block", &jinfo_attr, NULL);
                // if we're here we need to fill in the fileid's for the
                // journal and journal_info_block.
                hfsmp->hfs_jnlinfoblkid = GetFileInfo(vcb, kRootDirID, ".journal_info_block", &jinfo_attr, NULL);


@@ -615,6 +678,14 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                        printf("hfs: danger! couldn't find the file-id's for the journal or journal_info_block\n");
                        printf("hfs: jnlfileid %d, jnlinfoblkid %d\n", hfsmp->hfs_jnlfileid, hfsmp->hfs_jnlinfoblkid);
                }
                        printf("hfs: danger! couldn't find the file-id's for the journal or journal_info_block\n");
                        printf("hfs: jnlfileid %d, jnlinfoblkid %d\n", hfsmp->hfs_jnlfileid, hfsmp->hfs_jnlinfoblkid);
                }

+
+               if (hfsmp->hfs_flags & HFS_READ_ONLY) {
+                   vcb->vcbAtrb |= kHFSVolumeJournaledMask;
+               }
+
+               if (hfsmp->jnl == NULL) {
+                   vfs_clearflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));
+               }

        }
 
        /*
        }
 
        /*


@@ -629,15 +700,30 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                /* Keep the roving allocator out of the metadata zone. */
                if (vcb->nextAllocation >= hfsmp->hfs_metazone_start &&
                    vcb->nextAllocation <= hfsmp->hfs_metazone_end) {       
                /* Keep the roving allocator out of the metadata zone. */
                if (vcb->nextAllocation >= hfsmp->hfs_metazone_start &&
                    vcb->nextAllocation <= hfsmp->hfs_metazone_end) {       

-                       vcb->nextAllocation = hfsmp->hfs_metazone_end + 1;
+                       HFS_UPDATE_NEXT_ALLOCATION(hfsmp, hfsmp->hfs_metazone_end + 1);
+               }
+       } else {
+               if (vcb->nextAllocation <= 1) {
+                       vcb->nextAllocation = hfsmp->hfs_min_alloc_start;

                }
        }
                }
        }

+       vcb->sparseAllocation = hfsmp->hfs_min_alloc_start;
+
+       /* Setup private/hidden directories for hardlinks. */
+       hfs_privatedir_init(hfsmp, FILE_HARDLINKS);
+       hfs_privatedir_init(hfsmp, DIR_HARDLINKS);

 
 

-       /* setup private/hidden directory for unlinked files */
-       FindMetaDataDirectory(vcb);

        if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) 
                hfs_remove_orphans(hfsmp);
 
        if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) 
                hfs_remove_orphans(hfsmp);
 

+       /* See if we need to erase unused Catalog nodes due to <rdar://problem/6947811>. */
+       if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0)
+       {
+               retval = hfs_erase_unused_nodes(hfsmp);
+               if (retval)
+                       goto ErrorExit;
+       }
+       

        if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) )     // if the disk is not write protected
        {
                MarkVCBDirty( vcb );    // mark VCB dirty so it will be written
        if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) )     // if the disk is not write protected
        {
                MarkVCBDirty( vcb );    // mark VCB dirty so it will be written


@@ -651,7 +737,11 @@ OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                (void) hfs_recording_init(hfsmp);
        }
 
                (void) hfs_recording_init(hfsmp);
        }
 

-       hfs_checkextendedsecurity(hfsmp);
+       /* Force ACLs on HFS+ file systems. */
+       vfs_setextendedsecurity(HFSTOVFS(hfsmp));
+
+       /* Check if volume supports writing of extent-based extended attributes */
+       hfs_check_volxattr(hfsmp, HFS_SET_XATTREXTENTS_STATE);

 
        return (0);
 
 
        return (0);
 


@@ -702,8 +792,22 @@ static void ReleaseMetaFileVNode(struct vnode *vp)
 
 __private_extern__
 int
 
 __private_extern__
 int

-hfsUnmount( register struct hfsmount *hfsmp, struct proc *p)
+hfsUnmount( register struct hfsmount *hfsmp, __unused struct proc *p)

 {
 {

+       /* Get rid of our attribute data vnode (if any). */
+       if (hfsmp->hfs_attrdata_vp) {
+               vnode_t advp = hfsmp->hfs_attrdata_vp;
+       
+               if (vnode_get(advp) == 0) {
+                       vnode_rele_ext(advp, O_EVTONLY, 0);
+                       vnode_put(advp);
+               }
+               hfsmp->hfs_attrdata_vp = NULLVP;
+       }
+
+       if (hfsmp->hfs_startup_vp)
+               ReleaseMetaFileVNode(hfsmp->hfs_startup_vp);
+

        if (hfsmp->hfs_allocation_vp)
                ReleaseMetaFileVNode(hfsmp->hfs_allocation_vp);
 
        if (hfsmp->hfs_allocation_vp)
                ReleaseMetaFileVNode(hfsmp->hfs_allocation_vp);
 


@@ -713,6 +817,18 @@ hfsUnmount( register struct hfsmount *hfsmp, struct proc *p)
        ReleaseMetaFileVNode(hfsmp->hfs_catalog_vp);
        ReleaseMetaFileVNode(hfsmp->hfs_extents_vp);
 
        ReleaseMetaFileVNode(hfsmp->hfs_catalog_vp);
        ReleaseMetaFileVNode(hfsmp->hfs_extents_vp);
 

+       /*
+        * Setting these pointers to NULL so that any references
+        * past this point will fail, and tell us the point of failure.
+        * Also, facilitates a check in hfs_update for a null catalog
+        * vp
+        */
+       hfsmp->hfs_allocation_vp = NULL;
+       hfsmp->hfs_attribute_vp = NULL;
+       hfsmp->hfs_catalog_vp = NULL;
+       hfsmp->hfs_extents_vp = NULL;
+       hfsmp->hfs_startup_vp = NULL;
+

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


@@ -724,9 +840,16 @@ __private_extern__
 int
 overflow_extents(struct filefork *fp)
 {
 int
 overflow_extents(struct filefork *fp)
 {

-       u_long blocks;
+       u_int32_t blocks;

 
 

-       if (VTOVCB(FTOV(fp))->vcbSigWord == kHFSPlusSigWord) {
+       //
+       // If the vnode pointer is NULL then we're being called
+       // from hfs_remove_orphans() with a faked-up filefork
+       // and therefore it has to be an HFS+ volume.  Otherwise
+       // we check through the volume header to see what type
+       // of volume we're on.
+        //
+       if (FTOV(fp) == NULL || VTOVCB(FTOV(fp))->vcbSigWord == kHFSPlusSigWord) {

                if (fp->ff_extents[7].blockCount == 0)
                        return (0);
 
                if (fp->ff_extents[7].blockCount == 0)
                        return (0);
 


@@ -758,13 +881,24 @@ __private_extern__
 int
 hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfslocktype locktype)
 {
 int
 hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfslocktype locktype)
 {

-       if (flags & ~SFL_VALIDMASK)
-               panic("hfs_systemfile_lock: invalid lock request (0x%x)", (unsigned long) flags);

        /*
        /*

-        * Locking order is Catalog file, Attributes file, Bitmap file, Extents file
+        * Locking order is Catalog file, Attributes file, Startup file, Bitmap file, Extents file

         */
        if (flags & SFL_CATALOG) {
         */
        if (flags & SFL_CATALOG) {

-               (void) hfs_lock(VTOC(hfsmp->hfs_catalog_vp), locktype);
+
+#ifdef HFS_CHECK_LOCK_ORDER
+               if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == current_thread()) {
+                       panic("hfs_systemfile_lock: bad lock order (Attributes before Catalog)");
+               }
+               if (hfsmp->hfs_startup_cp && hfsmp->hfs_startup_cp->c_lockowner == current_thread()) {
+                       panic("hfs_systemfile_lock: bad lock order (Startup before Catalog)");
+               }
+               if (hfsmp-> hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {
+                       panic("hfs_systemfile_lock: bad lock order (Extents before Catalog)");
+               }
+#endif /* HFS_CHECK_LOCK_ORDER */
+
+               (void) hfs_lock(hfsmp->hfs_catalog_cp, locktype);

                /*
                 * When the catalog file has overflow extents then
                 * also acquire the extents b-tree lock if its not
                /*
                 * When the catalog file has overflow extents then
                 * also acquire the extents b-tree lock if its not


@@ -776,8 +910,18 @@ hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfslocktype locktype
                }
        }
        if (flags & SFL_ATTRIBUTE) {
                }
        }
        if (flags & SFL_ATTRIBUTE) {

-               if (hfsmp->hfs_attribute_vp) {
-                       (void) hfs_lock(VTOC(hfsmp->hfs_attribute_vp), locktype);
+
+#ifdef HFS_CHECK_LOCK_ORDER
+               if (hfsmp->hfs_startup_cp && hfsmp->hfs_startup_cp->c_lockowner == current_thread()) {
+                       panic("hfs_systemfile_lock: bad lock order (Startup before Attributes)");
+               }
+               if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {
+                       panic("hfs_systemfile_lock: bad lock order (Extents before Attributes)");
+               }
+#endif /* HFS_CHECK_LOCK_ORDER */
+
+               if (hfsmp->hfs_attribute_cp) {
+                       (void) hfs_lock(hfsmp->hfs_attribute_cp, locktype);

                        /*
                         * When the attribute file has overflow extents then
                         * also acquire the extents b-tree lock if its not
                        /*
                         * When the attribute file has overflow extents then
                         * also acquire the extents b-tree lock if its not


@@ -791,7 +935,29 @@ hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfslocktype locktype
                        flags &= ~SFL_ATTRIBUTE;
                }
        }
                        flags &= ~SFL_ATTRIBUTE;
                }
        }

-       if (flags & SFL_BITMAP) {
+       if (flags & SFL_STARTUP) {
+#ifdef HFS_CHECK_LOCK_ORDER
+               if (hfsmp-> hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {
+                       panic("hfs_systemfile_lock: bad lock order (Extents before Startup)");
+               }
+#endif /* HFS_CHECK_LOCK_ORDER */
+
+               (void) hfs_lock(hfsmp->hfs_startup_cp, locktype);
+               /*
+                * When the startup file has overflow extents then
+                * also acquire the extents b-tree lock if its not
+                * already requested.
+                */
+               if ((flags & SFL_EXTENTS) == 0 &&
+                   overflow_extents(VTOF(hfsmp->hfs_startup_vp))) {
+                       flags |= SFL_EXTENTS;
+               }
+       }
+       /* 
+        * To prevent locks being taken in the wrong order, the extent lock
+        * gets a bitmap lock as well.
+        */
+       if (flags & (SFL_BITMAP | SFL_EXTENTS)) {

                /*
                 * Since the only bitmap operations are clearing and
                 * setting bits we always need exclusive access. And
                /*
                 * Since the only bitmap operations are clearing and
                 * setting bits we always need exclusive access. And


@@ -799,10 +965,15 @@ hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfslocktype locktype
                 * lock since we can only change the bitmap from
                 * within a transaction.
                 */
                 * lock since we can only change the bitmap from
                 * within a transaction.
                 */

-               if (hfsmp->jnl) {
+               if (hfsmp->jnl || (hfsmp->hfs_allocation_cp == NULL)) {

                        flags &= ~SFL_BITMAP;
                } else {
                        flags &= ~SFL_BITMAP;
                } else {

-                       (void) hfs_lock(VTOC(hfsmp->hfs_allocation_vp), HFS_EXCLUSIVE_LOCK);
+                       (void) hfs_lock(hfsmp->hfs_allocation_cp, HFS_EXCLUSIVE_LOCK);
+                       /* The bitmap lock is also grabbed when only extent lock 
+                        * was requested. Set the bitmap lock bit in the lock
+                        * flags which callers will use during unlock.
+                        */
+                       flags |= SFL_BITMAP;

                }
        }
        if (flags & SFL_EXTENTS) {
                }
        }
        if (flags & SFL_EXTENTS) {


@@ -810,7 +981,7 @@ hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfslocktype locktype
                 * Since the extents btree lock is recursive we always
                 * need exclusive access.
                 */
                 * Since the extents btree lock is recursive we always
                 * need exclusive access.
                 */

-               (void) hfs_lock(VTOC(hfsmp->hfs_extents_vp), HFS_EXCLUSIVE_LOCK);
+               (void) hfs_lock(hfsmp->hfs_extents_cp, HFS_EXCLUSIVE_LOCK);

        }
        return (flags);
 }
        }
        return (flags);
 }


@@ -826,13 +997,14 @@ hfs_systemfile_unlock(struct hfsmount *hfsmp, int flags)
        u_int32_t lastfsync;
        int numOfLockedBuffs;
 
        u_int32_t lastfsync;
        int numOfLockedBuffs;
 

-       microuptime(&tv);
-       lastfsync = tv.tv_sec;
-       
-       if (flags & ~SFL_VALIDMASK)
-               panic("hfs_systemfile_unlock: invalid lock request (0x%x)", (unsigned long) flags);
-
-       if (flags & SFL_ATTRIBUTE && hfsmp->hfs_attribute_vp) {
+       if (hfsmp->jnl == NULL) {
+               microuptime(&tv);
+               lastfsync = tv.tv_sec;
+       }
+       if (flags & SFL_STARTUP && hfsmp->hfs_startup_cp) {
+               hfs_unlock(hfsmp->hfs_startup_cp);
+       }
+       if (flags & SFL_ATTRIBUTE && hfsmp->hfs_attribute_cp) {

                if (hfsmp->jnl == NULL) {
                        BTGetLastSync((FCB*)VTOF(hfsmp->hfs_attribute_vp), &lastfsync);
                        numOfLockedBuffs = count_lock_queue();
                if (hfsmp->jnl == NULL) {
                        BTGetLastSync((FCB*)VTOF(hfsmp->hfs_attribute_vp), &lastfsync);
                        numOfLockedBuffs = count_lock_queue();


@@ -842,7 +1014,7 @@ hfs_systemfile_unlock(struct hfsmount *hfsmp, int flags)
                                hfs_btsync(hfsmp->hfs_attribute_vp, HFS_SYNCTRANS);
                        }
                }
                                hfs_btsync(hfsmp->hfs_attribute_vp, HFS_SYNCTRANS);
                        }
                }

-               hfs_unlock(VTOC(hfsmp->hfs_attribute_vp));
+               hfs_unlock(hfsmp->hfs_attribute_cp);

        }
        if (flags & SFL_CATALOG) {
                if (hfsmp->jnl == NULL) {
        }
        if (flags & SFL_CATALOG) {
                if (hfsmp->jnl == NULL) {


@@ -854,10 +1026,10 @@ hfs_systemfile_unlock(struct hfsmount *hfsmp, int flags)
                                hfs_btsync(hfsmp->hfs_catalog_vp, HFS_SYNCTRANS);
                        }
                }
                                hfs_btsync(hfsmp->hfs_catalog_vp, HFS_SYNCTRANS);
                        }
                }

-               hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
+               hfs_unlock(hfsmp->hfs_catalog_cp);

        }
        if (flags & SFL_BITMAP) {
        }
        if (flags & SFL_BITMAP) {

-               hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
+               hfs_unlock(hfsmp->hfs_allocation_cp);

        }
        if (flags & SFL_EXTENTS) {
                if (hfsmp->jnl == NULL) {
        }
        if (flags & SFL_EXTENTS) {
                if (hfsmp->jnl == NULL) {


@@ -869,7 +1041,7 @@ hfs_systemfile_unlock(struct hfsmount *hfsmp, int flags)
                                hfs_btsync(hfsmp->hfs_extents_vp, HFS_SYNCTRANS);
                        }
                }
                                hfs_btsync(hfsmp->hfs_extents_vp, HFS_SYNCTRANS);
                        }
                }

-               hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
+               hfs_unlock(hfsmp->hfs_extents_cp);

        }
 }
 
        }
 }
 


@@ -896,18 +1068,20 @@ void RequireFileLock(FileReference vp, int shareable)
        if (!locked && !shareable) {
                switch (VTOC(vp)->c_fileid) {
                case kHFSExtentsFileID:
        if (!locked && !shareable) {
                switch (VTOC(vp)->c_fileid) {
                case kHFSExtentsFileID:

-                       panic("extents btree not locked! v: 0x%08X\n #\n", (u_int)vp);
+                       panic("hfs: extents btree not locked! v: 0x%08X\n #\n", (u_int)vp);

                        break;
                case kHFSCatalogFileID:
                        break;
                case kHFSCatalogFileID:

-                       panic("catalog btree not locked! v: 0x%08X\n #\n", (u_int)vp);
+                       panic("hfs: catalog btree not locked! v: 0x%08X\n #\n", (u_int)vp);

                        break;
                case kHFSAllocationFileID:
                        /* The allocation file can hide behind the jornal lock. */
                        if (VTOHFS(vp)->jnl == NULL)
                        break;
                case kHFSAllocationFileID:
                        /* The allocation file can hide behind the jornal lock. */
                        if (VTOHFS(vp)->jnl == NULL)

-                               panic("allocation file not locked! v: 0x%08X\n #\n", (u_int)vp);
+                               panic("hfs: allocation file not locked! v: 0x%08X\n #\n", (u_int)vp);

                        break;
                        break;

+               case kHFSStartupFileID:
+                       panic("hfs: startup file not locked! v: 0x%08X\n #\n", (u_int)vp);

                case kHFSAttributesFileID:
                case kHFSAttributesFileID:

-                       panic("attributes btree not locked! v: 0x%08X\n #\n", (u_int)vp);
+                       panic("hfs: attributes btree not locked! v: 0x%08X\n #\n", (u_int)vp);

                        break;
                }
        }
                        break;
                }
        }


@@ -929,7 +1103,7 @@ void RequireFileLock(FileReference vp, int shareable)
  */
 int
 hfs_owner_rights(struct hfsmount *hfsmp, uid_t cnode_uid, kauth_cred_t cred,
  */
 int
 hfs_owner_rights(struct hfsmount *hfsmp, uid_t cnode_uid, kauth_cred_t cred,

-               struct proc *p, int invokesuperuserstatus)
+               __unused struct proc *p, int invokesuperuserstatus)

 {
        if ((kauth_cred_getuid(cred) == cnode_uid) ||                                    /* [1a] */
            (cnode_uid == UNKNOWNUID) ||                                                                          /* [1b] */
 {
        if ((kauth_cred_getuid(cred) == cnode_uid) ||                                    /* [1a] */
            (cnode_uid == UNKNOWNUID) ||                                                                          /* [1b] */


@@ -944,15 +1118,15 @@ hfs_owner_rights(struct hfsmount *hfsmp, uid_t cnode_uid, kauth_cred_t cred,
 }
 
 
 }
 
 

-unsigned long BestBlockSizeFit(unsigned long allocationBlockSize,
-                               unsigned long blockSizeLimit,
-                               unsigned long baseMultiple) {
+u_int32_t BestBlockSizeFit(u_int32_t allocationBlockSize,
+                               u_int32_t blockSizeLimit,
+                               u_int32_t baseMultiple) {

     /*
        Compute the optimal (largest) block size (no larger than allocationBlockSize) that is less than the
        specified limit but still an even multiple of the baseMultiple.
      */
     int baseBlockCount, blockCount;
     /*
        Compute the optimal (largest) block size (no larger than allocationBlockSize) that is less than the
        specified limit but still an even multiple of the baseMultiple.
      */
     int baseBlockCount, blockCount;

-    unsigned long trialBlockSize;
+    u_int32_t trialBlockSize;

 
     if (allocationBlockSize % baseMultiple != 0) {
         /*
 
     if (allocationBlockSize % baseMultiple != 0) {
         /*


@@ -987,148 +1161,12 @@ unsigned long BestBlockSizeFit(unsigned long allocationBlockSize,
 }
 
 
 }
 
 

-/*
- * To make the HFS Plus filesystem follow UFS unlink semantics, a remove
- * of an active vnode is translated to a move/rename so the file appears
- * deleted. The destination folder for these move/renames is setup here
- * and a reference to it is place in hfsmp->hfs_privdir_desc.
- */

 __private_extern__
 __private_extern__

-u_long
-FindMetaDataDirectory(ExtendedVCB *vcb)
-{
-       struct hfsmount * hfsmp;
-       struct vnode * dvp = NULL;
-       struct cnode * dcp = NULL;
-       struct FndrDirInfo * fndrinfo;
-       struct cat_desc out_desc = {0};
-       struct proc *p = current_proc();
-       struct timeval tv;
-       cat_cookie_t cookie;
-       int lockflags;
-       int error;
-       
-       if (vcb->vcbSigWord != kHFSPlusSigWord)
-               return (0);
-
-       hfsmp = VCBTOHFS(vcb);
-
-       if (hfsmp->hfs_privdir_desc.cd_parentcnid == 0) {
-               hfsmp->hfs_privdir_desc.cd_parentcnid = kRootDirID;
-               hfsmp->hfs_privdir_desc.cd_nameptr = hfs_privdirname;
-               hfsmp->hfs_privdir_desc.cd_namelen = strlen(hfs_privdirname);
-               hfsmp->hfs_privdir_desc.cd_flags = CD_ISDIR;
-       }
-
-       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
-
-       error = cat_lookup(hfsmp, &hfsmp->hfs_privdir_desc, 0, NULL,
-                       &hfsmp->hfs_privdir_attr, NULL, NULL);
-
-       hfs_systemfile_unlock(hfsmp, lockflags);
-
-       if (error == 0) {
-               hfsmp->hfs_metadata_createdate = hfsmp->hfs_privdir_attr.ca_itime;
-               hfsmp->hfs_privdir_desc.cd_cnid = hfsmp->hfs_privdir_attr.ca_fileid;
-               /*
-                * Clear the system immutable flag if set...
-                */
-               if ((hfsmp->hfs_privdir_attr.ca_flags & SF_IMMUTABLE) &&
-                   (hfsmp->hfs_flags & HFS_READ_ONLY) == 0) {
-                       hfsmp->hfs_privdir_attr.ca_flags &= ~SF_IMMUTABLE;
-
-                       if ((error = hfs_start_transaction(hfsmp)) != 0) {
-                           return (hfsmp->hfs_privdir_attr.ca_fileid);
-                       }
-
-                       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
-                       (void) cat_update(hfsmp, &hfsmp->hfs_privdir_desc,
-                                        &hfsmp->hfs_privdir_attr, NULL, NULL);
-                       hfs_systemfile_unlock(hfsmp, lockflags);
-
-                       hfs_end_transaction(hfsmp);
-               }
-               return (hfsmp->hfs_privdir_attr.ca_fileid);
-
-       } else if (hfsmp->hfs_flags & HFS_READ_ONLY) {
-
-               return (0);
-       }
-    
-       /* Setup the default attributes */
-       bzero(&hfsmp->hfs_privdir_attr, sizeof(struct cat_attr));
-       hfsmp->hfs_privdir_attr.ca_mode = S_IFDIR;
-       hfsmp->hfs_privdir_attr.ca_nlink = 2;
-       hfsmp->hfs_privdir_attr.ca_itime = vcb->vcbCrDate;
-       microtime(&tv);
-       hfsmp->hfs_privdir_attr.ca_mtime = tv.tv_sec;
-
-       /* hidden and off the desktop view */
-       fndrinfo = (struct FndrDirInfo *)&hfsmp->hfs_privdir_attr.ca_finderinfo;
-       fndrinfo->frLocation.v = SWAP_BE16 (22460);
-       fndrinfo->frLocation.h = SWAP_BE16 (22460);
-       fndrinfo->frFlags |= SWAP_BE16 (kIsInvisible + kNameLocked);            
-
-       if ((error = hfs_start_transaction(hfsmp)) != 0) {
-           return (0);
-       }
-       /* Reserve some space in the Catalog file. */
-       if (cat_preflight(hfsmp, CAT_CREATE, &cookie, p) != 0) {
-           hfs_end_transaction(hfsmp);
-
-           return (0);
-       }
-
-       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
-
-               error = cat_create(hfsmp, &hfsmp->hfs_privdir_desc,
-                               &hfsmp->hfs_privdir_attr, &out_desc);
-
-       hfs_systemfile_unlock(hfsmp, lockflags);
-
-       cat_postflight(hfsmp, &cookie, p);
-       
-       if (error) {
-               hfs_volupdate(hfsmp, VOL_UPDATE, 0);
-
-               hfs_end_transaction(hfsmp);
-
-               return (0);
-       }
-
-       hfsmp->hfs_privdir_desc.cd_hint = out_desc.cd_hint;
-       hfsmp->hfs_privdir_desc.cd_cnid = out_desc.cd_cnid;
-       hfsmp->hfs_privdir_attr.ca_fileid = out_desc.cd_cnid;
-       hfsmp->hfs_metadata_createdate = vcb->vcbCrDate;
-
-       if (hfs_vget(hfsmp, kRootDirID, &dvp, 0) == 0) {
-               dcp = VTOC(dvp);
-               dcp->c_childhint = out_desc.cd_hint;
-               dcp->c_nlink++;
-               dcp->c_entries++;
-               dcp->c_touch_chgtime = TRUE;
-               dcp->c_touch_modtime = TRUE;
-               (void) hfs_update(dvp, 0);
-               hfs_unlock(dcp);
-               vnode_put(dvp);
-       }
-       hfs_volupdate(hfsmp, VOL_MKDIR, 1);
-       hfs_end_transaction(hfsmp);
-
-       cat_releasedesc(&out_desc);
-
-       return (out_desc.cd_cnid);
-}
-
-__private_extern__
-u_long
-GetFileInfo(ExtendedVCB *vcb, u_int32_t dirid, const char *name,
+u_int32_t
+GetFileInfo(ExtendedVCB *vcb, __unused u_int32_t dirid, const char *name,

                        struct cat_attr *fattr, struct cat_fork *forkinfo)
 {
        struct hfsmount * hfsmp;
                        struct cat_attr *fattr, struct cat_fork *forkinfo)
 {
        struct hfsmount * hfsmp;

-       struct vnode * dvp = NULL;
-       struct cnode * dcp = NULL;
-       struct FndrDirInfo * fndrinfo;

        struct cat_desc jdesc;
        int lockflags;
        int error;
        struct cat_desc jdesc;
        int lockflags;
        int error;


@@ -1140,7 +1178,7 @@ GetFileInfo(ExtendedVCB *vcb, u_int32_t dirid, const char *name,
 
        memset(&jdesc, 0, sizeof(struct cat_desc));
        jdesc.cd_parentcnid = kRootDirID;
 
        memset(&jdesc, 0, sizeof(struct cat_desc));
        jdesc.cd_parentcnid = kRootDirID;

-       jdesc.cd_nameptr = name;
+       jdesc.cd_nameptr = (const u_int8_t *)name;

        jdesc.cd_namelen = strlen(name);
 
        lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
        jdesc.cd_namelen = strlen(name);
 
        lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);


@@ -1158,9 +1196,9 @@ GetFileInfo(ExtendedVCB *vcb, u_int32_t dirid, const char *name,
 
 
 /*
 
 
 /*

- * On HFS Plus Volume, there can be orphaned files.  These
- * are files that were unlinked while busy. If the volume
- * was not cleanly unmounted then some of these files may
+ * On HFS Plus Volumes, there can be orphaned files or directories
+ * These are files or directories that were unlinked while busy. 
+ * If the volume was not cleanly unmounted then some of these may

  * have persisted and need to be removed.
  */
 __private_extern__
  * have persisted and need to be removed.
  */
 __private_extern__


@@ -1183,7 +1221,8 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
        int started_tr = 0;
        int lockflags;
        int result;
        int started_tr = 0;
        int lockflags;
        int result;

-       int orphanedlinks = 0;
+       int orphaned_files = 0;
+       int orphaned_dirs = 0;

 
        bzero(&cookie, sizeof(cookie));
 
 
        bzero(&cookie, sizeof(cookie));
 


@@ -1202,7 +1241,7 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
        
        /* Build a key to "temp" */
        keyp = (HFSPlusCatalogKey*)&iterator->key;
        
        /* Build a key to "temp" */
        keyp = (HFSPlusCatalogKey*)&iterator->key;

-       keyp->parentID = hfsmp->hfs_privdir_desc.cd_cnid;
+       keyp->parentID = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;

        keyp->nodeName.length = 4;  /* "temp" */
        keyp->keyLength = kHFSPlusCatalogKeyMinimumLength + keyp->nodeName.length * 2;
        keyp->nodeName.unicode[0] = 't';
        keyp->nodeName.length = 4;  /* "temp" */
        keyp->keyLength = kHFSPlusCatalogKeyMinimumLength + keyp->nodeName.length * 2;
        keyp->nodeName.unicode[0] = 't';


@@ -1211,32 +1250,31 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
        keyp->nodeName.unicode[3] = 'p';
 
        /*
        keyp->nodeName.unicode[3] = 'p';
 
        /*

-        * Position the iterator just before the first real temp file.
+        * Position the iterator just before the first real temp file/dir.

         */
        lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
        (void) BTSearchRecord(fcb, iterator, NULL, NULL, iterator);
        hfs_systemfile_unlock(hfsmp, lockflags);
 
         */
        lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
        (void) BTSearchRecord(fcb, iterator, NULL, NULL, iterator);
        hfs_systemfile_unlock(hfsmp, lockflags);
 

-       /* Visit all the temp files in the HFS+ private directory. */
+       /* Visit all the temp files/dirs in the HFS+ private directory. */

        for (;;) {
                lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
                result = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
                hfs_systemfile_unlock(hfsmp, lockflags);
                if (result)
                        break;
        for (;;) {
                lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
                result = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
                hfs_systemfile_unlock(hfsmp, lockflags);
                if (result)
                        break;

-               if (keyp->parentID != hfsmp->hfs_privdir_desc.cd_cnid)
+               if (keyp->parentID != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid)

                        break;
                        break;

-               if (filerec.recordType != kHFSPlusFileRecord)
-                       continue;

                
                (void) utf8_encodestr(keyp->nodeName.unicode, keyp->nodeName.length * 2,
                
                (void) utf8_encodestr(keyp->nodeName.unicode, keyp->nodeName.length * 2,

-                                     filename, &namelen, sizeof(filename), 0, 0);
+                                     (u_int8_t *)filename, &namelen, sizeof(filename), 0, 0);

                
                

-               (void) sprintf(tempname, "%s%d", HFS_DELETE_PREFIX, filerec.fileID);
+               (void) snprintf(tempname, sizeof(tempname), "%s%d",
+                               HFS_DELETE_PREFIX, filerec.fileID);

                
                /*
                
                /*

-                * Delete all files named "tempxxx", where
-                * xxx is the file's cnid in decimal.
+                * Delete all files (and directories) named "tempxxx", 
+                * where xxx is the file's cnid in decimal.

                 *
                 */
                if (bcmp(tempname, filename, namelen) == 0) {
                 *
                 */
                if (bcmp(tempname, filename, namelen) == 0) {


@@ -1248,6 +1286,9 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
                        bzero(&rfork, sizeof(rfork));
                        bzero(&cnode, sizeof(cnode));
                        
                        bzero(&rfork, sizeof(rfork));
                        bzero(&cnode, sizeof(cnode));
                        

+                       /* Delete any attributes, ignore errors */
+                       (void) hfs_removeallattr(hfsmp, filerec.fileID);
+                       

                        if (hfs_start_transaction(hfsmp) != 0) {
                            printf("hfs_remove_orphans: failed to start transaction\n");
                            goto exit;
                        if (hfs_start_transaction(hfsmp) != 0) {
                            printf("hfs_remove_orphans: failed to start transaction\n");
                            goto exit;


@@ -1269,8 +1310,8 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
                        /* Build a fake cnode */
                        cat_convertattr(hfsmp, (CatalogRecord *)&filerec, &cnode.c_attr,
                                        &dfork.ff_data, &rfork.ff_data);
                        /* Build a fake cnode */
                        cat_convertattr(hfsmp, (CatalogRecord *)&filerec, &cnode.c_attr,
                                        &dfork.ff_data, &rfork.ff_data);

-                       cnode.c_desc.cd_parentcnid = hfsmp->hfs_privdir_desc.cd_cnid;
-                       cnode.c_desc.cd_nameptr = filename;
+                       cnode.c_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;
+                       cnode.c_desc.cd_nameptr = (const u_int8_t *)filename;

                        cnode.c_desc.cd_namelen = namelen;
                        cnode.c_desc.cd_cnid = cnode.c_attr.ca_fileid;
                        cnode.c_blocks = dfork.ff_blocks + rfork.ff_blocks;
                        cnode.c_desc.cd_namelen = namelen;
                        cnode.c_desc.cd_cnid = cnode.c_attr.ca_fileid;
                        cnode.c_blocks = dfork.ff_blocks + rfork.ff_blocks;


@@ -1290,14 +1331,14 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
                                cnode.c_rsrcfork = NULL;
                                fsize = (u_int64_t)dfork.ff_blocks * (u_int64_t)HFSTOVCB(hfsmp)->blockSize;
                                while (fsize > 0) {
                                cnode.c_rsrcfork = NULL;
                                fsize = (u_int64_t)dfork.ff_blocks * (u_int64_t)HFSTOVCB(hfsmp)->blockSize;
                                while (fsize > 0) {

-                                       if (fsize > HFS_BIGFILE_SIZE) {
+                                   if (fsize > HFS_BIGFILE_SIZE && overflow_extents(&dfork)) {

                                                fsize -= HFS_BIGFILE_SIZE;
                                        } else {
                                                fsize = 0;
                                        }
 
                                        if (TruncateFileC(vcb, (FCB*)&dfork, fsize, false) != 0) {
                                                fsize -= HFS_BIGFILE_SIZE;
                                        } else {
                                                fsize = 0;
                                        }
 
                                        if (TruncateFileC(vcb, (FCB*)&dfork, fsize, false) != 0) {

-                                               printf("error truncting data fork!\n");
+                                               printf("hfs: error truncting data fork!\n");

                                                break;
                                        }
 
                                                break;
                                        }
 


@@ -1307,11 +1348,19 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
                                        // that no one transaction gets too big.
                                        //
                                        if (fsize > 0 && started_tr) {
                                        // that no one transaction gets too big.
                                        //
                                        if (fsize > 0 && started_tr) {

+                                               /* Drop system file locks before starting 
+                                                * another transaction to preserve lock order.
+                                                */
+                                               hfs_systemfile_unlock(hfsmp, lockflags);
+                                               catlock = 0;

                                                hfs_end_transaction(hfsmp);
                                                hfs_end_transaction(hfsmp);

+

                                                if (hfs_start_transaction(hfsmp) != 0) {
                                                        started_tr = 0;
                                                        break;
                                                }
                                                if (hfs_start_transaction(hfsmp) != 0) {
                                                        started_tr = 0;
                                                        break;
                                                }

+                                               lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
+                                               catlock = 1;

                                        }
                                }
                        }
                                        }
                                }
                        }


@@ -1321,32 +1370,52 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
                                cnode.c_datafork = NULL;
                                cnode.c_rsrcfork = &rfork;
                                if (TruncateFileC(vcb, (FCB*)&rfork, 0, false) != 0) {
                                cnode.c_datafork = NULL;
                                cnode.c_rsrcfork = &rfork;
                                if (TruncateFileC(vcb, (FCB*)&rfork, 0, false) != 0) {

-                                       printf("error truncting rsrc fork!\n");
+                                       printf("hfs: error truncting rsrc fork!\n");

                                        break;
                                }
                        }
 
                                        break;
                                }
                        }
 

-                       /* Remove the file record from the Catalog */   
+                       /* Remove the file or folder record from the Catalog */ 

                        if (cat_delete(hfsmp, &cnode.c_desc, &cnode.c_attr) != 0) {
                        if (cat_delete(hfsmp, &cnode.c_desc, &cnode.c_attr) != 0) {

-                               printf("hfs_remove_oprhans: error deleting cat rec for id %d!\n", cnode.c_desc.cd_cnid);
+                               printf("hfs_remove_orphans: error deleting cat rec for id %d!\n", cnode.c_desc.cd_cnid);
+                               hfs_systemfile_unlock(hfsmp, lockflags);
+                               catlock = 0;

                                hfs_volupdate(hfsmp, VOL_UPDATE, 0);
                                break;
                        }
                                hfs_volupdate(hfsmp, VOL_UPDATE, 0);
                                break;
                        }

-                       ++orphanedlinks;
-
-                       /* Delete any attributes, ignore errors */
-                       (void) hfs_removeallattr(hfsmp, cnode.c_fileid);

                        
                        

+                       if (cnode.c_attr.ca_mode & S_IFDIR) {
+                               orphaned_dirs++;
+                       }
+                       else {
+                               orphaned_files++;
+                       }
+

                        /* Update parent and volume counts */   
                        /* Update parent and volume counts */   

-                       hfsmp->hfs_privdir_attr.ca_entries--;
-                       (void)cat_update(hfsmp, &hfsmp->hfs_privdir_desc,
-                                        &hfsmp->hfs_privdir_attr, NULL, NULL);
-                       hfs_volupdate(hfsmp, VOL_RMFILE, 0);
+                       hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries--;
+                       if (cnode.c_attr.ca_mode & S_IFDIR) {
+                               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);

 
                        /* Drop locks and end the transaction */
                        hfs_systemfile_unlock(hfsmp, lockflags);
                        cat_postflight(hfsmp, &cookie, p);
                        catlock = catreserve = 0;
 
                        /* Drop locks and end the transaction */
                        hfs_systemfile_unlock(hfsmp, lockflags);
                        cat_postflight(hfsmp, &cookie, p);
                        catlock = catreserve = 0;

+
+                       /* 
+                          Now that Catalog is unlocked, update the volume info, making
+                          sure to differentiate between files and directories
+                       */
+                       if (cnode.c_attr.ca_mode & S_IFDIR) {
+                               hfs_volupdate(hfsmp, VOL_RMDIR, 0);
+                       }
+                       else{
+                               hfs_volupdate(hfsmp, VOL_RMFILE, 0);
+                       }
+

                        if (started_tr) {
                                hfs_end_transaction(hfsmp);
                                started_tr = 0;
                        if (started_tr) {
                                hfs_end_transaction(hfsmp);
                                started_tr = 0;


@@ -1354,8 +1423,8 @@ hfs_remove_orphans(struct hfsmount * hfsmp)
 
                } /* end if */
        } /* end for */
 
                } /* end if */
        } /* end for */

-       if (orphanedlinks > 0)
-               printf("HFS: Removed %d orphaned unlinked files\n", orphanedlinks);
+       if (orphaned_files > 0 || orphaned_dirs > 0)
+               printf("hfs: Removed %d orphaned / unlinked files and %d directories \n", orphaned_files, orphaned_dirs);

 exit:
        if (catlock) {
                hfs_systemfile_unlock(hfsmp, lockflags);
 exit:
        if (catlock) {
                hfs_systemfile_unlock(hfsmp, lockflags);


@@ -1417,22 +1486,29 @@ __private_extern__
 u_int32_t
 hfs_freeblks(struct hfsmount * hfsmp, int wantreserve)
 {
 u_int32_t
 hfs_freeblks(struct hfsmount * hfsmp, int wantreserve)
 {

-       ExtendedVCB *vcb = HFSTOVCB(hfsmp);

        u_int32_t freeblks;
        u_int32_t freeblks;

+       u_int32_t rsrvblks;
+       u_int32_t loanblks;

 
 

-       HFS_MOUNT_LOCK(hfsmp, TRUE);
-       freeblks = vcb->freeBlocks;
+       /*
+        * We don't bother taking the mount lock
+        * to look at these values since the values
+        * themselves are each updated automically
+        * on aligned addresses.
+        */
+       freeblks = hfsmp->freeBlocks;
+       rsrvblks = hfsmp->reserveBlocks;
+       loanblks = hfsmp->loanedBlocks;

        if (wantreserve) {
        if (wantreserve) {

-               if (freeblks > vcb->reserveBlocks)
-                       freeblks -= vcb->reserveBlocks;
+               if (freeblks > rsrvblks)
+                       freeblks -= rsrvblks;

                else
                        freeblks = 0;
        }
                else
                        freeblks = 0;
        }

-       if (freeblks > vcb->loanedBlocks)
-               freeblks -= vcb->loanedBlocks;
+       if (freeblks > loanblks)
+               freeblks -= loanblks;

        else
                freeblks = 0;
        else
                freeblks = 0;

-       HFS_MOUNT_UNLOCK(hfsmp, TRUE);

 
 #ifdef HFS_SPARSE_DEV
        /* 
 
 #ifdef HFS_SPARSE_DEV
        /* 


@@ -1441,31 +1517,41 @@ hfs_freeblks(struct hfsmount * hfsmp, int wantreserve)
         */
        if ((hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) && hfsmp->hfs_backingfs_rootvp) {
                struct vfsstatfs *vfsp;  /* 272 bytes */
         */
        if ((hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) && hfsmp->hfs_backingfs_rootvp) {
                struct vfsstatfs *vfsp;  /* 272 bytes */

-               u_int32_t vfreeblks;
+               u_int64_t vfreeblks;

                u_int32_t loanedblks;
                struct mount * backingfs_mp;
                u_int32_t loanedblks;
                struct mount * backingfs_mp;

+               struct timeval now;

 
                backingfs_mp = vnode_mount(hfsmp->hfs_backingfs_rootvp);
 
 
                backingfs_mp = vnode_mount(hfsmp->hfs_backingfs_rootvp);
 

-               if (vfsp = vfs_statfs(backingfs_mp)) {
+               microtime(&now);
+               if ((now.tv_sec - hfsmp->hfs_last_backingstatfs) >= 1) {
+                   vfs_update_vfsstat(backingfs_mp, vfs_context_kernel(), VFS_KERNEL_EVENT);
+                   hfsmp->hfs_last_backingstatfs = now.tv_sec;
+               }
+
+               if ((vfsp = vfs_statfs(backingfs_mp))) {

                        HFS_MOUNT_LOCK(hfsmp, TRUE);
                        HFS_MOUNT_LOCK(hfsmp, TRUE);

-                       vfreeblks = (u_int32_t)vfsp->f_bavail;
+                       vfreeblks = vfsp->f_bavail;

                        /* Normalize block count if needed. */
                        /* Normalize block count if needed. */

-                       if (vfsp->f_bsize != vcb->blockSize) {
-                               vfreeblks = ((u_int64_t)vfreeblks * (u_int64_t)(vfsp->f_bsize)) / vcb->blockSize;
+                       if (vfsp->f_bsize != hfsmp->blockSize) {
+                               vfreeblks = ((u_int64_t)vfreeblks * (u_int64_t)(vfsp->f_bsize)) / hfsmp->blockSize;

                        }
                        }

-                       if (vfreeblks > hfsmp->hfs_sparsebandblks)
+                       if (vfreeblks > (unsigned int)hfsmp->hfs_sparsebandblks)

                                vfreeblks -= hfsmp->hfs_sparsebandblks;
                        else
                                vfreeblks = 0;
                        
                        /* Take into account any delayed allocations. */
                                vfreeblks -= hfsmp->hfs_sparsebandblks;
                        else
                                vfreeblks = 0;
                        
                        /* Take into account any delayed allocations. */

-                       loanedblks = 2 * vcb->loanedBlocks;
+                       loanedblks = 2 * hfsmp->loanedBlocks;

                        if (vfreeblks > loanedblks)
                                vfreeblks -= loanedblks;
                        else
                                vfreeblks = 0;
 
                        if (vfreeblks > loanedblks)
                                vfreeblks -= loanedblks;
                        else
                                vfreeblks = 0;
 

+                       if (hfsmp->hfs_backingfs_maxblocks) {
+                               vfreeblks = MIN(vfreeblks, hfsmp->hfs_backingfs_maxblocks);
+                       }

                        freeblks = MIN(vfreeblks, freeblks);
                        HFS_MOUNT_UNLOCK(hfsmp, TRUE);
                }
                        freeblks = MIN(vfreeblks, freeblks);
                        HFS_MOUNT_UNLOCK(hfsmp, TRUE);
                }


@@ -1534,15 +1620,17 @@ short MacToVFSError(OSErr err)
  * Find the current thread's directory hint for a given index.
  *
  * Requires an exclusive lock on directory cnode.
  * Find the current thread's directory hint for a given index.
  *
  * Requires an exclusive lock on directory cnode.

+ *
+ * Use detach if the cnode lock must be dropped while the hint is still active.

  */
 __private_extern__
 directoryhint_t *
  */
 __private_extern__
 directoryhint_t *

-hfs_getdirhint(struct cnode *dcp, int index)
+hfs_getdirhint(struct cnode *dcp, int index, int detach)

 {
        struct timeval tv;
        directoryhint_t *hint;
        boolean_t need_remove, need_init;
 {
        struct timeval tv;
        directoryhint_t *hint;
        boolean_t need_remove, need_init;

-       char * name;
+       const u_int8_t * name;

 
        microuptime(&tv);
 
 
        microuptime(&tv);
 


@@ -1568,9 +1656,12 @@ hfs_getdirhint(struct cnode *dcp, int index)
                        need_remove = false;
                } else {                                /* recycle the last (i.e., the oldest) hint */
                        hint = TAILQ_LAST(&dcp->c_hintlist, hfs_hinthead);
                        need_remove = false;
                } else {                                /* recycle the last (i.e., the oldest) hint */
                        hint = TAILQ_LAST(&dcp->c_hintlist, hfs_hinthead);

-                       if ((name = hint->dh_desc.cd_nameptr)) {
+                       if ((hint->dh_desc.cd_flags & CD_HASBUF) &&
+                           (name = hint->dh_desc.cd_nameptr)) {

                                hint->dh_desc.cd_nameptr = NULL;
                                hint->dh_desc.cd_nameptr = NULL;

-                               vfs_removename(name);
+                               hint->dh_desc.cd_namelen = 0;
+                               hint->dh_desc.cd_flags &= ~CD_HASBUF;                           
+                               vfs_removename((const char *)name);

                        }
                        need_remove = true;
                }
                        }
                        need_remove = true;
                }


@@ -1579,7 +1670,10 @@ hfs_getdirhint(struct cnode *dcp, int index)
        if (need_remove)
                TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);
 
        if (need_remove)
                TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);
 

-       TAILQ_INSERT_HEAD(&dcp->c_hintlist, hint, dh_link);
+       if (detach)
+               --dcp->c_dirhintcnt;
+       else
+               TAILQ_INSERT_HEAD(&dcp->c_hintlist, hint, dh_link);

 
        if (need_init) {
                hint->dh_index = index;
 
        if (need_init) {
                hint->dh_index = index;


@@ -1587,7 +1681,7 @@ hfs_getdirhint(struct cnode *dcp, int index)
                hint->dh_desc.cd_encoding = 0;
                hint->dh_desc.cd_namelen = 0;
                hint->dh_desc.cd_nameptr = NULL;
                hint->dh_desc.cd_encoding = 0;
                hint->dh_desc.cd_namelen = 0;
                hint->dh_desc.cd_nameptr = NULL;

-               hint->dh_desc.cd_parentcnid = dcp->c_cnid;
+               hint->dh_desc.cd_parentcnid = dcp->c_fileid;

                hint->dh_desc.cd_hint = dcp->c_childhint;
                hint->dh_desc.cd_cnid = 0;
        }
                hint->dh_desc.cd_hint = dcp->c_childhint;
                hint->dh_desc.cd_cnid = 0;
        }


@@ -1604,16 +1698,25 @@ __private_extern__
 void
 hfs_reldirhint(struct cnode *dcp, directoryhint_t * relhint)
 {
 void
 hfs_reldirhint(struct cnode *dcp, directoryhint_t * relhint)
 {

-       char * name;
+       const u_int8_t * name;
+       directoryhint_t *hint;

 
 

-       TAILQ_REMOVE(&dcp->c_hintlist, relhint, dh_link);
+       /* Check if item is on list (could be detached) */
+       TAILQ_FOREACH(hint, &dcp->c_hintlist, dh_link) {
+               if (hint == relhint) {
+                       TAILQ_REMOVE(&dcp->c_hintlist, relhint, dh_link);
+                       --dcp->c_dirhintcnt;
+                       break;
+               }
+       }

        name = relhint->dh_desc.cd_nameptr;
        name = relhint->dh_desc.cd_nameptr;

-       if (name != NULL) {
+       if ((relhint->dh_desc.cd_flags & CD_HASBUF) && (name != NULL)) {

                relhint->dh_desc.cd_nameptr = NULL;
                relhint->dh_desc.cd_nameptr = NULL;

-               vfs_removename(name);
+               relhint->dh_desc.cd_namelen = 0;
+               relhint->dh_desc.cd_flags &= ~CD_HASBUF;
+               vfs_removename((const char *)name);

        }
        FREE_ZONE(relhint, sizeof(directoryhint_t), M_HFSDIRHINT);
        }
        FREE_ZONE(relhint, sizeof(directoryhint_t), M_HFSDIRHINT);

-       --dcp->c_dirhintcnt;

 }
 
 /*
 }
 
 /*


@@ -1627,7 +1730,7 @@ hfs_reldirhints(struct cnode *dcp, int stale_hints_only)
 {
        struct timeval tv;
        directoryhint_t *hint, *prev;
 {
        struct timeval tv;
        directoryhint_t *hint, *prev;

-       char * name;
+       const u_int8_t * name;

 
        if (stale_hints_only)
                microuptime(&tv);
 
        if (stale_hints_only)
                microuptime(&tv);


@@ -1637,9 +1740,11 @@ hfs_reldirhints(struct cnode *dcp, int stale_hints_only)
                if (stale_hints_only && (tv.tv_sec - hint->dh_time) < HFS_DIRHINT_TTL)
                        break;  /* stop here if this entry is too new */
                name = hint->dh_desc.cd_nameptr;
                if (stale_hints_only && (tv.tv_sec - hint->dh_time) < HFS_DIRHINT_TTL)
                        break;  /* stop here if this entry is too new */
                name = hint->dh_desc.cd_nameptr;

-               if (name != NULL) {
+               if ((hint->dh_desc.cd_flags & CD_HASBUF) && (name != NULL)) {

                        hint->dh_desc.cd_nameptr = NULL;
                        hint->dh_desc.cd_nameptr = NULL;

-                       vfs_removename(name);
+                       hint->dh_desc.cd_namelen = 0;
+                       hint->dh_desc.cd_flags &= ~CD_HASBUF;
+                       vfs_removename((const char *)name);

                }
                prev = TAILQ_PREV(hint, hfs_hinthead, dh_link); /* must save this pointer before calling FREE_ZONE on this node */
                TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);
                }
                prev = TAILQ_PREV(hint, hfs_hinthead, dh_link); /* must save this pointer before calling FREE_ZONE on this node */
                TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);


@@ -1648,6 +1753,25 @@ hfs_reldirhints(struct cnode *dcp, int stale_hints_only)
        }
 }
 
        }
 }
 

+/*
+ * Insert a detached directory hint back into the list of dirhints.
+ *
+ * Requires an exclusive lock on directory cnode.
+ */
+__private_extern__
+void
+hfs_insertdirhint(struct cnode *dcp, directoryhint_t * hint)
+{
+       directoryhint_t *test;
+
+       TAILQ_FOREACH(test, &dcp->c_hintlist, dh_link) {
+               if (test == hint)
+                       panic("hfs_insertdirhint: hint %p already on list!", hint);
+       }
+
+       TAILQ_INSERT_HEAD(&dcp->c_hintlist, hint, dh_link);
+       ++dcp->c_dirhintcnt;
+}

 
 /*
  * Perform a case-insensitive compare of two UTF-8 filenames.
 
 /*
  * Perform a case-insensitive compare of two UTF-8 filenames.


@@ -1656,7 +1780,7 @@ hfs_reldirhints(struct cnode *dcp, int stale_hints_only)
  */
 __private_extern__
 int
  */
 __private_extern__
 int

-hfs_namecmp(const char *str1, size_t len1, const char *str2, size_t len2)
+hfs_namecmp(const u_int8_t *str1, size_t len1, const u_int8_t *str2, size_t len2)

 {
        u_int16_t *ustr1, *ustr2;
        size_t ulen1, ulen2;
 {
        u_int16_t *ustr1, *ustr2;
        size_t ulen1, ulen2;


@@ -1682,6 +1806,133 @@ out:
 }
 
 
 }
 
 

+typedef struct jopen_cb_info {
+       off_t   jsize;
+       char   *desired_uuid;
+        struct  vnode *jvp;
+       size_t  blksize;
+       int     need_clean;
+       int     need_init;
+} jopen_cb_info;
+
+static int
+journal_open_cb(const char *bsd_dev_name, const char *uuid_str, void *arg)
+{
+       struct nameidata nd;
+       jopen_cb_info *ji = (jopen_cb_info *)arg;
+       char bsd_name[256];
+       int error;
+       
+       strlcpy(&bsd_name[0], "/dev/", sizeof(bsd_name));
+       strlcpy(&bsd_name[5], bsd_dev_name, sizeof(bsd_name)-5);
+
+       if (ji->desired_uuid && ji->desired_uuid[0] && strcmp(uuid_str, ji->desired_uuid) != 0) {
+               return 1;   // keep iterating
+       }
+
+       // if we're here, either the desired uuid matched or there was no
+       // desired uuid so let's try to open the device for writing and
+       // see if it works.  if it does, we'll use it.
+       
+       NDINIT(&nd, LOOKUP, LOCKLEAF, UIO_SYSSPACE32, CAST_USER_ADDR_T(bsd_name), vfs_context_kernel());
+       if ((error = namei(&nd))) {
+               printf("hfs: journal open cb: error %d looking up device %s (dev uuid %s)\n", error, bsd_name, uuid_str);
+               return 1;   // keep iterating
+       }
+
+       ji->jvp = nd.ni_vp;
+       nameidone(&nd);
+
+       if (ji->jvp == NULL) {
+               printf("hfs: journal open cb: did not find %s (error %d)\n", bsd_name, error);
+       } else {
+               error = VNOP_OPEN(ji->jvp, FREAD|FWRITE, vfs_context_kernel());
+               if (error == 0) {
+                       // if the journal is dirty and we didn't specify a desired
+                       // journal device uuid, then do not use the journal.  but
+                       // if the journal is just invalid (e.g. it hasn't been
+                       // initialized) then just set the need_init flag.
+                       if (ji->need_clean && ji->desired_uuid && ji->desired_uuid[0] == '\0') {
+                               error = journal_is_clean(ji->jvp, 0, ji->jsize, (void *)1, ji->blksize);
+                               if (error == EBUSY) {
+                                       VNOP_CLOSE(ji->jvp, FREAD|FWRITE, vfs_context_kernel());
+                                       vnode_put(ji->jvp);
+                                       ji->jvp = NULL;
+                                       return 1;    // keep iterating
+                               } else if (error == EINVAL) {
+                                       ji->need_init = 1;
+                               }
+                       }
+
+                       if (ji->desired_uuid && ji->desired_uuid[0] == '\0') {
+                               strlcpy(ji->desired_uuid, uuid_str, 128);
+                       }
+                       vnode_setmountedon(ji->jvp);
+                       // printf("hfs: journal open cb: got device %s (%s)\n", bsd_name, uuid_str);
+                       return 0;   // stop iterating
+               } else {
+                       vnode_put(ji->jvp);
+                       ji->jvp = NULL;
+               }
+       }
+
+       return 1;   // keep iterating
+}
+
+extern dev_t IOBSDGetMediaWithUUID(const char *uuid_cstring, char *bsd_name, int bsd_name_len, int timeout);
+extern void IOBSDIterateMediaWithContent(const char *uuid_cstring, int (*func)(const char *bsd_dev_name, const char *uuid_str, void *arg), void *arg);
+extern kern_return_t IOBSDGetPlatformUUID(__darwin_uuid_t uuid, mach_timespec_t timeoutp);
+kern_return_t IOBSDGetPlatformSerialNumber(char *serial_number_str, u_int32_t len);
+
+
+static vnode_t
+open_journal_dev(const char *vol_device,
+                int need_clean,
+                char *uuid_str,
+                char *machine_serial_num,
+                off_t jsize,
+                size_t blksize,
+                int *need_init)
+{
+    int retry_counter=0;
+    jopen_cb_info ji;
+
+    ji.jsize        = jsize;
+    ji.desired_uuid = uuid_str;
+    ji.jvp          = NULL;
+    ji.blksize      = blksize;
+    ji.need_clean   = need_clean;
+    ji.need_init    = 0;
+
+//    if (uuid_str[0] == '\0') {
+//         printf("hfs: open journal dev: %s: locating any available non-dirty external journal partition\n", vol_device);
+//    } else {
+//         printf("hfs: open journal dev: %s: trying to find the external journal partition w/uuid %s\n", vol_device, uuid_str);
+//    }
+    while (ji.jvp == NULL && retry_counter++ < 4) {
+           if (retry_counter > 1) {
+                   if (uuid_str[0]) {
+                           printf("hfs: open_journal_dev: uuid %s not found.  waiting 10sec.\n", uuid_str);
+                   } else {
+                           printf("hfs: open_journal_dev: no available external journal partition found.  waiting 10sec.\n");
+                   }
+                   delay_for_interval(10* 1000000, NSEC_PER_USEC);    // wait for ten seconds and then try again
+           }
+
+           IOBSDIterateMediaWithContent(EXTJNL_CONTENT_TYPE_UUID, journal_open_cb, &ji);
+    }
+
+    if (ji.jvp == NULL) {
+           printf("hfs: volume: %s: did not find jnl device uuid: %s from machine serial number: %s\n",
+                  vol_device, uuid_str, machine_serial_num);
+    }
+
+    *need_init = ji.need_init;
+
+    return ji.jvp;
+}
+
+

 __private_extern__
 int
 hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
 __private_extern__
 int
 hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,


@@ -1691,11 +1942,20 @@ hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
        JournalInfoBlock *jibp;
        struct buf       *jinfo_bp, *bp;
        int               sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;
        JournalInfoBlock *jibp;
        struct buf       *jinfo_bp, *bp;
        int               sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;

-       int               retval, blksize = hfsmp->hfs_phys_block_size;
+       int               retval, write_jibp = 0;
+       uint32_t                  blksize = hfsmp->hfs_logical_block_size;

        struct vnode     *devvp;
        struct hfs_mount_args *args = _args;
        struct vnode     *devvp;
        struct hfs_mount_args *args = _args;

-
+       u_int32_t         jib_flags;
+       u_int64_t         jib_offset;
+       u_int64_t         jib_size;
+       const char *dev_name;
+       

        devvp = hfsmp->hfs_devvp;
        devvp = hfsmp->hfs_devvp;

+       dev_name = vnode_name(devvp);
+       if (dev_name == NULL) {
+               dev_name = "unknown-dev";
+       }

 
        if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS)) {
                arg_flags  = args->journal_flags;
 
        if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS)) {
                arg_flags  = args->journal_flags;


@@ -1704,36 +1964,93 @@ hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
 
        sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / blksize;
                                
 
        sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / blksize;
                                

+       jinfo_bp = NULL;

        retval = (int)buf_meta_bread(devvp,
                                                (daddr64_t)((embeddedOffset/blksize) + 
        retval = (int)buf_meta_bread(devvp,
                                                (daddr64_t)((embeddedOffset/blksize) + 

-                                               (SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock)),
-                                               SWAP_BE32(vhp->blockSize), cred, &jinfo_bp);
-       if (retval)
+                                               ((u_int64_t)SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock)),
+                                               hfsmp->hfs_physical_block_size, cred, &jinfo_bp);
+       if (retval) {
+               if (jinfo_bp) {
+                       buf_brelse(jinfo_bp);
+               }

                return retval;
                return retval;

-
+       }
+       

        jibp = (JournalInfoBlock *)buf_dataptr(jinfo_bp);
        jibp = (JournalInfoBlock *)buf_dataptr(jinfo_bp);

-       jibp->flags  = SWAP_BE32(jibp->flags);
-       jibp->offset = SWAP_BE64(jibp->offset);
-       jibp->size   = SWAP_BE64(jibp->size);
+       jib_flags  = SWAP_BE32(jibp->flags);
+       jib_size   = SWAP_BE64(jibp->size);

 
 

-       if (jibp->flags & kJIJournalInFSMask) {
+       if (jib_flags & kJIJournalInFSMask) {

                hfsmp->jvp = hfsmp->hfs_devvp;
                hfsmp->jvp = hfsmp->hfs_devvp;

+               jib_offset = SWAP_BE64(jibp->offset);

        } else {
        } else {

-               printf("hfs: journal not stored in fs! don't know what to do.\n");
+           int need_init=0;
+       
+           // if the volume was unmounted cleanly then we'll pick any
+           // available external journal partition
+           //
+           if (SWAP_BE32(vhp->attributes) & kHFSVolumeUnmountedMask) {
+                   *((char *)&jibp->ext_jnl_uuid[0]) = '\0';
+           }
+
+           hfsmp->jvp = open_journal_dev(dev_name,
+                                         !(jib_flags & kJIJournalNeedInitMask),
+                                         (char *)&jibp->ext_jnl_uuid[0],
+                                         (char *)&jibp->machine_serial_num[0],
+                                         jib_size,
+                                         hfsmp->hfs_logical_block_size,
+                                         &need_init);
+           if (hfsmp->jvp == NULL) {

                buf_brelse(jinfo_bp);
                buf_brelse(jinfo_bp);

-               return EINVAL;
+               return EROFS;
+           } else {
+                   if (IOBSDGetPlatformSerialNumber(&jibp->machine_serial_num[0], sizeof(jibp->machine_serial_num)) != KERN_SUCCESS) {
+                           strlcpy(&jibp->machine_serial_num[0], "unknown-machine-uuid", sizeof(jibp->machine_serial_num));
+                   }
+           }
+
+           jib_offset = 0;
+           write_jibp = 1;
+           if (need_init) {
+                   jib_flags |= kJIJournalNeedInitMask;
+           }

        }
 
        // save this off for the hack-y check in hfs_remove()
        }
 
        // save this off for the hack-y check in hfs_remove()

-       hfsmp->jnl_start = jibp->offset / SWAP_BE32(vhp->blockSize);
-       hfsmp->jnl_size  = jibp->size;
+       hfsmp->jnl_start = jib_offset / SWAP_BE32(vhp->blockSize);
+       hfsmp->jnl_size  = jib_size;
+
+       if ((hfsmp->hfs_flags & HFS_READ_ONLY) && (vfs_flags(hfsmp->hfs_mp) & MNT_ROOTFS) == 0) {
+           // if the file system is read-only, check if the journal is empty.
+           // if it is, then we can allow the mount.  otherwise we have to
+           // return failure.
+           retval = journal_is_clean(hfsmp->jvp,
+                                     jib_offset + embeddedOffset,
+                                     jib_size,
+                                     devvp,
+                                     hfsmp->hfs_logical_block_size);
+
+           hfsmp->jnl = NULL;
+
+           buf_brelse(jinfo_bp);
+
+           if (retval) {
+               const char *name = vnode_getname(devvp);
+             printf("hfs: early journal init: volume on %s is read-only and journal is dirty.  Can not mount volume.\n",
+                     name ? name : "");
+               if (name)
+                       vnode_putname(name);
+           }
+
+           return retval;
+       }

 
 

-       if (jibp->flags & kJIJournalNeedInitMask) {
+       if (jib_flags & kJIJournalNeedInitMask) {

                printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",
                printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",

-                          jibp->offset + embeddedOffset, jibp->size);
+                          jib_offset + embeddedOffset, jib_size);

                hfsmp->jnl = journal_create(hfsmp->jvp,
                hfsmp->jnl = journal_create(hfsmp->jvp,

-                                                                       jibp->offset + embeddedOffset,
-                                                                       jibp->size,
+                                                                       jib_offset + embeddedOffset,
+                                                                       jib_size,

                                                                        devvp,
                                                                        blksize,
                                                                        arg_flags,
                                                                        devvp,
                                                                        blksize,
                                                                        arg_flags,


@@ -1742,28 +2059,30 @@ hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
 
                // no need to start a transaction here... if this were to fail
                // we'd just re-init it on the next mount.
 
                // no need to start a transaction here... if this were to fail
                // we'd just re-init it on the next mount.

-               jibp->flags &= ~kJIJournalNeedInitMask;
-               jibp->flags  = SWAP_BE32(jibp->flags);
-               jibp->offset = SWAP_BE64(jibp->offset);
-               jibp->size   = SWAP_BE64(jibp->size);
+               jib_flags &= ~kJIJournalNeedInitMask;
+               jibp->flags  = SWAP_BE32(jib_flags);

                buf_bwrite(jinfo_bp);
                jinfo_bp = NULL;
                jibp     = NULL;
        } else { 
                //printf("hfs: Opening the journal (joffset 0x%llx sz 0x%llx vhp_blksize %d)...\n",
                buf_bwrite(jinfo_bp);
                jinfo_bp = NULL;
                jibp     = NULL;
        } else { 
                //printf("hfs: Opening the journal (joffset 0x%llx sz 0x%llx vhp_blksize %d)...\n",

-               //         jibp->offset + embeddedOffset,
-               //         jibp->size, SWAP_BE32(vhp->blockSize));
+               //         jib_offset + embeddedOffset,
+               //         jib_size, SWAP_BE32(vhp->blockSize));

                                
                hfsmp->jnl = journal_open(hfsmp->jvp,
                                
                hfsmp->jnl = journal_open(hfsmp->jvp,

-                                                                 jibp->offset + embeddedOffset,
-                                                                 jibp->size,
+                                                                 jib_offset + embeddedOffset,
+                                                                 jib_size,

                                                                  devvp,
                                                                  blksize,
                                                                  arg_flags,
                                                                  arg_tbufsz,
                                                                  hfs_sync_metadata, hfsmp->hfs_mp);
 
                                                                  devvp,
                                                                  blksize,
                                                                  arg_flags,
                                                                  arg_tbufsz,
                                                                  hfs_sync_metadata, hfsmp->hfs_mp);
 

-               buf_brelse(jinfo_bp);
+               if (write_jibp) {
+                       buf_bwrite(jinfo_bp);
+               } else {
+                       buf_brelse(jinfo_bp);
+               }

                jinfo_bp = NULL;
                jibp     = NULL;
 
                jinfo_bp = NULL;
                jibp     = NULL;
 


@@ -1773,14 +2092,19 @@ hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
                        if (mdb_offset == 0) {
                                mdb_offset = (daddr64_t)((embeddedOffset / blksize) + HFS_PRI_SECTOR(blksize));
                        }
                        if (mdb_offset == 0) {
                                mdb_offset = (daddr64_t)((embeddedOffset / blksize) + HFS_PRI_SECTOR(blksize));
                        }

-                       retval = (int)buf_meta_bread(devvp, mdb_offset, blksize, cred, &bp);
+                       bp = NULL;
+                       retval = (int)buf_meta_bread(devvp, 
+                                       HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
+                                       hfsmp->hfs_physical_block_size, cred, &bp);

                        if (retval) {
                        if (retval) {

-                               buf_brelse(bp);
+                               if (bp) {
+                                       buf_brelse(bp);
+                               }

                                printf("hfs: failed to reload the mdb after opening the journal (retval %d)!\n",
                                           retval);
                                return retval;
                        }
                                printf("hfs: failed to reload the mdb after opening the journal (retval %d)!\n",
                                           retval);
                                return retval;
                        }

-                       bcopy((char *)buf_dataptr(bp) + HFS_PRI_OFFSET(blksize), mdbp, 512);
+                       bcopy((char *)buf_dataptr(bp) + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size), mdbp, 512);

                        buf_brelse(bp);
                        bp = NULL;
                }
                        buf_brelse(bp);
                        bp = NULL;
                }


@@ -1818,15 +2142,18 @@ static int
 hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args)
 {
        JournalInfoBlock *jibp;
 hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args)
 {
        JournalInfoBlock *jibp;

-       struct buf       *jinfo_bp, *bp;
+       struct buf       *jinfo_bp;

        int               sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;
        int               sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;

-       int               retval, need_flush = 0, write_jibp = 0;
+       int               retval, write_jibp = 0, recreate_journal = 0;

        struct vnode     *devvp;
        struct cat_attr   jib_attr, jattr;
        struct cat_fork   jib_fork, jfork;
        ExtendedVCB      *vcb;
        struct vnode     *devvp;
        struct cat_attr   jib_attr, jattr;
        struct cat_fork   jib_fork, jfork;
        ExtendedVCB      *vcb;

-       u_long            fid;
+       u_int32_t            fid;

        struct hfs_mount_args *args = _args;
        struct hfs_mount_args *args = _args;

+       u_int32_t         jib_flags;
+       u_int64_t         jib_offset;
+       u_int64_t         jib_size;

        
        devvp = hfsmp->hfs_devvp;
        vcb = HFSTOVCB(hfsmp);
        
        devvp = hfsmp->hfs_devvp;
        vcb = HFSTOVCB(hfsmp);


@@ -1856,24 +2183,29 @@ hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_a
 
                vcb->vcbJinfoBlock    = jib_fork.cf_extents[0].startBlock;
                vhp->journalInfoBlock = SWAP_BE32(jib_fork.cf_extents[0].startBlock);
 
                vcb->vcbJinfoBlock    = jib_fork.cf_extents[0].startBlock;
                vhp->journalInfoBlock = SWAP_BE32(jib_fork.cf_extents[0].startBlock);

+               recreate_journal = 1;

        }
 
 
        }
 
 

-       sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / hfsmp->hfs_phys_block_size;
+       sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / hfsmp->hfs_logical_block_size;
+       jinfo_bp = NULL;

        retval = (int)buf_meta_bread(devvp,
        retval = (int)buf_meta_bread(devvp,

-                                               (daddr64_t)(vcb->hfsPlusIOPosOffset / hfsmp->hfs_phys_block_size + 
-                                               (SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock)),
-                                               SWAP_BE32(vhp->blockSize), NOCRED, &jinfo_bp);
+                                               (vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size + 
+                                               ((u_int64_t)SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock)),
+                                               hfsmp->hfs_physical_block_size, NOCRED, &jinfo_bp);

        if (retval) {
        if (retval) {

+               if (jinfo_bp) {
+                       buf_brelse(jinfo_bp);
+               }

                printf("hfs: can't read journal info block. disabling journaling.\n");
                vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
                return 0;
        }
 
        jibp = (JournalInfoBlock *)buf_dataptr(jinfo_bp);
                printf("hfs: can't read journal info block. disabling journaling.\n");
                vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
                return 0;
        }
 
        jibp = (JournalInfoBlock *)buf_dataptr(jinfo_bp);

-       jibp->flags  = SWAP_BE32(jibp->flags);
-       jibp->offset = SWAP_BE64(jibp->offset);
-       jibp->size   = SWAP_BE64(jibp->size);
+       jib_flags  = SWAP_BE32(jibp->flags);
+       jib_offset = SWAP_BE64(jibp->offset);
+       jib_size   = SWAP_BE64(jibp->size);

 
        fid = GetFileInfo(vcb, kRootDirID, ".journal", &jattr, &jfork);
        if (fid == 0 || jfork.cf_extents[0].startBlock == 0 || jfork.cf_size == 0) {
 
        fid = GetFileInfo(vcb, kRootDirID, ".journal", &jattr, &jfork);
        if (fid == 0 || jfork.cf_extents[0].startBlock == 0 || jfork.cf_size == 0) {


@@ -1886,50 +2218,108 @@ hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_a
        hfsmp->hfs_jnlfileid = fid;
 
        // make sure the journal file begins where we think it should.
        hfsmp->hfs_jnlfileid = fid;
 
        // make sure the journal file begins where we think it should.

-       if ((jibp->offset / (u_int64_t)vcb->blockSize) != jfork.cf_extents[0].startBlock) {
+       if ((jib_flags & kJIJournalInFSMask) && (jib_offset / (u_int64_t)vcb->blockSize) != jfork.cf_extents[0].startBlock) {

                printf("hfs: The journal file moved (was: %lld; is: %d).  Fixing up\n",
                printf("hfs: The journal file moved (was: %lld; is: %d).  Fixing up\n",

-                          (jibp->offset / (u_int64_t)vcb->blockSize), jfork.cf_extents[0].startBlock);
+                          (jib_offset / (u_int64_t)vcb->blockSize), jfork.cf_extents[0].startBlock);

 
 

-               jibp->offset = (u_int64_t)jfork.cf_extents[0].startBlock * (u_int64_t)vcb->blockSize;
+               jib_offset = (u_int64_t)jfork.cf_extents[0].startBlock * (u_int64_t)vcb->blockSize;

                write_jibp   = 1;
                write_jibp   = 1;

+               recreate_journal = 1;

        }
 
        // check the size of the journal file.
        }
 
        // check the size of the journal file.

-       if (jibp->size != (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize) {
+       if (jib_size != (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize) {

                printf("hfs: The journal file changed size! (was %lld; is %lld).  Fixing up.\n",
                printf("hfs: The journal file changed size! (was %lld; is %lld).  Fixing up.\n",

-                          jibp->size, (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize);
+                          jib_size, (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize);

                
                

-               jibp->size = (u_int64_t)jfork.cf_extents[0].blockCount * vcb->blockSize;
+               jib_size = (u_int64_t)jfork.cf_extents[0].blockCount * vcb->blockSize;

                write_jibp = 1;
                write_jibp = 1;

+               recreate_journal = 1;

        }
        
        }
        

-       if (jibp->flags & kJIJournalInFSMask) {
+       if (jib_flags & kJIJournalInFSMask) {

                hfsmp->jvp = hfsmp->hfs_devvp;
                hfsmp->jvp = hfsmp->hfs_devvp;

+               jib_offset += (off_t)vcb->hfsPlusIOPosOffset;

        } else {
        } else {

-               printf("hfs: journal not stored in fs! don't know what to do.\n");
+           const char *dev_name;
+           int need_init = 0;
+
+           dev_name = vnode_name(devvp);
+           if (dev_name == NULL) {
+                   dev_name = "unknown-dev";
+           }
+
+            // since the journal is empty, just use any available external journal
+           *((char *)&jibp->ext_jnl_uuid[0]) = '\0';
+
+           // this fills in the uuid of the device we actually get
+           hfsmp->jvp = open_journal_dev(dev_name,
+                                         !(jib_flags & kJIJournalNeedInitMask),
+                                         (char *)&jibp->ext_jnl_uuid[0],
+                                         (char *)&jibp->machine_serial_num[0],
+                                         jib_size,
+                                         hfsmp->hfs_logical_block_size,
+                                         &need_init);
+           if (hfsmp->jvp == NULL) {

                buf_brelse(jinfo_bp);
                buf_brelse(jinfo_bp);

-               return EINVAL;
+               return EROFS;
+           } else {
+                   if (IOBSDGetPlatformSerialNumber(&jibp->machine_serial_num[0], sizeof(jibp->machine_serial_num)) != KERN_SUCCESS) {
+                           strlcpy(&jibp->machine_serial_num[0], "unknown-machine-serial-num", sizeof(jibp->machine_serial_num));
+                   }
+           } 
+           jib_offset = 0;
+           recreate_journal = 1;
+           write_jibp = 1;
+           if (need_init) {
+                   jib_flags |= kJIJournalNeedInitMask;
+           }

        }
 
        // save this off for the hack-y check in hfs_remove()
        }
 
        // save this off for the hack-y check in hfs_remove()

-       hfsmp->jnl_start = jibp->offset / SWAP_BE32(vhp->blockSize);
-       hfsmp->jnl_size  = jibp->size;
+       hfsmp->jnl_start = jib_offset / SWAP_BE32(vhp->blockSize);
+       hfsmp->jnl_size  = jib_size;
+
+       if ((hfsmp->hfs_flags & HFS_READ_ONLY) && (vfs_flags(hfsmp->hfs_mp) & MNT_ROOTFS) == 0) {
+           // if the file system is read-only, check if the journal is empty.
+           // if it is, then we can allow the mount.  otherwise we have to
+           // return failure.
+           retval = journal_is_clean(hfsmp->jvp,
+                                     jib_offset,
+                                     jib_size,
+                                     devvp,
+                                     hfsmp->hfs_logical_block_size);
+
+           hfsmp->jnl = NULL;

 
 

-       if (jibp->flags & kJIJournalNeedInitMask) {
+           buf_brelse(jinfo_bp);
+
+           if (retval) {
+               const char *name = vnode_getname(devvp);
+             printf("hfs: late journal init: volume on %s is read-only and journal is dirty.  Can not mount volume.\n",
+                    name ? name : "");
+               if (name)
+                       vnode_putname(name);
+           }
+
+           return retval;
+       }
+
+       if ((jib_flags & kJIJournalNeedInitMask) || recreate_journal) {

                printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",
                printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",

-                          jibp->offset + (off_t)vcb->hfsPlusIOPosOffset, jibp->size);
+                          jib_offset, jib_size);

                hfsmp->jnl = journal_create(hfsmp->jvp,
                hfsmp->jnl = journal_create(hfsmp->jvp,

-                                                                       jibp->offset + (off_t)vcb->hfsPlusIOPosOffset,
-                                                                       jibp->size,
+                                                                       jib_offset,
+                                                                       jib_size,

                                                                        devvp,
                                                                        devvp,

-                                                                       hfsmp->hfs_phys_block_size,
+                                                                       hfsmp->hfs_logical_block_size,

                                                                        arg_flags,
                                                                        arg_tbufsz,
                                                                        hfs_sync_metadata, hfsmp->hfs_mp);
 
                // no need to start a transaction here... if this were to fail
                // we'd just re-init it on the next mount.
                                                                        arg_flags,
                                                                        arg_tbufsz,
                                                                        hfs_sync_metadata, hfsmp->hfs_mp);
 
                // no need to start a transaction here... if this were to fail
                // we'd just re-init it on the next mount.

-               jibp->flags &= ~kJIJournalNeedInitMask;
+               jib_flags &= ~kJIJournalNeedInitMask;

                write_jibp   = 1;
 
        } else { 
                write_jibp   = 1;
 
        } else { 


@@ -1944,14 +2334,14 @@ hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_a
                arg_flags |= JOURNAL_RESET;
                
                //printf("hfs: Opening the journal (joffset 0x%llx sz 0x%llx vhp_blksize %d)...\n",
                arg_flags |= JOURNAL_RESET;
                
                //printf("hfs: Opening the journal (joffset 0x%llx sz 0x%llx vhp_blksize %d)...\n",

-               //         jibp->offset + (off_t)vcb->hfsPlusIOPosOffset,
-               //         jibp->size, SWAP_BE32(vhp->blockSize));
+               //         jib_offset,
+               //         jib_size, SWAP_BE32(vhp->blockSize));

                                
                hfsmp->jnl = journal_open(hfsmp->jvp,
                                
                hfsmp->jnl = journal_open(hfsmp->jvp,

-                                                                 jibp->offset + (off_t)vcb->hfsPlusIOPosOffset,
-                                                                 jibp->size,
+                                                                 jib_offset,
+                                                                 jib_size,

                                                                  devvp,
                                                                  devvp,

-                                                                 hfsmp->hfs_phys_block_size,
+                                                                 hfsmp->hfs_logical_block_size,

                                                                  arg_flags,
                                                                  arg_tbufsz,
                                                                  hfs_sync_metadata, hfsmp->hfs_mp);
                                                                  arg_flags,
                                                                  arg_tbufsz,
                                                                  hfs_sync_metadata, hfsmp->hfs_mp);


@@ -1959,9 +2349,9 @@ hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_a
                        
 
        if (write_jibp) {
                        
 
        if (write_jibp) {

-               jibp->flags  = SWAP_BE32(jibp->flags);
-               jibp->offset = SWAP_BE64(jibp->offset);
-               jibp->size   = SWAP_BE64(jibp->size);
+               jibp->flags  = SWAP_BE32(jib_flags);
+               jibp->offset = SWAP_BE64(jib_offset);
+               jibp->size   = SWAP_BE64(jib_size);

 
                buf_bwrite(jinfo_bp);
        } else {
 
                buf_bwrite(jinfo_bp);
        } else {


@@ -1970,7 +2360,7 @@ hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_a
        jinfo_bp = NULL;
        jibp     = NULL;
 
        jinfo_bp = NULL;
        jibp     = NULL;
 

-       //printf("journal @ 0x%x\n", hfsmp->jnl);
+       //printf("hfs: journal @ 0x%x\n", hfsmp->jnl);

        
        // if we expected the journal to be there and we couldn't
        // create it or open it then we have to bail out.
        
        // if we expected the journal to be there and we couldn't
        // create it or open it then we have to bail out.


@@ -2020,7 +2410,7 @@ hfs_metadatazone_init(struct hfsmount *hfsmp)
        u_int64_t  temp;
        u_int64_t  filesize;
        u_int32_t  blk;
        u_int64_t  temp;
        u_int64_t  filesize;
        u_int32_t  blk;

-       int  items;
+       int  items, really_do_it=1;

 
        vcb = HFSTOVCB(hfsmp);
        fs_size = (u_int64_t)vcb->blockSize * (u_int64_t)vcb->totalBlocks;
 
        vcb = HFSTOVCB(hfsmp);
        fs_size = (u_int64_t)vcb->blockSize * (u_int64_t)vcb->totalBlocks;


@@ -2028,50 +2418,65 @@ hfs_metadatazone_init(struct hfsmount *hfsmp)
        /*
         * For volumes less than 10 GB, don't bother.
         */
        /*
         * For volumes less than 10 GB, don't bother.
         */

-       if (fs_size < ((u_int64_t)10 * GIGABYTE))
-               return;
+       if (fs_size < ((u_int64_t)10 * GIGABYTE)) {
+               really_do_it = 0;
+       }
+       

        /*
         * Skip non-journaled volumes as well.
         */
        /*
         * Skip non-journaled volumes as well.
         */

-       if (hfsmp->jnl == NULL)
-               return;
+       if (hfsmp->jnl == NULL) {
+               really_do_it = 0;
+       }

 
        /*
 
        /*

-        * Start with allocation bitmap (a fixed size).
+        * Start with space for the boot blocks and Volume Header.
+        * 1536 = byte offset from start of volume to end of volume header:
+        * 1024 bytes is the offset from the start of the volume to the
+        * start of the volume header (defined by the volume format)
+        * + 512 bytes (the size of the volume header).

         */
         */

-       zonesize = roundup(vcb->totalBlocks / 8, vcb->vcbVBMIOSize);
-
+       zonesize = roundup(1536, hfsmp->blockSize);
+       

        /*
        /*

-        * Overflow Extents file gets 4 MB per 100 GB.
+        * Add the on-disk size of allocation bitmap.

         */
         */

-       items = fs_size / ((u_int64_t)100 * GIGABYTE);
-       filesize = (u_int64_t)(items + 1) * OVERFLOW_DEFAULT_SIZE;
-       if (filesize > OVERFLOW_MAXIMUM_SIZE)
-               filesize = OVERFLOW_MAXIMUM_SIZE;
-       zonesize += filesize;
-       hfsmp->hfs_overflow_maxblks = filesize / vcb->blockSize;
-
+       zonesize += hfsmp->hfs_allocation_cp->c_datafork->ff_blocks * hfsmp->blockSize;
+       
+       /* 
+        * Add space for the Journal Info Block and Journal (if they're in
+        * this file system).
+        */
+       if (hfsmp->jnl && hfsmp->jvp == hfsmp->hfs_devvp) {
+               zonesize += hfsmp->blockSize + hfsmp->jnl_size;
+       }
+       

        /*
        /*

-        * Plan for at least 8 MB of journal for each
-        * 100 GB of disk space (up to a 512 MB).
+        * Add the existing size of the Extents Overflow B-tree.
+        * (It rarely grows, so don't bother reserving additional room for it.)

         */
         */

-       items = fs_size / ((u_int64_t)100 * GIGABYTE);
-       filesize = (u_int64_t)(items + 1) * JOURNAL_DEFAULT_SIZE;
-       if (filesize > JOURNAL_MAXIMUM_SIZE)
-               filesize = JOURNAL_MAXIMUM_SIZE;
-       zonesize += filesize;
-
+       zonesize += hfsmp->hfs_extents_cp->c_datafork->ff_blocks * hfsmp->blockSize;
+       

        /*
        /*

-        * Catalog file gets 10 MB per 1 GB.
-        *
-        * How about considering the current catalog size (used nodes * node size)
-        * and the current file data size to help estimate the required
-        * catalog size.
+        * If there is an Attributes B-tree, leave room for 11 clumps worth.
+        * newfs_hfs allocates one clump, and leaves a gap of 10 clumps.
+        * When installing a full OS install onto a 20GB volume, we use
+        * 7 to 8 clumps worth of space (depending on packages), so that leaves
+        * us with another 3 or 4 clumps worth before we need another extent.

         */
         */

-       filesize = MIN((fs_size / 1024) * 10, GIGABYTE);
-       hfsmp->hfs_catalog_maxblks = filesize / vcb->blockSize;
-       zonesize += filesize;
-
+       if (hfsmp->hfs_attribute_cp) {
+               zonesize += 11 * hfsmp->hfs_attribute_cp->c_datafork->ff_clumpsize;
+       }
+       
+       /*
+        * Leave room for 11 clumps of the Catalog B-tree.
+        * Again, newfs_hfs allocates one clump plus a gap of 10 clumps.
+        * When installing a full OS install onto a 20GB volume, we use
+        * 7 to 8 clumps worth of space (depending on packages), so that leaves
+        * us with another 3 or 4 clumps worth before we need another extent.
+        */
+       zonesize += 11 * hfsmp->hfs_catalog_cp->c_datafork->ff_clumpsize;
+       

        /*
         * Add space for hot file region.
         *
        /*
         * Add space for hot file region.
         *


@@ -2085,38 +2490,40 @@ hfs_metadatazone_init(struct hfsmount *hfsmp)
        /*
         * Calculate user quota file requirements.
         */
        /*
         * Calculate user quota file requirements.
         */

-       items = QF_USERS_PER_GB * (fs_size / GIGABYTE);
-       if (items < QF_MIN_USERS)
-               items = QF_MIN_USERS;
-       else if (items > QF_MAX_USERS)
-               items = QF_MAX_USERS;
-       if (!powerof2(items)) {
-               int x = items;
-               items = 4;
-               while (x>>1 != 1) {
-                       x = x >> 1;
-                       items = items << 1;
+       if (hfsmp->hfs_flags & HFS_QUOTAS) {
+               items = QF_USERS_PER_GB * (fs_size / GIGABYTE);
+               if (items < QF_MIN_USERS)
+                       items = QF_MIN_USERS;
+               else if (items > QF_MAX_USERS)
+                       items = QF_MAX_USERS;
+               if (!powerof2(items)) {
+                       int x = items;
+                       items = 4;
+                       while (x>>1 != 1) {
+                               x = x >> 1;
+                               items = items << 1;
+                       }

                }
                }

-       }
-       filesize += (items + 1) * sizeof(struct dqblk);
-       /*
-        * Calculate group quota file requirements.
-        *
-        */
-       items = QF_GROUPS_PER_GB * (fs_size / GIGABYTE);
-       if (items < QF_MIN_GROUPS)
-               items = QF_MIN_GROUPS;
-       else if (items > QF_MAX_GROUPS)
-               items = QF_MAX_GROUPS;
-       if (!powerof2(items)) {
-               int x = items;
-               items = 4;
-               while (x>>1 != 1) {
-                       x = x >> 1;
-                       items = items << 1;
+               filesize += (items + 1) * sizeof(struct dqblk);
+               /*
+                * Calculate group quota file requirements.
+                *
+                */
+               items = QF_GROUPS_PER_GB * (fs_size / GIGABYTE);
+               if (items < QF_MIN_GROUPS)
+                       items = QF_MIN_GROUPS;
+               else if (items > QF_MAX_GROUPS)
+                       items = QF_MAX_GROUPS;
+               if (!powerof2(items)) {
+                       int x = items;
+                       items = 4;
+                       while (x>>1 != 1) {
+                               x = x >> 1;
+                               items = items << 1;
+                       }

                }
                }

+               filesize += (items + 1) * sizeof(struct dqblk);

        }
        }

-       filesize += (items + 1) * sizeof(struct dqblk);

        zonesize += filesize;
 
        /*
        zonesize += filesize;
 
        /*


@@ -2124,7 +2531,23 @@ hfs_metadatazone_init(struct hfsmount *hfsmp)
         * The extra space goes to the catalog file and hot file area.
         */
        temp = zonesize;
         * The extra space goes to the catalog file and hot file area.
         */
        temp = zonesize;

-       zonesize = roundup(zonesize, vcb->vcbVBMIOSize * 8 * vcb->blockSize);
+       zonesize = roundup(zonesize, (u_int64_t)vcb->vcbVBMIOSize * 8 * vcb->blockSize);
+       hfsmp->hfs_min_alloc_start = zonesize / vcb->blockSize;
+       /*
+        * If doing the round up for hfs_min_alloc_start would push us past
+        * totalBlocks, then just reset it back to 0.  Though using a value 
+        * bigger than totalBlocks would not cause damage in the block allocator
+        * code, this value could get stored in the volume header and make it out 
+        * to disk, making the volume header technically corrupt.
+        */
+       if (hfsmp->hfs_min_alloc_start >= hfsmp->totalBlocks) {
+               hfsmp->hfs_min_alloc_start = 0;
+       }
+
+       if (really_do_it == 0) {
+               return;
+       }
+       

        temp = zonesize - temp;  /* temp has extra space */
        filesize += temp / 3;
        hfsmp->hfs_catalog_maxblks += (temp - (temp / 3)) / vcb->blockSize;
        temp = zonesize - temp;  /* temp has extra space */
        filesize += temp / 3;
        hfsmp->hfs_catalog_maxblks += (temp - (temp / 3)) / vcb->blockSize;


@@ -2143,9 +2566,9 @@ hfs_metadatazone_init(struct hfsmount *hfsmp)
        hfsmp->hfs_hotfile_end = hfsmp->hfs_metazone_end;
        hfsmp->hfs_hotfile_freeblks = hfs_hotfile_freeblocks(hfsmp);
 #if 0
        hfsmp->hfs_hotfile_end = hfsmp->hfs_metazone_end;
        hfsmp->hfs_hotfile_freeblks = hfs_hotfile_freeblocks(hfsmp);
 #if 0

-       printf("HFS: metadata zone is %d to %d\n", hfsmp->hfs_metazone_start, hfsmp->hfs_metazone_end);
-       printf("HFS: hot file band is %d to %d\n", hfsmp->hfs_hotfile_start, hfsmp->hfs_hotfile_end);
-       printf("HFS: hot file band free blocks = %d\n", hfsmp->hfs_hotfile_freeblks);
+       printf("hfs: metadata zone is %d to %d\n", hfsmp->hfs_metazone_start, hfsmp->hfs_metazone_end);
+       printf("hfs: hot file band is %d to %d\n", hfsmp->hfs_hotfile_start, hfsmp->hfs_hotfile_end);
+       printf("hfs: hot file band free blocks = %d\n", hfsmp->hfs_hotfile_freeblks);

 #endif
        hfsmp->hfs_flags |= HFS_METADATA_ZONE;
 }
 #endif
        hfsmp->hfs_flags |= HFS_METADATA_ZONE;
 }


@@ -2182,37 +2605,115 @@ __private_extern__
 int
 hfs_virtualmetafile(struct cnode *cp)
 {
 int
 hfs_virtualmetafile(struct cnode *cp)
 {

-       char * filename;
+       const char * filename;

 
 
        if (cp->c_parentcnid != kHFSRootFolderID)
                return (0);
 
 
 
        if (cp->c_parentcnid != kHFSRootFolderID)
                return (0);
 

-       filename = cp->c_desc.cd_nameptr;
+       filename = (const char *)cp->c_desc.cd_nameptr;

        if (filename == NULL)
                return (0);
 
        if (filename == NULL)
                return (0);
 

-       if ((strcmp(filename, ".journal") == 0) ||
-           (strcmp(filename, ".journal_info_block") == 0) ||
-           (strcmp(filename, ".quota.user") == 0) ||
-           (strcmp(filename, ".quota.group") == 0) ||
-           (strcmp(filename, ".hotfiles.btree") == 0))
+       if ((strncmp(filename, ".journal", sizeof(".journal")) == 0) ||
+           (strncmp(filename, ".journal_info_block", sizeof(".journal_info_block")) == 0) ||
+           (strncmp(filename, ".quota.user", sizeof(".quota.user")) == 0) ||
+           (strncmp(filename, ".quota.group", sizeof(".quota.group")) == 0) ||
+           (strncmp(filename, ".hotfiles.btree", sizeof(".hotfiles.btree")) == 0))

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

+//
+// Fire off a timed callback to sync the disk if the
+// volume is on ejectable media.
+//
+ __private_extern__
+void
+hfs_sync_ejectable(struct hfsmount *hfsmp)
+{
+       if (hfsmp->hfs_syncer)  {
+               clock_sec_t secs;
+               clock_usec_t usecs;
+               uint64_t now;
+
+               clock_get_calendar_microtime(&secs, &usecs);
+               now = ((uint64_t)secs * 1000000ULL) + (uint64_t)usecs;
+
+               if (hfsmp->hfs_sync_incomplete && hfsmp->hfs_mp->mnt_pending_write_size >= hfsmp->hfs_max_pending_io) {
+                       // if we have a sync scheduled but i/o is starting to pile up,
+                       // don't call thread_call_enter_delayed() again because that
+                       // will defer the sync.
+                       return;
+               }
+
+               if (hfsmp->hfs_sync_scheduled == 0) {
+                       uint64_t deadline;
+
+                       hfsmp->hfs_last_sync_request_time = now;
+
+                       clock_interval_to_deadline(HFS_META_DELAY, HFS_MILLISEC_SCALE, &deadline);
+
+                       /*
+                        * Increment hfs_sync_scheduled on the assumption that we're the
+                        * first thread to schedule the timer.  If some other thread beat
+                        * us, then we'll decrement it.  If we *were* the first to
+                        * schedule the timer, then we need to keep track that the
+                        * callback is waiting to complete.
+                        */
+                       OSIncrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_scheduled);
+                       if (thread_call_enter_delayed(hfsmp->hfs_syncer, deadline))
+                               OSDecrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_scheduled);
+                       else
+                               OSIncrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_incomplete);
+               }               
+       }
+}
+
+

 __private_extern__
 int
 hfs_start_transaction(struct hfsmount *hfsmp)
 {
 __private_extern__
 int
 hfs_start_transaction(struct hfsmount *hfsmp)
 {

-    int ret;
+       int ret, unlock_on_err=0;
+       void * thread = current_thread();

 
 

-    if (hfsmp->jnl == NULL || journal_owner(hfsmp->jnl) != current_thread()) {
+#ifdef HFS_CHECK_LOCK_ORDER
+       /*
+        * You cannot start a transaction while holding a system
+        * file lock. (unless the transaction is nested.)
+        */
+       if (hfsmp->jnl && journal_owner(hfsmp->jnl) != thread) {
+               if (hfsmp->hfs_catalog_cp && hfsmp->hfs_catalog_cp->c_lockowner == thread) {
+                       panic("hfs_start_transaction: bad lock order (cat before jnl)\n");
+               }
+               if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == thread) {
+                       panic("hfs_start_transaction: bad lock order (attr before jnl)\n");
+               }
+               if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == thread) {
+                       panic("hfs_start_transaction: bad lock order (ext before jnl)\n");
+               }
+       }
+#endif /* HFS_CHECK_LOCK_ORDER */
+
+    if (hfsmp->jnl == NULL || journal_owner(hfsmp->jnl) != thread) {

        lck_rw_lock_shared(&hfsmp->hfs_global_lock);
        lck_rw_lock_shared(&hfsmp->hfs_global_lock);

+       OSAddAtomic(1, (SInt32 *)&hfsmp->hfs_active_threads);
+       unlock_on_err = 1;

     }
 
     }
 

+       /* If a downgrade to read-only mount is in progress, no other
+        * process than the downgrade process is allowed to modify 
+        * the file system.
+        */
+       if ((hfsmp->hfs_flags & HFS_RDONLY_DOWNGRADE) && 
+                       (hfsmp->hfs_downgrading_proc != thread)) {
+               ret = EROFS;
+               goto out;
+       }
+

     if (hfsmp->jnl) {
        ret = journal_start_transaction(hfsmp->jnl);
        if (ret == 0) {
     if (hfsmp->jnl) {
        ret = journal_start_transaction(hfsmp->jnl);
        if (ret == 0) {


@@ -2222,8 +2723,10 @@ hfs_start_transaction(struct hfsmount *hfsmp)
        ret = 0;
     }
 
        ret = 0;
     }
 

-    if (ret != 0) {
-       lck_rw_done(&hfsmp->hfs_global_lock);
+out:
+    if (ret != 0 && unlock_on_err) {
+       lck_rw_unlock_shared(&hfsmp->hfs_global_lock);
+       OSAddAtomic(-1, (SInt32 *)&hfsmp->hfs_active_threads);

     }
 
     return ret;
     }
 
     return ret;


@@ -2249,8 +2752,102 @@ hfs_end_transaction(struct hfsmount *hfsmp)
     }
 
     if (need_unlock) {
     }
 
     if (need_unlock) {

-       lck_rw_done(&hfsmp->hfs_global_lock);
+       OSAddAtomic(-1, (SInt32 *)&hfsmp->hfs_active_threads);
+       lck_rw_unlock_shared(&hfsmp->hfs_global_lock);
+       hfs_sync_ejectable(hfsmp);

     }
 
     return ret;
 }
     }
 
     return ret;
 }

+
+
+__private_extern__
+int
+hfs_journal_flush(struct hfsmount *hfsmp)
+{
+       int ret;
+
+       if (hfsmp->jnl) {
+               lck_rw_lock_shared(&hfsmp->hfs_global_lock);
+               ret = journal_flush(hfsmp->jnl);
+               lck_rw_unlock_shared(&hfsmp->hfs_global_lock);
+       } else {
+               ret = 0;
+       }
+
+       return ret;
+}
+
+
+/*
+ * hfs_erase_unused_nodes
+ *
+ * Check wheter a volume may suffer from unused Catalog B-tree nodes that
+ * are not zeroed (due to <rdar://problem/6947811>).  If so, just write
+ * zeroes to the unused nodes.
+ *
+ * How do we detect when a volume needs this repair?  We can't always be
+ * certain.  If a volume was created after a certain date, then it may have
+ * been created with the faulty newfs_hfs.  Since newfs_hfs only created one
+ * clump, we can assume that if a Catalog B-tree is larger than its clump size,
+ * that means that the entire first clump must have been written to, which means
+ * there shouldn't be unused and unwritten nodes in that first clump, and this
+ * repair is not needed.
+ *
+ * We have defined a bit in the Volume Header's attributes to indicate when the
+ * unused nodes have been repaired.  A newer newfs_hfs will set this bit.
+ * As will fsck_hfs when it repairs the unused nodes.
+ */
+__private_extern__
+int hfs_erase_unused_nodes(struct hfsmount *hfsmp)
+{
+       int result; 
+       struct filefork *catalog;
+       int lockflags;
+       
+       if (hfsmp->vcbAtrb & kHFSUnusedNodeFixMask)
+       {
+               /* This volume has already been checked and repaired. */
+               return 0;
+       }
+
+       if ((hfsmp->localCreateDate < kHFSUnusedNodesFixDate))
+       {
+               /* This volume is too old to have had the problem. */
+               hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;
+               return 0;
+       }
+
+       catalog = hfsmp->hfs_catalog_cp->c_datafork;
+       if (catalog->ff_size > catalog->ff_clumpsize)
+       {
+               /* The entire first clump must have been in use at some point. */
+               hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;
+               return 0;
+       }
+       
+       /*
+        * If we get here, we need to zero out those unused nodes.
+        *
+        * We start a transaction and lock the catalog since we're going to be
+        * making on-disk changes.  But note that BTZeroUnusedNodes doens't actually
+        * do its writing via the journal, because that would be too much I/O
+        * to fit in a transaction, and it's a pain to break it up into multiple
+        * transactions.  (It behaves more like growing a B-tree would.)
+        */
+       printf("hfs_erase_unused_nodes: updating volume %s.\n", hfsmp->vcbVN);
+       result = hfs_start_transaction(hfsmp);
+       if (result)
+               goto done;
+       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
+       result = BTZeroUnusedNodes(catalog);
+       vnode_waitforwrites(hfsmp->hfs_catalog_vp, 0, 0, 0, "hfs_erase_unused_nodes");
+       hfs_systemfile_unlock(hfsmp, lockflags);
+       hfs_end_transaction(hfsmp);
+       if (result == 0)
+               hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;
+       printf("hfs_erase_unused_nodes: done updating volume %s.\n", hfsmp->vcbVN);
+
+done:
+       return result;
+}