[apple/hfs.git] / fsck_hfs / dfalib / SRuntime.h

/*
 * Copyright (c) 1999, 2005-2011 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@
 */
/* SRuntime.h */

#ifndef __SRUNTIME__
#define __SRUNTIME__

#if BSD

#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>

#include <hfs/hfs_format.h>
#else

#include <MacTypes.h>
#include <MacMemory.h>
#include <HFSVolumes.h>
#include <Errors.h>

#endif

#if BSD
/* Classic Mac OS Types */
typedef int8_t		SInt8;
typedef int16_t		SInt16;
typedef int32_t		SInt32;
typedef int64_t		SInt64;

typedef u_int8_t	UInt8;
typedef u_int16_t	UInt16;
typedef u_int32_t	UInt32;
typedef u_int64_t	UInt64;

typedef void *		LogicalAddress;
typedef char *		Ptr;
typedef Ptr *		Handle;
typedef u_int8_t	Byte;
typedef size_t 		Size;
typedef unsigned char	Boolean;
typedef u_int32_t	ItemCount;
typedef u_int32_t	ByteCount;
typedef u_int32_t	OptionBits;

typedef int16_t 	OSErr;
typedef int32_t 	OSStatus;

typedef u_int32_t	OSType;
typedef u_int32_t	ResType;

typedef u_int16_t	UniChar;
typedef u_int32_t	UniCharCount;
typedef UniChar *	UniCharArrayPtr;
typedef const UniChar *	ConstUniCharArrayPtr;
typedef u_int32_t	TextEncoding;

typedef unsigned char *	StringPtr;
typedef unsigned char	Str27[28];
typedef unsigned char	Str31[32];
typedef unsigned char	Str63[64];
typedef unsigned char	Str255[256];

typedef const unsigned char *	ConstStr31Param;
typedef const unsigned char *	ConstStr63Param;
typedef const unsigned char *	ConstStr255Param;

typedef u_int32_t	HFSCatalogNodeID;

enum {
	false		= 0,
	true		= 1
};

/* OS error codes */
enum {
	noErr		=     0,
	dskFulErr	=   -34,
	nsvErr		=   -35,
	ioErr		=   -36,
	eofErr		=   -39,
	fnfErr		=   -43,
	fBsyErr		=   -47,
	paramErr	=   -50,
	noMacDskErr	=   -57,
	badMDBErr	=   -60,
	memFullErr	=  -108,
	notBTree	=  -410,
	fileBoundsErr	= -1309,
};

/* Finder Flags */
enum {
    kIsOnDesk		= 0x0001,
    kColor		= 0x000E,
    kIsShared		= 0x0040,
    kHasBeenInited	= 0x0100,
    kHasCustomIcon	= 0x0400,
    kIsStationery	= 0x0800,
    kNameLocked		= 0x1000,
    kHasBundle		= 0x2000,
    kIsInvisible	= 0x4000,
    kIsAlias		= 0x8000
};

#define EXTERN_API(_type)	extern _type
#define EXTERN_API_C(_type)	extern _type

#define nil NULL

EXTERN_API( void )
DebugStr(ConstStr255Param debuggerMsg);

typedef void * QElemPtr;
typedef void * DrvQElPtr;


#endif


/* vcbFlags bits */
enum {
  kVCBFlagsIdleFlushBit           = 3,                                                    /* Set if volume should be flushed at idle time */
        kVCBFlagsIdleFlushMask          = 0x0008,
        kVCBFlagsHFSPlusAPIsBit         = 4,                                                    /* Set if volume implements HFS Plus APIs itself (not via emu\
												   lation) */
        kVCBFlagsHFSPlusAPIsMask        = 0x0010,
        kVCBFlagsHardwareGoneBit        = 5,                                                    /* Set if disk driver returned a hardwareGoneErr to Read or W\
												   rite */
        kVCBFlagsHardwareGoneMask       = 0x0020,
        kVCBFlagsVolumeDirtyBit         = 15,                                                   /* Set if volume information has changed since the last Flush\
												   Vol */
        kVCBFlagsVolumeDirtyMask        = 0x8000
};


/* Disk Cache constants */
/*
 * UTGetBlock options
 */
