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

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_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 Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*	@(#)hfs_btreeio.c
*
*	(c) 1998, 2000 Apple Computer, Inc.  All Rights Reserved
*
*	hfs_btreeio.c -- I/O Routines for the HFS B-tree files.
*
*	HISTORY
*	15-Feb-2000	Don Brady	Added ClearBTNodes.
*	16-Jul-1998	Don Brady		In ExtendBtreeFile force all b-tree nodes to be contiguous on disk.
*	 4-Jun-1998	Pat Dirks		Changed to do all B*-Tree writes synchronously (FORCESYNCBTREEWRITES = 1)
*	18-apr-1998	Don Brady		Call brelse on bread failure.
*	17-Apr-1998	Pat Dirks		Fixed ReleaseBTreeBlock to not call brelse when bwrite or bdwrite is called.
*	13-apr-1998	Don Brady		Add ExtendBTreeFile routine (from BTreeWrapper.c).
*	26-mar-1998	Don Brady		SetBTreeBlockSize was incorrectly excluding 512 byte blockSize.
*	18-feb-1998	Don Brady		Initially created file.
*
*/

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/mount.h>
#include <sys/vnode.h>


#include "hfs.h"
#include "hfs_dbg.h"
#include "hfs_endian.h"

#include "hfscommon/headers/FileMgrInternal.h"
#include "hfscommon/headers/BTreesPrivate.h"

#define FORCESYNCBTREEWRITES 0

static OSStatus FlushAlternate( ExtendedVCB *vcb );

static int ClearBTNodes(struct vnode *vp, long blksize, off_t offset, off_t amount);


OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize, ItemCount minBlockCount)
{
	BTreeControlBlockPtr	bTreePtr;
	
	DBG_ASSERT(vp != NULL);
	DBG_ASSERT(VTOFCB(vp) != NULL);
	DBG_ASSERT(VTOFCB(vp)->fcbBTCBPtr != NULL);
	DBG_ASSERT(blockSize >= kMinNodeSize);
    if (blockSize > MAXBSIZE )
        return (fsBTBadNodeSize);

    DBG_TREE(("SetBlockSizeProc: blockSize=%ld for file %ld\n", blockSize, H_FILEID(VTOH(vp))));

	bTreePtr = (BTreeControlBlockPtr)(VTOH(vp)->fcbBTCBPtr);
	bTreePtr->nodeSize = blockSize;
	
    return (E_NONE);
}


OSStatus GetBTreeBlock(FileReference vp, UInt32 blockNum, GetBlockOptions options, BlockDescriptor *block)
{
    OSStatus	 retval = E_NONE;
    struct buf   *bp = NULL;

    if (options & kGetEmptyBlock)
        bp = getblk (vp,
                    IOBLKNOFORBLK(blockNum, VTOHFS(vp)->hfs_phys_block_size),
                    IOBYTECCNTFORBLK(blockNum, block->blockSize, VTOHFS(vp)->hfs_phys_block_size),
                    0,
                    0,
                    BLK_META);
    else
        retval = meta_bread(vp,
                        IOBLKNOFORBLK(blockNum, VTOHFS(vp)->hfs_phys_block_size),
                        IOBYTECCNTFORBLK(blockNum, block->blockSize, VTOHFS(vp)->hfs_phys_block_size),
                        NOCRED,
                        &bp);

    DBG_ASSERT(bp != NULL);
    DBG_ASSERT(bp->b_data != NULL);
    DBG_ASSERT(bp->b_bcount == block->blockSize);
    DBG_ASSERT(bp->b_lblkno == blockNum);

    if (bp == NULL)
        retval = -1;	//XXX need better error

    if (retval == E_NONE) {
        block->blockHeader = bp;
        block->buffer = bp->b_data + IOBYTEOFFSETFORBLK(bp->b_blkno, VTOHFS(vp)->hfs_phys_block_size);
        block->blockReadFromDisk = (bp->b_flags & B_CACHE) == 0;	/* not found in cache ==> came from disk */

#if BYTE_ORDER == LITTLE_ENDIAN
        /* Endian swap B-Tree node (only if it's a valid block) */
        if (!(options & kGetEmptyBlock)) {
            /* This happens when we first open the b-tree, we might not have all the node data on hand */
            if ((((BTNodeDescriptor *)block->buffer)->kind == kBTHeaderNode) &&
                (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize != bp->b_bcount) &&
                (SWAP_BE16 (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize) != bp->b_bcount)) {

                /* Don't swap the descriptors at all, we don't care (this block will be invalidated) */
                SWAP_BT_NODE (block, ISHFSPLUS(VTOVCB(vp)), H_FILEID(VTOH(vp)), 3);

            /* The node needs swapping */
            } else if (*((UInt16 *)((char *)block->buffer + (block->blockSize - sizeof (UInt16)))) == 0x0e00) {
                SWAP_BT_NODE (block, ISHFSPLUS(VTOVCB(vp)), H_FILEID(VTOH(vp)), 0);
#if 0
            /* The node is not already in native byte order, hence corrupt */
            } else if (*((UInt16 *)((char *)block->buffer + (block->blockSize - sizeof (UInt16)))) != 0x000e) {
                panic ("%s Corrupt B-Tree node detected!\n", "GetBTreeBlock:");
#endif
            }
        }
#endif
    } else {
    	if (bp)
   			brelse(bp);
        block->blockHeader = NULL;
        block->buffer = NULL;
    }

    return (retval);
}


OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr, ReleaseBlockOptions options)
{
    OSStatus	retval = E_NONE;
    struct buf *bp = NULL;

    bp = (struct buf *) blockPtr->blockHeader;

    if (bp == NULL) {
        DBG_TREE(("ReleaseBlockProc: blockHeader is zero!\n"));
        retval = -1;
        goto exit;
    }

    if (options & kTrashBlock) {
        bp->b_flags |= B_INVAL;
    	brelse(bp);	/* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */
    } else {
        if (options & kForceWriteBlock) {
            bp->b_flags |= B_DIRTY;
            retval = VOP_BWRITE(bp);
        } else if (options & kMarkBlockDirty) {
            bp->b_flags |= B_DIRTY;
#if FORCESYNCBTREEWRITES
            VOP_BWRITE(bp);
#else
			if (options & kLockTransaction) {

	            /*
	             *
	             * Set the B_LOCKED flag and unlock the buffer, causing brelse to move
	             * the buffer onto the LOCKED free list.  This is necessary, otherwise
	             * getnewbuf() would try to reclaim the buffers using bawrite, which
	             * isn't going to work.
	             *
	             */
	            bp->b_flags |= B_LOCKED;
	        };
            bdwrite(bp);

#endif
        } else {
    		brelse(bp);	/* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */
        };
    };

exit:
    return (retval);
}


OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF)
{
#pragma unused (maxEOF)

	OSStatus	retval;
	UInt64		actualBytesAdded;
	UInt64		bytesToAdd;
    UInt32		extendFlags;
	BTreeInfoRec btInfo;
	ExtendedVCB	*vcb;
	FCB			*filePtr;
    struct proc *p = NULL;


	filePtr = GetFileControlBlock(vp);

	if ( minEOF > filePtr->fcbEOF )
	{
		bytesToAdd = minEOF - filePtr->fcbEOF;

		if (bytesToAdd < filePtr->fcbClmpSize)
			bytesToAdd = filePtr->fcbClmpSize;		//XXX why not always be a mutiple of clump size?
	}
	else
	{
		DBG_TREE((" ExtendBTreeFile: minEOF is smaller than current size!"));
		return -1;
	}

	vcb = FCBTOVCB(filePtr);
	
	/*
	 * The Extents B-tree can't have overflow extents. ExtendFileC will
	 * return an error if an attempt is made to extend the Extents B-tree
	 * when the resident extents are exhausted.
	 */
    /* XXX warning - this can leave the volume bitmap unprotected during ExtendFileC call */
	if(H_FILEID(filePtr) != kHFSExtentsFileID)
	{
		p = current_proc();
		/* lock extents b-tree (also protects volume bitmap) */
		retval = hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_EXCLUSIVE, p);
		if (retval)
			return (retval);
	}

    (void) BTGetInformation(filePtr, 0, &btInfo);

	/*
     * The b-tree code expects nodes to be contiguous. So when
	 * the allocation block size is less than the b-tree node
     * size, we need to force disk allocations to be contiguous.
     */
	if (vcb->blockSize >= btInfo.nodeSize) {
		extendFlags = 0;
	} else {
		/* Ensure that all b-tree nodes are contiguous on disk */
		extendFlags = kEFAllMask | kEFContigMask;
	}

    retval = ExtendFileC(vcb, filePtr, bytesToAdd, extendFlags, &actualBytesAdded );

	if(H_FILEID(filePtr) != kHFSExtentsFileID)
		(void) hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_RELEASE, p);

	if (retval)
		return (retval);

	if (actualBytesAdded < bytesToAdd)
		DBG_TREE((" ExtendBTreeFile: actualBytesAdded < bytesToAdd!"));
	
	filePtr->fcbEOF = filePtr->fcbPLen;

	retval = ClearBTNodes(vp, btInfo.nodeSize, filePtr->fcbEOF - actualBytesAdded, actualBytesAdded);	
	if (retval)
		return (retval);
	
	/*
	 * Update the Alternate MDB or Alternate VolumeHeader
	 */
	if ((H_FILEID(filePtr) == kHFSExtentsFileID)	||
	    (H_FILEID(filePtr) == kHFSCatalogFileID)	||
	    (H_FILEID(filePtr) == kHFSAttributesFileID)
	   ) {
		MarkVCBDirty( vcb );
		if (vcb->vcbSigWord == kHFSPlusSigWord) {
			retval = hfs_flushvolumeheader(VCBTOHFS(vcb), 0);
		} else {
			retval = hfs_flushMDB(VCBTOHFS(vcb), 0);
		}
		if (retval == 0) {
			retval = FlushAlternate(vcb);
		}
	}
	
	return retval;
}


static OSStatus
FlushAlternate( ExtendedVCB *vcb )
{
	void *maindata;
	void *altdata;
	int result;

	/* Get the main MDB/VolumeHeader block */
	result = GetBlock_glue(gbDefault,
                	(vcb->hfsPlusIOPosOffset / kHFSBlockSize) + kMasterDirectoryBlock,
                	(Ptr *)&maindata, kNoFileReference, vcb);
	if (result) return (result);
	
	/* Get the alternate MDB/VolumeHeader block */
	result = GetBlock_glue( gbDefault, vcb->altIDSector,
                	(Ptr *)&altdata, kNoFileReference, vcb );

	if (result == 0) {
		bcopy(maindata, altdata, kMDBSize);

		result = RelBlock_glue( (Ptr)altdata, rbWriteMask );
	}

	(void) RelBlock_glue( (Ptr)maindata, rbFreeMask );
	
	return (result);
}


/*
 * Clear out (zero) new b-tree nodes on disk.
 */
