xnu-1504.15.3.tar.gz

[apple/xnu.git] / bsd / hfs / hfscommon / Misc / FileExtentMapping.c

diff --git a/bsd/hfs/hfscommon/Misc/FileExtentMapping.c b/bsd/hfs/hfscommon/Misc/FileExtentMapping.c
index 76c6a407acc48fef35bded000795c49dcef233e2..5d037026bea87ca45d5e11e3c3ca3749d38bc8d6 100644 (file)
--- a/bsd/hfs/hfscommon/Misc/FileExtentMapping.c
+++ b/bsd/hfs/hfscommon/Misc/FileExtentMapping.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2008 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@

  */
 
 
  */
 
 


@@ -91,7 +97,7 @@ Internal Routines:
                                        and was in the extents file, then delete the record instead.
 */
 
                                        and was in the extents file, then delete the record instead.
 */
 

-static const SInt64 kTwoGigabytes = 0x80000000LL;
+static const int64_t kTwoGigabytes = 0x80000000LL;

 
 enum
 {
 
 enum
 {


@@ -108,25 +114,25 @@ static OSErr HFSPlusToHFSExtents(
 
 static OSErr FindExtentRecord(
        const ExtendedVCB               *vcb,
 
 static OSErr FindExtentRecord(
        const ExtendedVCB               *vcb,

-       UInt8                                   forkType,
-       UInt32                                  fileID,
-       UInt32                                  startBlock,
+       u_int8_t                                forkType,
+       u_int32_t                               fileID,
+       u_int32_t                               startBlock,

        Boolean                                 allowPrevious,
        HFSPlusExtentKey                *foundKey,
        HFSPlusExtentRecord             foundData,
        Boolean                                 allowPrevious,
        HFSPlusExtentKey                *foundKey,
        HFSPlusExtentRecord             foundData,

-       UInt32                                  *foundHint);
+       u_int32_t                               *foundHint);

 
 static OSErr DeleteExtentRecord(
        const ExtendedVCB               *vcb,
 
 static OSErr DeleteExtentRecord(
        const ExtendedVCB               *vcb,

-       UInt8                                   forkType,
-       UInt32                                  fileID,
-       UInt32                                  startBlock);
+       u_int8_t                                forkType,
+       u_int32_t                               fileID,
+       u_int32_t                               startBlock);

 
 static OSErr CreateExtentRecord(
        ExtendedVCB             *vcb,
        HFSPlusExtentKey                *key,
        HFSPlusExtentRecord             extents,
 
 static OSErr CreateExtentRecord(
        ExtendedVCB             *vcb,
        HFSPlusExtentKey                *key,
        HFSPlusExtentRecord             extents,

-       UInt32                                  *hint);
+       u_int32_t                               *hint);

 
 
 static OSErr GetFCBExtentRecord(
 
 
 static OSErr GetFCBExtentRecord(


@@ -136,40 +142,40 @@ static OSErr GetFCBExtentRecord(
 static OSErr SearchExtentFile(
        ExtendedVCB             *vcb,
        const FCB                               *fcb,
 static OSErr SearchExtentFile(
        ExtendedVCB             *vcb,
        const FCB                               *fcb,

-       SInt64                                  filePosition,
+       int64_t                                 filePosition,

        HFSPlusExtentKey                *foundExtentKey,
        HFSPlusExtentRecord             foundExtentData,
        HFSPlusExtentKey                *foundExtentKey,
        HFSPlusExtentRecord             foundExtentData,

-       UInt32                                  *foundExtentDataIndex,
-       UInt32                                  *extentBTreeHint,
-       UInt32                                  *endingFABNPlusOne );
+       u_int32_t                               *foundExtentDataIndex,
+       u_int32_t                               *extentBTreeHint,
+       u_int32_t                               *endingFABNPlusOne );

 
 static OSErr SearchExtentRecord(
        ExtendedVCB             *vcb,
 
 static OSErr SearchExtentRecord(
        ExtendedVCB             *vcb,

-       UInt32                                  searchFABN,
+       u_int32_t                               searchFABN,

        const HFSPlusExtentRecord       extentData,
        const HFSPlusExtentRecord       extentData,

-       UInt32                                  extentDataStartFABN,
-       UInt32                                  *foundExtentDataOffset,
-       UInt32                                  *endingFABNPlusOne,
+       u_int32_t                               extentDataStartFABN,
+       u_int32_t                               *foundExtentDataOffset,
+       u_int32_t                               *endingFABNPlusOne,

        Boolean                                 *noMoreExtents);
 
 static OSErr ReleaseExtents(
        ExtendedVCB                             *vcb,
        const HFSPlusExtentRecord       extentRecord,
        Boolean                                 *noMoreExtents);
 
 static OSErr ReleaseExtents(
        ExtendedVCB                             *vcb,
        const HFSPlusExtentRecord       extentRecord,

-       UInt32                                  *numReleasedAllocationBlocks,
+       u_int32_t                               *numReleasedAllocationBlocks,

        Boolean                                 *releasedLastExtent);
 
 static OSErr DeallocateFork(
        ExtendedVCB             *vcb,
        HFSCatalogNodeID        fileID,
        Boolean                                 *releasedLastExtent);
 
 static OSErr DeallocateFork(
        ExtendedVCB             *vcb,
        HFSCatalogNodeID        fileID,

-       UInt8                   forkType,
+       u_int8_t                        forkType,

        HFSPlusExtentRecord     catalogExtents,
        Boolean *               recordDeleted);
 
 static OSErr TruncateExtents(
        ExtendedVCB                     *vcb,
        HFSPlusExtentRecord     catalogExtents,
        Boolean *               recordDeleted);
 
 static OSErr TruncateExtents(
        ExtendedVCB                     *vcb,

-       UInt8                           forkType,
-       UInt32                          fileID,
-       UInt32                          startBlock,
+       u_int8_t                        forkType,
+       u_int32_t                       fileID,
+       u_int32_t                       startBlock,

        Boolean *                       recordDeleted);
 
 static OSErr UpdateExtentRecord (
        Boolean *                       recordDeleted);
 
 static OSErr UpdateExtentRecord (


@@ -177,12 +183,12 @@ static OSErr UpdateExtentRecord (
        FCB                                             *fcb,
        const HFSPlusExtentKey  *extentFileKey,
        const HFSPlusExtentRecord       extentData,
        FCB                                             *fcb,
        const HFSPlusExtentKey  *extentFileKey,
        const HFSPlusExtentRecord       extentData,

-       UInt32                                  extentBTreeHint);
+       u_int32_t                                       extentBTreeHint);

 
 static Boolean ExtentsAreIntegral(
        const HFSPlusExtentRecord extentRecord,
 
 static Boolean ExtentsAreIntegral(
        const HFSPlusExtentRecord extentRecord,

-       UInt32          mask,
-       UInt32          *blocksChecked,
+       u_int32_t       mask,
+       u_int32_t       *blocksChecked,

        Boolean         *checkedLastExtent);
 
 //_________________________________________________________________________________
        Boolean         *checkedLastExtent);
 
 //_________________________________________________________________________________


@@ -209,33 +215,32 @@ static Boolean ExtentsAreIntegral(
 //_________________________________________________________________________________
 static OSErr FindExtentRecord(
        const ExtendedVCB       *vcb,
 //_________________________________________________________________________________
 static OSErr FindExtentRecord(
        const ExtendedVCB       *vcb,

-       UInt8                           forkType,
-       UInt32                          fileID,
-       UInt32                          startBlock,
+       u_int8_t                        forkType,
+       u_int32_t                       fileID,
+       u_int32_t                       startBlock,

        Boolean                         allowPrevious,
        HFSPlusExtentKey        *foundKey,
        HFSPlusExtentRecord     foundData,
        Boolean                         allowPrevious,
        HFSPlusExtentKey        *foundKey,
        HFSPlusExtentRecord     foundData,

-       UInt32                          *foundHint)
+       u_int32_t                       *foundHint)

 {
        FCB *                           fcb;
 {
        FCB *                           fcb;

-       BTreeIterator           *btIterator;
+       BTreeIterator           btIterator;

        FSBufferDescriptor      btRecord;
        OSErr                           err;
        FSBufferDescriptor      btRecord;
        OSErr                           err;

-       UInt16                          btRecordSize;
+       u_int16_t                       btRecordSize;

        
        err = noErr;
        if (foundHint)
                *foundHint = 0;
        fcb = GetFileControlBlock(vcb->extentsRefNum);
        
        
        err = noErr;
        if (foundHint)
                *foundHint = 0;
        fcb = GetFileControlBlock(vcb->extentsRefNum);
        

-       MALLOC(btIterator, BTreeIterator *, sizeof(*btIterator), M_TEMP, M_WAITOK);
-       bzero(btIterator, sizeof(*btIterator));
+       bzero(&btIterator, sizeof(btIterator));

 
        if (vcb->vcbSigWord == kHFSSigWord) {
                HFSExtentKey *          extentKeyPtr;
                HFSExtentRecord         extentData;
 
 
        if (vcb->vcbSigWord == kHFSSigWord) {
                HFSExtentKey *          extentKeyPtr;
                HFSExtentRecord         extentData;
 

-               extentKeyPtr = (HFSExtentKey*) &btIterator->key;
+               extentKeyPtr = (HFSExtentKey*) &btIterator.key;

                extentKeyPtr->keyLength = kHFSExtentKeyMaximumLength;
                extentKeyPtr->forkType = forkType;
                extentKeyPtr->fileID = fileID;
                extentKeyPtr->keyLength = kHFSExtentKeyMaximumLength;
                extentKeyPtr->forkType = forkType;
                extentKeyPtr->fileID = fileID;


@@ -245,10 +250,10 @@ static OSErr FindExtentRecord(
                btRecord.itemSize = sizeof(HFSExtentRecord);
                btRecord.itemCount = 1;
 
                btRecord.itemSize = sizeof(HFSExtentRecord);
                btRecord.itemCount = 1;
 

-               err = BTSearchRecord(fcb, btIterator, &btRecord, &btRecordSize, btIterator);
+               err = BTSearchRecord(fcb, &btIterator, &btRecord, &btRecordSize, &btIterator);

 
                if (err == btNotFound && allowPrevious) {
 
                if (err == btNotFound && allowPrevious) {

-                       err = BTIterateRecord(fcb, kBTreePrevRecord, btIterator, &btRecord, &btRecordSize);
+                       err = BTIterateRecord(fcb, kBTreePrevRecord, &btIterator, &btRecord, &btRecordSize);

 
                        //      A previous record may not exist, so just return btNotFound (like we would if
                        //      it was for the wrong file/fork).
 
                        //      A previous record may not exist, so just return btNotFound (like we would if
                        //      it was for the wrong file/fork).


@@ -263,7 +268,7 @@ static OSErr FindExtentRecord(
                }
 
                if (err == noErr) {
                }
 
                if (err == noErr) {

-                       UInt16  i;
+                       u_int16_t       i;

                        
                        // Copy the found key back for the caller
                        if (foundKey) {
                        
                        // Copy the found key back for the caller
                        if (foundKey) {


@@ -292,7 +297,7 @@ static OSErr FindExtentRecord(
                HFSPlusExtentKey *      extentKeyPtr;
                HFSPlusExtentRecord     extentData;
 
                HFSPlusExtentKey *      extentKeyPtr;
                HFSPlusExtentRecord     extentData;
 

-               extentKeyPtr = (HFSPlusExtentKey*) &btIterator->key;
+               extentKeyPtr = (HFSPlusExtentKey*) &btIterator.key;

                extentKeyPtr->keyLength  = kHFSPlusExtentKeyMaximumLength;
                extentKeyPtr->forkType   = forkType;
                extentKeyPtr->pad                = 0;
                extentKeyPtr->keyLength  = kHFSPlusExtentKeyMaximumLength;
                extentKeyPtr->forkType   = forkType;
                extentKeyPtr->pad                = 0;


@@ -303,10 +308,10 @@ static OSErr FindExtentRecord(
                btRecord.itemSize = sizeof(HFSPlusExtentRecord);
                btRecord.itemCount = 1;
 
                btRecord.itemSize = sizeof(HFSPlusExtentRecord);
                btRecord.itemCount = 1;
 

-               err = BTSearchRecord(fcb, btIterator, &btRecord, &btRecordSize, btIterator);
+               err = BTSearchRecord(fcb, &btIterator, &btRecord, &btRecordSize, &btIterator);

 
                if (err == btNotFound && allowPrevious) {
 
                if (err == btNotFound && allowPrevious) {

-                       err = BTIterateRecord(fcb, kBTreePrevRecord, btIterator, &btRecord, &btRecordSize);
+                       err = BTIterateRecord(fcb, kBTreePrevRecord, &btIterator, &btRecord, &btRecordSize);

 
                        //      A previous record may not exist, so just return btNotFound (like we would if
                        //      it was for the wrong file/fork).
 
                        //      A previous record may not exist, so just return btNotFound (like we would if
                        //      it was for the wrong file/fork).


@@ -330,8 +335,7 @@ static OSErr FindExtentRecord(
        }
 
        if (foundHint)
        }
 
        if (foundHint)

-               *foundHint = btIterator->hint.nodeNum;
-       FREE(btIterator, M_TEMP);       
+               *foundHint = btIterator.hint.nodeNum;

        return err;
 }
 
        return err;
 }
 


@@ -341,19 +345,18 @@ static OSErr CreateExtentRecord(
        ExtendedVCB     *vcb,
        HFSPlusExtentKey        *key,
        HFSPlusExtentRecord     extents,
        ExtendedVCB     *vcb,
        HFSPlusExtentKey        *key,
        HFSPlusExtentRecord     extents,

-       UInt32                          *hint)
+       u_int32_t                       *hint)

 {
 {

-       BTreeIterator * btIterator;
+       BTreeIterator btIterator;

        FSBufferDescriptor      btRecord;
        FSBufferDescriptor      btRecord;

-       UInt16  btRecordSize;
+       u_int16_t  btRecordSize;

        int  lockflags;
        OSErr  err;
        
        err = noErr;
        *hint = 0;
 
        int  lockflags;
        OSErr  err;
        
        err = noErr;
        *hint = 0;
 

-       MALLOC(btIterator, BTreeIterator *, sizeof(*btIterator), M_TEMP, M_WAITOK);
-       bzero(btIterator, sizeof(*btIterator));
+       bzero(&btIterator, sizeof(btIterator));

 
        /*
         * The lock taken by callers of ExtendFileC is speculative and
 
        /*
         * The lock taken by callers of ExtendFileC is speculative and


@@ -373,7 +376,7 @@ static OSErr CreateExtentRecord(
                btRecord.itemSize = btRecordSize;
                btRecord.itemCount = 1;
 
                btRecord.itemSize = btRecordSize;
                btRecord.itemCount = 1;
 

-               keyPtr = (HFSExtentKey*) &btIterator->key;
+               keyPtr = (HFSExtentKey*) &btIterator.key;

                keyPtr->keyLength       = kHFSExtentKeyMaximumLength;
                keyPtr->forkType        = key->forkType;
                keyPtr->fileID          = key->fileID;
                keyPtr->keyLength       = kHFSExtentKeyMaximumLength;
                keyPtr->forkType        = key->forkType;
                keyPtr->fileID          = key->fileID;


@@ -387,42 +390,40 @@ static OSErr CreateExtentRecord(
                btRecord.itemSize = btRecordSize;
                btRecord.itemCount = 1;
 
                btRecord.itemSize = btRecordSize;
                btRecord.itemCount = 1;
 

-               BlockMoveData(key, &btIterator->key, sizeof(HFSPlusExtentKey));
+               BlockMoveData(key, &btIterator.key, sizeof(HFSPlusExtentKey));

        }
 
        if (err == noErr)
        }
 
        if (err == noErr)

-               err = BTInsertRecord(GetFileControlBlock(vcb->extentsRefNum), btIterator, &btRecord, btRecordSize);
+               err = BTInsertRecord(GetFileControlBlock(vcb->extentsRefNum), &btIterator, &btRecord, btRecordSize);

 
        if (err == noErr)
 
        if (err == noErr)

-               *hint = btIterator->hint.nodeNum;
+               *hint = btIterator.hint.nodeNum;

 
        (void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));
        
        hfs_systemfile_unlock(vcb, lockflags);
        
 
        (void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));
        
        hfs_systemfile_unlock(vcb, lockflags);
        

-       FREE(btIterator, M_TEMP);       

        return err;
 }
 
 
 static OSErr DeleteExtentRecord(
        const ExtendedVCB       *vcb,
        return err;
 }
 
 
 static OSErr DeleteExtentRecord(
        const ExtendedVCB       *vcb,

-       UInt8                           forkType,
-       UInt32                          fileID,
-       UInt32                          startBlock)
+       u_int8_t                        forkType,
+       u_int32_t                       fileID,
+       u_int32_t                       startBlock)

 {
 {

-       BTreeIterator * btIterator;
+       BTreeIterator btIterator;

        OSErr                           err;
        
        err = noErr;
 
        OSErr                           err;
        
        err = noErr;
 

-       MALLOC(btIterator, BTreeIterator *, sizeof(*btIterator), M_TEMP, M_WAITOK);
-       bzero(btIterator, sizeof(*btIterator));
+       bzero(&btIterator, sizeof(btIterator));

        
        if (vcb->vcbSigWord == kHFSSigWord) {
                HFSExtentKey *  keyPtr;
 
        
        if (vcb->vcbSigWord == kHFSSigWord) {
                HFSExtentKey *  keyPtr;
 

-               keyPtr = (HFSExtentKey*) &btIterator->key;
+               keyPtr = (HFSExtentKey*) &btIterator.key;

                keyPtr->keyLength       = kHFSExtentKeyMaximumLength;
                keyPtr->forkType        = forkType;
                keyPtr->fileID          = fileID;
                keyPtr->keyLength       = kHFSExtentKeyMaximumLength;
                keyPtr->forkType        = forkType;
                keyPtr->fileID          = fileID;


@@ -431,7 +432,7 @@ static OSErr DeleteExtentRecord(
        else {          //      HFS Plus volume
                HFSPlusExtentKey *      keyPtr;
 
        else {          //      HFS Plus volume
                HFSPlusExtentKey *      keyPtr;
 

-               keyPtr = (HFSPlusExtentKey*) &btIterator->key;
+               keyPtr = (HFSPlusExtentKey*) &btIterator.key;

                keyPtr->keyLength       = kHFSPlusExtentKeyMaximumLength;
                keyPtr->forkType        = forkType;
                keyPtr->pad                     = 0;
                keyPtr->keyLength       = kHFSPlusExtentKeyMaximumLength;
                keyPtr->forkType        = forkType;
                keyPtr->pad                     = 0;


@@ -439,10 +440,9 @@ static OSErr DeleteExtentRecord(
                keyPtr->startBlock      = startBlock;
        }
 
                keyPtr->startBlock      = startBlock;
        }
 

-       err = BTDeleteRecord(GetFileControlBlock(vcb->extentsRefNum), btIterator);
+       err = BTDeleteRecord(GetFileControlBlock(vcb->extentsRefNum), &btIterator);

        (void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));
        
        (void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));
        

-       FREE(btIterator, M_TEMP);       

        return err;
 }
 
        return err;
 }
 


@@ -466,22 +466,22 @@ OSErr MapFileBlockC (
        size_t                  *availableBytes)        // number of contiguous bytes (up to numberOfBytes)
 {
        OSErr                           err;
        size_t                  *availableBytes)        // number of contiguous bytes (up to numberOfBytes)
 {
        OSErr                           err;

-       UInt32                          allocBlockSize;                 //      Size of the volume's allocation block
-       UInt32                  sectorSize;
+       u_int32_t                       allocBlockSize;                 //      Size of the volume's allocation block
+       u_int32_t                       sectorSize;

        HFSPlusExtentKey        foundKey;
        HFSPlusExtentRecord     foundData;
        HFSPlusExtentKey        foundKey;
        HFSPlusExtentRecord     foundData;

-       UInt32                          foundIndex;
-       UInt32                          hint;
-       UInt32                          firstFABN;                              // file allocation block of first block in found extent
-       UInt32                          nextFABN;                               // file allocation block of block after end of found extent
+       u_int32_t                       foundIndex;
+       u_int32_t                       hint;
+       u_int32_t                       firstFABN;                              // file allocation block of first block in found extent
+       u_int32_t                       nextFABN;                               // file allocation block of block after end of found extent

        off_t                           dataEnd;                                // (offset) end of range that is contiguous
        off_t                           dataEnd;                                // (offset) end of range that is contiguous

-       UInt32                          sectorsPerBlock;                // Number of sectors per allocation block
-       UInt32                          startBlock;                             // volume allocation block corresponding to firstFABN
+       u_int32_t                       sectorsPerBlock;                // Number of sectors per allocation block
+       u_int32_t                       startBlock;                             // volume allocation block corresponding to firstFABN

        daddr64_t                       temp;
        off_t                           tmpOff;
 
        allocBlockSize = vcb->blockSize;
        daddr64_t                       temp;
        off_t                           tmpOff;
 
        allocBlockSize = vcb->blockSize;

-       sectorSize = VCBTOHFS(vcb)->hfs_phys_block_size;
+       sectorSize = VCBTOHFS(vcb)->hfs_logical_block_size;

 
        err = SearchExtentFile(vcb, fcb, offset, &foundKey, foundData, &foundIndex, &hint, &nextFABN);
        if (err == noErr) {
 
        err = SearchExtentFile(vcb, fcb, offset, &foundKey, foundData, &foundIndex, &hint, &nextFABN);
        if (err == noErr) {


@@ -511,7 +511,7 @@ OSErr MapFileBlockC (
        //      offset in sectors from start of allocation block space
        //
        temp = (daddr64_t)((offset - (off_t)((off_t)(firstFABN) * (off_t)(allocBlockSize)))/sectorSize);
        //      offset in sectors from start of allocation block space
        //
        temp = (daddr64_t)((offset - (off_t)((off_t)(firstFABN) * (off_t)(allocBlockSize)))/sectorSize);

-       temp += startBlock * sectorsPerBlock;
+       temp += (daddr64_t)startBlock * (daddr64_t)sectorsPerBlock;

 
        /* Add in any volume offsets */
        if (vcb->vcbSigWord == kHFSPlusSigWord)
 
        /* Add in any volume offsets */
        if (vcb->vcbSigWord == kHFSPlusSigWord)


@@ -548,11 +548,11 @@ OSErr MapFileBlockC (
 static OSErr ReleaseExtents(
        ExtendedVCB                     *vcb,
        const HFSPlusExtentRecord       extentRecord,
 static OSErr ReleaseExtents(
        ExtendedVCB                     *vcb,
        const HFSPlusExtentRecord       extentRecord,

-       UInt32                                  *numReleasedAllocationBlocks,
+       u_int32_t                               *numReleasedAllocationBlocks,

        Boolean                                 *releasedLastExtent)
 {
        Boolean                                 *releasedLastExtent)
 {

-       UInt32  extentIndex;
-       UInt32  numberOfExtents;
+       u_int32_t       extentIndex;
+       u_int32_t       numberOfExtents;

        OSErr   err = noErr;
        
        *numReleasedAllocationBlocks = 0;
        OSErr   err = noErr;
        
        *numReleasedAllocationBlocks = 0;


@@ -565,7 +565,7 @@ static OSErr ReleaseExtents(
 
        for( extentIndex = 0; extentIndex < numberOfExtents; extentIndex++)
        {
 
        for( extentIndex = 0; extentIndex < numberOfExtents; extentIndex++)
        {

-               UInt32  numAllocationBlocks;
+               u_int32_t       numAllocationBlocks;

                
                // Loop over the extent record and release the blocks associated with each extent.
                
                
                // Loop over the extent record and release the blocks associated with each extent.
                


@@ -576,7 +576,7 @@ static OSErr ReleaseExtents(
                        break;
                }
 
                        break;
                }
 

-               err = BlockDeallocate( vcb, extentRecord[extentIndex].startBlock, numAllocationBlocks );
+               err = BlockDeallocate( vcb, extentRecord[extentIndex].startBlock, numAllocationBlocks , 0);

                if ( err != noErr )
                        break;
                                        
                if ( err != noErr )
                        break;
                                        


@@ -604,15 +604,15 @@ static OSErr ReleaseExtents(
 
 static OSErr TruncateExtents(
        ExtendedVCB             *vcb,
 
 static OSErr TruncateExtents(
        ExtendedVCB             *vcb,

-       UInt8                   forkType,
-       UInt32                  fileID,
-       UInt32                  startBlock,
+       u_int8_t                forkType,
+       u_int32_t               fileID,
+       u_int32_t               startBlock,

        Boolean *               recordDeleted)
 {
        OSErr                           err;
        Boolean *               recordDeleted)
 {
        OSErr                           err;

-       UInt32                          numberExtentsReleased;
+       u_int32_t                       numberExtentsReleased;

        Boolean                         releasedLastExtent;
        Boolean                         releasedLastExtent;

-       UInt32                          hint;
+       u_int32_t                       hint;

        HFSPlusExtentKey        key;
        HFSPlusExtentRecord     extents;
        int  lockflags;
        HFSPlusExtentKey        key;
        HFSPlusExtentRecord     extents;
        int  lockflags;


@@ -659,12 +659,12 @@ static OSErr TruncateExtents(
 static OSErr DeallocateFork(
        ExtendedVCB             *vcb,
        HFSCatalogNodeID        fileID,
 static OSErr DeallocateFork(
        ExtendedVCB             *vcb,
        HFSCatalogNodeID        fileID,

-       UInt8                   forkType,
+       u_int8_t                        forkType,

        HFSPlusExtentRecord     catalogExtents,
        Boolean *               recordDeleted) /* true if a record was deleted */
 {
        OSErr                           err;
        HFSPlusExtentRecord     catalogExtents,
        Boolean *               recordDeleted) /* true if a record was deleted */
 {
        OSErr                           err;

-       UInt32                          numReleasedAllocationBlocks;
+       u_int32_t                       numReleasedAllocationBlocks;

        Boolean                         releasedLastExtent;
        
        //      Release the catalog extents
        Boolean                         releasedLastExtent;
        
        //      Release the catalog extents


@@ -718,15 +718,15 @@ OSErr FlushExtentFile( ExtendedVCB *vcb )
 //\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b
 
 __private_extern__
 //\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b
 
 __private_extern__

-SInt32 CompareExtentKeys( const HFSExtentKey *searchKey, const HFSExtentKey *trialKey )
+int32_t CompareExtentKeys( const HFSExtentKey *searchKey, const HFSExtentKey *trialKey )

 {
 {

-       SInt32  result;         //      ± 1
+       int32_t result;         //      ± 1

        
        #if DEBUG_BUILD
                if (searchKey->keyLength != kHFSExtentKeyMaximumLength)
        
        #if DEBUG_BUILD
                if (searchKey->keyLength != kHFSExtentKeyMaximumLength)

-                       DebugStr("\pHFS: search Key is wrong length");
+                       DebugStr("HFS: search Key is wrong length");

                if (trialKey->keyLength != kHFSExtentKeyMaximumLength)
                if (trialKey->keyLength != kHFSExtentKeyMaximumLength)

-                       DebugStr("\pHFS: trial Key is wrong length");
+                       DebugStr("HFS: trial Key is wrong length");

        #endif
        
        result = -1;            //      assume searchKey < trialKey
        #endif
        
        result = -1;            //      assume searchKey < trialKey


@@ -782,15 +782,15 @@ SInt32 CompareExtentKeys( const HFSExtentKey *searchKey, const HFSExtentKey *tri
 //\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b
 
 __private_extern__
 //\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b\8b
 
 __private_extern__

-SInt32 CompareExtentKeysPlus( const HFSPlusExtentKey *searchKey, const HFSPlusExtentKey *trialKey )
+int32_t CompareExtentKeysPlus( const HFSPlusExtentKey *searchKey, const HFSPlusExtentKey *trialKey )

 {
 {

-       SInt32  result;         //      ± 1
+       int32_t result;         //      ± 1

        
        #if DEBUG_BUILD
                if (searchKey->keyLength != kHFSPlusExtentKeyMaximumLength)
        
        #if DEBUG_BUILD
                if (searchKey->keyLength != kHFSPlusExtentKeyMaximumLength)

-                       DebugStr("\pHFS: search Key is wrong length");
+                       DebugStr("HFS: search Key is wrong length");

                if (trialKey->keyLength != kHFSPlusExtentKeyMaximumLength)
                if (trialKey->keyLength != kHFSPlusExtentKeyMaximumLength)

-                       DebugStr("\pHFS: trial Key is wrong length");
+                       DebugStr("HFS: trial Key is wrong length");

        #endif
        
        result = -1;            //      assume searchKey < trialKey
        #endif
        
        result = -1;            //      assume searchKey < trialKey


@@ -844,18 +844,18 @@ SInt32 CompareExtentKeysPlus( const HFSPlusExtentKey *searchKey, const HFSPlusEx
  */
 __private_extern__
 int
  */
 __private_extern__
 int

-AddFileExtent(ExtendedVCB *vcb, FCB *fcb, UInt32 startBlock, UInt32 blockCount)
+AddFileExtent(ExtendedVCB *vcb, FCB *fcb, u_int32_t startBlock, u_int32_t blockCount)

 {
        HFSPlusExtentKey foundKey;
        HFSPlusExtentRecord foundData;
 {
        HFSPlusExtentKey foundKey;
        HFSPlusExtentRecord foundData;

-       UInt32 foundIndex;
-       UInt32 hint;
-       UInt32 nextBlock;
-       SInt64 peof;
+       u_int32_t foundIndex;
+       u_int32_t hint;
+       u_int32_t nextBlock;
+       int64_t peof;

        int i;
        int error;
 
        int i;
        int error;
 

-       peof = (SInt64)(fcb->ff_blocks + blockCount) * (SInt64)vcb->blockSize;
+       peof = (int64_t)(fcb->ff_blocks + blockCount) * (int64_t)vcb->blockSize;

 
        error = SearchExtentFile(vcb, fcb, peof-1, &foundKey, foundData, &foundIndex, &hint, &nextBlock);
        if (error != fxRangeErr)
 
        error = SearchExtentFile(vcb, fcb, peof-1, &foundKey, foundData, &foundIndex, &hint, &nextBlock);
        if (error != fxRangeErr)


@@ -916,32 +916,33 @@ __private_extern__
 OSErr ExtendFileC (
        ExtendedVCB             *vcb,                           // volume that file resides on
        FCB                             *fcb,                           // FCB of file to truncate
 OSErr ExtendFileC (
        ExtendedVCB             *vcb,                           // volume that file resides on
        FCB                             *fcb,                           // FCB of file to truncate

-       SInt64                  bytesToAdd,                     // number of bytes to allocate
-       UInt32                  blockHint,                      // desired starting allocation block
-       UInt32                  flags,                          // EFContig and/or EFAll
-       SInt64                  *actualBytesAdded)      // number of bytes actually allocated
+       int64_t                 bytesToAdd,                     // number of bytes to allocate
+       u_int32_t               blockHint,                      // desired starting allocation block
+       u_int32_t               flags,                          // EFContig and/or EFAll
+       int64_t                 *actualBytesAdded)      // number of bytes actually allocated

 {
        OSErr                           err;
 {
        OSErr                           err;

-       UInt32                          volumeBlockSize;
-       SInt64                          blocksToAdd;
-       SInt64                          bytesThisExtent;
+       u_int32_t                       volumeBlockSize;
+       int64_t                         blocksToAdd;
+       int64_t                         bytesThisExtent;

        HFSPlusExtentKey        foundKey;
        HFSPlusExtentRecord     foundData;
        HFSPlusExtentKey        foundKey;
        HFSPlusExtentRecord     foundData;

-       UInt32                          foundIndex;
-       UInt32                          hint;
-       UInt32                          nextBlock;
-       UInt32                          startBlock;
+       u_int32_t                       foundIndex;
+       u_int32_t                       hint;
+       u_int32_t                       nextBlock;
+       u_int32_t                       startBlock;

        Boolean                         allOrNothing;
        Boolean                         forceContig;
        Boolean                         wantContig;
        Boolean                         useMetaZone;
        Boolean                         needsFlush;
        Boolean                         allOrNothing;
        Boolean                         forceContig;
        Boolean                         wantContig;
        Boolean                         useMetaZone;
        Boolean                         needsFlush;

-       UInt32                          actualStartBlock;
-       UInt32                          actualNumBlocks;
-       UInt32                          numExtentsPerRecord;
-       SInt64                          maximumBytes;
-       SInt64                          peof;
-       UInt32                          prevblocks;
+       u_int32_t                       actualStartBlock;
+       u_int32_t                       actualNumBlocks;
+       u_int32_t                       numExtentsPerRecord;
+       int64_t                         maximumBytes;
+       int64_t                         availbytes;
+       int64_t                         peof;
+       u_int32_t                       prevblocks;

        
 
        needsFlush = false;
        
 
        needsFlush = false;


@@ -962,7 +963,7 @@ OSErr ExtendFileC (
        if (vcb->vcbSigWord == kHFSSigWord) {
                if (bytesToAdd >=  kTwoGigabytes)
                        goto Overflow;
        if (vcb->vcbSigWord == kHFSSigWord) {
                if (bytesToAdd >=  kTwoGigabytes)
                        goto Overflow;

-               if ((((SInt64)fcb->ff_blocks * (SInt64)volumeBlockSize) + bytesToAdd) >= kTwoGigabytes)
+               if ((((int64_t)fcb->ff_blocks * (int64_t)volumeBlockSize) + bytesToAdd) >= kTwoGigabytes)

                        goto Overflow;
        }
        //
                        goto Overflow;
        }
        //


@@ -970,14 +971,14 @@ OSErr ExtendFileC (
        //      Round up the number of desired bytes to add.
        //
        blocksToAdd = howmany(bytesToAdd, volumeBlockSize);
        //      Round up the number of desired bytes to add.
        //
        blocksToAdd = howmany(bytesToAdd, volumeBlockSize);

-       bytesToAdd = (SInt64)((SInt64)blocksToAdd * (SInt64)volumeBlockSize);
+       bytesToAdd = (int64_t)((int64_t)blocksToAdd * (int64_t)volumeBlockSize);

 
        /*
         * For deferred allocations just reserve the blocks.
         */
        if ((flags & kEFDeferMask)
        &&  (vcb->vcbSigWord == kHFSPlusSigWord)
 
        /*
         * For deferred allocations just reserve the blocks.
         */
        if ((flags & kEFDeferMask)
        &&  (vcb->vcbSigWord == kHFSPlusSigWord)

-       &&  (bytesToAdd < (SInt64)HFS_MAX_DEFERED_ALLOC)
+       &&  (bytesToAdd < (int64_t)HFS_MAX_DEFERED_ALLOC)

        &&  (blocksToAdd < hfs_freeblks(VCBTOHFS(vcb), 1))) {
                HFS_MOUNT_LOCK(vcb, TRUE);
                vcb->loanedBlocks += blocksToAdd;
        &&  (blocksToAdd < hfs_freeblks(VCBTOHFS(vcb), 1))) {
                HFS_MOUNT_LOCK(vcb, TRUE);
                vcb->loanedBlocks += blocksToAdd;


@@ -999,7 +1000,7 @@ OSErr ExtendFileC (
 
                loanedBlocks = fcb->ff_unallocblocks;
                blocksToAdd += loanedBlocks;
 
                loanedBlocks = fcb->ff_unallocblocks;
                blocksToAdd += loanedBlocks;

-               bytesToAdd = (SInt64)blocksToAdd * (SInt64)volumeBlockSize;
+               bytesToAdd = (int64_t)blocksToAdd * (int64_t)volumeBlockSize;

                FTOC(fcb)->c_blocks -= loanedBlocks;
                fcb->ff_blocks -= loanedBlocks;
                fcb->ff_unallocblocks  = 0;
                FTOC(fcb)->c_blocks -= loanedBlocks;
                fcb->ff_blocks -= loanedBlocks;
                fcb->ff_unallocblocks  = 0;


@@ -1015,9 +1016,9 @@ OSErr ExtendFileC (
        //      rounded up to a multiple of the clump size.
        //
        if ((vcb->vcbClpSiz > (int32_t)volumeBlockSize)
        //      rounded up to a multiple of the clump size.
        //
        if ((vcb->vcbClpSiz > (int32_t)volumeBlockSize)

-       &&  (bytesToAdd < (SInt64)HFS_MAX_DEFERED_ALLOC)
+       &&  (bytesToAdd < (int64_t)HFS_MAX_DEFERED_ALLOC)

        &&  (flags & kEFNoClumpMask) == 0) {
        &&  (flags & kEFNoClumpMask) == 0) {

-               maximumBytes = (SInt64)howmany(bytesToAdd, vcb->vcbClpSiz);
+               maximumBytes = (int64_t)howmany(bytesToAdd, vcb->vcbClpSiz);

                maximumBytes *= vcb->vcbClpSiz;
        } else {
                maximumBytes = bytesToAdd;
                maximumBytes *= vcb->vcbClpSiz;
        } else {
                maximumBytes = bytesToAdd;


@@ -1027,7 +1028,7 @@ OSErr ExtendFileC (
        //      Compute new physical EOF, rounded up to a multiple of a block.
        //
        if ( (vcb->vcbSigWord == kHFSSigWord) &&                //      Too big?
        //      Compute new physical EOF, rounded up to a multiple of a block.
        //
        if ( (vcb->vcbSigWord == kHFSSigWord) &&                //      Too big?

-                ((((SInt64)fcb->ff_blocks * (SInt64)volumeBlockSize) + bytesToAdd) >= kTwoGigabytes) ) {
+                ((((int64_t)fcb->ff_blocks * (int64_t)volumeBlockSize) + bytesToAdd) >= kTwoGigabytes) ) {

                if (allOrNothing)                                       // Yes, must they have it all?
                        goto Overflow;                                          // Yes, can't have it
                else {
                if (allOrNothing)                                       // Yes, must they have it all?
                        goto Overflow;                                          // Yes, can't have it
                else {


@@ -1049,7 +1050,7 @@ OSErr ExtendFileC (
        //
        //      See if there are already enough blocks allocated to the file.
        //
        //
        //      See if there are already enough blocks allocated to the file.
        //

-       peof = ((SInt64)fcb->ff_blocks * (SInt64)volumeBlockSize) + bytesToAdd;  // potential new PEOF
+       peof = ((int64_t)fcb->ff_blocks * (int64_t)volumeBlockSize) + bytesToAdd;  // potential new PEOF

        err = SearchExtentFile(vcb, fcb, peof-1, &foundKey, foundData, &foundIndex, &hint, &nextBlock);
        if (err == noErr) {
                //      Enough blocks are already allocated.  Just update the FCB to reflect the new length.
        err = SearchExtentFile(vcb, fcb, peof-1, &foundKey, foundData, &foundIndex, &hint, &nextBlock);
        if (err == noErr) {
                //      Enough blocks are already allocated.  Just update the FCB to reflect the new length.


@@ -1064,8 +1065,8 @@ OSErr ExtendFileC (
        //
        //      Adjust the PEOF to the end of the last extent.
        //
        //
        //      Adjust the PEOF to the end of the last extent.
        //

-       peof = (SInt64)((SInt64)nextBlock * (SInt64)volumeBlockSize);                   // currently allocated PEOF
-       bytesThisExtent = (SInt64)(nextBlock - fcb->ff_blocks) * (SInt64)volumeBlockSize;
+       peof = (int64_t)((int64_t)nextBlock * (int64_t)volumeBlockSize);                        // currently allocated PEOF
+       bytesThisExtent = (int64_t)(nextBlock - fcb->ff_blocks) * (int64_t)volumeBlockSize;

        if (bytesThisExtent != 0) {
                fcb->ff_blocks = nextBlock;
                FTOC(fcb)->c_blocks += (bytesThisExtent / volumeBlockSize);
        if (bytesThisExtent != 0) {
                fcb->ff_blocks = nextBlock;
                FTOC(fcb)->c_blocks += (bytesThisExtent / volumeBlockSize);


@@ -1080,46 +1081,58 @@ OSErr ExtendFileC (
        //      If that fails, get whatever we can.
        //              If forceContig, then take whatever we got
        //              else, keep getting bits and pieces (non-contig)
        //      If that fails, get whatever we can.
        //              If forceContig, then take whatever we got
        //              else, keep getting bits and pieces (non-contig)

+       
+       /*
+        * Note that for sparse devices (like sparse bundle dmgs), we
+        * should only be aggressive with re-using once-allocated pieces
+        * if we're not dealing with system files.  If we're trying to operate
+        * on behalf of a system file, we need the maximum contiguous amount
+        * possible.
+        */

        err = noErr;
        err = noErr;

-       wantContig = true;
+       if (   (vcb->hfs_flags & HFS_HAS_SPARSE_DEVICE)
+           && (fcb->ff_cp->c_fileid >= kHFSFirstUserCatalogNodeID)
+           && (flags & kEFMetadataMask) == 0) {
+               if (vcb->hfs_flags & HFS_DID_CONTIG_SCAN) {
+                       wantContig = false;
+               } else {
+                       // we only want to do this once to scan the bitmap to
+                       // fill in the vcbFreeExt table of free blocks
+                       vcb->hfs_flags |= HFS_DID_CONTIG_SCAN;
+                       wantContig = true;
+               }
+       } else {
+               wantContig = true;
+       }

        useMetaZone = flags & kEFMetadataMask;
        useMetaZone = flags & kEFMetadataMask;

-       vcb->vcbFreeExtCnt = 0; /* For now, force rebuild of free extent list */

        do {
                if (blockHint != 0)
                        startBlock = blockHint;
                else
                        startBlock = foundData[foundIndex].startBlock + foundData[foundIndex].blockCount;
 
        do {
                if (blockHint != 0)
                        startBlock = blockHint;
                else
                        startBlock = foundData[foundIndex].startBlock + foundData[foundIndex].blockCount;
 

-               /* Force reserve checking if requested. */
-               if (flags & kEFReserveMask) {
-                       SInt64 availbytes;
-
-                       actualNumBlocks = 0;
-                       actualStartBlock = 0;
+               actualNumBlocks = 0;
+               actualStartBlock = 0;

                        
                        

-                       availbytes = (SInt64)hfs_freeblks(VCBTOHFS(vcb), 1) *
-                                    (SInt64)volumeBlockSize;
-                       if (availbytes <= 0) {
+               /* Find number of free blocks based on reserved block flag option */
+               availbytes = (int64_t)hfs_freeblks(VCBTOHFS(vcb), flags & kEFReserveMask) *
+                            (int64_t)volumeBlockSize;
+               if (availbytes <= 0) {
+                       err = dskFulErr;
+               } else {
+                       if (wantContig && (availbytes < bytesToAdd))

                                err = dskFulErr;
                                err = dskFulErr;

-                       } else {
-                               if (wantContig && (availbytes < bytesToAdd))
-                                       err = dskFulErr;
-                               else {
-                                       err = BlockAllocate(
+                       else {
+                               err = BlockAllocate(

                                                  vcb,
                                                  startBlock,
                                                  howmany(MIN(bytesToAdd, availbytes), volumeBlockSize),
                                                  howmany(MIN(maximumBytes, availbytes), volumeBlockSize),
                                                  vcb,
                                                  startBlock,
                                                  howmany(MIN(bytesToAdd, availbytes), volumeBlockSize),
                                                  howmany(MIN(maximumBytes, availbytes), volumeBlockSize),

-                                                 wantContig,
-                                                 useMetaZone,
+                                                 (wantContig ? HFS_ALLOC_FORCECONTIG : 0) | 
+                                                 (useMetaZone ? HFS_ALLOC_METAZONE : 0),

                                                  &actualStartBlock,
                                                  &actualNumBlocks);
                                                  &actualStartBlock,
                                                  &actualNumBlocks);

-                               }

                        }
                        }

-               } else {
-                       err = BlockAllocate(vcb, startBlock, howmany(bytesToAdd, volumeBlockSize),
-                                           howmany(maximumBytes, volumeBlockSize), wantContig, useMetaZone,
-                                           &actualStartBlock, &actualNumBlocks);

                }
                if (err == dskFulErr) {
                        if (forceContig)
                }
                if (err == dskFulErr) {
                        if (forceContig)


@@ -1154,7 +1167,7 @@ OSErr ExtendFileC (
                                if (err != noErr) break;
                        }
                        else {
                                if (err != noErr) break;
                        }
                        else {

-                               UInt16  i;
+                               u_int16_t       i;

 
                                //      Need to add a new extent.  See if there is room in the current record.
                                if (foundData[foundIndex].blockCount != 0)      //      Is current extent free to use?
 
                                //      Need to add a new extent.  See if there is room in the current record.
                                if (foundData[foundIndex].blockCount != 0)      //      Is current extent free to use?


@@ -1162,7 +1175,7 @@ OSErr ExtendFileC (
                                if (foundIndex == numExtentsPerRecord) {
                                        //      This record is full.  Need to create a new one.
                                        if (FTOC(fcb)->c_fileid == kHFSExtentsFileID) {
                                if (foundIndex == numExtentsPerRecord) {
                                        //      This record is full.  Need to create a new one.
                                        if (FTOC(fcb)->c_fileid == kHFSExtentsFileID) {

-                                               (void) BlockDeallocate(vcb, actualStartBlock, actualNumBlocks);
+                                               (void) BlockDeallocate(vcb, actualStartBlock, actualNumBlocks, 0);

                                                err = dskFulErr;                // Oops.  Can't extend extents file past first record.
                                                break;
                                        }
                                                err = dskFulErr;                // Oops.  Can't extend extents file past first record.
                                                break;
                                        }


@@ -1193,7 +1206,7 @@ OSErr ExtendFileC (
                                                //      We couldn't create an extent record because extents B-tree
                                                //      couldn't grow.  Dellocate the extent just allocated and
                                                //      return a disk full error.
                                                //      We couldn't create an extent record because extents B-tree
                                                //      couldn't grow.  Dellocate the extent just allocated and
                                                //      return a disk full error.

-                                               (void) BlockDeallocate(vcb, actualStartBlock, actualNumBlocks);
+                                               (void) BlockDeallocate(vcb, actualStartBlock, actualNumBlocks, 0);

                                                err = dskFulErr;
                                        }
                                        if (err != noErr) break;
                                                err = dskFulErr;
                                        }
                                        if (err != noErr) break;


@@ -1213,7 +1226,7 @@ OSErr ExtendFileC (
                        // NOTE: BlockAllocate could have allocated more than we asked for.
                        // Don't set the PEOF beyond what our client asked for.
                        nextBlock += actualNumBlocks;
                        // NOTE: BlockAllocate could have allocated more than we asked for.
                        // Don't set the PEOF beyond what our client asked for.
                        nextBlock += actualNumBlocks;

-                       bytesThisExtent = (SInt64)((SInt64)actualNumBlocks * (SInt64)volumeBlockSize);
+                       bytesThisExtent = (int64_t)((int64_t)actualNumBlocks * (int64_t)volumeBlockSize);

                        if (bytesThisExtent > bytesToAdd) {
                                bytesToAdd = 0;
                        }
                        if (bytesThisExtent > bytesToAdd) {
                                bytesToAdd = 0;
                        }


@@ -1242,13 +1255,13 @@ Exit:
                if (vcb->nextAllocation >= VCBTOHFS(vcb)->hfs_metazone_start &&
                    vcb->nextAllocation <= VCBTOHFS(vcb)->hfs_metazone_end) {
                        HFS_MOUNT_LOCK(vcb, TRUE);
                if (vcb->nextAllocation >= VCBTOHFS(vcb)->hfs_metazone_start &&
                    vcb->nextAllocation <= VCBTOHFS(vcb)->hfs_metazone_end) {
                        HFS_MOUNT_LOCK(vcb, TRUE);

-                       vcb->nextAllocation = VCBTOHFS(vcb)->hfs_metazone_end + 1;
-                       vcb->vcbFlags |= 0xFF00;
+                       HFS_UPDATE_NEXT_ALLOCATION(vcb, VCBTOHFS(vcb)->hfs_metazone_end + 1);   
+                       MarkVCBDirty(vcb);

                        HFS_MOUNT_UNLOCK(vcb, TRUE);
                }
        }
        if (prevblocks < fcb->ff_blocks) {
                        HFS_MOUNT_UNLOCK(vcb, TRUE);
                }
        }
        if (prevblocks < fcb->ff_blocks) {

-               *actualBytesAdded = (SInt64)(fcb->ff_blocks - prevblocks) * (SInt64)volumeBlockSize;
+               *actualBytesAdded = (int64_t)(fcb->ff_blocks - prevblocks) * (int64_t)volumeBlockSize;

        } else {
                *actualBytesAdded = 0;
        }
        } else {
                *actualBytesAdded = 0;
        }


@@ -1280,22 +1293,22 @@ __private_extern__
 OSErr TruncateFileC (
        ExtendedVCB             *vcb,                           // volume that file resides on
        FCB                             *fcb,                           // FCB of file to truncate
 OSErr TruncateFileC (
        ExtendedVCB             *vcb,                           // volume that file resides on
        FCB                             *fcb,                           // FCB of file to truncate

-       SInt64                  peof,                           // new physical size for file
+       int64_t                 peof,                           // new physical size for file

        Boolean                 truncateToExtent)       // if true, truncate to end of extent containing newPEOF
 {
        OSErr                           err;
        Boolean                 truncateToExtent)       // if true, truncate to end of extent containing newPEOF
 {
        OSErr                           err;

-       UInt32                          nextBlock;              //      next file allocation block to consider
-       UInt32                          startBlock;             //      Physical (volume) allocation block number of start of a range
-       UInt32                          physNumBlocks;  //      Number of allocation blocks in file (according to PEOF)
-       UInt32                          numBlocks;
+       u_int32_t                       nextBlock;              //      next file allocation block to consider
+       u_int32_t                       startBlock;             //      Physical (volume) allocation block number of start of a range
+       u_int32_t                       physNumBlocks;  //      Number of allocation blocks in file (according to PEOF)
+       u_int32_t                       numBlocks;

        HFSPlusExtentKey        key;                    //      key for current extent record; key->keyLength == 0 if FCB's extent record
        HFSPlusExtentKey        key;                    //      key for current extent record; key->keyLength == 0 if FCB's extent record

-       UInt32                          hint;                   //      BTree hint corresponding to key
+       u_int32_t                       hint;                   //      BTree hint corresponding to key

        HFSPlusExtentRecord     extentRecord;
        HFSPlusExtentRecord     extentRecord;

-       UInt32                          extentIndex;
-       UInt32                          extentNextBlock;
-       UInt32                          numExtentsPerRecord;
-       SInt64                          temp64;
-       UInt8                           forkType;
+       u_int32_t                       extentIndex;
+       u_int32_t                       extentNextBlock;
+       u_int32_t                       numExtentsPerRecord;
+       int64_t             temp64;
+       u_int8_t                        forkType;

        Boolean                         extentChanged;  // true if we actually changed an extent
        Boolean                         recordDeleted;  // true if an extent record got deleted
 
        Boolean                         extentChanged;  // true if we actually changed an extent
        Boolean                         recordDeleted;  // true if an extent record got deleted
 


@@ -1312,7 +1325,7 @@ OSErr TruncateFileC (
                forkType = kDataForkType;
 
        temp64 = fcb->ff_blocks;
                forkType = kDataForkType;
 
        temp64 = fcb->ff_blocks;

-       physNumBlocks = (UInt32)temp64;
+       physNumBlocks = (u_int32_t)temp64;

 
        //
        //      Round newPEOF up to a multiple of the allocation block size.  If new size is
 
        //
        //      Round newPEOF up to a multiple of the allocation block size.  If new size is


@@ -1320,10 +1333,10 @@ OSErr TruncateFileC (
        //      shouldn't that be an error?).
        //
        nextBlock = howmany(peof, vcb->blockSize);      // number of allocation blocks to remain in file
        //      shouldn't that be an error?).
        //
        nextBlock = howmany(peof, vcb->blockSize);      // number of allocation blocks to remain in file

-       peof = (SInt64)((SInt64)nextBlock * (SInt64)vcb->blockSize);                                    // number of bytes in those blocks
+       peof = (int64_t)((int64_t)nextBlock * (int64_t)vcb->blockSize);                                 // number of bytes in those blocks

        if ((vcb->vcbSigWord == kHFSSigWord) && (peof >= kTwoGigabytes)) {
                #if DEBUG_BUILD
        if ((vcb->vcbSigWord == kHFSSigWord) && (peof >= kTwoGigabytes)) {
                #if DEBUG_BUILD

-                       DebugStr("\pHFS: Trying to truncate a file to 2GB or more");
+                       DebugStr("HFS: Trying to truncate a file to 2GB or more");

                #endif
                err = fileBoundsErr;
                goto ErrorExit;
                #endif
                err = fileBoundsErr;
                goto ErrorExit;


@@ -1385,7 +1398,7 @@ OSErr TruncateFileC (
                        //      Compute first volume allocation block to free
                        startBlock = extentRecord[extentIndex].startBlock + extentRecord[extentIndex].blockCount - numBlocks;
                        //      Free the blocks in bitmap
                        //      Compute first volume allocation block to free
                        startBlock = extentRecord[extentIndex].startBlock + extentRecord[extentIndex].blockCount - numBlocks;
                        //      Free the blocks in bitmap

-                       err = BlockDeallocate(vcb, startBlock, numBlocks);
+                       err = BlockDeallocate(vcb, startBlock, numBlocks, 0);

                        if (err != noErr) goto ErrorExit;
                        //      Adjust length of this extent
                        extentRecord[extentIndex].blockCount -= numBlocks;
                        if (err != noErr) goto ErrorExit;
                        //      Adjust length of this extent
                        extentRecord[extentIndex].blockCount -= numBlocks;


@@ -1409,7 +1422,7 @@ OSErr TruncateFileC (
        while (extentIndex < numExtentsPerRecord && extentRecord[extentIndex].blockCount != 0) {
                numBlocks = extentRecord[extentIndex].blockCount;
                //      Deallocate this extent
        while (extentIndex < numExtentsPerRecord && extentRecord[extentIndex].blockCount != 0) {
                numBlocks = extentRecord[extentIndex].blockCount;
                //      Deallocate this extent

-               err = BlockDeallocate(vcb, extentRecord[extentIndex].startBlock, numBlocks);
+               err = BlockDeallocate(vcb, extentRecord[extentIndex].startBlock, numBlocks, 0);

                if (err != noErr) goto ErrorExit;
                //      Update next file allocation block number
                nextBlock += numBlocks;
                if (err != noErr) goto ErrorExit;
                //      Update next file allocation block number
                nextBlock += numBlocks;


@@ -1456,15 +1469,15 @@ __private_extern__
 OSErr HeadTruncateFile (
        ExtendedVCB  *vcb,
        FCB  *fcb,
 OSErr HeadTruncateFile (
        ExtendedVCB  *vcb,
        FCB  *fcb,

-       UInt32  headblks)
+       u_int32_t  headblks)

 {
        HFSPlusExtentRecord  extents;
        HFSPlusExtentRecord  tailExtents;
        HFSCatalogNodeID  fileID;
 {
        HFSPlusExtentRecord  extents;
        HFSPlusExtentRecord  tailExtents;
        HFSCatalogNodeID  fileID;

-       UInt8  forkType;
-       UInt32  blkcnt;
-       UInt32  startblk;
-       UInt32  blksfreed;
+       u_int8_t  forkType;
+       u_int32_t  blkcnt;
+       u_int32_t  startblk;
+       u_int32_t  blksfreed;

        int  i, j;
        int  error = 0;
        int  lockflags;
        int  i, j;
        int  error = 0;
        int  lockflags;


@@ -1489,7 +1502,7 @@ OSErr HeadTruncateFile (
                        break;  /* end of extents */
 
                if (blksfreed < headblks) {
                        break;  /* end of extents */
 
                if (blksfreed < headblks) {

-                       error = BlockDeallocate(vcb, fcb->fcbExtents[i].startBlock, blkcnt);
+                       error = BlockDeallocate(vcb, fcb->fcbExtents[i].startBlock, blkcnt, 0);

                        /*
                         * Any errors after the first BlockDeallocate
                         * must be ignored so we can put the file in
                        /*
                         * Any errors after the first BlockDeallocate
                         * must be ignored so we can put the file in


@@ -1500,8 +1513,8 @@ OSErr HeadTruncateFile (
                                        goto ErrorExit;  /* uh oh */
                                else {
                                        error = 0;
                                        goto ErrorExit;  /* uh oh */
                                else {
                                        error = 0;

-                                       printf("HeadTruncateFile: problems deallocating %s (%d)\n",
-                                              FTOC(fcb)->c_desc.cd_nameptr ? FTOC(fcb)->c_desc.cd_nameptr : "", error);
+                                       printf("hfs: HeadTruncateFile: problems deallocating %s (%d)\n",
+                                              FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);

                                }
                        }
 
                                }
                        }
 


@@ -1525,7 +1538,7 @@ OSErr HeadTruncateFile (
         * Process overflow extents
         */
        for (;;) {
         * Process overflow extents
         */
        for (;;) {

-               UInt32  extblks;
+               u_int32_t  extblks;

 
                error = FindExtentRecord(vcb, forkType, fileID, startblk, false, NULL, extents, NULL);
                if (error) {
 
                error = FindExtentRecord(vcb, forkType, fileID, startblk, false, NULL, extents, NULL);
                if (error) {


@@ -1535,8 +1548,8 @@ OSErr HeadTruncateFile (
                         * a known state.
                         */
                        if (error != btNotFound)
                         * a known state.
                         */
                        if (error != btNotFound)

-                               printf("HeadTruncateFile: problems finding extents %s (%d)\n",
-                                      FTOC(fcb)->c_desc.cd_nameptr ? FTOC(fcb)->c_desc.cd_nameptr : "", error);
+                               printf("hfs: HeadTruncateFile: problems finding extents %s (%d)\n",
+                                      FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);

                        error = 0;
                        break;
                }
                        error = 0;
                        break;
                }


@@ -1547,10 +1560,10 @@ OSErr HeadTruncateFile (
                                break;  /* end of extents */
 
                        if (blksfreed < headblks) {
                                break;  /* end of extents */
 
                        if (blksfreed < headblks) {

-                               error = BlockDeallocate(vcb, extents[i].startBlock, blkcnt);
+                               error = BlockDeallocate(vcb, extents[i].startBlock, blkcnt, 0);

                                if (error) {
                                if (error) {

-                                       printf("HeadTruncateFile: problems deallocating %s (%d)\n",
-                                              FTOC(fcb)->c_desc.cd_nameptr ? FTOC(fcb)->c_desc.cd_nameptr : "", error);
+                                       printf("hfs: HeadTruncateFile: problems deallocating %s (%d)\n",
+                                              FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);

                                        error = 0;
                                }
                                blksfreed += blkcnt;
                                        error = 0;
                                }
                                blksfreed += blkcnt;


@@ -1564,8 +1577,8 @@ OSErr HeadTruncateFile (
                
                error = DeleteExtentRecord(vcb, forkType, fileID, startblk);
                if (error) {
                
                error = DeleteExtentRecord(vcb, forkType, fileID, startblk);
                if (error) {

-                       printf("HeadTruncateFile: problems deallocating %s (%d)\n",
-                               FTOC(fcb)->c_desc.cd_nameptr ? FTOC(fcb)->c_desc.cd_nameptr : "", error);
+                       printf("hfs: HeadTruncateFile: problems deallocating %s (%d)\n",
+                               FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);

                        error = 0;
                }
                
                        error = 0;
                }
                


@@ -1580,7 +1593,7 @@ CopyExtents:
        if (blksfreed) {
                bcopy(tailExtents, fcb->fcbExtents, sizeof(tailExtents));
                blkcnt = fcb->ff_blocks - headblks;
        if (blksfreed) {
                bcopy(tailExtents, fcb->fcbExtents, sizeof(tailExtents));
                blkcnt = fcb->ff_blocks - headblks;

-               FTOC(fcb)->c_blocks -= blkcnt;
+               FTOC(fcb)->c_blocks -= headblks;

                fcb->ff_blocks = blkcnt;
 
                FTOC(fcb)->c_flag |= C_FORCEUPDATE;
                fcb->ff_blocks = blkcnt;
 
                FTOC(fcb)->c_flag |= C_FORCEUPDATE;


@@ -1619,17 +1632,17 @@ ErrorExit:
 
 static OSErr SearchExtentRecord(
        ExtendedVCB             *vcb,
 
 static OSErr SearchExtentRecord(
        ExtendedVCB             *vcb,

-       UInt32                                  searchFABN,
+       u_int32_t                               searchFABN,

        const HFSPlusExtentRecord       extentData,
        const HFSPlusExtentRecord       extentData,

-       UInt32                                  extentDataStartFABN,
-       UInt32                                  *foundExtentIndex,
-       UInt32                                  *endingFABNPlusOne,
+       u_int32_t                               extentDataStartFABN,
+       u_int32_t                               *foundExtentIndex,
+       u_int32_t                               *endingFABNPlusOne,

        Boolean                                 *noMoreExtents)
 {
        OSErr   err = noErr;
        Boolean                                 *noMoreExtents)
 {
        OSErr   err = noErr;

-       UInt32  extentIndex;
-       UInt32  numberOfExtents;
-       UInt32  numAllocationBlocks;
+       u_int32_t       extentIndex;
+       u_int32_t       numberOfExtents;
+       u_int32_t       numAllocationBlocks;

        Boolean foundExtent;
        
        *endingFABNPlusOne      = extentDataStartFABN;
        Boolean foundExtent;
        
        *endingFABNPlusOne      = extentDataStartFABN;


@@ -1721,21 +1734,21 @@ static OSErr SearchExtentRecord(
 static OSErr SearchExtentFile(
        ExtendedVCB     *vcb,
        const FCB                       *fcb,
 static OSErr SearchExtentFile(
        ExtendedVCB     *vcb,
        const FCB                       *fcb,

-       SInt64                          filePosition,
+       int64_t                         filePosition,

        HFSPlusExtentKey        *foundExtentKey,
        HFSPlusExtentRecord     foundExtentData,
        HFSPlusExtentKey        *foundExtentKey,
        HFSPlusExtentRecord     foundExtentData,

-       UInt32                          *foundExtentIndex,
-       UInt32                          *extentBTreeHint,
-       UInt32                          *endingFABNPlusOne )
+       u_int32_t                       *foundExtentIndex,
+       u_int32_t                       *extentBTreeHint,
+       u_int32_t                       *endingFABNPlusOne )

 {
        OSErr                           err;
 {
        OSErr                           err;

-       UInt32                          filePositionBlock;
-       SInt64                          temp64;
+       u_int32_t                       filePositionBlock;
+       int64_t                         temp64;

        Boolean                         noMoreExtents;
        int  lockflags;
        
        Boolean                         noMoreExtents;
        int  lockflags;
        

-       temp64 = filePosition / (SInt64)vcb->blockSize;
-       filePositionBlock = (UInt32)temp64;
+       temp64 = filePosition / (int64_t)vcb->blockSize;
+       filePositionBlock = (u_int32_t)temp64;

 
     bcopy ( fcb->fcbExtents, foundExtentData, sizeof(HFSPlusExtentRecord));
        
 
     bcopy ( fcb->fcbExtents, foundExtentData, sizeof(HFSPlusExtentRecord));
        


@@ -1826,7 +1839,7 @@ static OSErr UpdateExtentRecord (
        FCB  *fcb,
        const HFSPlusExtentKey  *extentFileKey,
        const HFSPlusExtentRecord  extentData,
        FCB  *fcb,
        const HFSPlusExtentKey  *extentFileKey,
        const HFSPlusExtentRecord  extentData,

-       UInt32  extentBTreeHint)
+       u_int32_t  extentBTreeHint)

 {
     OSErr err = noErr;
        
 {
     OSErr err = noErr;
        


@@ -1835,9 +1848,9 @@ static OSErr UpdateExtentRecord (
                FTOC(fcb)->c_flag |= C_MODIFIED;
        }
        else {
                FTOC(fcb)->c_flag |= C_MODIFIED;
        }
        else {

-               BTreeIterator * btIterator;
+               BTreeIterator btIterator;

                FSBufferDescriptor btRecord;
                FSBufferDescriptor btRecord;

-               UInt16 btRecordSize;
+               u_int16_t btRecordSize;

                FCB * btFCB;
                int lockflags;
 
                FCB * btFCB;
                int lockflags;
 


@@ -1846,8 +1859,7 @@ static OSErr UpdateExtentRecord (
                //
                btFCB = GetFileControlBlock(vcb->extentsRefNum);
 
                //
                btFCB = GetFileControlBlock(vcb->extentsRefNum);
 

-               MALLOC(btIterator, BTreeIterator *, sizeof(*btIterator), M_TEMP, M_WAITOK);
-               bzero(btIterator, sizeof(*btIterator));
+               bzero(&btIterator, sizeof(btIterator));

 
                /*
                 * The lock taken by callers of ExtendFileC/TruncateFileC is
 
                /*
                 * The lock taken by callers of ExtendFileC/TruncateFileC is


@@ -1862,50 +1874,49 @@ static OSErr UpdateExtentRecord (
                        HFSExtentKey *  key;                            // Actual extent key used on disk in HFS
                        HFSExtentRecord foundData;                      // The extent data actually found
 
                        HFSExtentKey *  key;                            // Actual extent key used on disk in HFS
                        HFSExtentRecord foundData;                      // The extent data actually found
 

-                       key = (HFSExtentKey*) &btIterator->key;
+                       key = (HFSExtentKey*) &btIterator.key;

                        key->keyLength  = kHFSExtentKeyMaximumLength;
                        key->forkType   = extentFileKey->forkType;
                        key->fileID             = extentFileKey->fileID;
                        key->startBlock = extentFileKey->startBlock;
 
                        key->keyLength  = kHFSExtentKeyMaximumLength;
                        key->forkType   = extentFileKey->forkType;
                        key->fileID             = extentFileKey->fileID;
                        key->startBlock = extentFileKey->startBlock;
 

-                       btIterator->hint.index = 0;
-                       btIterator->hint.nodeNum = extentBTreeHint;
+                       btIterator.hint.index = 0;
+                       btIterator.hint.nodeNum = extentBTreeHint;

 
                        btRecord.bufferAddress = &foundData;
                        btRecord.itemSize = sizeof(HFSExtentRecord);
                        btRecord.itemCount = 1;
 
 
                        btRecord.bufferAddress = &foundData;
                        btRecord.itemSize = sizeof(HFSExtentRecord);
                        btRecord.itemCount = 1;
 

-                       err = BTSearchRecord(btFCB, btIterator, &btRecord, &btRecordSize, btIterator);
+                       err = BTSearchRecord(btFCB, &btIterator, &btRecord, &btRecordSize, &btIterator);

                        
                        if (err == noErr)
                                err = HFSPlusToHFSExtents(extentData, (HFSExtentDescriptor *)&foundData);
 
                        if (err == noErr)
                        
                        if (err == noErr)
                                err = HFSPlusToHFSExtents(extentData, (HFSExtentDescriptor *)&foundData);
 
                        if (err == noErr)

-                               err = BTReplaceRecord(btFCB, btIterator, &btRecord, btRecordSize);
+                               err = BTReplaceRecord(btFCB, &btIterator, &btRecord, btRecordSize);

                        (void) BTFlushPath(btFCB);
                }
                else {          //      HFS Plus volume
                        HFSPlusExtentRecord     foundData;              // The extent data actually found
 
                        (void) BTFlushPath(btFCB);
                }
                else {          //      HFS Plus volume
                        HFSPlusExtentRecord     foundData;              // The extent data actually found
 

-                       BlockMoveData(extentFileKey, &btIterator->key, sizeof(HFSPlusExtentKey));
+                       BlockMoveData(extentFileKey, &btIterator.key, sizeof(HFSPlusExtentKey));

 
 

-                       btIterator->hint.index = 0;
-                       btIterator->hint.nodeNum = extentBTreeHint;
+                       btIterator.hint.index = 0;
+                       btIterator.hint.nodeNum = extentBTreeHint;

 
                        btRecord.bufferAddress = &foundData;
                        btRecord.itemSize = sizeof(HFSPlusExtentRecord);
                        btRecord.itemCount = 1;
 
 
                        btRecord.bufferAddress = &foundData;
                        btRecord.itemSize = sizeof(HFSPlusExtentRecord);
                        btRecord.itemCount = 1;
 

-                       err = BTSearchRecord(btFCB, btIterator, &btRecord, &btRecordSize, btIterator);
+                       err = BTSearchRecord(btFCB, &btIterator, &btRecord, &btRecordSize, &btIterator);

        
                        if (err == noErr) {
                                BlockMoveData(extentData, &foundData, sizeof(HFSPlusExtentRecord));
        
                        if (err == noErr) {
                                BlockMoveData(extentData, &foundData, sizeof(HFSPlusExtentRecord));

-                               err = BTReplaceRecord(btFCB, btIterator, &btRecord, btRecordSize);
+                               err = BTReplaceRecord(btFCB, &btIterator, &btRecord, btRecordSize);

                        }
                        (void) BTFlushPath(btFCB);
                }
                hfs_systemfile_unlock(vcb, lockflags);
                        }
                        (void) BTFlushPath(btFCB);
                }
                hfs_systemfile_unlock(vcb, lockflags);

-               FREE(btIterator, M_TEMP);       

        }
        
        return err;
        }
        
        return err;


@@ -1932,7 +1943,7 @@ static OSErr HFSPlusToHFSExtents(
 
        #if DEBUG_BUILD
                if (oldExtents[3].startBlock || oldExtents[3].blockCount) {
 
        #if DEBUG_BUILD
                if (oldExtents[3].startBlock || oldExtents[3].blockCount) {

-                       DebugStr("\pExtentRecord with > 3 extents is invalid for HFS");
+                       DebugStr("ExtentRecord with > 3 extents is invalid for HFS");

                        err = fsDSIntErr;
                }
        #endif
                        err = fsDSIntErr;
                }
        #endif


@@ -1964,12 +1975,12 @@ static OSErr GetFCBExtentRecord(
 
 static Boolean ExtentsAreIntegral(
        const HFSPlusExtentRecord extentRecord,
 
 static Boolean ExtentsAreIntegral(
        const HFSPlusExtentRecord extentRecord,

-       UInt32          mask,
-       UInt32          *blocksChecked,
+       u_int32_t       mask,
+       u_int32_t       *blocksChecked,

        Boolean         *checkedLastExtent)
 {
        Boolean         *checkedLastExtent)
 {

-       UInt32          blocks;
-       UInt32          extentIndex;
+       u_int32_t       blocks;
+       u_int32_t       extentIndex;

 
        *blocksChecked = 0;
        *checkedLastExtent = false;
 
        *blocksChecked = 0;
        *checkedLastExtent = false;


@@ -2006,12 +2017,12 @@ __private_extern__
 Boolean NodesAreContiguous(
        ExtendedVCB     *vcb,
        FCB                     *fcb,
 Boolean NodesAreContiguous(
        ExtendedVCB     *vcb,
        FCB                     *fcb,

-       UInt32          nodeSize)
+       u_int32_t       nodeSize)

 {
 {

-       UInt32                          mask;
-       UInt32                          startBlock;
-       UInt32                          blocksChecked;
-       UInt32                          hint;
+       u_int32_t                       mask;
+       u_int32_t                       startBlock;
+       u_int32_t                       blocksChecked;
+       u_int32_t                       hint;

        HFSPlusExtentKey        key;
        HFSPlusExtentRecord     extents;
        OSErr                           result;
        HFSPlusExtentKey        key;
        HFSPlusExtentRecord     extents;
        OSErr                           result;


@@ -2030,7 +2041,7 @@ Boolean NodesAreContiguous(
                return FALSE;
 
        if ( lastExtentReached || 
                return FALSE;
 
        if ( lastExtentReached || 

-                (SInt64)((SInt64)blocksChecked * (SInt64)vcb->blockSize) >= (SInt64)fcb->ff_size)
+                (int64_t)((int64_t)blocksChecked * (int64_t)vcb->blockSize) >= (int64_t)fcb->ff_size)

                return TRUE;
 
        startBlock = blocksChecked;
                return TRUE;
 
        startBlock = blocksChecked;