enum {
	gbDefault					= 0,							/* default value - read if not found */
																/*	bits and masks */
	gbReadBit					= 0,							/* read block from disk (forced read) */
	gbReadMask					= 0x0001,
	gbExistBit					= 1,							/* get existing cache block */
	gbExistMask					= 0x0002,
	gbNoReadBit					= 2,							/* don't read block from disk if not found in cache */
	gbNoReadMask				= 0x0004,
	gbReleaseBit				= 3,							/* release block immediately after GetBlock */
	gbReleaseMask				= 0x0008
};


/*
 * UTReleaseBlock options
 */
enum {
	rbDefault					= 0,							/* default value - just mark the buffer not in-use */
																/*	bits and masks */
	rbWriteBit					= 0,							/* force write buffer to disk */
	rbWriteMask					= 0x0001,
	rbTrashBit					= 1,							/* trash buffer contents after release */
	rbTrashMask					= 0x0002,
	rbDirtyBit					= 2,							/* mark buffer dirty */
	rbDirtyMask					= 0x0004,
	rbFreeBit					= 3,							/* free the buffer (save in the hash) */
	rbFreeMask					= 0x000A						/* rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache; on >= System 7.0, rbfreeMask overrides rbTrash */
};


/*
 * UTFlushCache options
 */
enum {
	fcDefault					= 0,							/* default value - pass this fcOption to just flush any dirty buffers */
																/*	bits and masks */
	fcTrashBit					= 0,							/* (don't pass this as fcOption, use only for testing bit) */
	fcTrashMask					= 0x0001,						/* pass this fcOption value to flush and trash cache blocks */
	fcFreeBit					= 1,							/* (don't pass this as fcOption, use only for testing bit) */
	fcFreeMask					= 0x0003						/* pass this fcOption to flush and free cache blocks (Note: both fcTrash and fcFree bits are set) */
};


/*
 * UTCacheReadIP and UTCacheWriteIP cacheOption bits and masks are the ioPosMode
 * bits and masks in Files.x
 */

/*
 * Cache routine internal error codes
 */
enum {
	chNoBuf						= 1,							/* no free cache buffers (all in use) */
	chInUse						= 2,							/* requested block in use */
	chnotfound					= 3,							/* requested block not found */
	chNotInUse					= 4								/* block being released was not in use */
};


/*
 * FCBRec.fcbFlags bits
 */
enum {
	fcbWriteBit					= 0,							/* Data can be written to this file */
	fcbWriteMask				= 0x01,
	fcbResourceBit				= 1,							/* This file is a resource fork */
	fcbResourceMask				= 0x02,
	fcbWriteLockedBit			= 2,							/* File has a locked byte range */
	fcbWriteLockedMask			= 0x04,
	fcbSharedWriteBit			= 4,							/* File is open for shared write access */
	fcbSharedWriteMask			= 0x10,
	fcbFileLockedBit			= 5,							/* File is locked (write-protected) */
	fcbFileLockedMask			= 0x20,
	fcbOwnClumpBit				= 6,							/* File has clump size specified in FCB */
	fcbOwnClumpMask				= 0x40,
	fcbModifiedBit				= 7,							/* File has changed since it was last flushed */
	fcbModifiedMask				= 0x80
};

enum {
	fcbLargeFileBit				= 3,							/* File may grow beyond 2GB; cache uses file blocks, not bytes */
	fcbLargeFileMask			= 0x08
};

#define kSectorShift  9   /* log2(kSectorSize); used for bit shifts */

/*
	Fork Level Access Method Block get options
*/
enum {
	kGetBlock	= 0x00000000,
	kForceReadBlock	= 0x00000002,
	kGetEmptyBlock	= 0x00000008,
	kSkipEndianSwap	= 0x00000010
};
typedef OptionBits  GetBlockOptions;

/*
	Fork Level Access Method Block release options
*/
enum {
	kReleaseBlock	 = 0x00000000,
	kForceWriteBlock = 0x00000001,
	kMarkBlockDirty	 = 0x00000002,
	kTrashBlock	 	 = 0x00000004
};
typedef OptionBits  ReleaseBlockOptions;

