/*
- * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
static OSErr UpdateExtentRecord (
ExtendedVCB *vcb,
- FCB *fcb,
+ FCB *fcb,
+ int deleted,
const HFSPlusExtentKey *extentFileKey,
const HFSPlusExtentRecord extentData,
u_int32_t extentBTreeHint);
u_int32_t *foundHint)
{
FCB * fcb;
- BTreeIterator *btIterator;
+ BTreeIterator btIterator;
FSBufferDescriptor btRecord;
OSErr err;
u_int16_t btRecordSize;
*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;
- extentKeyPtr = (HFSExtentKey*) &btIterator->key;
+ extentKeyPtr = (HFSExtentKey*) &btIterator.key;
extentKeyPtr->keyLength = kHFSExtentKeyMaximumLength;
extentKeyPtr->forkType = forkType;
extentKeyPtr->fileID = fileID;
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) {
- 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).
HFSPlusExtentKey * extentKeyPtr;
HFSPlusExtentRecord extentData;
- extentKeyPtr = (HFSPlusExtentKey*) &btIterator->key;
+ extentKeyPtr = (HFSPlusExtentKey*) &btIterator.key;
extentKeyPtr->keyLength = kHFSPlusExtentKeyMaximumLength;
extentKeyPtr->forkType = forkType;
extentKeyPtr->pad = 0;
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) {
- 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).
}
if (foundHint)
- *foundHint = btIterator->hint.nodeNum;
- FREE(btIterator, M_TEMP);
+ *foundHint = btIterator.hint.nodeNum;
return err;
}
HFSPlusExtentRecord extents,
u_int32_t *hint)
{
- BTreeIterator * btIterator;
+ BTreeIterator btIterator;
FSBufferDescriptor btRecord;
u_int16_t btRecordSize;
int lockflags;
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
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;
btRecord.itemSize = btRecordSize;
btRecord.itemCount = 1;
- BlockMoveData(key, &btIterator->key, sizeof(HFSPlusExtentKey));
+ BlockMoveData(key, &btIterator.key, sizeof(HFSPlusExtentKey));
}
if (err == noErr)
- err = BTInsertRecord(GetFileControlBlock(vcb->extentsRefNum), btIterator, &btRecord, btRecordSize);
+ err = BTInsertRecord(GetFileControlBlock(vcb->extentsRefNum), &btIterator, &btRecord, btRecordSize);
if (err == noErr)
- *hint = btIterator->hint.nodeNum;
+ *hint = btIterator.hint.nodeNum;
(void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));
hfs_systemfile_unlock(vcb, lockflags);
- FREE(btIterator, M_TEMP);
return err;
}
u_int32_t fileID,
u_int32_t startBlock)
{
- BTreeIterator * btIterator;
+ BTreeIterator btIterator;
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;
- keyPtr = (HFSExtentKey*) &btIterator->key;
+ keyPtr = (HFSExtentKey*) &btIterator.key;
keyPtr->keyLength = kHFSExtentKeyMaximumLength;
keyPtr->forkType = forkType;
keyPtr->fileID = fileID;
else { // HFS Plus volume
HFSPlusExtentKey * keyPtr;
- keyPtr = (HFSPlusExtentKey*) &btIterator->key;
+ keyPtr = (HFSPlusExtentKey*) &btIterator.key;
keyPtr->keyLength = kHFSPlusExtentKeyMaximumLength;
keyPtr->forkType = forkType;
keyPtr->pad = 0;
keyPtr->startBlock = startBlock;
}
- err = BTDeleteRecord(GetFileControlBlock(vcb->extentsRefNum), btIterator);
+ err = BTDeleteRecord(GetFileControlBlock(vcb->extentsRefNum), &btIterator);
(void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));
- FREE(btIterator, M_TEMP);
return err;
}
//
//_________________________________________________________________________________
-__private_extern__
OSErr MapFileBlockC (
ExtendedVCB *vcb, // volume that file resides on
FCB *fcb, // FCB of file
//
// Determine the end of the available space. It will either be the end of the extent,
// or the file's PEOF, whichever is smaller.
+
//
dataEnd = (off_t)((off_t)(nextFABN) * (off_t)(allocBlockSize)); // Assume valid data through end of this extent
if (((off_t)fcb->ff_blocks * (off_t)allocBlockSize) < dataEnd) // Is PEOF shorter?
if (availableBytes)
{
tmpOff = dataEnd - offset;
+ /*
+ * Disallow negative runs.
+ */
+ if (tmpOff <= 0) {
+ return EINVAL;
+ }
if (tmpOff > (off_t)(numberOfBytes))
*availableBytes = numberOfBytes; // more there than they asked for, so pin the output
else
break;
}
- err = BlockDeallocate( vcb, extentRecord[extentIndex].startBlock, numAllocationBlocks );
+ err = BlockDeallocate( vcb, extentRecord[extentIndex].startBlock, numAllocationBlocks , 0);
if ( err != noErr )
break;
// Function: Flushes the extent file for a specified volume
//\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__
OSErr FlushExtentFile( ExtendedVCB *vcb )
{
FCB * fcb;
#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)
- DebugStr("\pHFS: trial Key is wrong length");
+ DebugStr("HFS: trial Key is wrong length");
#endif
result = -1; // assume searchKey < trialKey
#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)
- DebugStr("\pHFS: trial Key is wrong length");
+ DebugStr("HFS: trial Key is wrong length");
#endif
result = -1; // assume searchKey < trialKey
* Used by hfs_extendfs to extend the volume allocation bitmap file.
*
*/
-__private_extern__
int
AddFileExtent(ExtendedVCB *vcb, FCB *fcb, u_int32_t startBlock, u_int32_t blockCount)
{
*/
foundData[foundIndex].startBlock = startBlock;
foundData[foundIndex].blockCount = blockCount;
- error = UpdateExtentRecord(vcb, fcb, &foundKey, foundData, hint);
+ error = UpdateExtentRecord(vcb, fcb, 0, &foundKey, foundData, hint);
}
(void) FlushExtentFile(vcb);
//
//_________________________________________________________________________________
-__private_extern__
OSErr ExtendFileC (
ExtendedVCB *vcb, // volume that file resides on
FCB *fcb, // FCB of file to truncate
// 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. For non-system files we favor locality and fragmentation over
+ * contiguity as it can result in fewer blocks being needed from the underlying
+ * filesystem that the sparse image resides upon.
+ */
err = noErr;
- wantContig = true;
+ if ( (vcb->hfs_flags & HFS_HAS_SPARSE_DEVICE)
+ && (fcb->ff_cp->c_fileid >= kHFSFirstUserCatalogNodeID)
+ && (flags & kEFMetadataMask) == 0) {
+ /*
+ * We want locality over contiguity so by default we set wantContig to
+ * false unless we hit one of the circumstances below.
+ */
+ wantContig = false;
+ if (hfs_isrbtree_active(VCBTOHFS(vcb))) {
+ /*
+ * If the red-black tree is acive, we can always find a suitable contiguous
+ * chunk. So if the user specifically requests contiguous files, we should
+ * honor that no matter what kind of device it is.
+ */
+ if (forceContig) {
+ wantContig = true;
+ }
+ }
+ else {
+ /*
+ * If the red-black tree is not active, then only set wantContig to true
+ * if we have never done a contig scan on the device, which would populate
+ * the free extent cache. Note that the caller may explicitly unset the
+ * DID_CONTIG_SCAN bit in order to force us to vend a contiguous extent here
+ * if the caller wants to get a contiguous chunk.
+ */
+ if ((vcb->hfs_flags & HFS_DID_CONTIG_SCAN) == 0) {
+ vcb->hfs_flags |= HFS_DID_CONTIG_SCAN;
+ wantContig = true;
+ }
+ }
+ }
+ else {
+ wantContig = true;
+ }
useMetaZone = flags & kEFMetadataMask;
- vcb->vcbFreeExtCnt = 0; /* For now, force rebuild of free extent list */
do {
if (blockHint != 0)
startBlock = blockHint;
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);
}
if ((actualStartBlock == startBlock) && (blockHint == 0)) {
// We grew the file's last extent, so just adjust the number of blocks.
foundData[foundIndex].blockCount += actualNumBlocks;
- err = UpdateExtentRecord(vcb, fcb, &foundKey, foundData, hint);
+ err = UpdateExtentRecord(vcb, fcb, 0, &foundKey, foundData, hint);
if (err != noErr) break;
}
else {
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;
}
// 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;
// Add a new extent into this record and update.
foundData[foundIndex].startBlock = actualStartBlock;
foundData[foundIndex].blockCount = actualNumBlocks;
- err = UpdateExtentRecord(vcb, fcb, &foundKey, foundData, hint);
+ err = UpdateExtentRecord(vcb, fcb, 0, &foundKey, foundData, hint);
if (err != noErr) break;
}
}
//
//_________________________________________________________________________________
-__private_extern__
OSErr TruncateFileC (
ExtendedVCB *vcb, // volume that file resides on
FCB *fcb, // FCB of file to truncate
int64_t peof, // new physical size for file
+ int deleted, // if nonzero, the file's catalog record has already been deleted.
+ int rsrc, // does this represent a resource fork or not?
+ uint32_t fileid, // the fileid of the file we're manipulating.
Boolean truncateToExtent) // if true, truncate to end of extent containing newPEOF
+
{
OSErr err;
u_int32_t nextBlock; // next file allocation block to consider
recordDeleted = false;
- if (vcb->vcbSigWord == kHFSPlusSigWord)
+ if (vcb->vcbSigWord == kHFSPlusSigWord) {
numExtentsPerRecord = kHFSPlusExtentDensity;
- else
+ }
+ else {
numExtentsPerRecord = kHFSExtentDensity;
-
- if (FORK_IS_RSRC(fcb))
+ }
+
+ if (rsrc) {
forkType = kResourceForkType;
- else
+ }
+ else {
forkType = kDataForkType;
-
+ }
+
temp64 = fcb->ff_blocks;
physNumBlocks = (u_int32_t)temp64;
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
- 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;
* XXX Any errors could cause ff_blocks and c_blocks to get out of sync...
*/
numBlocks = peof / vcb->blockSize;
- FTOC(fcb)->c_blocks -= (fcb->ff_blocks - numBlocks);
+ if (!deleted) {
+ FTOC(fcb)->c_blocks -= (fcb->ff_blocks - numBlocks);
+ }
fcb->ff_blocks = numBlocks;
-
+
// this catalog entry is modified and *must* get forced
// to disk when hfs_update() is called
- FTOC(fcb)->c_flag |= C_MODIFIED | C_FORCEUPDATE;
-
+ if (!deleted) {
+ /*
+ * If the file is already C_NOEXISTS, then the catalog record
+ * has been removed from disk already. We wouldn't need to force
+ * another update
+ */
+ FTOC(fcb)->c_flag |= (C_MODIFIED | C_FORCEUPDATE);
+ }
//
// If the new PEOF is 0, then truncateToExtent has no meaning (we should always deallocate
// all storage).
int i;
// Deallocate all the extents for this fork
- err = DeallocateFork(vcb, FTOC(fcb)->c_fileid, forkType, fcb->fcbExtents, &recordDeleted);
+ err = DeallocateFork(vcb, fileid, forkType, fcb->fcbExtents, &recordDeleted);
if (err != noErr) goto ErrorExit; // got some error, so return it
// Update the catalog extent record (making sure it's zeroed out)
// 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;
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;
// record (in the FCB, or extents file).
//
if (extentChanged) {
- err = UpdateExtentRecord(vcb, fcb, &key, extentRecord, hint);
+ err = UpdateExtentRecord(vcb, fcb, deleted, &key, extentRecord, hint);
if (err != noErr) goto ErrorExit;
}
// blocks.
//
if (nextBlock < physNumBlocks)
- err = TruncateExtents(vcb, forkType, FTOC(fcb)->c_fileid, nextBlock, &recordDeleted);
+ err = TruncateExtents(vcb, forkType, fileid, nextBlock, &recordDeleted);
Done:
ErrorExit:
* HFS Plus only
*
*/
-__private_extern__
OSErr HeadTruncateFile (
ExtendedVCB *vcb,
FCB *fcb,
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
goto ErrorExit; /* uh oh */
else {
error = 0;
- printf("HeadTruncateFile: problems deallocating %s (%d)\n",
+ printf("hfs: HeadTruncateFile: problems deallocating %s (%d)\n",
FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);
}
}
* a known state.
*/
if (error != btNotFound)
- printf("HeadTruncateFile: problems finding extents %s (%d)\n",
+ 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;
break; /* end of extents */
if (blksfreed < headblks) {
- error = BlockDeallocate(vcb, extents[i].startBlock, blkcnt);
+ error = BlockDeallocate(vcb, extents[i].startBlock, blkcnt, 0);
if (error) {
- printf("HeadTruncateFile: problems deallocating %s (%d)\n",
+ 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 = DeleteExtentRecord(vcb, forkType, fileID, startblk);
if (error) {
- printf("HeadTruncateFile: problems deallocating %s (%d)\n",
+ 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;
}
//
// Input: vcb - the volume containing the extents
// fcb - the file that owns the extents
+// deleted - whether or not the file is already deleted
// extentFileKey - pointer to extent key record (xkr)
// If the key length is 0, then the extents are actually part
// of the catalog record, stored in the FCB.
// (other) = error from BTree
//============================================================================
-static OSErr UpdateExtentRecord (
- ExtendedVCB *vcb,
- FCB *fcb,
- const HFSPlusExtentKey *extentFileKey,
- const HFSPlusExtentRecord extentData,
- u_int32_t extentBTreeHint)
+static OSErr UpdateExtentRecord (ExtendedVCB *vcb, FCB *fcb, int deleted,
+ const HFSPlusExtentKey *extentFileKey,
+ const HFSPlusExtentRecord extentData,
+ u_int32_t extentBTreeHint)
{
OSErr err = noErr;
if (extentFileKey->keyLength == 0) { // keyLength == 0 means the FCB's extent record
BlockMoveData(extentData, fcb->fcbExtents, sizeof(HFSPlusExtentRecord));
- FTOC(fcb)->c_flag |= C_MODIFIED;
+ if (!deleted) {
+ FTOC(fcb)->c_flag |= C_MODIFIED;
+ }
}
else {
- BTreeIterator * btIterator;
+ BTreeIterator btIterator;
FSBufferDescriptor btRecord;
u_int16_t btRecordSize;
FCB * btFCB;
//
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
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;
- 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;
- 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)
- 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
- 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;
- err = BTSearchRecord(btFCB, btIterator, &btRecord, &btRecordSize, btIterator);
+ err = BTSearchRecord(btFCB, &btIterator, &btRecord, &btRecordSize, &btIterator);
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);
- FREE(btIterator, M_TEMP);
}
return err;
#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
// Called by BTOpenPath during volume mount
//_________________________________________________________________________________
-__private_extern__
Boolean NodesAreContiguous(
ExtendedVCB *vcb,
FCB *fcb,
projects / apple / xnu.git / blobdiff