[apple/hfs.git] / fsck_hfs / dfalib / BlockCache.c

/*
 * Copyright (c) 2000-2003, 2005, 2007-2008 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * 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,
 * 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@
 */

#include "SRuntime.h"
#include "Scavenger.h"
#include "../cache.h"


extern Cache_t fscache;


static OSStatus  ReadFragmentedBlock (SFCB *file, UInt32 blockNum, BlockDescriptor *block);
static OSStatus  WriteFragmentedBlock( 	SFCB *file, 
										BlockDescriptor *block, 
										int age, 
										uint32_t writeOptions );
static OSStatus  ReleaseFragmentedBlock (SFCB *file, BlockDescriptor *block, int age);


void
InitBlockCache(SVCB *volume)
{
	volume->vcbBlockCache = (void *) &fscache;
}


/*
 *  kGetBlock
 *  kForceReadBlock
 *  kGetEmptyBlock
 *  kSkipEndianSwap
 */
OSStatus
GetVolumeBlock (SVCB *volume, UInt64 blockNum, GetBlockOptions options, BlockDescriptor *block)
{
	UInt32  blockSize;
	SInt64  offset;
	UInt16  signature;
	OSStatus result;	
	Buf_t *   buffer;
	Cache_t * cache;

	buffer = NULL;
	cache  = (Cache_t *) volume->vcbBlockCache;
	blockSize = 512;

	offset = (SInt64) ((UInt64) blockNum) << kSectorShift;

	result = CacheRead (cache, offset, blockSize, &buffer);

	if (result == 0) {
		block->blockHeader = buffer;
		block->buffer = buffer->Buffer;
		block->blockNum = blockNum;
		block->blockSize = blockSize;
		block->blockReadFromDisk = 0;
		block->fragmented = 0;
	} else {
		block->blockHeader = NULL;
		block->buffer = NULL;
	}
	
	if (!(options & kSkipEndianSwap) && (result == 0)) {
		HFSMasterDirectoryBlock *mdb;

		mdb = (HFSMasterDirectoryBlock *)block->buffer;
		signature = SWAP_BE16(mdb->drSigWord);
		if (signature == kHFSPlusSigWord || signature == kHFSXSigWord)
			SWAP_HFSPLUSVH(block->buffer);
		else if (signature == kHFSSigWord)
			SWAP_HFSMDB(block->buffer);
	}
	return (result);
}


/*
 *  kReleaseBlock
 *  kForceWriteBlock
 *  kMarkBlockDirty
 *  kTrashBlock
 *  kSkipEndianSwap
 */
OSStatus
ReleaseVolumeBlock (SVCB *volume, BlockDescriptor *block, ReleaseBlockOptions options)
{
	OSStatus  result = 0;
	Cache_t * cache;
	Buf_t *   buffer;
	int       age;
	UInt16  signature;

	cache  = (Cache_t *) volume->vcbBlockCache;
	buffer = (Buf_t *) block->blockHeader;
	age    = ((options & kTrashBlock) != 0);

	/*
	 * Always leave the blocks in the cache in big endian
	 */
	if (!(options & kSkipEndianSwap)) {
		signature = ((HFSMasterDirectoryBlock *)block->buffer)->drSigWord;
		if (signature == kHFSPlusSigWord || signature == kHFSXSigWord)
			SWAP_HFSPLUSVH(block->buffer);
		else if (signature == kHFSSigWord)
			SWAP_HFSMDB(block->buffer);
	}

	if (options & (kMarkBlockDirty | kForceWriteBlock)) {
		result = CacheWrite(cache, buffer, age, 0);
	} else { /* not dirty */
		result = CacheRelease (cache, buffer, age);
	}
	return (result);
}


/*
 *  kGetBlock
 *  kForceReadBlock
 *  kGetEmptyBlock
 */