struct BlockDescriptor{
	void		*buffer;
	void		*blockHeader;
	UInt64		 blockNum;
	UInt32		 blockSize;
	Boolean		 blockReadFromDisk;
	Boolean		 fragmented;
};
typedef struct BlockDescriptor BlockDescriptor;
typedef BlockDescriptor *BlockDescPtr;


struct SFCB;

struct SVCB {
	UInt16		vcbSignature;
	UInt16		vcbVersion;
	UInt32		vcbAttributes;
	UInt32		vcbLastMountedVersion;
	UInt32		vcbReserved1;
	UInt32		vcbCreateDate;
	UInt32		vcbModifyDate;
	UInt32		vcbBackupDate;
	UInt32		vcbCheckedDate;
	UInt32		vcbFileCount;
	UInt32		vcbFolderCount;
	UInt32		vcbBlockSize;
	UInt32		vcbTotalBlocks;
	UInt32		vcbFreeBlocks;
	UInt32		vcbNextAllocation;
	UInt32 		vcbRsrcClumpSize;
	UInt32		vcbDataClumpSize;
	UInt32 		vcbNextCatalogID;
	UInt32		vcbWriteCount;
	UInt64		vcbEncodingsBitmap;
	UInt8		vcbFinderInfo[32];

	/* MDB-specific fields... */
	SInt16		vcbNmFls;	/* number of files in root folder */
	SInt16		vcbNmRtDirs;	/* number of directories in root folder */
	UInt16		vcbVBMSt;	/* first sector of HFS volume bitmap */
	UInt16		vcbAlBlSt;	/* first allocation block in HFS volume */
	UInt16		vcbVSeqNum;	/* volume backup sequence number */
	UInt16		vcbReserved2;
	Str27		vcbVN;		/* HFS volume name */

	/* runtime fields... */
	struct SFCB * 	vcbAllocationFile;
	struct SFCB * 	vcbExtentsFile;
	struct SFCB * 	vcbCatalogFile;
	struct SFCB * 	vcbAttributesFile;
	struct SFCB * 	vcbStartupFile;

	UInt32		vcbEmbeddedOffset;	/* Byte offset where HFS+ starts */
	UInt16		vcbFlags;
	SInt16		vcbDriveNumber;
	SInt16		vcbDriverReadRef;
	SInt16		vcbDriverWriteRef;

	void *		vcbBlockCache;

	struct SGlob *	vcbGPtr;

	/* deprecated fields... */
	SInt16		vcbVRefNum;
};
typedef struct SVCB SVCB;


struct SFCB {
	UInt32			fcbFileID;
	UInt32			fcbFlags;
	struct SVCB *		fcbVolume;
	void *			fcbBtree;
	HFSExtentRecord		fcbExtents16;
	HFSPlusExtentRecord	fcbExtents32;
	UInt32			fcbCatalogHint;
	UInt32			fcbClumpSize;
	UInt64 			fcbLogicalSize;
	UInt64			fcbPhysicalSize;
	UInt32			fcbBlockSize;
};
typedef struct SFCB SFCB;


extern OSErr GetDeviceSize(int driveRefNum, UInt64 *numBlocks, UInt32 *blockSize);

extern OSErr DeviceRead(int device, int drive, void* buffer, SInt64 offset, UInt32 reqBytes, UInt32 *actBytes);

extern OSErr DeviceWrite(int device, int drive, void* buffer, SInt64 offset, UInt32 reqBytes, UInt32 *actBytes);


/*
 *  Block Cache Interface
 */
extern void      InitBlockCache(SVCB *volume);

extern OSStatus  GetVolumeBlock (SVCB *volume, UInt64 blockNum, GetBlockOptions options,
				BlockDescriptor *block);

extern OSStatus  ReleaseVolumeBlock (SVCB *volume, BlockDescriptor *block,
				ReleaseBlockOptions options);

extern OSStatus  GetFileBlock (SFCB *file, UInt32 blockNum, GetBlockOptions options,
				BlockDescriptor *block);

extern OSStatus  ReleaseFileBlock (SFCB *file, BlockDescriptor *block,
				ReleaseBlockOptions options);

extern OSStatus  SetFileBlockSize (SFCB *file, ByteCount blockSize);


#if BSD

