ext2fs.h

一个windows 文件系统驱动源码

 /*                                                                            
  *		Copyright (c) 2001 - 2003 Satish Kumar J ([e-mail])
  *
  *		Project:		Win2fs
  *                                                                            
  *		Module Name:	\FSD\Win2000\Ext2fs.h
  *                                                                            
  *		Abstract:		Main header for the driver.
  *
  *		Notes:			None  
  *
  *		Revision History:
  *
  *		Date		Version		Author				Change Log
  *		------------------------------------------------------------------------
  *
  *					0.0.1		Satish Kumar J		Initial Version
  */                          		

 #ifndef __EXT2FS_H
 #define __EXT2FS_H

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

 // Global declarations.

 // Indicate we are building the driver.
 #define DRIVER

 // Use this to force a debug build.
 // #undef  DBG
 #define DBG	1

 // Use this to force a read only build of the driver.
 //#define EXT2_READ_ONLY 1 

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

 // Includes.

 #include "ntifs.h"
 #include "ntddk.h"
 #include "ntdddisk.h"

 #include "debug.h"
 #include "ioctls.h"
 #include "linux/ext2_fs.h"

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

 #pragma pack(1)

 typedef PVOID PBCB;

 #define SECTOR_SIZE                     (512)
 #define READ_AHEAD_GRANULARITY          (0x10000)

 // Define IsEndofFile for read and write operations
 #define FILE_WRITE_TO_END_OF_FILE       0xffffffff
 #define FILE_USE_FILE_POINTER_POSITION  0xfffffffe
 
 #define IsEndOfFile(Pos) ((Pos.LowPart == FILE_WRITE_TO_END_OF_FILE) && \
                           (Pos.HighPart == FILE_USE_FILE_POINTER_POSITION ))

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

 #define CHECK_AND_SET(Status, Val)		if (NT_SUCCESS(Status))	{ Val = TRUE; }

 //
 // Inode flags
 //

 #define S_IFMT   0x0F000            /*017 0000 */

 #define S_IFSOCK 0x0C000            /*014 0000 */
 #define S_IFLNK  0x0A000            /*012 0000 */
 #define S_IFFIL  0x08000            /*010 0000 */
 #define S_IFBLK  0x06000            /*006 0000 */
 #define S_IFDIR  0x04000            /*004 0000 */
 #define S_IFCHR  0x02000            /*002 0000 */
 #define S_IFIFO  0x01000            /*001 0000 */

 #define S_ISSOCK(m)     (((m) & S_IFMT) == S_IFSOCK)
 #define S_ISLNK(m)      (((m) & S_IFMT) == S_IFLNK)
 #define S_ISFIL(m)      (((m) & S_IFMT) == S_IFFIL)
 #define S_ISBLK(m)      (((m) & S_IFMT) == S_IFBLK)
 #define S_ISDIR(m)      (((m) & S_IFMT) == S_IFDIR)
 #define S_ISCHR(m)      (((m) & S_IFMT) == S_IFCHR)
 #define S_ISFIFO(m)     (((m) & S_IFMT) == S_IFIFO)
 
 #define S_IPERMISSION_MASK 0x1FF 

 #define S_IRWXU 0x01C0     /*  00700 */
 #define S_IRUSR 0x0100     /*  00400 */
 #define S_IWUSR 0x0080     /*  00200 */
 #define S_IXUSR 0x0040     /*  00100 */

 #define S_IRWXG 0x0038     /*  00070 */
 #define S_IRGRP 0x0020     /*  00040 */
 #define S_IWGRP 0x0010     /*  00020 */
 #define S_IXGRP 0x0008     /*  00010 */
 
 #define S_IRWXO 0x0007     /*  00007 */
 #define S_IROTH 0x0004     /*  00004 */
 #define S_IWOTH 0x0002     /*  00002 */
 #define S_IXOTH 0x0001     /*  00001 */
 
 #define S_ISREADABLE(m)    (((m) & S_IPERMISSION_MASK) == (S_IRUSR | S_IRGRP | S_IROTH))
 #define S_ISWRITABLE(m)    (((m) & S_IPERMISSION_MASK) == (S_IWUSR | S_IWGRP | S_IWOTH))

 #define Ext2SetReadable(m) (m) = ((m) | (S_IRUSR | S_IRGRP | S_IROTH))
 #define Ext2SetWritable(m) (m) = ((m) | (S_IWUSR | S_IWGRP | S_IWOTH))

 #define Ext2SetReadOnly(m) (m) = ((m) & (~(S_IWUSR | S_IWGRP | S_IWOTH)))
 #define Ext2IsReadOnly(m)  (!((m) & (S_IWUSR | S_IWGRP | S_IWOTH)))
 
 #define EXT2_FIRST_DATA_BLOCK   (Vcb->ext2_super_block->s_first_data_block)

 typedef struct ext2_inode			EXT2_INODE,			*PEXT2_INODE;
 typedef struct ext2_dir_entry		EXT2_DIR_ENTRY,		*PEXT2_DIR_ENTRY;
 typedef struct ext2_dir_entry_2	EXT2_DIR_ENTRY2,	*PEXT2_DIR_ENTRY2;
 typedef struct ext2_group_desc		EXT2_GROUP_DESC,	*PEXT2_GROUP_DESC;
 typedef struct ext2_super_block	EXT2_SUPER_BLOCK,	*PEXT2_SUPER_BLOCK;

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

 //
 // Filesystem related stuff.
 //

 #define DRIVER_NAME		"Win2fs"
 #define DEVICE_NAME		L"\\FileSystem\\Ext2"

 //
 // Registry
 //

 #define PARAMETERS_KEY		L"\\Parameters"
 #define WRITING_SUPPORT	L"WritingSupport"

 #ifndef SetFlag
 #define SetFlag(x,f)    ((x) |= (f))
 #endif

 #ifndef ClearFlag
 #define ClearFlag(x,f)  ((x) &= ~(f))
 #endif

 #define IsFlagOn(a,b) ((BOOLEAN)(FlagOn(a,b) ? TRUE : FALSE))

 #define Ext2RaiseStatus(IRPCONTEXT,STATUS) {   \
    (IRPCONTEXT)->ExceptionStatus = (STATUS);	\
    ExRaiseStatus( (STATUS) );					\
 }

 #define Ext2NormalizeAndRaiseStatus(IRPCONTEXT,STATUS) {                       \
    /* (IRPCONTEXT)->ExceptionStatus = (STATUS);  */                            \
    if ((STATUS) == STATUS_VERIFY_REQUIRED) { ExRaiseStatus((STATUS)); }        \
    ExRaiseStatus(FsRtlNormalizeNtstatus((STATUS),STATUS_UNEXPECTED_IO_ERROR)); \
 }

 //
 // EXT2_IDENTIFIER_TYPE
 //
 // Identifiers used to mark the structures
 //

 typedef enum _EXT2_IDENTIFIER_TYPE 
 {
    EXT2FGD  = ':DGF',
    EXT2VCB  = ':BCV',
    EXT2FCB  = ':BCF',
    EXT2CCB  = ':BCC',
    EXT2ICX  = ':XCI',
    EXT2FSD  = ':DSF',
    EXT2MCB  = ':BCM'
 } EXT2_IDENTIFIER_TYPE;

 //
 // EXT2_IDENTIFIER
 //
 // Header used to mark the structures
 //

 typedef struct _EXT2_IDENTIFIER 
 {
    EXT2_IDENTIFIER_TYPE     Type;
    ULONG                    Size;
 } EXT2_IDENTIFIER, *PEXT2_IDENTIFIER;

 #define NodeType(Ptr) (*((EXT2_IDENTIFIER_TYPE *)(Ptr)))

 typedef struct _EXT2_MCB  EXT2_MCB, *PEXT2_MCB;

 //
 // EXT2_GLOBAL_DATA
 //
 // Data that is not specific to a mounted volume.
 //

 typedef struct _EXT2_GLOBAL 
 {
    // Identifier for this structure
    EXT2_IDENTIFIER             Identifier;
    
    // Syncronization primitive for this structure
    ERESOURCE                   Resource;
    
    // Table of pointers to the fast I/O entry points
    FAST_IO_DISPATCH            FastIoDispatch;
    
    // Table of pointers to the Cache Manager callbacks
    CACHE_MANAGER_CALLBACKS     CacheManagerCallbacks;
    CACHE_MANAGER_CALLBACKS     CacheManagerNoOpCallbacks;
    
    // Pointer to the driver object
    PDRIVER_OBJECT              DriverObject;
    
    // Pointer to the main device object
    PDEVICE_OBJECT              DeviceObject;
    
    // List of mounted volumes
    LIST_ENTRY                  VcbList;

    // Look Aside table of IRP_CONTEXT, FCB, MCB, CCB
    USHORT                      MaxDepth;
    NPAGED_LOOKASIDE_LIST       Ext2IrpContextLookasideList;
    NPAGED_LOOKASIDE_LIST       Ext2FcbLookasideList;
    NPAGED_LOOKASIDE_LIST       Ext2CcbLookasideList;
    PAGED_LOOKASIDE_LIST        Ext2McbLookasideList;

    // Mcb Count ...
    USHORT                      McbAllocated;

 #if DBG
    // Fcb Count
    USHORT                      FcbAllocated;

    // IRP_MJ_CLOSE : FCB
    USHORT                      IRPCloseCount;
 #endif
    
    // Global flags for the driver
    ULONG                       Flags;
    
    LARGE_INTEGER               TimeZone;
    
 } EXT2_GLOBAL, *PEXT2_GLOBAL;

 //
 // Flags for EXT2_GLOBAL_DATA
 //

 #define EXT2_SUPPORT_WRITING    0x00000002

 //
 // Driver Extension define
 //

 typedef struct 
 {
    EXT2_GLOBAL gExt2Global;
 } EXT2FS_EXT, *PEXT2FS_EXT;

 typedef struct _EXT2_FCBVCB 
 {
    // FCB header required by NT
    FSRTL_COMMON_FCB_HEADER         CommonFCBHeader;
    SECTION_OBJECT_POINTERS         SectionObject;
    ERESOURCE                       MainResource;
    ERESOURCE                       PagingIoResource;
    // end FCB header required by NT
    
    // Identifier for this structure
    EXT2_IDENTIFIER                  Identifier;
 } EXT2_FCBVCB, *PEXT2_FCBVCB;

 //
 // EXT2_VCB Volume Control Block.
 //
 // Data that represents a mounted logical volume.
 // It is allocated as the device extension of the volume device object.
 //

 typedef struct _EXT2_VCB 
 {
    // FCB header required by NT
    // The VCB is also used as an FCB for file objects
    // that represents the volume itself
    FSRTL_COMMON_FCB_HEADER     CommonFCBHeader;
    SECTION_OBJECT_POINTERS     SectionObject;
    ERESOURCE                   MainResource;
    ERESOURCE                   PagingIoResource;
    // end FCB header required by NT
    
    // Identifier for this structure
    EXT2_IDENTIFIER             Identifier;
    
    LIST_ENTRY                  Next;
    
    // Share Access for the file object
    SHARE_ACCESS                ShareAccess;

    // Count Lock
    ERESOURCE                   CountResource;

    // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
    // for files on this volume.
    ULONG                       OpenFileHandleCount;
    
    // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE
    // for both files on this volume and open instances of the
    // volume itself.
    ULONG                       ReferenceCount;
    ULONG                       OpenHandleCount;
    
    // Pointer to the VPB in the target device object
    PVPB                        Vpb;

    // List of FCBs for open files on this volume
    LIST_ENTRY                  FcbList;

    // List of IRPs pending on directory change notify requests
    LIST_ENTRY                  NotifyList;

    // Pointer to syncronization primitive for this list
    PNOTIFY_SYNC                NotifySync;
    
    // This volumes device object
    PDEVICE_OBJECT              DeviceObject;
    
    // The physical device object (the disk)
    PDEVICE_OBJECT              TargetDeviceObject;
    
    // Information about the physical device object
    DISK_GEOMETRY               DiskGeometry;
    PARTITION_INFORMATION       PartitionInformation;
    
    PEXT2_SUPER_BLOCK           ext2_super_block;
    PEXT2_GROUP_DESC            ext2_group_desc;
    
    // Number of Group Decsciptions
    ULONG                       ext2_groups;

    // Bitmap Block per group
    //PRTL_BITMAP                 BlockBitMaps;
    //PRTL_BITMAP                 InodeBitMaps;
    
	// Block and fragment size
    ULONG                       ext2_block;
    ULONG                       ext2_frag;
    
    // Flags for the volume
    ULONG                       Flags;

    // Streaming File Object
    PFILE_OBJECT                StreamObj;

    // Dirty Mcbs of modifications for volume stream
    LARGE_MCB                   DirtyMcbs;

    // Entry of Mcb Tree (Root Node)
    PEXT2_MCB                   Ext2McbTree;
 } EXT2_VCB, *PEXT2_VCB;

 //
 // Flags for EXT2_VCB
 //

 #define VCB_INITIALIZED         0x00000001
 #define VCB_VOLUME_LOCKED       0x00000002
 #define VCB_DISMOUNT_PENDING    0x00000004
 #define VCB_READ_ONLY           0x00000008
 #define VCB_DISMOUNTED          0x00000010

 //
 // EXT2_FCB File Control Block
 //
 // Data that represents an open file
 // There is a single instance of the FCB for every open file
 //

 typedef struct _EXT2_FCB 
 {
    // FCB header required by NT
    FSRTL_COMMON_FCB_HEADER         CommonFCBHeader;
    SECTION_OBJECT_POINTERS         SectionObject;
    ERESOURCE                       MainResource;
    ERESOURCE                       PagingIoResource;
    // end FCB header required by NT
    
    // Identifier for this structure
    EXT2_IDENTIFIER                 Identifier;
    
    // List of FCBs for this volume
    LIST_ENTRY                      Next;
    
    // Share Access for the file object
    SHARE_ACCESS                    ShareAccess;

    // Count Lock
    ERESOURCE                       CountResource;

    // List of byte-range locks for this file
    FILE_LOCK                       FileLockAnchor;

    // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
    ULONG                           OpenHandleCount;
    
    // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE
    ULONG                           ReferenceCount;

    // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
    // But only for Files with FO_NO_INTERMEDIATE_BUFFERING flag
    ULONG                           NonCachedOpenCount;

    // Flags for the FCB
    ULONG                           Flags;
    
    // Pointer to the inode
    PEXT2_INODE                     ext2_inode;

    // Hint block for next allocation
    ULONG                           BlkHint;
    
    // Vcb

    PEXT2_VCB                       Vcb;

    // Mcb Node ...
    PEXT2_MCB                       Ext2Mcb;

 #if DBG
    // The filename
    ANSI_STRING                     AnsiFileName;   
 #endif
 } EXT2_FCB, *PEXT2_FCB;

 //
 // Flags for EXT2_FCB
 //

 #define FCB_FROM_POOL               0x00000001
 #define FCB_PAGE_FILE               0x00000002
 #define FCB_DELETE_ON_CLOSE         0x00000004
 #define FCB_DELETE_PENDING          0x00000008
 #define FCB_FILE_DELETED            0x00000010
 #define FCB_FILE_MODIFIED           0x00000020

 //
 // Mcb Node
 //

 struct _EXT2_MCB 
 {
    // Identifier for this structure
    EXT2_IDENTIFIER                 Identifier;

    // Flags
    ULONG                           Flags;

    // Link List Info

    PEXT2_MCB                       Parent; // Parent
    PEXT2_MCB                       Child;  // Children
    PEXT2_MCB                       Next;   // Brothers

    // Mcb Node Info

    // Ticker Count when created
    LONGLONG                        TickerCount;

    // -> Fcb
    PEXT2_FCB                       Ext2Fcb;

    // Short name
    UNICODE_STRING                  ShortName;

    // Inode number
    ULONG                           Inode;

    // Dir entry offset in parent
    ULONG                           DeOffset;

    // File attribute
    ULONG                           FileAttr;
 };

 //
 // Flags for MCB
 //

 #define MCB_FROM_POOL               0x00000001
 #define MCB_IN_TREE                 0x00000002

 //
 // EXT2_CCB Context Control Block
 //
 // Data that represents one instance of an open file
 // There is one instance of the CCB for every instance of an open file
 //

 typedef struct _EXT2_CCB 
 {
    // Identifier for this structure
    EXT2_IDENTIFIER  Identifier;

    // Flags
    ULONG               Flags;
    
    // State that may need to be maintained
    ULONG           CurrentByteOffset;
    UNICODE_STRING  DirectorySearchPattern;
 } EXT2_CCB, *PEXT2_CCB;

 //