OSStatus
GetFileBlock (SFCB *file, UInt32 blockNum, GetBlockOptions options, BlockDescriptor *block)
{
	UInt64	diskBlock;
	UInt32	contiguousBytes;
	SInt64  offset;

	OSStatus result;	
	Buf_t *   buffer;
	Cache_t * cache;

	buffer = NULL;
	block->buffer = NULL;
	block->blockHeader = NULL;
	cache  = (Cache_t *)file->fcbVolume->vcbBlockCache;

	/* Map file block to volume block */
	result = MapFileBlockC(file->fcbVolume, file, file->fcbBlockSize,
			(((UInt64)blockNum * (UInt64)file->fcbBlockSize) >> kSectorShift),
			&diskBlock, &contiguousBytes);
	if (result) return (result);

	if (contiguousBytes < file->fcbBlockSize)
		return ( ReadFragmentedBlock(file, blockNum, block) );

	offset = (SInt64) ((UInt64) diskBlock) << kSectorShift;

	result = CacheRead (cache, offset, file->fcbBlockSize, &buffer);
	if (result)  return (result);

	block->blockHeader = buffer;
	block->buffer = buffer->Buffer;
	block->blockNum = blockNum;
	block->blockSize = file->fcbBlockSize;
	block->blockReadFromDisk = 0;
	block->fragmented = 0;
	
	return (noErr);
}


/*
 *  kReleaseBlock
 *  kForceWriteBlock
 *  kMarkBlockDirty
 *  kTrashBlock
 */
OSStatus
ReleaseFileBlock (SFCB *file, BlockDescriptor *block, ReleaseBlockOptions options)
{
	OSStatus  result = 0;
	Cache_t * cache;
	Buf_t *   buffer;
	int       age;
	uint32_t  writeOptions = 0;

	cache  = (Cache_t *)file->fcbVolume->vcbBlockCache;
	buffer = (Buf_t *) block->blockHeader;
	age    = ((options & kTrashBlock) != 0);

	if ( (options & kForceWriteBlock) == 0 )
		/* only write if we're forced to */
		writeOptions |= kLazyWrite;

	if (options & (kMarkBlockDirty | kForceWriteBlock)) {
		if (block->fragmented)
			result = WriteFragmentedBlock(file, block, age, writeOptions);
		else
			result = CacheWrite(cache, buffer, age, writeOptions);
	} else { /* not dirty */

		if (block->fragmented)
			result = ReleaseFragmentedBlock(file, block, age);
		else
			result = CacheRelease (cache, buffer, age);
	}
	return (result);
}


/*
 *
 */
OSStatus
SetFileBlockSize (SFCB *file, ByteCount blockSize)
{
	file->fcbBlockSize = blockSize;

	return (0);
}


/*
 * Read a block that is fragmented across 2 or more allocation blocks
 *
 *  - a block descriptor buffer is allocated here
 *  - the blockHeader field holds a list of Buf_t buffers.
 *  - the fragmented flag is set
 */
static OSStatus
ReadFragmentedBlock (SFCB *file, UInt32 blockNum, BlockDescriptor *block)
{
	UInt64	sector;
	UInt32	fragSize, blockSize;
	UInt64  fileOffset; 
	SInt64  diskOffset;
	SVCB *  volume;
	int     i, maxFrags;
	OSStatus result;	
	Buf_t **   bufs;   /* list of Buf_t pointers */
	Cache_t * cache;
	char *	buffer;

	volume = file->fcbVolume;
	cache  = (Cache_t *)volume->vcbBlockCache;

	blockSize = file->fcbBlockSize;
	maxFrags = blockSize / volume->vcbBlockSize;
	fileOffset = (UInt64)blockNum * (UInt64)blockSize;
	
	buffer = (char *) AllocateMemory(blockSize);
	bufs = (Buf_t **) AllocateClearMemory(maxFrags * sizeof(Buf_t *));
	if (buffer == NULL || bufs == NULL) {
		result = memFullErr;
		return (result);
	}
	
	block->buffer = buffer;
	block->blockHeader = bufs;
	block->blockNum = blockNum;
	block->blockSize = blockSize;
	block->blockReadFromDisk = false;
	block->fragmented = true;
	
	for (i = 0; (i < maxFrags) && (blockSize > 0); ++i) {
		result = MapFileBlockC (volume, file, blockSize,
					fileOffset >> kSectorShift,
					&sector, &fragSize);
		if (result) goto ErrorExit;

		diskOffset = (SInt64) (sector) << kSectorShift;
		result = CacheRead (cache, diskOffset, fragSize, &bufs[i]);
		if (result) goto ErrorExit;
		
		if (bufs[i]->Length != fragSize) {
			plog("ReadFragmentedBlock: cache failure (Length != fragSize)\n");
			result = -1;
			goto ErrorExit;
		}

		CopyMemory(bufs[i]->Buffer, buffer, fragSize);
		buffer     += fragSize;
		fileOffset += fragSize;
		blockSize  -= fragSize;
	}
	
	return (noErr);

ErrorExit:
	i = 0;
	while (bufs[i] != NULL) {
		(void) CacheRelease (cache, bufs[i], true);
		++i;
	}

	DisposeMemory(block->buffer);
	DisposeMemory(block->blockHeader);

	block->blockHeader = NULL;
	block->buffer = NULL;

	return (result);
}