#define AllocateMemory(size)		malloc((size_t)(size))
#define	AllocateClearMemory(size)	calloc(1,(size_t)(size))
#define ReallocateMemory(ptr,newSize)	SetPtrSize((void*)(ptr),(size_t)(newSize))
#define MemorySize(ptr)			malloc_size((void*)(ptr))
#define DisposeMemory(ptr)		free((void *)(ptr))
#define CopyMemory(src,dst,len)		bcopy((void*)(src),(void*)(dst),(size_t)(len))
#define ClearMemory(start,len)	 	bzero((void*)(start),(size_t)(len))

extern UInt32	TickCount();
extern OSErr	MemError(void);
extern Handle	NewHandleClear(Size byteCount);
extern Handle	NewHandle(Size byteCount);
extern void	DisposeHandle(Handle h);
extern Size	GetHandleSize(Handle h);
extern void	SetHandleSize(Handle h, Size newSize);
extern OSErr	PtrAndHand(const void *ptr1, Handle hand2, long size);

#else

#define AllocateMemory(size)		NewPtr((Size)(size))
#define	AllocateClearMemory(size)	NewPtrClear((Size)(size))
#define ReallocateMemory(ptr,newSize)	SetPtrSize((Ptr)(ptr),(Size)(newSize))
#define MemorySize(ptr)			GetPtrSize((Ptr)(ptr))
#define DisposeMemory(ptr)		DisposePtr((Ptr)(ptr))
#define CopyMemory(src,dst,len)		BlockMoveData((void *)(src),(void *)(dst),(Size)(len))
void ClearMemory(void* start, long len);
#endif


#endif /* __SRUNTIME__ */
Commit	Line	Data
51e135ce A	1	/*
	2	* Copyright (c) 1999, 2005-2011 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	/* SRuntime.h */
	24
	25	#ifndef __SRUNTIME__
	26	#define __SRUNTIME__
	27
	28	#if BSD
	29
	30	#include <sys/types.h>
	31	#include <stdlib.h>
	32	#include <string.h>
	33	#include <stdio.h>
	34	#include <stdarg.h>
	35
	36	#include <hfs/hfs_format.h>
	37	#else
	38
	39	#include <MacTypes.h>
	40	#include <MacMemory.h>
	41	#include <HFSVolumes.h>
	42	#include <Errors.h>
	43
	44	#endif
	45
	46	#if BSD
	47	/* Classic Mac OS Types */
	48	typedef int8_t SInt8;
	49	typedef int16_t SInt16;
	50	typedef int32_t SInt32;
	51	typedef int64_t SInt64;
	52
	53	typedef u_int8_t UInt8;
	54	typedef u_int16_t UInt16;
	55	typedef u_int32_t UInt32;
	56	typedef u_int64_t UInt64;
	57
	58	typedef void * LogicalAddress;
	59	typedef char * Ptr;
	60	typedef Ptr * Handle;
	61	typedef u_int8_t Byte;
	62	typedef size_t Size;
	63	typedef unsigned char Boolean;
	64	typedef u_int32_t ItemCount;