static int
ClearBTNodes(struct vnode *vp, long blksize, off_t offset, off_t amount)
{
	struct buf *bp = NULL;
	daddr_t blk;
	daddr_t blkcnt;
    
	blk = offset / blksize;
	blkcnt = amount / blksize;
	
	while (blkcnt > 0) {
		bp = getblk(vp, blk, blksize, 0, 0, BLK_META);
		if (bp == NULL)
			continue;
		bzero((char *)bp->b_data, blksize);
		bp->b_flags |= (B_DIRTY | B_AGE);

		 /* wait/yield every 32 blocks so we don't hog all the buffers */
		if ((blk % 32) == 0)
			VOP_BWRITE(bp);
		else
			bawrite(bp);
		--blkcnt;
		++blk;
	}

	return (0);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/* @(#)hfs_btreeio.c
	23	*
	24	* (c) 1998, 2000 Apple Computer, Inc. All Rights Reserved
	25	*
	26	* hfs_btreeio.c -- I/O Routines for the HFS B-tree files.
	27	*
	28	* HISTORY
	29	* 15-Feb-2000 Don Brady Added ClearBTNodes.
	30	* 16-Jul-1998 Don Brady In ExtendBtreeFile force all b-tree nodes to be contiguous on disk.
	31	* 4-Jun-1998 Pat Dirks Changed to do all B*-Tree writes synchronously (FORCESYNCBTREEWRITES = 1)
	32	* 18-apr-1998 Don Brady Call brelse on bread failure.
	33	* 17-Apr-1998 Pat Dirks Fixed ReleaseBTreeBlock to not call brelse when bwrite or bdwrite is called.
	34	* 13-apr-1998 Don Brady Add ExtendBTreeFile routine (from BTreeWrapper.c).
	35	* 26-mar-1998 Don Brady SetBTreeBlockSize was incorrectly excluding 512 byte blockSize.
	36	* 18-feb-1998 Don Brady Initially created file.
	37	*
	38	*/
	39
	40	#include <sys/param.h>
	41	#include <sys/systm.h>
	42	#include <sys/buf.h>
	43	#include <sys/mount.h>
	44	#include <sys/vnode.h>
	45
	46
	47	#include "hfs.h"
	48	#include "hfs_dbg.h"
	49	#include "hfs_endian.h"
	50
	51	#include "hfscommon/headers/FileMgrInternal.h"
	52	#include "hfscommon/headers/BTreesPrivate.h"
	53
	54	#define FORCESYNCBTREEWRITES 0
	55
	56	static OSStatus FlushAlternate( ExtendedVCB *vcb );
	57
	58	static int ClearBTNodes(struct vnode *vp, long blksize, off_t offset, off_t amount);
	59
	60
	61	OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize, ItemCount minBlockCount)
	62	{
	63	BTreeControlBlockPtr bTreePtr;
	64
65	DBG_ASSERT(vp != NULL);
66	DBG_ASSERT(VTOFCB(vp) != NULL);
67	DBG_ASSERT(VTOFCB(vp)->fcbBTCBPtr != NULL);
68	DBG_ASSERT(blockSize >= kMinNodeSize);
69	if (blockSize > MAXBSIZE )
70	return (fsBTBadNodeSize);
71
72	DBG_TREE(("SetBlockSizeProc: blockSize=%ld for file %ld\n", blockSize, H_FILEID(VTOH(vp))));
73
74	bTreePtr = (BTreeControlBlockPtr)(VTOH(vp)->fcbBTCBPtr);
75	bTreePtr->nodeSize = blockSize;
76
77	return (E_NONE);
78	}
79
80
81	OSStatus GetBTreeBlock(FileReference vp, UInt32 blockNum, GetBlockOptions options, BlockDescriptor *block)
82	{
83	OSStatus retval = E_NONE;
84	struct buf *bp = NULL;
85
86	if (options & kGetEmptyBlock)
87	bp = getblk (vp,
88	IOBLKNOFORBLK(blockNum, VTOHFS(vp)->hfs_phys_block_size),
89	IOBYTECCNTFORBLK(blockNum, block->blockSize, VTOHFS(vp)->hfs_phys_block_size),
90	0,
91	0,
92	BLK_META);
93	else
94	retval = meta_bread(vp,
95	IOBLKNOFORBLK(blockNum, VTOHFS(vp)->hfs_phys_block_size),
96	IOBYTECCNTFORBLK(blockNum, block->blockSize, VTOHFS(vp)->hfs_phys_block_size),
97	NOCRED,
98	&bp);
99
100	DBG_ASSERT(bp != NULL);
101	DBG_ASSERT(bp->b_data != NULL);
102	DBG_ASSERT(bp->b_bcount == block->blockSize);
103	DBG_ASSERT(bp->b_lblkno == blockNum);
104
105	if (bp == NULL)
106	retval = -1; //XXX need better error
107
108	if (retval == E_NONE) {
109	block->blockHeader = bp;
110	block->buffer = bp->b_data + IOBYTEOFFSETFORBLK(bp->b_blkno, VTOHFS(vp)->hfs_phys_block_size);
111	block->blockReadFromDisk = (bp->b_flags & B_CACHE) == 0; /* not found in cache ==> came from disk */
112
113	#if BYTE_ORDER == LITTLE_ENDIAN
114	/* Endian swap B-Tree node (only if it's a valid block) */
115	if (!(options & kGetEmptyBlock)) {
116	/* This happens when we first open the b-tree, we might not have all the node data on hand */
117	if ((((BTNodeDescriptor *)block->buffer)->kind == kBTHeaderNode) &&
118	(((BTHeaderRec )((char )block->buffer + 14))->nodeSize != bp->b_bcount) &&
119	(SWAP_BE16 (((BTHeaderRec )((char )block->buffer + 14))->nodeSize) != bp->b_bcount)) {
120
121	/* Don't swap the descriptors at all, we don't care (this block will be invalidated) */
122	SWAP_BT_NODE (block, ISHFSPLUS(VTOVCB(vp)), H_FILEID(VTOH(vp)), 3);
123
124	/* The node needs swapping */
125	} else if (((UInt16 )((char *)block->buffer + (block->blockSize - sizeof (UInt16)))) == 0x0e00) {
126	SWAP_BT_NODE (block, ISHFSPLUS(VTOVCB(vp)), H_FILEID(VTOH(vp)), 0);
127	#if 0
128	/* The node is not already in native byte order, hence corrupt */
129	} else if (((UInt16 )((char *)block->buffer + (block->blockSize - sizeof (UInt16)))) != 0x000e) {
130	panic ("%s Corrupt B-Tree node detected!\n", "GetBTreeBlock:");
131	#endif
132	}
133	}
134	#endif
135	} else {
136	if (bp)
137	brelse(bp);
138	block->blockHeader = NULL;
139	block->buffer = NULL;
140	}
141
142	return (retval);
143	}
144
145
146	OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr, ReleaseBlockOptions options)
147	{
148	OSStatus retval = E_NONE;
149	struct buf *bp = NULL;
150
151	bp = (struct buf *) blockPtr->blockHeader;
152
153	if (bp == NULL) {
154	DBG_TREE(("ReleaseBlockProc: blockHeader is zero!\n"));
155	retval = -1;
156	goto exit;
157	}
158
159	if (options & kTrashBlock) {
160	bp->b_flags \|= B_INVAL;
161	brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */
162	} else {
163	if (options & kForceWriteBlock) {
164	bp->b_flags \|= B_DIRTY;
165	retval = VOP_BWRITE(bp);
166	} else if (options & kMarkBlockDirty) {
167	bp->b_flags \|= B_DIRTY;
168	#if FORCESYNCBTREEWRITES
169	VOP_BWRITE(bp);
170	#else
171	if (options & kLockTransaction) {
172
173	/*
174	*
175	* Set the B_LOCKED flag and unlock the buffer, causing brelse to move
176	* the buffer onto the LOCKED free list. This is necessary, otherwise
177	* getnewbuf() would try to reclaim the buffers using bawrite, which
178	* isn't going to work.
179	*
180	*/
181	bp->b_flags \|= B_LOCKED;
182	};
183	bdwrite(bp);
184
185	#endif
186	} else {
187	brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */
188	};
189	};
190
191	exit:
192	return (retval);
193	}
194
195
196	OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF)
197	{
198	#pragma unused (maxEOF)
199
200	OSStatus retval;
201	UInt64 actualBytesAdded;
202	UInt64 bytesToAdd;
203	UInt32 extendFlags;
204	BTreeInfoRec btInfo;
205	ExtendedVCB *vcb;
206	FCB *filePtr;
207	struct proc *p = NULL;
208
209
210	filePtr = GetFileControlBlock(vp);
211
212	if ( minEOF > filePtr->fcbEOF )
213	{
214	bytesToAdd = minEOF - filePtr->fcbEOF;
215
216	if (bytesToAdd < filePtr->fcbClmpSize)
217	bytesToAdd = filePtr->fcbClmpSize; //XXX why not always be a mutiple of clump size?
218	}
219	else
220	{
221	DBG_TREE((" ExtendBTreeFile: minEOF is smaller than current size!"));
222	return -1;
223	}
224
225	vcb = FCBTOVCB(filePtr);
226
227	/*
228	* The Extents B-tree can't have overflow extents. ExtendFileC will
229	* return an error if an attempt is made to extend the Extents B-tree
230	* when the resident extents are exhausted.
231	*/
232	/* XXX warning - this can leave the volume bitmap unprotected during ExtendFileC call */
233	if(H_FILEID(filePtr) != kHFSExtentsFileID)
234	{
235	p = current_proc();
236	/* lock extents b-tree (also protects volume bitmap) */
237	retval = hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_EXCLUSIVE, p);
238	if (retval)
239	return (retval);
240	}
241
242	(void) BTGetInformation(filePtr, 0, &btInfo);
243
244	/*
245	* The b-tree code expects nodes to be contiguous. So when
246	* the allocation block size is less than the b-tree node
247	* size, we need to force disk allocations to be contiguous.
248	*/
249	if (vcb->blockSize >= btInfo.nodeSize) {
250	extendFlags = 0;
251	} else {
252	/* Ensure that all b-tree nodes are contiguous on disk */
253	extendFlags = kEFAllMask \| kEFContigMask;
254	}
255
256	retval = ExtendFileC(vcb, filePtr, bytesToAdd, extendFlags, &actualBytesAdded );
257
258	if(H_FILEID(filePtr) != kHFSExtentsFileID)
259	(void) hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_RELEASE, p);
260
261	if (retval)
262	return (retval);
263
264	if (actualBytesAdded < bytesToAdd)
265	DBG_TREE((" ExtendBTreeFile: actualBytesAdded < bytesToAdd!"));
266
267	filePtr->fcbEOF = filePtr->fcbPLen;
268
269	retval = ClearBTNodes(vp, btInfo.nodeSize, filePtr->fcbEOF - actualBytesAdded, actualBytesAdded);
270	if (retval)
271	return (retval);
272
273	/*
274	* Update the Alternate MDB or Alternate VolumeHeader
275	*/
276	if ((H_FILEID(filePtr) == kHFSExtentsFileID) \|\|
277	(H_FILEID(filePtr) == kHFSCatalogFileID) \|\|
278	(H_FILEID(filePtr) == kHFSAttributesFileID)
279	) {
280	MarkVCBDirty( vcb );
281	if (vcb->vcbSigWord == kHFSPlusSigWord) {
282	retval = hfs_flushvolumeheader(VCBTOHFS(vcb), 0);
283	} else {
284	retval = hfs_flushMDB(VCBTOHFS(vcb), 0);
285	}
286	if (retval == 0) {
287	retval = FlushAlternate(vcb);
288	}
289	}
290
291	return retval;
292	}
293
294
295	static OSStatus
296	FlushAlternate( ExtendedVCB *vcb )
297	{
298	void *maindata;
299	void *altdata;
300	int result;
301
302	/* Get the main MDB/VolumeHeader block */
303	result = GetBlock_glue(gbDefault,
304	(vcb->hfsPlusIOPosOffset / kHFSBlockSize) + kMasterDirectoryBlock,
305	(Ptr *)&maindata, kNoFileReference, vcb);
306	if (result) return (result);
307
308	/* Get the alternate MDB/VolumeHeader block */
309	result = GetBlock_glue( gbDefault, vcb->altIDSector,
310	(Ptr *)&altdata, kNoFileReference, vcb );
311
312	if (result == 0) {
313	bcopy(maindata, altdata, kMDBSize);
314
315	result = RelBlock_glue( (Ptr)altdata, rbWriteMask );
316	}
317
318	(void) RelBlock_glue( (Ptr)maindata, rbFreeMask );
319
320	return (result);
321	}
322
323
324	/*
325	* Clear out (zero) new b-tree nodes on disk.
326	*/
327	static int
328	ClearBTNodes(struct vnode *vp, long blksize, off_t offset, off_t amount)
329	{
330	struct buf *bp = NULL;
331	daddr_t blk;
332	daddr_t blkcnt;
333
334	blk = offset / blksize;
335	blkcnt = amount / blksize;
336
337	while (blkcnt > 0) {
338	bp = getblk(vp, blk, blksize, 0, 0, BLK_META);
339	if (bp == NULL)
340	continue;
341	bzero((char *)bp->b_data, blksize);
342	bp->b_flags \|= (B_DIRTY \| B_AGE);
343
344	/* wait/yield every 32 blocks so we don't hog all the buffers */
345	if ((blk % 32) == 0)
346	VOP_BWRITE(bp);
347	else
348	bawrite(bp);
349	--blkcnt;
350	++blk;
351	}
352
353	return (0);
354	}