ext2fs.h

一个windows 文件系统驱动源码

 // Flags for CCB
 //

 #define CCB_FROM_POOL               0x00000001

 //
 // REPINNED_BCBS List
 //

 #define EXT2_REPINNED_BCBS_ARRAY_SIZE         (8)

 typedef struct _EXT2_REPINNED_BCBS 
 {
    //
    //  A pointer to the next structure contains additional repinned bcbs
    //

    struct _EXT2_REPINNED_BCBS *Next;

    //
    //  A fixed size array of pinned bcbs.  Whenever a new bcb is added to
    //  the repinned bcb structure it is added to this array.  If the
    //  array is already full then another repinned bcb structure is allocated
    //  and pointed to with Next.
    //

    PBCB Bcb[EXT2_REPINNED_BCBS_ARRAY_SIZE];

 } EXT2_REPINNED_BCBS, *PEXT2_REPINNED_BCBS;

 //
 // EXT2_IRP_CONTEXT
 //
 // Used to pass information about a request between the drivers functions
 //

 typedef struct _EXT2_IRP_CONTEXT 
 {
    // Identifier for this structure
    EXT2_IDENTIFIER     Identifier;
    
    // Pointer to the IRP this request describes
    PIRP                Irp;

    // Flags
    ULONG               Flags;
    
    // The major and minor function code for the request
    UCHAR               MajorFunction;
    UCHAR               MinorFunction;
    
    // The device object
    PDEVICE_OBJECT      DeviceObject;
    
    // The file object
    PFILE_OBJECT        FileObject;
    
    // If the request is synchronous (we are allowed to block)
    BOOLEAN             IsSynchronous;
    
    // If the request is top level
    BOOLEAN             IsTopLevel;
    
    // Used if the request needs to be queued for later processing
    WORK_QUEUE_ITEM     WorkQueueItem;
    
    // If an exception is currently in progress
    BOOLEAN             ExceptionInProgress;
    
    // The exception code when an exception is in progress
    NTSTATUS            ExceptionCode;

    // Repinned BCBs List
    EXT2_REPINNED_BCBS  Repinned;
 } EXT2_IRP_CONTEXT, *PEXT2_IRP_CONTEXT;

 #define IRP_CONTEXT_FLAG_FROM_POOL       (0x00000001)
 #define IRP_CONTEXT_FLAG_WAIT            (0x00000002)
 #define IRP_CONTEXT_FLAG_WRITE_THROUGH   (0x00000004)
 #define IRP_CONTEXT_FLAG_FLOPPY          (0x00000008)
 #define IRP_CONTEXT_FLAG_RECURSIVE_CALL  (0x00000010)
 #define IRP_CONTEXT_FLAG_DISABLE_POPUPS  (0x00000020)
 #define IRP_CONTEXT_FLAG_DEFERRED_WRITE  (0x00000040)
 #define IRP_CONTEXT_FLAG_VERIFY_READ     (0x00000080)
 #define IRP_CONTEXT_STACK_IO_CONTEXT     (0x00000100)
 #define IRP_CONTEXT_FLAG_IN_FSP          (0x00000200)
 #define IRP_CONTEXT_FLAG_USER_IO         (0x00000400)
 #define IRP_CONTEXT_FLAG_QUEUED_REQ      (0x00000800)

 //
 // EXT2_ALLOC_HEADER
 //
 // In the checked version of the driver this header is put in the beginning of
 // every memory allocation
 //

 typedef struct _EXT2_ALLOC_HEADER 
 {
    EXT2_IDENTIFIER Identifier;
 } EXT2_ALLOC_HEADER, *PEXT2_ALLOC_HEADER;

 typedef struct _FCB_LIST_ENTRY 
 {
    PEXT2_FCB    Fcb;
    LIST_ENTRY   Next;
 } FCB_LIST_ENTRY, *PFCB_LIST_ENTRY;

 //
 // Block Description List
 //

 typedef struct _EXT2_BDL 
 {
    LONGLONG    Lba;
    ULONG       Offset;
    ULONG       Length;
    PIRP        Irp;
 } EXT2_BDL, *PEXT2_BDL;

 #pragma pack()

 /////////////////////////////////////////////////////////////////////////////

 // Function protos.

 //
 //  The following macro is used to determine if an FSD thread can block
 //  for I/O or wait for a resource.  It returns TRUE if the thread can
 //  block and FALSE otherwise.  This attribute can then be used to call
 //  the FSD & FSP common work routine with the proper wait value.
 //

 #define Ext2CanWait(IRP) IoIsOperationSynchronous(Irp)

 // util.c

 LARGE_INTEGER 
 Ext2SysTime (
	IN ULONG i_time );

 ULONG 
 Ext2InodeTime (
	IN LARGE_INTEGER	SysTime );

 VOID 
 Ext2SyncUninitializeCacheMap (
	IN PFILE_OBJECT		FileObject );

 BOOLEAN 
 Ext2CopyRead(
    IN PFILE_OBJECT		FileObject,
    IN PLARGE_INTEGER	FileOffset,
    IN ULONG			Length,
    IN BOOLEAN			Wait,
    OUT PVOID			Buffer,
    OUT PIO_STATUS_BLOCK  IoStatus );

 // block.c

 NTSTATUS
 Ext2ReadWriteBlocks(
    IN PEXT2_IRP_CONTEXT IrpContext,
    IN PEXT2_VCB        Vcb,
    IN PEXT2_BDL        Ext2BDL,
    IN ULONG            Length,
    IN ULONG            Count,
    IN BOOLEAN          bVerify );

 NTSTATUS
 Ext2ReadSync(
    IN PDEVICE_OBJECT   DeviceObject,
    IN LONGLONG         Offset,
    IN ULONG            Length,
    OUT PVOID           Buffer,
    BOOLEAN             bVerify );

 NTSTATUS
 Ext2ReadDisk(
	IN PDEVICE_OBJECT	pDeviceObject,
    IN ULONG			lba,
    IN ULONG			offset,
    IN ULONG			Size,
    IN PVOID			Buffer );

 NTSTATUS 
 Ext2DiskIoControl (
	IN PDEVICE_OBJECT   pDeviceObject,
    IN ULONG            IoctlCode,
    IN PVOID            InputBuffer,
    IN ULONG            InputBufferSize,
    IN OUT PVOID        OutputBuffer,
    IN OUT PULONG       OutputBufferSize );

 NTSTATUS
 Ext2DiskShutDown(
	PEXT2_VCB Vcb );

 NTSTATUS
 Ext2ReadDiskOverrideVerify (
	IN PDEVICE_OBJECT	pDeviceObject,
    IN ULONG			DiskSector, 
    IN ULONG			SectorCount,
    IN OUT PUCHAR		Buffer );

 // ext2.c

 PEXT2_SUPER_BLOCK
 Ext2LoadSuper(
	IN PDEVICE_OBJECT pDeviceObject );

 BOOLEAN
 Ext2SaveSuper(  
	IN PEXT2_IRP_CONTEXT    IrpContext,
    IN PEXT2_VCB            Vcb );

 PEXT2_GROUP_DESC
 Ext2LoadGroup(
	IN PEXT2_VCB vcb );

 BOOLEAN
 Ext2SaveGroup(  
	IN PEXT2_IRP_CONTEXT    IrpContext,
    IN PEXT2_VCB            Vcb       );
 
 BOOLEAN
 Ext2GetInodeLba (
	IN PEXT2_VCB vcb,
    IN ULONG inode,
    OUT PLONGLONG offset );

 BOOLEAN
 Ext2LoadInode (
	IN PEXT2_VCB vcb,
    IN ULONG inode,
    IN PEXT2_INODE ext2_inode );

 BOOLEAN
 Ext2SaveInode (
	IN PEXT2_IRP_CONTEXT IrpContext,
    IN PEXT2_VCB vcb,
    IN ULONG inode,
    IN PEXT2_INODE ext2_inode);

 BOOLEAN
 Ext2LoadBlock (
    IN PEXT2_VCB Vcb,
    IN ULONG     dwBlk,
    IN PVOID     Buffer);

 BOOLEAN
 Ext2SaveBlock ( 
	IN PEXT2_IRP_CONTEXT    IrpContext,
    IN PEXT2_VCB            Vcb,
    IN ULONG                dwBlk,
    IN PVOID                Buf );

 BOOLEAN
 Ext2SaveBuffer( 
	IN PEXT2_IRP_CONTEXT    IrpContext,
    IN PEXT2_VCB            Vcb,
    IN LONGLONG             Offset,
    IN ULONG                Size,
    IN PVOID                Buf );

 ULONG  
 Ext2GetBlock(
	IN PEXT2_VCB	vcb,
    ULONG			dwContent,
    ULONG			Index,
    int				layer );

 ULONG 
 Ext2BlockMap(
	IN PEXT2_VCB vcb,
    IN PEXT2_INODE ext2_inode,
    IN ULONG Index );

 ULONG 
 Ext2BuildBDL(
	IN PEXT2_IRP_CONTEXT    IrpContext,
	IN PEXT2_VCB			Vcb,
	IN PEXT2_INODE			ext2_inode,
	IN ULONG				offset, 
	IN ULONG				size, 
	OUT PEXT2_BDL*			ext2_bdl );

 BOOLEAN 
 Ext2NewBlock(   
	PEXT2_IRP_CONTEXT	IrpContext,
    PEXT2_VCB			Vcb,
    ULONG				GroupHint,
    ULONG				BlockHint,  
    PULONG				dwRet );

 BOOLEAN 
 Ext2FreeBlock(  
	PEXT2_IRP_CONTEXT	IrpContext,
    PEXT2_VCB			Vcb,
    ULONG				Block );

 BOOLEAN 
 Ext2ExpandBlock(
    PEXT2_IRP_CONTEXT	IrpContext,
    PEXT2_VCB			Vcb,
    PEXT2_FCB			Fcb,
    ULONG				dwContent,
    ULONG				Index,
    ULONG				layer,
    BOOLEAN				bNew,
    ULONG				*dwRet );


 BOOLEAN 
 Ext2ExpandInode(
	PEXT2_IRP_CONTEXT	IrpContext,
    PEXT2_VCB			Vcb,
    PEXT2_FCB			Fcb,
    ULONG				*dwRet );

 BOOLEAN
 Ext2NewInode(
    PEXT2_IRP_CONTEXT	IrpContext,
    PEXT2_VCB			Vcb,
    ULONG				GroupHint,
    ULONG				mode,
    PULONG				Inode );

 BOOLEAN
 Ext2FreeInode(
    PEXT2_IRP_CONTEXT	IrpContext,
    PEXT2_VCB			Vcb,
    ULONG				Inode,
    ULONG				Type );

 NTSTATUS
 Ext2AddEntry (
	IN PEXT2_IRP_CONTEXT   IrpContext,
	IN PEXT2_VCB           Vcb,
	IN PEXT2_FCB           Dcb,
	IN ULONG               FileType,
	IN ULONG               Inode,
	IN PUNICODE_STRING     FileName );

 NTSTATUS
 Ext2RemoveEntry (
	IN PEXT2_IRP_CONTEXT   IrpContext,
	IN PEXT2_VCB           Vcb,
	IN PEXT2_FCB           Dcb,
	IN ULONG               Inode );

 BOOLEAN 
 Ext2TruncateBlock(
    PEXT2_IRP_CONTEXT		IrpContext,
    PEXT2_VCB				Vcb,
    ULONG					dwContent,
    ULONG					Index,
    ULONG					layer,
    BOOLEAN					*bFreed );

 BOOLEAN
 Ext2TruncateInode(
    PEXT2_IRP_CONTEXT	IrpContext,
    PEXT2_VCB			Vcb,
    PEXT2_FCB			Fcb );

 BOOLEAN
 Ext2AddMcbEntry (
    IN PEXT2_VCB Vcb,
    IN LONGLONG  Lba,
    IN LONGLONG  Length );

 VOID
 Ext2RemoveMcbEntry (
    IN PEXT2_VCB Vcb,
    IN LONGLONG  Lba,
    IN LONGLONG  Length );

 BOOLEAN
 Ext2LookupMcbEntry (
    IN PEXT2_VCB    Vcb,
    IN LONGLONG     Offset,
    OUT PLONGLONG   Lba OPTIONAL,
    OUT PLONGLONG   Length OPTIONAL,
    OUT PLONGLONG   RunStart OPTIONAL,
    OUT PLONGLONG   RunLength OPTIONAL,
    OUT PULONG      Index OPTIONAL );

 // read.c

 NTSTATUS
 Ext2ReadInode (
    IN PEXT2_IRP_CONTEXT    IrpContext,
    IN PEXT2_VCB			vcb,
    IN PEXT2_INODE			ext2_inode,
    IN ULONG				offset,
    IN PVOID				Buffer,
    IN ULONG				size,
    OUT PULONG				dwReturn);

 // write.c

 NTSTATUS
 Ext2WriteInode (
    IN PEXT2_IRP_CONTEXT    IrpContext,
    IN PEXT2_VCB            Vcb,
    IN PEXT2_INODE          ext2_inode,
    IN ULONG                offset,
    IN PVOID                Buffer,
    IN ULONG                size,
    IN BOOLEAN              bWriteToDisk,
    OUT PULONG              dwReturn);

 // memory.c

 PEXT2_IRP_CONTEXT
 Ext2AllocateIrpContext (
	IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp );

 VOID
 Ext2FreeIrpContext (
	IN PEXT2_IRP_CONTEXT IrpContext );

 VOID
 Ext2RepinBcb (
    IN PEXT2_IRP_CONTEXT IrpContext,
    IN PBCB Bcb );

 VOID
 Ext2UnpinRepinnedBcbs (
    IN PEXT2_IRP_CONTEXT IrpContext );

 PEXT2_FCB
 Ext2AllocateFcb (
	IN PEXT2_VCB		Vcb,
	IN PEXT2_MCB       Ext2Mcb,
	IN PEXT2_INODE     ext2_inode );

 VOID
 Ext2FreeFcb (
	IN PEXT2_FCB Fcb );

 PEXT2_CCB
 Ext2AllocateCcb (VOID);

 VOID
 Ext2FreeMcb (
	IN PEXT2_MCB Mcb );

 PEXT2_FCB
 Ext2CreateFcbFromMcb(
	PEXT2_VCB Vcb, 
	PEXT2_MCB Mcb );

 VOID
 Ext2FreeCcb (
	IN PEXT2_CCB Ccb );

 PEXT2_MCB
 Ext2AllocateMcb (
	PEXT2_VCB		Vcb, 
	PUNICODE_STRING FileName, 
	ULONG			FileAttr );

 PEXT2_MCB
 Ext2SearchMcbTree(
	PEXT2_MCB	Ext2Mcb, 
	ULONG		Inode);

 PEXT2_MCB
 Ext2SearchMcb(
	PEXT2_MCB		Parent, 
	PUNICODE_STRING FileName);

 BOOLEAN
 Ext2GetFullFileName(
	PEXT2_MCB		Mcb, 
	PUNICODE_STRING FileName);

 VOID
 Ext2AddMcbNode(
	PEXT2_MCB Parent, 
	PEXT2_MCB Child );

 BOOLEAN
 Ext2DeleteMcbNode(
	PEXT2_MCB Ext2McbTree, 
	PEXT2_MCB Ext2Mcb);

 int Ext2GetMcbDepth(
	PEXT2_MCB Ext2Mcb );

 BOOLEAN
 Ext2CompareMcb(
	PEXT2_MCB Ext2Mcb1, 
	PEXT2_MCB Ext2Mcb2);

 VOID
 Ext2FindUnusedMcb (
	PEXT2_MCB	Ext2McbTree, 
	PEXT2_MCB	*Ext2Mcb);

 VOID
 Ext2FreeMcbTree(
	PEXT2_MCB McbTree );

 BOOLEAN
 Ext2CheckSetBlock(
	PEXT2_IRP_CONTEXT	IrpContext, 
	PEXT2_VCB			Vcb, 
	ULONG Block );

 BOOLEAN
 Ext2CheckBitmapConsistency(
	PEXT2_IRP_CONTEXT IrpContext, 
	PEXT2_VCB Vcb );