65	typedef u_int32_t ByteCount;
66	typedef u_int32_t OptionBits;
67
68	typedef int16_t OSErr;
69	typedef int32_t OSStatus;
70
71	typedef u_int32_t OSType;
72	typedef u_int32_t ResType;
73
74	typedef u_int16_t UniChar;
75	typedef u_int32_t UniCharCount;
76	typedef UniChar * UniCharArrayPtr;
77	typedef const UniChar * ConstUniCharArrayPtr;
78	typedef u_int32_t TextEncoding;
79
80	typedef unsigned char * StringPtr;
81	typedef unsigned char Str27[28];
82	typedef unsigned char Str31[32];
83	typedef unsigned char Str63[64];
84	typedef unsigned char Str255[256];
85
86	typedef const unsigned char * ConstStr31Param;
87	typedef const unsigned char * ConstStr63Param;
88	typedef const unsigned char * ConstStr255Param;
89
90	typedef u_int32_t HFSCatalogNodeID;
91
92	enum {
93	false = 0,
94	true = 1
95	};
96
97	/* OS error codes */
98	enum {
99	noErr = 0,
100	dskFulErr = -34,
101	nsvErr = -35,
102	ioErr = -36,
103	eofErr = -39,
104	fnfErr = -43,
105	fBsyErr = -47,
106	paramErr = -50,
107	noMacDskErr = -57,
108	badMDBErr = -60,
109	memFullErr = -108,
110	notBTree = -410,
111	fileBoundsErr = -1309,
112	};
113
114	/* Finder Flags */
115	enum {
116	kIsOnDesk = 0x0001,
117	kColor = 0x000E,
118	kIsShared = 0x0040,
119	kHasBeenInited = 0x0100,
120	kHasCustomIcon = 0x0400,
121	kIsStationery = 0x0800,
122	kNameLocked = 0x1000,
123	kHasBundle = 0x2000,
124	kIsInvisible = 0x4000,
125	kIsAlias = 0x8000
126	};
127
128	#define EXTERN_API(_type) extern _type
129	#define EXTERN_API_C(_type) extern _type
130
131	#define nil NULL
132
133	EXTERN_API( void )
134	DebugStr(ConstStr255Param debuggerMsg);
135
136	typedef void * QElemPtr;
137	typedef void * DrvQElPtr;
138
139
140	#endif
141
142
143
144	/* vcbFlags bits */
145	enum {
146	kVCBFlagsIdleFlushBit = 3, /* Set if volume should be flushed at idle time */
147	kVCBFlagsIdleFlushMask = 0x0008,
148	kVCBFlagsHFSPlusAPIsBit = 4, /* Set if volume implements HFS Plus APIs itself (not via emu\
149	lation) */
150	kVCBFlagsHFSPlusAPIsMask = 0x0010,
151	kVCBFlagsHardwareGoneBit = 5, /* Set if disk driver returned a hardwareGoneErr to Read or W\
152	rite */
153	kVCBFlagsHardwareGoneMask = 0x0020,
154	kVCBFlagsVolumeDirtyBit = 15, /* Set if volume information has changed since the last Flush\
155	Vol */
156	kVCBFlagsVolumeDirtyMask = 0x8000
157	};
158
159
160	/* Disk Cache constants */
161	/*
162	* UTGetBlock options
163	*/
164	enum {
165	gbDefault = 0, /* default value - read if not found */
166	/* bits and masks */
167	gbReadBit = 0, /* read block from disk (forced read) */
168	gbReadMask = 0x0001,
169	gbExistBit = 1, /* get existing cache block */
170	gbExistMask = 0x0002,
171	gbNoReadBit = 2, /* don't read block from disk if not found in cache */
172	gbNoReadMask = 0x0004,
173	gbReleaseBit = 3, /* release block immediately after GetBlock */
174	gbReleaseMask = 0x0008
175	};
176
177
178	/*
179	* UTReleaseBlock options
180	*/
181	enum {
182	rbDefault = 0, /* default value - just mark the buffer not in-use */
183	/* bits and masks */
184	rbWriteBit = 0, /* force write buffer to disk */
185	rbWriteMask = 0x0001,
186	rbTrashBit = 1, /* trash buffer contents after release */
187	rbTrashMask = 0x0002,
188	rbDirtyBit = 2, /* mark buffer dirty */
189	rbDirtyMask = 0x0004,
190	rbFreeBit = 3, /* free the buffer (save in the hash) */
191	rbFreeMask = 0x000A /* rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache; on >= System 7.0, rbfreeMask overrides rbTrash */
192	};
193
194
195	/*
196	* UTFlushCache options
197	*/
198	enum {
199	fcDefault = 0, /* default value - pass this fcOption to just flush any dirty buffers */
200	/* bits and masks */
201	fcTrashBit = 0, /* (don't pass this as fcOption, use only for testing bit) */
202	fcTrashMask = 0x0001, /* pass this fcOption value to flush and trash cache blocks */
203	fcFreeBit = 1, /* (don't pass this as fcOption, use only for testing bit) */
204	fcFreeMask = 0x0003 /* pass this fcOption to flush and free cache blocks (Note: both fcTrash and fcFree bits are set) */
205	};
206
207
208	/*
209	* UTCacheReadIP and UTCacheWriteIP cacheOption bits and masks are the ioPosMode
210	* bits and masks in Files.x
211	*/
212
213	/*
214	* Cache routine internal error codes
215	*/
216	enum {
217	chNoBuf = 1, /* no free cache buffers (all in use) */
218	chInUse = 2, /* requested block in use */
219	chnotfound = 3, /* requested block not found */
220	chNotInUse = 4 /* block being released was not in use */
221	};
222
223
224	/*
225	* FCBRec.fcbFlags bits
226	*/
227	enum {
228	fcbWriteBit = 0, /* Data can be written to this file */
229	fcbWriteMask = 0x01,
230	fcbResourceBit = 1, /* This file is a resource fork */
231	fcbResourceMask = 0x02,
232	fcbWriteLockedBit = 2, /* File has a locked byte range */
233	fcbWriteLockedMask = 0x04,
234	fcbSharedWriteBit = 4, /* File is open for shared write access */
235	fcbSharedWriteMask = 0x10,
236	fcbFileLockedBit = 5, /* File is locked (write-protected) */
237	fcbFileLockedMask = 0x20,
238	fcbOwnClumpBit = 6, /* File has clump size specified in FCB */
239	fcbOwnClumpMask = 0x40,
240	fcbModifiedBit = 7, /* File has changed since it was last flushed */
241	fcbModifiedMask = 0x80
242	};
243
244	enum {
245	fcbLargeFileBit = 3, /* File may grow beyond 2GB; cache uses file blocks, not bytes */
246	fcbLargeFileMask = 0x08
247	};
248
249	#define kSectorShift 9 /* log2(kSectorSize); used for bit shifts */
250
251	/*
252	Fork Level Access Method Block get options
253	*/
254	enum {
255	kGetBlock = 0x00000000,
256	kForceReadBlock = 0x00000002,
257	kGetEmptyBlock = 0x00000008,
258	kSkipEndianSwap = 0x00000010
259	};
260	typedef OptionBits GetBlockOptions;
261
262	/*
263	Fork Level Access Method Block release options
264	*/
265	enum {
266	kReleaseBlock = 0x00000000,
267	kForceWriteBlock = 0x00000001,
268	kMarkBlockDirty = 0x00000002,
269	kTrashBlock = 0x00000004
270	};
271	typedef OptionBits ReleaseBlockOptions;
272
273	struct BlockDescriptor{
274	void *buffer;
275	void *blockHeader;
276	UInt64 blockNum;
277	UInt32 blockSize;
278	Boolean blockReadFromDisk;
279	Boolean fragmented;
280	};
281	typedef struct BlockDescriptor BlockDescriptor;
282	typedef BlockDescriptor *BlockDescPtr;
283
284
285
286	struct SFCB;
287
288	struct SVCB {
289	UInt16 vcbSignature;
290	UInt16 vcbVersion;
291	UInt32 vcbAttributes;
292	UInt32 vcbLastMountedVersion;
293	UInt32 vcbReserved1;
294	UInt32 vcbCreateDate;
295	UInt32 vcbModifyDate;
296	UInt32 vcbBackupDate;
297	UInt32 vcbCheckedDate;
298	UInt32 vcbFileCount;
299	UInt32 vcbFolderCount;
300	UInt32 vcbBlockSize;
301	UInt32 vcbTotalBlocks;
302	UInt32 vcbFreeBlocks;
303	UInt32 vcbNextAllocation;
304	UInt32 vcbRsrcClumpSize;
305	UInt32 vcbDataClumpSize;
306	UInt32 vcbNextCatalogID;
307	UInt32 vcbWriteCount;
308	UInt64 vcbEncodingsBitmap;
309	UInt8 vcbFinderInfo[32];
310
311	/* MDB-specific fields... */
312	SInt16 vcbNmFls; /* number of files in root folder */
313	SInt16 vcbNmRtDirs; /* number of directories in root folder */
314	UInt16 vcbVBMSt; /* first sector of HFS volume bitmap */
315	UInt16 vcbAlBlSt; /* first allocation block in HFS volume */
316	UInt16 vcbVSeqNum; /* volume backup sequence number */
317	UInt16 vcbReserved2;
318	Str27 vcbVN; /* HFS volume name */
319
320	/* runtime fields... */
321	struct SFCB * vcbAllocationFile;
322	struct SFCB * vcbExtentsFile;
323	struct SFCB * vcbCatalogFile;
324	struct SFCB * vcbAttributesFile;
325	struct SFCB * vcbStartupFile;
326
327	UInt32 vcbEmbeddedOffset; /* Byte offset where HFS+ starts */
328	UInt16 vcbFlags;
329	SInt16 vcbDriveNumber;
330	SInt16 vcbDriverReadRef;
331	SInt16 vcbDriverWriteRef;
332
333	void * vcbBlockCache;
334
335	struct SGlob * vcbGPtr;
336
337	/* deprecated fields... */
338	SInt16 vcbVRefNum;
339	};
340	typedef struct SVCB SVCB;
341
342
343	struct SFCB {
344	UInt32 fcbFileID;
345	UInt32 fcbFlags;
346	struct SVCB * fcbVolume;
347	void * fcbBtree;
348	HFSExtentRecord fcbExtents16;
349	HFSPlusExtentRecord fcbExtents32;
350	UInt32 fcbCatalogHint;
351	UInt32 fcbClumpSize;
352	UInt64 fcbLogicalSize;
353	UInt64 fcbPhysicalSize;
354	UInt32 fcbBlockSize;
355	};
356	typedef struct SFCB SFCB;
357
358
359	extern OSErr GetDeviceSize(int driveRefNum, UInt64 numBlocks, UInt32 blockSize);
360
361	extern OSErr DeviceRead(int device, int drive, void* buffer, SInt64 offset, UInt32 reqBytes, UInt32 *actBytes);
362
363	extern OSErr DeviceWrite(int device, int drive, void* buffer, SInt64 offset, UInt32 reqBytes, UInt32 *actBytes);
364
365
366	/*
367	* Block Cache Interface
368	*/
369	extern void InitBlockCache(SVCB *volume);
370
371	extern OSStatus GetVolumeBlock (SVCB *volume, UInt64 blockNum, GetBlockOptions options,
372	BlockDescriptor *block);
373
374	extern OSStatus ReleaseVolumeBlock (SVCB volume, BlockDescriptor block,
375	ReleaseBlockOptions options);
376
377	extern OSStatus GetFileBlock (SFCB *file, UInt32 blockNum, GetBlockOptions options,
378	BlockDescriptor *block);
379
380	extern OSStatus ReleaseFileBlock (SFCB file, BlockDescriptor block,
381	ReleaseBlockOptions options);
382
383	extern OSStatus SetFileBlockSize (SFCB *file, ByteCount blockSize);
384
385
386
387	#if BSD
388
389	#define AllocateMemory(size) malloc((size_t)(size))
390	#define AllocateClearMemory(size) calloc(1,(size_t)(size))
391	#define ReallocateMemory(ptr,newSize) SetPtrSize((void*)(ptr),(size_t)(newSize))
392	#define MemorySize(ptr) malloc_size((void*)(ptr))
393	#define DisposeMemory(ptr) free((void *)(ptr))
394	#define CopyMemory(src,dst,len) bcopy((void)(src),(void)(dst),(size_t)(len))
395	#define ClearMemory(start,len) bzero((void*)(start),(size_t)(len))
396
397	extern UInt32 TickCount();
398	extern OSErr MemError(void);
399	extern Handle NewHandleClear(Size byteCount);
400	extern Handle NewHandle(Size byteCount);
401	extern void DisposeHandle(Handle h);
402	extern Size GetHandleSize(Handle h);
403	extern void SetHandleSize(Handle h, Size newSize);
404	extern OSErr PtrAndHand(const void *ptr1, Handle hand2, long size);
405
406	#else
407
408	#define AllocateMemory(size) NewPtr((Size)(size))
409	#define AllocateClearMemory(size) NewPtrClear((Size)(size))
410	#define ReallocateMemory(ptr,newSize) SetPtrSize((Ptr)(ptr),(Size)(newSize))
411	#define MemorySize(ptr) GetPtrSize((Ptr)(ptr))
412	#define DisposeMemory(ptr) DisposePtr((Ptr)(ptr))
413	#define CopyMemory(src,dst,len) BlockMoveData((void )(src),(void )(dst),(Size)(len))
414	void ClearMemory(void* start, long len);
415	#endif
416
417
418	#endif /* __SRUNTIME__ */
419
420