/*
 * Write a block that is fragmented across 2 or more allocation blocks
 *
 */
static OSStatus
WriteFragmentedBlock( SFCB *file, BlockDescriptor *block, int age, uint32_t writeOptions )
{
	Cache_t * cache;
	Buf_t **  bufs;  /* list of Buf_t pointers */
	char *	  buffer;
	char *    bufEnd;
	UInt32	  fragSize;
	OSStatus  result;
	int i = 0;

	result = 0;
	cache  = (Cache_t *) file->fcbVolume->vcbBlockCache;
	bufs   = (Buf_t **) block->blockHeader;
	buffer = (char *) block->buffer;
	bufEnd = buffer + file->fcbBlockSize;

	if (bufs == NULL) {
		plog("WriteFragmentedBlock: NULL bufs list!\n");
		return (-1);
	}
	
	while ((bufs[i] != NULL) && (buffer < bufEnd)) {
		fragSize = bufs[i]->Length;
		
		/* copy data for this fragment */
		CopyMemory(buffer, bufs[i]->Buffer, fragSize);
		
		/* write it back to cache */
		result = CacheWrite(cache, bufs[i], age, writeOptions);
		if (result) break;

		buffer += fragSize;
		++i;
	}
	
	DisposeMemory(block->buffer);
	DisposeMemory(block->blockHeader);

	block->buffer = NULL;
	block->blockHeader = NULL;
	block->fragmented = false;

	return (result);
}


/*
 * Release a block that is fragmented across 2 or more allocation blocks
 *
 */
static OSStatus
ReleaseFragmentedBlock (SFCB *file, BlockDescriptor *block, int age)
{
	Cache_t * cache;
	Buf_t **   bufs;  /* list of Buf_t pointers */
	char	*buffer;
	char	*bufEnd;
	UInt32	fragSize;
	int i = 0;

	cache = (Cache_t *)file->fcbVolume->vcbBlockCache;
	bufs  = (Buf_t **) block->blockHeader;

	if (bufs == NULL) {
		plog("ReleaseFragmentedBlock: NULL buf list!\n");
		return (-1);
	}

	buffer = (char*)block->buffer;
	bufEnd = buffer + file->fcbBlockSize;

	while (bufs[i] != NULL && (buffer < bufEnd)) {
		fragSize = bufs[i]->Length;
		buffer += fragSize;
		(void) CacheRelease (cache, bufs[i], true);
		++i;
	}
	
	DisposeMemory(block->buffer);
	DisposeMemory(block->blockHeader);

	block->buffer = NULL;
	block->blockHeader = NULL;
	block->fragmented = false;

	return (noErr);
}
Commit	Line	Data
51e135ce A	1	/*
	2	* Copyright (c) 2000-2003, 2005, 2007-2008 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24	#include "SRuntime.h"
	25	#include "Scavenger.h"
	26	#include "../cache.h"
	27
	28
	29
	30	extern Cache_t fscache;
	31
	32
	33	static OSStatus ReadFragmentedBlock (SFCB file, UInt32 blockNum, BlockDescriptor block);
	34	static OSStatus WriteFragmentedBlock( SFCB *file,
	35	BlockDescriptor *block,
	36	int age,
	37	uint32_t writeOptions );
	38	static OSStatus ReleaseFragmentedBlock (SFCB file, BlockDescriptor block, int age);
	39
	40
	41	void
	42	InitBlockCache(SVCB *volume)
	43	{
	44	volume->vcbBlockCache = (void *) &fscache;
	45	}
	46
	47
	48	/*
	49	* kGetBlock
	50	* kForceReadBlock
	51	* kGetEmptyBlock
	52	* kSkipEndianSwap
	53	*/
	54	OSStatus
	55	GetVolumeBlock (SVCB volume, UInt64 blockNum, GetBlockOptions options, BlockDescriptor block)
	56	{
	57	UInt32 blockSize;
	58	SInt64 offset;
	59	UInt16 signature;
	60	OSStatus result;
	61	Buf_t * buffer;
	62	Cache_t * cache;
	63
	64	buffer = NULL;
65	cache = (Cache_t *) volume->vcbBlockCache;
66	blockSize = 512;
67
68	offset = (SInt64) ((UInt64) blockNum) << kSectorShift;
69
70	result = CacheRead (cache, offset, blockSize, &buffer);
71
72	if (result == 0) {
73	block->blockHeader = buffer;
74	block->buffer = buffer->Buffer;
75	block->blockNum = blockNum;
76	block->blockSize = blockSize;
77	block->blockReadFromDisk = 0;
78	block->fragmented = 0;
79	} else {
80	block->blockHeader = NULL;
81	block->buffer = NULL;
82	}
83
84	if (!(options & kSkipEndianSwap) && (result == 0)) {
85	HFSMasterDirectoryBlock *mdb;
86
87	mdb = (HFSMasterDirectoryBlock *)block->buffer;
88	signature = SWAP_BE16(mdb->drSigWord);
89	if (signature == kHFSPlusSigWord \|\| signature == kHFSXSigWord)
90	SWAP_HFSPLUSVH(block->buffer);
91	else if (signature == kHFSSigWord)
92	SWAP_HFSMDB(block->buffer);
93	}
94	return (result);
95	}
96
97
98	/*
99	* kReleaseBlock
100	* kForceWriteBlock
101	* kMarkBlockDirty
102	* kTrashBlock
103	* kSkipEndianSwap
104	*/
105	OSStatus
106	ReleaseVolumeBlock (SVCB volume, BlockDescriptor block, ReleaseBlockOptions options)
107	{
108	OSStatus result = 0;
109	Cache_t * cache;
110	Buf_t * buffer;
111	int age;
112	UInt16 signature;
113
114	cache = (Cache_t *) volume->vcbBlockCache;
115	buffer = (Buf_t *) block->blockHeader;
116	age = ((options & kTrashBlock) != 0);
117
118	/*
119	* Always leave the blocks in the cache in big endian
120	*/
121	if (!(options & kSkipEndianSwap)) {
122	signature = ((HFSMasterDirectoryBlock *)block->buffer)->drSigWord;
123	if (signature == kHFSPlusSigWord \|\| signature == kHFSXSigWord)
124	SWAP_HFSPLUSVH(block->buffer);
125	else if (signature == kHFSSigWord)
126	SWAP_HFSMDB(block->buffer);
127	}
128
129	if (options & (kMarkBlockDirty \| kForceWriteBlock)) {
130	result = CacheWrite(cache, buffer, age, 0);
131	} else { /* not dirty */
132	result = CacheRelease (cache, buffer, age);
133	}
134	return (result);
135	}
136
137
138	/*
139	* kGetBlock
140	* kForceReadBlock
141	* kGetEmptyBlock
142	*/
143	OSStatus
144	GetFileBlock (SFCB file, UInt32 blockNum, GetBlockOptions options, BlockDescriptor block)
145	{
146	UInt64 diskBlock;
147	UInt32 contiguousBytes;
148	SInt64 offset;
149
150	OSStatus result;
151	Buf_t * buffer;
152	Cache_t * cache;
153
154	buffer = NULL;
155	block->buffer = NULL;
156	block->blockHeader = NULL;
157	cache = (Cache_t *)file->fcbVolume->vcbBlockCache;
158
159	/* Map file block to volume block */
160	result = MapFileBlockC(file->fcbVolume, file, file->fcbBlockSize,
161	(((UInt64)blockNum * (UInt64)file->fcbBlockSize) >> kSectorShift),
162	&diskBlock, &contiguousBytes);
163	if (result) return (result);
164
165	if (contiguousBytes < file->fcbBlockSize)
166	return ( ReadFragmentedBlock(file, blockNum, block) );
167
168	offset = (SInt64) ((UInt64) diskBlock) << kSectorShift;
169
170	result = CacheRead (cache, offset, file->fcbBlockSize, &buffer);
171	if (result) return (result);
172
173	block->blockHeader = buffer;
174	block->buffer = buffer->Buffer;
175	block->blockNum = blockNum;
176	block->blockSize = file->fcbBlockSize;
177	block->blockReadFromDisk = 0;
178	block->fragmented = 0;
179
180	return (noErr);
181	}
182
183
184	/*
185	* kReleaseBlock
186	* kForceWriteBlock
187	* kMarkBlockDirty
188	* kTrashBlock
189	*/
190	OSStatus
191	ReleaseFileBlock (SFCB file, BlockDescriptor block, ReleaseBlockOptions options)
192	{
193	OSStatus result = 0;
194	Cache_t * cache;
195	Buf_t * buffer;
196	int age;
197	uint32_t writeOptions = 0;
198
199	cache = (Cache_t *)file->fcbVolume->vcbBlockCache;
200	buffer = (Buf_t *) block->blockHeader;
201	age = ((options & kTrashBlock) != 0);
202
203	if ( (options & kForceWriteBlock) == 0 )
204	/* only write if we're forced to */
205	writeOptions \|= kLazyWrite;
206
207	if (options & (kMarkBlockDirty \| kForceWriteBlock)) {
208	if (block->fragmented)
209	result = WriteFragmentedBlock(file, block, age, writeOptions);
210	else
211	result = CacheWrite(cache, buffer, age, writeOptions);
212	} else { /* not dirty */
213
214	if (block->fragmented)
215	result = ReleaseFragmentedBlock(file, block, age);
216	else
217	result = CacheRelease (cache, buffer, age);
218	}
219	return (result);
220	}
221
222
223	/*
224	*
225	*/
226	OSStatus
227	SetFileBlockSize (SFCB *file, ByteCount blockSize)
228	{
229	file->fcbBlockSize = blockSize;
230
231	return (0);
232	}
233
234
235	/*
236	* Read a block that is fragmented across 2 or more allocation blocks
237	*
238	* - a block descriptor buffer is allocated here
239	* - the blockHeader field holds a list of Buf_t buffers.
240	* - the fragmented flag is set
241	*/
242	static OSStatus
243	ReadFragmentedBlock (SFCB file, UInt32 blockNum, BlockDescriptor block)
244	{
245	UInt64 sector;
246	UInt32 fragSize, blockSize;
247	UInt64 fileOffset;
248	SInt64 diskOffset;
249	SVCB * volume;
250	int i, maxFrags;
251	OSStatus result;
252	Buf_t ** bufs; /* list of Buf_t pointers */
253	Cache_t * cache;
254	char * buffer;
255
256	volume = file->fcbVolume;
257	cache = (Cache_t *)volume->vcbBlockCache;
258
259	blockSize = file->fcbBlockSize;
260	maxFrags = blockSize / volume->vcbBlockSize;
261	fileOffset = (UInt64)blockNum * (UInt64)blockSize;
262
263	buffer = (char *) AllocateMemory(blockSize);
264	bufs = (Buf_t *) AllocateClearMemory(maxFrags sizeof(Buf_t *));
265	if (buffer == NULL \|\| bufs == NULL) {
266	result = memFullErr;
267	return (result);
268	}
269
270	block->buffer = buffer;
271	block->blockHeader = bufs;
272	block->blockNum = blockNum;
273	block->blockSize = blockSize;
274	block->blockReadFromDisk = false;
275	block->fragmented = true;
276
277	for (i = 0; (i < maxFrags) && (blockSize > 0); ++i) {
278	result = MapFileBlockC (volume, file, blockSize,
279	fileOffset >> kSectorShift,
280	&sector, &fragSize);
281	if (result) goto ErrorExit;
282
283	diskOffset = (SInt64) (sector) << kSectorShift;
284	result = CacheRead (cache, diskOffset, fragSize, &bufs[i]);
285	if (result) goto ErrorExit;
286
287	if (bufs[i]->Length != fragSize) {
288	plog("ReadFragmentedBlock: cache failure (Length != fragSize)\n");
289	result = -1;
290	goto ErrorExit;
291	}
292
293	CopyMemory(bufs[i]->Buffer, buffer, fragSize);
294	buffer += fragSize;
295	fileOffset += fragSize;
296	blockSize -= fragSize;
297	}
298
299	return (noErr);
300
301	ErrorExit:
302	i = 0;
303	while (bufs[i] != NULL) {
304	(void) CacheRelease (cache, bufs[i], true);
305	++i;
306	}
307
308	DisposeMemory(block->buffer);
309	DisposeMemory(block->blockHeader);
310
311	block->blockHeader = NULL;
312	block->buffer = NULL;
313
314	return (result);
315	}
316
317
318	/*
319	* Write a block that is fragmented across 2 or more allocation blocks
320	*
321	*/
322	static OSStatus
323	WriteFragmentedBlock( SFCB file, BlockDescriptor block, int age, uint32_t writeOptions )
324	{
325	Cache_t * cache;
326	Buf_t ** bufs; /* list of Buf_t pointers */
327	char * buffer;
328	char * bufEnd;
329	UInt32 fragSize;
330	OSStatus result;
331	int i = 0;
332
333	result = 0;
334	cache = (Cache_t *) file->fcbVolume->vcbBlockCache;
335	bufs = (Buf_t **) block->blockHeader;
336	buffer = (char *) block->buffer;
337	bufEnd = buffer + file->fcbBlockSize;
338
339	if (bufs == NULL) {
340	plog("WriteFragmentedBlock: NULL bufs list!\n");
341	return (-1);
342	}
343
344	while ((bufs[i] != NULL) && (buffer < bufEnd)) {
345	fragSize = bufs[i]->Length;
346
347	/* copy data for this fragment */
348	CopyMemory(buffer, bufs[i]->Buffer, fragSize);
349
350	/* write it back to cache */
351	result = CacheWrite(cache, bufs[i], age, writeOptions);
352	if (result) break;
353
354	buffer += fragSize;
355	++i;
356	}
357
358	DisposeMemory(block->buffer);
359	DisposeMemory(block->blockHeader);
360
361	block->buffer = NULL;
362	block->blockHeader = NULL;
363	block->fragmented = false;
364
365	return (result);
366	}
367
368
369	/*
370	* Release a block that is fragmented across 2 or more allocation blocks
371	*
372	*/
373	static OSStatus
374	ReleaseFragmentedBlock (SFCB file, BlockDescriptor block, int age)
375	{
376	Cache_t * cache;
377	Buf_t ** bufs; /* list of Buf_t pointers */
378	char *buffer;
379	char *bufEnd;
380	UInt32 fragSize;
381	int i = 0;
382
383	cache = (Cache_t *)file->fcbVolume->vcbBlockCache;
384	bufs = (Buf_t **) block->blockHeader;
385
386	if (bufs == NULL) {
387	plog("ReleaseFragmentedBlock: NULL buf list!\n");
388	return (-1);
389	}
390
391	buffer = (char*)block->buffer;
392	bufEnd = buffer + file->fcbBlockSize;
393
394	while (bufs[i] != NULL && (buffer < bufEnd)) {
395	fragSize = bufs[i]->Length;
396	buffer += fragSize;
397	(void) CacheRelease (cache, bufs[i], true);
398	++i;
399	}
400
401	DisposeMemory(block->buffer);
402	DisposeMemory(block->blockHeader);
403
404	block->buffer = NULL;
405	block->blockHeader = NULL;
406	block->fragmented = false;
407
408	return (noErr);
409	}
410