Index: drivers/filesystems/ext2/inc/common.h =================================================================== --- drivers/filesystems/ext2/inc/common.h (révision 71375) +++ drivers/filesystems/ext2/inc/common.h (copie de travail) @@ -167,8 +167,8 @@ BOOLEAN bExt3Writable; BOOLEAN bExt2; BOOLEAN bExt3; - UCHAR Codepage[CODEPAGE_MAXLEN]; -} EXT2_VOLUME_PROPERTY; + CHAR Codepage[CODEPAGE_MAXLEN]; +} EXT2_VOLUME_PROPERTY, *PEXT2_VOLUME_PROPERTY; #ifdef __cplusplus typedef struct _EXT2_VOLUME_PROPERTY2:EXT2_VOLUME_PROPERTY { @@ -196,14 +196,24 @@ } EXT2_VOLUME_PROPERTY2, *PEXT2_VOLUME_PROPERTY2; -#define EXT2_VPROP3_AUTOMOUNT 0x0000000000000001 +#define EXT2_VPROP3_AUTOMOUNT (1ULL << 0) +#define EXT2_VPROP3_USERIDS (1ULL << 1) +#ifdef __cplusplus +typedef struct _EXT2_VOLUME_PROPERTY3:EXT2_VOLUME_PROPERTY2 { +#else // __cplusplus typedef struct _EXT2_VOLUME_PROPERTY3 { - EXT2_VOLUME_PROPERTY2 Prop2; - unsigned __int64 Flags; - int AutoMount:1; - int Reserved1:31; - int Reserved2[31]; + EXT2_VOLUME_PROPERTY2 ; +#endif // __cplusplus + unsigned __int64 Flags2; + ULONG AutoMount:1; + ULONG EIDS:1; + ULONG Reserved1:30; + USHORT uid; + USHORT gid; + USHORT euid; + USHORT egid; + ULONG Reserved2[29]; } EXT2_VOLUME_PROPERTY3, *PEXT2_VOLUME_PROPERTY3; /* Ext2Fsd driver version and built time */ Index: drivers/filesystems/ext2/inc/ext2fs.h =================================================================== --- drivers/filesystems/ext2/inc/ext2fs.h (révision 71375) +++ drivers/filesystems/ext2/inc/ext2fs.h (copie de travail) @@ -47,7 +47,7 @@ /* STRUCTS & CONSTS******************************************************/ -#define EXT2FSD_VERSION "0.63" +#define EXT2FSD_VERSION "0.66" /* WDK DEFINITIONS ******************************************************/ @@ -110,6 +110,26 @@ #define CEILING_ALIGNED(T, A, B) (((A) + (B) - 1) & (~((T)(B) - 1))) #define COCKLOFT_ALIGNED(T, A, B) (((A) + (B)) & (~((T)(B) - 1))) + + +/* + * Compile-time assertion: (Lustre version) + * + * Check an invariant described by a constant expression at compile time by + * forcing a compiler error if it does not hold. \a cond must be a constant + * expression as defined by the ISO C Standard: + * + * 6.8.4.2 The switch statement + * .... + * [#3] The expression of each case label shall be an integer + * constant expression and no two of the case constant + * expressions in the same switch statement shall have the same + * value after conversion... + * + */ + +#define CL_ASSERT(cond) do {switch('x') {case (cond): case 0: break;}} while (0) + /* File System Releated *************************************************/ #define DRIVER_NAME "Ext2Fsd" @@ -130,6 +150,10 @@ #define HIDING_SUFFIX L"HidingSuffix" #define AUTO_MOUNT L"AutoMount" #define MOUNT_POINT L"MountPoint" +#define UID L"uid" +#define GID L"gid" +#define EUID L"euid" +#define EGID L"egid" #define DOS_DEVICE_NAME L"\\DosDevices\\Ext2Fsd" @@ -464,6 +488,17 @@ // Data that is not specific to a mounted volume // +typedef VOID (NTAPI *EXT2_REAPER_RELEASE)(PVOID); + +typedef struct _EXT2_REAPER { + KEVENT Engine; + KEVENT Wait; + EXT2_REAPER_RELEASE Free; + ULONG Flags; +} EXT2_REAPER, *PEXT2_REAPER; + +#define EXT2_REAPER_FLAG_STOP (1 << 0) + typedef struct _EXT2_GLOBAL { /* Identifier for this structure */ @@ -479,6 +514,9 @@ /* Table of pointers to the fast I/O entry points */ FAST_IO_DISPATCH FastIoDispatch; + /* Filter callbacks */ + FS_FILTER_CALLBACKS FilterCallbacks; + /* Table of pointers to the Cache Manager callbacks */ CACHE_MANAGER_CALLBACKS CacheManagerCallbacks; CACHE_MANAGER_CALLBACKS CacheManagerNoOpCallbacks; @@ -496,10 +534,8 @@ LIST_ENTRY VcbList; /* Cleaning thread related: resource cleaner */ - struct { - KEVENT Engine; - KEVENT Wait; - } Reaper; + EXT2_REAPER McbReaper; + EXT2_REAPER bhReaper; /* Look Aside table of IRP_CONTEXT, FCB, MCB, CCB */ NPAGED_LOOKASIDE_LIST Ext2IrpContextLookasideList; @@ -512,11 +548,14 @@ /* User specified global codepage name */ struct { + WCHAR PageName[CODEPAGE_MAXLEN]; UCHAR AnsiName[CODEPAGE_MAXLEN]; struct nls_table * PageTable; } Codepage; /* global hiding patterns */ + WCHAR wHidingPrefix[HIDINGPAT_LEN]; + WCHAR wHidingSuffix[HIDINGPAT_LEN]; BOOLEAN bHidingPrefix; CHAR sHidingPrefix[HIDINGPAT_LEN]; BOOLEAN bHidingSuffix; @@ -599,9 +638,12 @@ /* Common header */ EXT2_FCBVCB; - // Resource for metadata (super block, tables) - ERESOURCE MetaLock; + // Resource for metadata (inode) + ERESOURCE MetaInode; + // Resource for metadata (block) + ERESOURCE MetaBlock; + // Resource for Mcb (Meta data control block) ERESOURCE McbLock; @@ -669,12 +711,6 @@ BOOLEAN IsExt3fs; PEXT2_SUPER_BLOCK SuperBlock; - /* - // Bitmap Block per group - PRTL_BITMAP BlockBitMaps; - PRTL_BITMAP InodeBitMaps; - */ - // Block / Cluster size ULONG BlockSize; @@ -745,6 +781,7 @@ #define VCB_USER_IDS 0x00000040 /* uid/gid specified by user */ #define VCB_USER_EIDS 0x00000080 /* euid/egid specified by user */ +#define VCB_BEING_DROPPED 0x00002000 #define VCB_FORCE_WRITING 0x00004000 #define VCB_DEVICE_REMOVED 0x00008000 #define VCB_JOURNAL_RECOVER 0x00080000 @@ -1148,7 +1185,6 @@ PMDL Ext2CreateMdl ( IN PVOID Buffer, - IN BOOLEAN bPaged, IN ULONG Length, IN LOCK_OPERATION Operation ); @@ -1255,44 +1291,6 @@ VOID NTAPI Ext2NoOpRelease (IN PVOID Fcb); -VOID NTAPI -Ext2AcquireForCreateSection ( - IN PFILE_OBJECT FileObject -); - -VOID NTAPI -Ext2ReleaseForCreateSection ( - IN PFILE_OBJECT FileObject -); - -NTSTATUS NTAPI -Ext2AcquireFileForModWrite ( - IN PFILE_OBJECT FileObject, - IN PLARGE_INTEGER EndingOffset, - OUT PERESOURCE *ResourceToRelease, - IN PDEVICE_OBJECT DeviceObject -); - -NTSTATUS NTAPI -Ext2ReleaseFileForModWrite ( - IN PFILE_OBJECT FileObject, - IN PERESOURCE ResourceToRelease, - IN PDEVICE_OBJECT DeviceObject -); - -NTSTATUS NTAPI -Ext2AcquireFileForCcFlush ( - IN PFILE_OBJECT FileObject, - IN PDEVICE_OBJECT DeviceObject -); - -NTSTATUS NTAPI -Ext2ReleaseFileForCcFlush ( - IN PFILE_OBJECT FileObject, - IN PDEVICE_OBJECT DeviceObject -); - - // // Create.c // @@ -1482,7 +1480,7 @@ NTSTATUS Ext2ProcessGlobalProperty( IN PDEVICE_OBJECT DeviceObject, - IN PEXT2_VOLUME_PROPERTY2 Property, + IN PEXT2_VOLUME_PROPERTY3 Property, IN ULONG Length ); @@ -1489,7 +1487,7 @@ NTSTATUS Ext2ProcessVolumeProperty( IN PEXT2_VCB Vcb, - IN PEXT2_VOLUME_PROPERTY2 Property, + IN PEXT2_VOLUME_PROPERTY3 Property, IN ULONG Length ); @@ -1496,7 +1494,7 @@ NTSTATUS Ext2ProcessUserProperty( IN PEXT2_IRP_CONTEXT IrpContext, - IN PEXT2_VOLUME_PROPERTY2 Property, + IN PEXT2_VOLUME_PROPERTY3 Property, IN ULONG Length ); @@ -1912,6 +1910,13 @@ ); NTSTATUS +Ext2UpdateGroupDirStat( + IN PEXT2_IRP_CONTEXT IrpContext, + IN PEXT2_VCB Vcb, + IN ULONG Group +); + +NTSTATUS Ext2FreeInode( IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, @@ -1934,7 +1939,8 @@ IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, - IN PEXT2_MCB Mcb + IN PEXT2_MCB Mcb, + IN umode_t mode ); NTSTATUS @@ -2110,7 +2116,57 @@ OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject); +VOID +NTAPI +Ext2AcquireForCreateSection ( + IN PFILE_OBJECT FileObject +); +VOID +NTAPI +Ext2ReleaseForCreateSection ( + IN PFILE_OBJECT FileObject +); + +NTSTATUS +NTAPI +Ext2AcquireFileForModWrite ( + IN PFILE_OBJECT FileObject, + IN PLARGE_INTEGER EndingOffset, + OUT PERESOURCE *ResourceToRelease, + IN PDEVICE_OBJECT DeviceObject +); + +NTSTATUS +NTAPI +Ext2ReleaseFileForModWrite ( + IN PFILE_OBJECT FileObject, + IN PERESOURCE ResourceToRelease, + IN PDEVICE_OBJECT DeviceObject +); + +NTSTATUS +NTAPI +Ext2AcquireFileForCcFlush ( + IN PFILE_OBJECT FileObject, + IN PDEVICE_OBJECT DeviceObject +); + +NTSTATUS +NTAPI +Ext2ReleaseFileForCcFlush ( + IN PFILE_OBJECT FileObject, + IN PDEVICE_OBJECT DeviceObject +); + + +NTSTATUS +NTAPI +Ext2PreAcquireForCreateSection( + IN PFS_FILTER_CALLBACK_DATA cd, + OUT PVOID *cc + ); + // // FileInfo.c // @@ -2402,8 +2458,10 @@ // Init.c // +NTSTATUS +Ext2QueryGlobalParameters(IN PUNICODE_STRING RegistryPath); BOOLEAN -Ext2QueryGlobalParameters (IN PUNICODE_STRING RegistryPath); +Ext2QueryRegistrySettings(IN PUNICODE_STRING RegistryPath); VOID NTAPI DriverUnload (IN PDRIVER_OBJECT DriverObject); @@ -2465,6 +2523,19 @@ // Memory.c // +VOID +NTAPI +Ext2McbReaperThread( + PVOID Context +); + +VOID +NTAPI +Ext2bhReaperThread( + PVOID Context +); + + PEXT2_IRP_CONTEXT Ext2AllocateIrpContext (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ); @@ -2769,7 +2840,10 @@ ); NTSTATUS -Ext2StartReaperThread(); +Ext2StartReaper(PEXT2_REAPER, EXT2_REAPER_RELEASE); +VOID +NTAPI +Ext2StopReaper(PEXT2_REAPER Reaper); // // Misc.c @@ -2948,6 +3022,7 @@ OUT PULONG dwReturn ); + VOID Ext2StartFloppyFlushDpc ( PEXT2_VCB Vcb, Index: drivers/filesystems/ext2/inc/linux/atomic.h =================================================================== --- drivers/filesystems/ext2/inc/linux/atomic.h (révision 71375) +++ drivers/filesystems/ext2/inc/linux/atomic.h (copie de travail) @@ -8,7 +8,7 @@ // typedef struct { - volatile int counter; + volatile LONG counter; } atomic_t; #define ATOMIC_INIT(i) (i) @@ -152,4 +152,4 @@ return (InterlockedExchangeAdd((PLONG)(&v->counter), (LONG) i) + i); } -#endif /* LINUX_ATOMIC_H */ \ No newline at end of file +#endif /* LINUX_ATOMIC_H */ Index: drivers/filesystems/ext2/inc/linux/ext3_fs_sb.h =================================================================== --- drivers/filesystems/ext2/inc/linux/ext3_fs_sb.h (révision 71375) +++ drivers/filesystems/ext2/inc/linux/ext3_fs_sb.h (copie de travail) @@ -22,8 +22,18 @@ /* * third extended-fs super-block data in memory */ + +struct ext3_gd { + ext3_fsblk_t block; + struct ext4_group_desc *gd; + struct buffer_head *bh; +}; + struct ext3_sb_info { + ERESOURCE s_gd_lock; + struct ext3_gd *s_gd; + unsigned long s_desc_size; /* size of group desc */ unsigned long s_gdb_count; /* Number of group descriptor blocks */ unsigned long s_desc_per_block; /* Number of group descriptors per block */ @@ -36,7 +46,6 @@ int s_addr_per_block_bits; int s_desc_per_block_bits; - ext3_fsblk_t *s_group_desc; #if 0 unsigned long s_frag_size; /* Size of a fragment in bytes */ Index: drivers/filesystems/ext2/inc/linux/module.h =================================================================== --- drivers/filesystems/ext2/inc/linux/module.h (révision 71375) +++ drivers/filesystems/ext2/inc/linux/module.h (copie de travail) @@ -546,9 +546,11 @@ PFILE_OBJECT bd_volume; /* streaming object file */ LARGE_MCB bd_extents; /* dirty extents */ - spinlock_t bd_bh_lock; /**/ - kmem_cache_t * bd_bh_cache; /* memory cache for buffer_head */ - struct rb_root bd_bh_root; /* buffer_head red-black tree root */ + kmem_cache_t * bd_bh_cache;/* memory cache for buffer_head */ + ERESOURCE bd_bh_lock; /* lock for bh tree and reaper list */ + struct rb_root bd_bh_root; /* buffer_head red-black tree root */ + LIST_ENTRY bd_bh_free; /* reaper list */ + KEVENT bd_bh_notify; /* notification event for cleanup */ }; // @@ -709,6 +711,7 @@ * for backward compatibility reasons (e.g. submit_bh). */ struct buffer_head { + LIST_ENTRY b_link; /* to be added to reaper list */ unsigned long b_state; /* buffer state bitmap (see above) */ struct page *b_page; /* the page this bh is mapped to */ PMDL b_mdl; /* MDL of the locked buffer */ @@ -725,7 +728,10 @@ // struct list_head b_assoc_buffers; /* associated with another mapping */ // struct address_space *b_assoc_map; /* mapping this buffer is associated with */ atomic_t b_count; /* users using this buffer_head */ - struct rb_node b_rb_node; /* Red-black tree node entry */ + struct rb_node b_rb_node; /* Red-black tree node entry */ + + LARGE_INTEGER b_ts_creat; /* creation time*/ + LARGE_INTEGER b_ts_drop; /* drop time (to be released) */ }; Index: drivers/filesystems/ext2/src/block.c =================================================================== --- drivers/filesystems/ext2/src/block.c (révision 71375) +++ drivers/filesystems/ext2/src/block.c (copie de travail) @@ -51,9 +51,8 @@ PMDL Ext2CreateMdl ( IN PVOID Buffer, - IN BOOLEAN bPaged, IN ULONG Length, - IN LOCK_OPERATION Operation + IN LOCK_OPERATION op ) { NTSTATUS Status; @@ -65,10 +64,10 @@ Status = STATUS_INSUFFICIENT_RESOURCES; } else { _SEH2_TRY { - if (bPaged) { - MmProbeAndLockPages(Mdl, KernelMode, Operation); + if (MmIsNonPagedSystemAddressValid(Buffer)) { + MmBuildMdlForNonPagedPool(Mdl); } else { - MmBuildMdlForNonPagedPool (Mdl); + MmProbeAndLockPages(Mdl, KernelMode, op); } Status = STATUS_SUCCESS; } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) { @@ -89,6 +88,7 @@ while (Mdl) { PMDL Next; Next = Mdl->Next; + Mdl->Next = NULL; if (IsFlagOn(Mdl->MdlFlags, MDL_PAGES_LOCKED)) { MmUnlockPages (Mdl); } Index: drivers/filesystems/ext2/src/cleanup.c =================================================================== --- drivers/filesystems/ext2/src/cleanup.c (révision 71375) +++ drivers/filesystems/ext2/src/cleanup.c (copie de travail) @@ -33,6 +33,7 @@ BOOLEAN VcbResourceAcquired = FALSE; BOOLEAN FcbResourceAcquired = FALSE; BOOLEAN FcbPagingIoResourceAcquired = FALSE; + BOOLEAN SymLinkDelete = FALSE; _SEH2_TRY { @@ -198,7 +199,11 @@ } if (IsFlagOn(Ccb->Flags, CCB_DELETE_ON_CLOSE)) { - SetLongFlag(Fcb->Flags, FCB_DELETE_PENDING); + if (Ccb->SymLink || IsInodeSymLink(&Mcb->Inode)) { + SymLinkDelete = TRUE; + } else { + SetLongFlag(Fcb->Flags, FCB_DELETE_PENDING); + } } // @@ -279,52 +284,52 @@ } } - if (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING)) { + if (SymLinkDelete || + (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING) && + Fcb->OpenHandleCount == 0) ) { - if (Fcb->OpenHandleCount == 0 || (Mcb = Ccb->SymLink)) { + // + // Ext2DeleteFile will acquire these lock inside + // - // - // Ext2DeleteFile will acquire these lock inside - // + if (FcbResourceAcquired) { + ExReleaseResourceLite(&Fcb->MainResource); + FcbResourceAcquired = FALSE; + } - if (FcbResourceAcquired) { - ExReleaseResourceLite(&Fcb->MainResource); - FcbResourceAcquired = FALSE; - } + // + // this file is to be deleted ... + // + if (Ccb->SymLink) { + Mcb = Ccb->SymLink; + FileObject->DeletePending = FALSE; + } - // - // this file is to be deleted ... - // - if (Ccb->SymLink) { - Mcb = Ccb->SymLink; - FileObject->DeletePending = FALSE; - } + Status = Ext2DeleteFile(IrpContext, Vcb, Fcb, Mcb); - Status = Ext2DeleteFile(IrpContext, Vcb, Fcb, Mcb); - - if (NT_SUCCESS(Status)) { - if (IsMcbDirectory(Mcb)) { - Ext2NotifyReportChange( IrpContext, Vcb, Mcb, - FILE_NOTIFY_CHANGE_DIR_NAME, - FILE_ACTION_REMOVED ); - } else { - Ext2NotifyReportChange( IrpContext, Vcb, Mcb, - FILE_NOTIFY_CHANGE_FILE_NAME, - FILE_ACTION_REMOVED ); - } + if (NT_SUCCESS(Status)) { + if (IsMcbDirectory(Mcb)) { + Ext2NotifyReportChange( IrpContext, Vcb, Mcb, + FILE_NOTIFY_CHANGE_DIR_NAME, + FILE_ACTION_REMOVED ); + } else { + Ext2NotifyReportChange( IrpContext, Vcb, Mcb, + FILE_NOTIFY_CHANGE_FILE_NAME, + FILE_ACTION_REMOVED ); } + } - // - // re-acquire the main resource lock - // + // + // re-acquire the main resource lock + // - FcbResourceAcquired = - ExAcquireResourceExclusiveLite( - &Fcb->MainResource, - TRUE - ); - - SetFlag(FileObject->Flags, FO_FILE_MODIFIED); + FcbResourceAcquired = + ExAcquireResourceExclusiveLite( + &Fcb->MainResource, + TRUE + ); + if (!SymLinkDelete) { + SetFlag(FileObject->Flags, FO_FILE_MODIFIED); if (CcIsFileCached(FileObject)) { CcSetFileSizes(FileObject, (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize))); Index: drivers/filesystems/ext2/src/cmcb.c =================================================================== --- drivers/filesystems/ext2/src/cmcb.c (révision 71375) +++ drivers/filesystems/ext2/src/cmcb.c (copie de travail) @@ -38,8 +38,7 @@ DEBUG(CMCB_DEBUG_LEVEL, ("Ext2AcquireForLazyWrite: %s %s Fcb=%p\n", Ext2GetCurrentProcessName(), "ACQUIRE_FOR_LAZY_WRITE", Fcb)); #endif - if (!ExAcquireResourceSharedLite( - &Fcb->PagingIoResource, Wait)) { + if (!ExAcquireResourceExclusiveLite(Fcb->Header.Resource, Wait)) { return FALSE; } @@ -47,7 +46,6 @@ Fcb->LazyWriterThread = PsGetCurrentThread(); ASSERT(IoGetTopLevelIrp() == NULL); - IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP); return TRUE; @@ -59,10 +57,8 @@ // // On a readonly filesystem this function still has to exist but it // doesn't need to do anything. - PEXT2_FCB Fcb; + PEXT2_FCB Fcb = (PEXT2_FCB) Context; - Fcb = (PEXT2_FCB) Context; - ASSERT(Fcb != NULL); ASSERT((Fcb->Identifier.Type == EXT2FCB) && @@ -74,7 +70,7 @@ ASSERT(Fcb->LazyWriterThread == PsGetCurrentThread()); Fcb->LazyWriterThread = NULL; - ExReleaseResourceLite(&Fcb->PagingIoResource); + ExReleaseResourceLite(Fcb->Header.Resource); ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP); IoSetTopLevelIrp( NULL ); @@ -84,12 +80,9 @@ Ext2AcquireForReadAhead (IN PVOID Context, IN BOOLEAN Wait) { - PEXT2_FCB Fcb; + PEXT2_FCB Fcb = (PEXT2_FCB) Context; - Fcb = (PEXT2_FCB) Context; - ASSERT(Fcb != NULL); - ASSERT((Fcb->Identifier.Type == EXT2FCB) && (Fcb->Identifier.Size == sizeof(EXT2_FCB))); @@ -96,12 +89,9 @@ DEBUG(CMCB_DEBUG_LEVEL, ("Ext2AcquireForReadAhead: i=%xh Fcb=%p\n", Fcb->Mcb->Inode.i_ino, Fcb)); - if (!ExAcquireResourceSharedLite( - &Fcb->MainResource, Wait )) + if (!ExAcquireResourceSharedLite(Fcb->Header.Resource, Wait)) return FALSE; - ASSERT(IoGetTopLevelIrp() == NULL); - IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP); return TRUE; @@ -110,10 +100,8 @@ VOID NTAPI Ext2ReleaseFromReadAhead (IN PVOID Context) { - PEXT2_FCB Fcb; + PEXT2_FCB Fcb = (PEXT2_FCB) Context; - Fcb = (PEXT2_FCB) Context; - ASSERT(Fcb != NULL); ASSERT((Fcb->Identifier.Type == EXT2FCB) && @@ -122,9 +110,8 @@ DEBUG(CMCB_DEBUG_LEVEL, ("Ext2ReleaseFromReadAhead: i=%xh Fcb=%p\n", Fcb->Mcb->Inode.i_ino, Fcb)); - IoSetTopLevelIrp( NULL ); - - ExReleaseResourceLite(&Fcb->MainResource); + IoSetTopLevelIrp(NULL); + ExReleaseResourceLite(Fcb->Header.Resource); } BOOLEAN NTAPI @@ -149,120 +136,3 @@ return; } - -VOID NTAPI -Ext2AcquireForCreateSection ( - IN PFILE_OBJECT FileObject -) - -{ - PEXT2_FCB Fcb = FileObject->FsContext; - - if (Fcb->Header.Resource != NULL) { - ExAcquireResourceExclusiveLite(Fcb->Header.Resource, TRUE); - } - - DEBUG(CMCB_DEBUG_LEVEL, ("Ext2AcquireForCreateSection: Fcb=%p\n", Fcb)); -} - -VOID NTAPI -Ext2ReleaseForCreateSection ( - IN PFILE_OBJECT FileObject -) - -{ - PEXT2_FCB Fcb = FileObject->FsContext; - - DEBUG(CMCB_DEBUG_LEVEL, ("Ext2ReleaseForCreateSection: Fcb=%p\n", Fcb)); - - if (Fcb->Header.Resource != NULL) { - ExReleaseResourceLite(Fcb->Header.Resource); - } -} - - -NTSTATUS NTAPI -Ext2AcquireFileForModWrite ( - IN PFILE_OBJECT FileObject, - IN PLARGE_INTEGER EndingOffset, - OUT PERESOURCE *ResourceToRelease, - IN PDEVICE_OBJECT DeviceObject -) - -{ - BOOLEAN ResourceAcquired = FALSE; - - PEXT2_FCB Fcb = FileObject->FsContext; - - if (Fcb->Header.PagingIoResource != NULL) { - *ResourceToRelease = Fcb->Header.PagingIoResource; - } else { - *ResourceToRelease = Fcb->Header.Resource; - } - - ResourceAcquired = ExAcquireResourceSharedLite(*ResourceToRelease, FALSE); - if (!ResourceAcquired) { - *ResourceToRelease = NULL; - } - - DEBUG(CMCB_DEBUG_LEVEL, ("Ext2AcquireFileForModWrite: Fcb=%p Acquired=%d\n", - Fcb, ResourceAcquired)); - - return (ResourceAcquired ? STATUS_SUCCESS : STATUS_CANT_WAIT); -} - -NTSTATUS NTAPI -Ext2ReleaseFileForModWrite ( - IN PFILE_OBJECT FileObject, - IN PERESOURCE ResourceToRelease, - IN PDEVICE_OBJECT DeviceObject -) -{ - PEXT2_FCB Fcb = FileObject->FsContext; - - DEBUG(CMCB_DEBUG_LEVEL, ("Ext2ReleaseFileForModWrite: Fcb=%p\n", Fcb)); - - if (ResourceToRelease != NULL) { - ASSERT(ResourceToRelease == Fcb->Header.PagingIoResource || - ResourceToRelease == Fcb->Header.Resource); - ExReleaseResourceLite(ResourceToRelease); - } else { - DbgBreak(); - } - - return STATUS_SUCCESS; -} - -NTSTATUS NTAPI -Ext2AcquireFileForCcFlush ( - IN PFILE_OBJECT FileObject, - IN PDEVICE_OBJECT DeviceObject -) -{ - PEXT2_FCB Fcb = FileObject->FsContext; - - if (Fcb->Header.PagingIoResource != NULL) { - ExAcquireResourceSharedLite(Fcb->Header.PagingIoResource, TRUE); - } - - DEBUG(CMCB_DEBUG_LEVEL, ("Ext2AcquireFileForCcFlush: Fcb=%p\n", Fcb)); - - return STATUS_SUCCESS; -} - -NTSTATUS NTAPI -Ext2ReleaseFileForCcFlush ( - IN PFILE_OBJECT FileObject, - IN PDEVICE_OBJECT DeviceObject -) -{ - PEXT2_FCB Fcb = FileObject->FsContext; - - DEBUG(CMCB_DEBUG_LEVEL, ("Ext2ReleaseFileForCcFlush: Fcb=%p\n", Fcb)); - - if (Fcb->Header.PagingIoResource != NULL) { - ExReleaseResourceLite(Fcb->Header.PagingIoResource); - } - - return STATUS_SUCCESS; -} Index: drivers/filesystems/ext2/src/create.c =================================================================== --- drivers/filesystems/ext2/src/create.c (révision 71375) +++ drivers/filesystems/ext2/src/create.c (copie de travail) @@ -93,7 +93,7 @@ } /* read the symlink target path */ - if (Mcb->Inode.i_size < EXT2_LINKLEN_IN_INODE) { + if (!Mcb->Inode.i_blocks) { OemName.Buffer = (PUCHAR) (&Mcb->Inode.i_block[0]); OemName.Length = (USHORT)Mcb->Inode.i_size; @@ -1388,6 +1388,7 @@ // // check the oplock state of the file // + Status = FsRtlCheckOplock( &Fcb->Oplock, IrpContext->Irp, IrpContext, @@ -1895,8 +1896,13 @@ Inode.i_ino = iNo; Inode.i_ctime = Inode.i_mtime = Inode.i_atime = Ext2LinuxTime(SysTime); - Inode.i_uid = Vcb->uid; - Inode.i_gid = Vcb->gid; + if (IsFlagOn(Vcb->Flags, VCB_USER_IDS)) { + Inode.i_uid = Vcb->uid; + Inode.i_gid = Vcb->gid; + } else { + Inode.i_uid = Parent->Mcb->Inode.i_uid; + Inode.i_gid = Parent->Mcb->Inode.i_gid; + } Inode.i_generation = Parent->Inode->i_generation; Inode.i_mode = S_IPERMISSION_MASK & Parent->Inode->i_mode; Index: drivers/filesystems/ext2/src/devctl.c =================================================================== --- drivers/filesystems/ext2/src/devctl.c (révision 71375) +++ drivers/filesystems/ext2/src/devctl.c (copie de travail) @@ -231,13 +231,16 @@ NTSTATUS Ext2ProcessGlobalProperty( IN PDEVICE_OBJECT DeviceObject, - IN PEXT2_VOLUME_PROPERTY2 Property, + IN PEXT2_VOLUME_PROPERTY3 Property3, IN ULONG Length ) { + PEXT2_VOLUME_PROPERTY3 Property2 = (PVOID)Property3; + PEXT2_VOLUME_PROPERTY Property = (PVOID)Property3; + struct nls_table * PageTable = NULL; + NTSTATUS Status = STATUS_SUCCESS; BOOLEAN GlobalDataResourceAcquired = FALSE; - struct nls_table * PageTable = NULL; _SEH2_TRY { @@ -289,51 +292,57 @@ ExAcquireResourceExclusiveLite(&Ext2Global->Resource, TRUE); GlobalDataResourceAcquired = TRUE; - if (Property->bReadonly) { - ClearLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); - ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); - } else { - SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); - if (Property->bExt3Writable) { - SetLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); - } else { - ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); + + switch (Property->Command) { + + case APP_CMD_SET_PROPERTY3: + + if (Property3->Flags2 & EXT2_VPROP3_AUTOMOUNT) { + if (Property3->AutoMount) + SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); + else + ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); } - } - PageTable = load_nls(Property->Codepage); - if (PageTable) { - memcpy(Ext2Global->Codepage.AnsiName, Property->Codepage, CODEPAGE_MAXLEN); - Ext2Global->Codepage.PageTable = PageTable; - } + case APP_CMD_SET_PROPERTY2: - if (Property->Command == APP_CMD_SET_PROPERTY2 || - Property->Command == APP_CMD_SET_PROPERTY3 ) { - RtlZeroMemory(Ext2Global->sHidingPrefix, HIDINGPAT_LEN); - if ((Ext2Global->bHidingPrefix = Property->bHidingPrefix)) { + if ((Ext2Global->bHidingPrefix = Property2->bHidingPrefix)) { RtlCopyMemory( Ext2Global->sHidingPrefix, - Property->sHidingPrefix, + Property2->sHidingPrefix, HIDINGPAT_LEN - 1); } RtlZeroMemory(Ext2Global->sHidingSuffix, HIDINGPAT_LEN); - if ((Ext2Global->bHidingSuffix = Property->bHidingSuffix)) { + if ((Ext2Global->bHidingSuffix = Property2->bHidingSuffix)) { RtlCopyMemory( Ext2Global->sHidingSuffix, - Property->sHidingSuffix, + Property2->sHidingSuffix, HIDINGPAT_LEN - 1); } - } - if (Property->Command == APP_CMD_SET_PROPERTY3) { + case APP_CMD_SET_PROPERTY: - PEXT2_VOLUME_PROPERTY3 Prop3 = (PEXT2_VOLUME_PROPERTY3)Property; + if (Property->bReadonly) { + ClearLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); + ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); + } else { + SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); + if (Property->bExt3Writable) { + SetLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); + } else { + ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); + } + } - if (Prop3->Flags & EXT2_VPROP3_AUTOMOUNT) { - if (Prop3->AutoMount) - SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); - else - ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); + PageTable = load_nls(Property->Codepage); + if (PageTable) { + memcpy(Ext2Global->Codepage.AnsiName, Property->Codepage, CODEPAGE_MAXLEN); + Ext2Global->Codepage.PageTable = PageTable; } + + break; + + default: + break; } } _SEH2_FINALLY { @@ -350,13 +359,15 @@ NTSTATUS Ext2ProcessVolumeProperty( IN PEXT2_VCB Vcb, - IN PEXT2_VOLUME_PROPERTY2 Property, + IN PEXT2_VOLUME_PROPERTY3 Property3, IN ULONG Length ) { - NTSTATUS Status = STATUS_SUCCESS; - BOOLEAN VcbResourceAcquired = FALSE; struct nls_table * PageTable = NULL; + PEXT2_VOLUME_PROPERTY2 Property2 = (PVOID)Property3; + PEXT2_VOLUME_PROPERTY Property = (PVOID)Property3; + NTSTATUS Status = STATUS_SUCCESS; + BOOLEAN VcbResourceAcquired = FALSE; _SEH2_TRY { @@ -364,7 +375,7 @@ VcbResourceAcquired = TRUE; if (Property->Command == APP_CMD_SET_PROPERTY || - Property->Command == APP_CMD_QUERY_PROPERTY) { + Property->Command == APP_CMD_QUERY_PROPERTY) { if (Length < sizeof(EXT2_VOLUME_PROPERTY)) { Status = STATUS_INVALID_PARAMETER; _SEH2_LEAVE; @@ -375,17 +386,67 @@ Status = STATUS_INVALID_PARAMETER; _SEH2_LEAVE; } + } else if (Property->Command == APP_CMD_SET_PROPERTY3 || + Property->Command == APP_CMD_QUERY_PROPERTY3) { + if (Length < sizeof(EXT2_VOLUME_PROPERTY3)) { + Status = STATUS_INVALID_PARAMETER; + _SEH2_LEAVE; + } } switch (Property->Command) { - case APP_CMD_SET_PROPERTY: + case APP_CMD_SET_PROPERTY3: + + if (Property3->Flags2 & EXT2_VPROP3_AUTOMOUNT) { + if (Property3->AutoMount) + SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); + else + ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); + } + if (Property3->Flags2 & EXT2_VPROP3_USERIDS) { + SetFlag(Vcb->Flags, VCB_USER_IDS); + Vcb->uid = Property3->uid; + Vcb->gid = Property3->gid; + if (Property3->EIDS) { + Vcb->euid = Property3->euid; + Vcb->egid = Property3->egid; + SetFlag(Vcb->Flags, VCB_USER_EIDS); + } else { + Vcb->euid = Vcb->egid = 0; + ClearFlag(Vcb->Flags, VCB_USER_EIDS); + } + } else { + ClearFlag(Vcb->Flags, VCB_USER_IDS); + ClearFlag(Vcb->Flags, VCB_USER_EIDS); + Vcb->uid = Vcb->gid = 0; + Vcb->euid = Vcb->egid = 0; + } + case APP_CMD_SET_PROPERTY2: + RtlZeroMemory(Vcb->sHidingPrefix, HIDINGPAT_LEN); + if (Vcb->bHidingPrefix == Property2->bHidingPrefix) { + RtlCopyMemory( Vcb->sHidingPrefix, + Property2->sHidingPrefix, + HIDINGPAT_LEN - 1); + } + + RtlZeroMemory(Vcb->sHidingSuffix, HIDINGPAT_LEN); + if (Vcb->bHidingSuffix == Property2->bHidingSuffix) { + RtlCopyMemory( Vcb->sHidingSuffix, + Property2->sHidingSuffix, + HIDINGPAT_LEN - 1); + } + Vcb->DrvLetter = Property2->DrvLetter; + + case APP_CMD_SET_PROPERTY: + if (Property->bReadonly) { - - Ext2FlushFiles(NULL, Vcb, FALSE); - Ext2FlushVolume(NULL, Vcb, FALSE); + if (IsFlagOn(Vcb->Flags, VCB_INITIALIZED)) { + Ext2FlushFiles(NULL, Vcb, FALSE); + Ext2FlushVolume(NULL, Vcb, FALSE); + } SetLongFlag(Vcb->Flags, VCB_READ_ONLY); } else { @@ -418,29 +479,57 @@ Ext2InitializeLabel(Vcb, Vcb->SuperBlock); } - if (Property->Command == APP_CMD_SET_PROPERTY2) { + break; - RtlZeroMemory(Vcb->sHidingPrefix, HIDINGPAT_LEN); - if ((Vcb->bHidingPrefix = Property->bHidingPrefix) != 0) { - RtlCopyMemory( Vcb->sHidingPrefix, - Property->sHidingPrefix, - HIDINGPAT_LEN - 1); - } + case APP_CMD_QUERY_PROPERTY3: - RtlZeroMemory(Vcb->sHidingSuffix, HIDINGPAT_LEN); - if ((Vcb->bHidingSuffix = Property->bHidingSuffix) != 0) { - RtlCopyMemory( Vcb->sHidingSuffix, - Property->sHidingSuffix, - HIDINGPAT_LEN - 1); + if (IsFlagOn(Ext2Global->Flags, EXT2_AUTO_MOUNT)) { + SetFlag(Property3->Flags2, EXT2_VPROP3_AUTOMOUNT); + Property3->AutoMount = TRUE; + } else { + ClearFlag(Property3->Flags2, EXT2_VPROP3_AUTOMOUNT); + Property3->AutoMount = FALSE; + } + + if (IsFlagOn(Vcb->Flags, VCB_USER_IDS)) { + SetFlag(Property3->Flags2, EXT2_VPROP3_USERIDS); + Property3->uid = Vcb->uid; + Property3->gid = Vcb->gid; + if (IsFlagOn(Vcb->Flags, VCB_USER_EIDS)) { + Property3->EIDS = TRUE; + Property3->euid = Vcb->euid; + Property3->egid = Vcb->egid; + } else { + Property3->EIDS = FALSE; } + } else { + ClearFlag(Property3->Flags2, EXT2_VPROP3_USERIDS); + } - Vcb->DrvLetter = Property->DrvLetter; + case APP_CMD_QUERY_PROPERTY2: + + RtlCopyMemory(Property2->UUID, Vcb->SuperBlock->s_uuid, 16); + Property2->DrvLetter = Vcb->DrvLetter; + + if (Property2->bHidingPrefix == Vcb->bHidingPrefix) { + RtlCopyMemory( Property2->sHidingPrefix, + Vcb->sHidingPrefix, + HIDINGPAT_LEN); + } else { + RtlZeroMemory( Property2->sHidingPrefix, + HIDINGPAT_LEN); } - break; + if (Property2->bHidingSuffix == Vcb->bHidingSuffix) { + RtlCopyMemory( Property2->sHidingSuffix, + Vcb->sHidingSuffix, + HIDINGPAT_LEN); + } else { + RtlZeroMemory( Property2->sHidingSuffix, + HIDINGPAT_LEN); + } case APP_CMD_QUERY_PROPERTY: - case APP_CMD_QUERY_PROPERTY2: Property->bExt2 = TRUE; Property->bExt3 = Vcb->IsExt3fs; @@ -457,32 +546,6 @@ } else { strncpy(Property->Codepage, "default", CODEPAGE_MAXLEN); } - - if (Property->Command == APP_CMD_QUERY_PROPERTY2) { - - RtlCopyMemory(Property->UUID, Vcb->SuperBlock->s_uuid, 16); - - Property->DrvLetter = Vcb->DrvLetter; - - if ((Property->bHidingPrefix = Vcb->bHidingPrefix) != 0) { - RtlCopyMemory( Property->sHidingPrefix, - Vcb->sHidingPrefix, - HIDINGPAT_LEN); - } else { - RtlZeroMemory( Property->sHidingPrefix, - HIDINGPAT_LEN); - } - - if ((Property->bHidingSuffix = Vcb->bHidingSuffix) != 0) { - RtlCopyMemory( Property->sHidingSuffix, - Vcb->sHidingSuffix, - HIDINGPAT_LEN); - } else { - RtlZeroMemory( Property->sHidingSuffix, - HIDINGPAT_LEN); - } - } - break; default: @@ -503,7 +566,7 @@ NTSTATUS Ext2ProcessUserProperty( IN PEXT2_IRP_CONTEXT IrpContext, - IN PEXT2_VOLUME_PROPERTY2 Property, + IN PEXT2_VOLUME_PROPERTY3 Property, IN ULONG Length ) { Index: drivers/filesystems/ext2/src/ext3/generic.c =================================================================== --- drivers/filesystems/ext2/src/ext3/generic.c (révision 71375) +++ drivers/filesystems/ext2/src/ext3/generic.c (copie de travail) @@ -127,6 +127,27 @@ return TRUE; } +VOID +Ext2PutGroup(IN PEXT2_VCB Vcb) +{ + struct ext3_sb_info *sbi = &Vcb->sbi; + unsigned long i; + + + if (NULL == Vcb->sbi.s_gd) { + return; + } + + for (i = 0; i < Vcb->sbi.s_gdb_count; i++) { + if (Vcb->sbi.s_gd[i].bh) + fini_bh(&sbi->s_gd[i].bh); + } + + kfree(Vcb->sbi.s_gd); + Vcb->sbi.s_gd = NULL; +} + + BOOLEAN Ext2LoadGroup(IN PEXT2_VCB Vcb) { @@ -134,34 +155,56 @@ struct ext3_sb_info *sbi = &Vcb->sbi; ext3_fsblk_t sb_block = 1; unsigned long i; + BOOLEAN rc = FALSE; - if (BLOCK_SIZE != EXT3_MIN_BLOCK_SIZE) { - sb_block = EXT4_MIN_BLOCK_SIZE / BLOCK_SIZE; - } + _SEH2_TRY { - if (NULL == sbi->s_group_desc) { - sbi->s_group_desc = kzalloc(sbi->s_gdb_count * sizeof(ext3_fsblk_t), - GFP_KERNEL); - } - if (sbi->s_group_desc == NULL) { - DEBUG(DL_ERR, ("Ext2LoadGroup: not enough memory.\n")); - return FALSE; - } + ExAcquireResourceExclusiveLite(&Vcb->sbi.s_gd_lock, TRUE); - for (i = 0; i < sbi->s_gdb_count; i++) { - sbi->s_group_desc[i] = descriptor_loc(sb, sb_block, i); - if (!sbi->s_group_desc[i]) { - DEBUG(DL_ERR, ("Ext2LoadGroup: can't read group descriptor %d\n", i)); - return FALSE; + if (NULL == sbi->s_gd) { + sbi->s_gd = kzalloc(sbi->s_gdb_count * sizeof(struct ext3_gd), + GFP_KERNEL); } - } + if (sbi->s_gd == NULL) { + DEBUG(DL_ERR, ("Ext2LoadGroup: not enough memory.\n")); + _SEH2_LEAVE; + } - if (!ext4_check_descriptors(sb)) { - DEBUG(DL_ERR, ("Ext2LoadGroup: group descriptors corrupted!\n")); - return FALSE; - } + if (BLOCK_SIZE != EXT3_MIN_BLOCK_SIZE) { + sb_block = EXT4_MIN_BLOCK_SIZE / BLOCK_SIZE; + } - return TRUE; + for (i = 0; i < sbi->s_gdb_count; i++) { + sbi->s_gd[i].block = descriptor_loc(sb, sb_block, i); + if (!sbi->s_gd[i].block) { + DEBUG(DL_ERR, ("Ext2LoadGroup: can't locate group descriptor %d\n", i)); + _SEH2_LEAVE; + } + sbi->s_gd[i].bh = sb_getblk(sb, sbi->s_gd[i].block); + if (!sbi->s_gd[i].bh) { + DEBUG(DL_ERR, ("Ext2LoadGroup: can't read group descriptor %d\n", i)); + _SEH2_LEAVE; + } + sbi->s_gd[i].gd = (struct ext4_group_desc *)sbi->s_gd[i].bh->b_data; + } + + if (!ext4_check_descriptors(sb)) { + DbgBreak(); + DEBUG(DL_ERR, ("Ext2LoadGroup: group descriptors corrupted!\n")); + _SEH2_LEAVE; + } + + rc = TRUE; + + } _SEH2_FINALLY { + + if (!rc) + Ext2PutGroup(Vcb); + + ExReleaseResourceLite(&Vcb->sbi.s_gd_lock); + } _SEH2_END; + + return rc; } @@ -169,14 +212,26 @@ Ext2DropGroup(IN PEXT2_VCB Vcb) { struct ext3_sb_info *sbi = &Vcb->sbi; + LARGE_INTEGER timeout; unsigned long i; - if (NULL == sbi->s_group_desc) { + /* do nothing if Vcb is not initialized yet */ + if (!IsFlagOn(Vcb->Flags, VCB_INITIALIZED)) return; - } - kfree(sbi->s_group_desc); - sbi->s_group_desc = NULL; + _SEH2_TRY { + SetFlag(Vcb->Flags, VCB_BEING_DROPPED); + ExAcquireResourceExclusiveLite(&Vcb->sbi.s_gd_lock, TRUE); + Ext2PutGroup(Vcb); + } _SEH2_FINALLY { + ExReleaseResourceLite(&Vcb->sbi.s_gd_lock); + } _SEH2_END; + + timeout.QuadPart = (LONGLONG)-10*1000*1000; + KeWaitForSingleObject(&Vcb->bd.bd_bh_notify, + Executive, KernelMode, + FALSE, &timeout); + ClearFlag(Vcb->Flags, VCB_BEING_DROPPED); } BOOLEAN @@ -592,7 +647,7 @@ *Block = 0; - ExAcquireResourceExclusiveLite(&Vcb->MetaLock, TRUE); + ExAcquireResourceExclusiveLite(&Vcb->MetaBlock, TRUE); /* validate the hint group and hint block */ if (GroupHint >= Vcb->sbi.s_groups_count) { @@ -762,7 +817,7 @@ errorout: - ExReleaseResourceLite(&Vcb->MetaLock); + ExReleaseResourceLite(&Vcb->MetaBlock); if (bh) fini_bh(&bh); @@ -799,7 +854,7 @@ NTSTATUS Status = STATUS_UNSUCCESSFUL; - ExAcquireResourceExclusiveLite(&Vcb->MetaLock, TRUE); + ExAcquireResourceExclusiveLite(&Vcb->MetaBlock, TRUE); DEBUG(DL_INF, ("Ext2FreeBlock: Block %xh - %x to be freed.\n", Block, Block + Number)); @@ -916,7 +971,7 @@ if (gb) fini_bh(&gb); - ExReleaseResourceLite(&Vcb->MetaLock); + ExReleaseResourceLite(&Vcb->MetaBlock); return Status; } @@ -948,7 +1003,7 @@ *Inode = dwInode = 0XFFFFFFFF; - ExAcquireResourceExclusiveLite(&Vcb->MetaLock, TRUE); + ExAcquireResourceExclusiveLite(&Vcb->MetaInode, TRUE); if (GroupHint >= Vcb->sbi.s_groups_count) GroupHint = GroupHint % Vcb->sbi.s_groups_count; @@ -1088,7 +1143,7 @@ break; } - fini_bh(&gb); + fini_bh(&gb); } } @@ -1272,7 +1327,7 @@ errorout: - ExReleaseResourceLite(&Vcb->MetaLock); + ExReleaseResourceLite(&Vcb->MetaInode); if (bh) fini_bh(&bh); @@ -1285,6 +1340,44 @@ } NTSTATUS +Ext2UpdateGroupDirStat( + IN PEXT2_IRP_CONTEXT IrpContext, + IN PEXT2_VCB Vcb, + IN ULONG group + ) +{ + struct super_block *sb = &Vcb->sb; + PEXT2_GROUP_DESC gd; + struct buffer_head *gb = NULL; + NTSTATUS status; + + ExAcquireResourceExclusiveLite(&Vcb->MetaInode, TRUE); + + /* get group desc */ + gd = ext4_get_group_desc(sb, group, &gb); + if (!gd) { + status = STATUS_INSUFFICIENT_RESOURCES; + goto errorout; + } + + /* update group_desc and super_block */ + ext4_used_dirs_set(sb, gd, ext4_used_dirs_count(sb, gd) - 1); + Ext2SaveGroup(IrpContext, Vcb, group); + Ext2UpdateVcbStat(IrpContext, Vcb); + status = STATUS_SUCCESS; + +errorout: + + ExReleaseResourceLite(&Vcb->MetaInode); + + if (gb) + fini_bh(&gb); + + return status; +} + + +NTSTATUS Ext2FreeInode( IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, @@ -1308,7 +1401,7 @@ NTSTATUS Status = STATUS_UNSUCCESSFUL; - ExAcquireResourceExclusiveLite(&Vcb->MetaLock, TRUE); + ExAcquireResourceExclusiveLite(&Vcb->MetaInode, TRUE); Group = (Inode - 1) / INODES_PER_GROUP; dwIno = (Inode - 1) % INODES_PER_GROUP; @@ -1385,7 +1478,7 @@ errorout: - ExReleaseResourceLite(&Vcb->MetaLock); + ExReleaseResourceLite(&Vcb->MetaInode); if (bh) fini_bh(&bh); @@ -1474,7 +1567,8 @@ IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, - IN PEXT2_MCB Mcb + IN PEXT2_MCB Mcb, + IN umode_t mode ) { struct inode *dir = Dcb->Inode; @@ -1507,15 +1601,21 @@ if (le32_to_cpu(de->inode) != inode->i_ino) _SEH2_LEAVE; - ext3_set_de_type(inode->i_sb, de, inode->i_mode); + ext3_set_de_type(inode->i_sb, de, mode); mark_buffer_dirty(bh); - - //if (!inode->i_nlink) - // ext3_orphan_add(handle, inode); + if (S_ISDIR(inode->i_mode) == S_ISDIR(mode)) { + } else if (S_ISDIR(inode->i_mode)) { + ext3_dec_count(dir); + } else if (S_ISDIR(mode)) { + ext3_inc_count(dir); + } dir->i_ctime = dir->i_mtime = ext3_current_time(dir); ext3_mark_inode_dirty(IrpContext, dir); + inode->i_mode = mode; + ext3_mark_inode_dirty(IrpContext, inode); + Status = STATUS_SUCCESS; } _SEH2_FINALLY { @@ -2134,27 +2234,30 @@ __le16 ext4_group_desc_csum(struct ext3_sb_info *sbi, __u32 block_group, struct ext4_group_desc *gdp) { - __u16 crc = 0; + int offset; + __u16 crc = 0; + __le32 le_group = cpu_to_le32(block_group); - if (sbi->s_es->s_feature_ro_compat & - cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { - int offset = offsetof(struct ext4_group_desc, bg_checksum); - __le32 le_group = cpu_to_le32(block_group); + /* old crc16 code */ + if (!(sbi->s_es->s_feature_ro_compat & + cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM))) + return 0; - crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid)); - crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group)); - crc = crc16(crc, (__u8 *)gdp, offset); - offset += sizeof(gdp->bg_checksum); /* skip checksum */ - /* for checksum of struct ext4_group_desc do the rest...*/ - if ((sbi->s_es->s_feature_incompat & - cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) && - offset < le16_to_cpu(sbi->s_es->s_desc_size)) - crc = crc16(crc, (__u8 *)gdp + offset, - le16_to_cpu(sbi->s_es->s_desc_size) - - offset); - } + offset = offsetof(struct ext4_group_desc, bg_checksum); - return cpu_to_le16(crc); + crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid)); + crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group)); + crc = crc16(crc, (__u8 *)gdp, offset); + offset += sizeof(gdp->bg_checksum); /* skip checksum */ + /* for checksum of struct ext4_group_desc do the rest...*/ + if ((sbi->s_es->s_feature_incompat & + cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) && + offset < le16_to_cpu(sbi->s_es->s_desc_size)) + crc = crc16(crc, (__u8 *)gdp + offset, + le16_to_cpu(sbi->s_es->s_desc_size) - + offset); + + return cpu_to_le16(crc); } int ext4_group_desc_csum_verify(struct ext3_sb_info *sbi, __u32 block_group, @@ -2489,13 +2592,11 @@ ext4_group_t block_group, struct buffer_head **bh) { struct ext4_group_desc *desc = NULL; - struct buffer_head *gb = NULL; struct ext3_sb_info *sbi = EXT3_SB(sb); PEXT2_VCB vcb = sb->s_priv; + ext4_group_t group; + ext4_group_t offset; - unsigned int group; - unsigned int offset; - if (bh) *bh = NULL; @@ -2507,44 +2608,33 @@ return NULL; } - smp_rmb(); - group = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb); - offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1); + _SEH2_TRY { - if (!sbi->s_group_desc || !sbi->s_group_desc[group]) { - Ext2LoadGroup(vcb); - } + group = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb); + offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1); - if (!sbi->s_group_desc[group]) { - ext4_error(sb, "ext4_get_group_desc", - "Group descriptor not loaded - " - "block_group = %u, group = %u, desc = %u", - block_group, group, offset); - goto errorout; - } + if (!sbi->s_gd || !sbi->s_gd[group].block || + !sbi->s_gd[group].bh) { + if (!Ext2LoadGroup(vcb)) { + _SEH2_LEAVE; + } + } - gb = sb_getblk(sb, sbi->s_group_desc[group]); - if (!gb) { - ext4_error(sb, "ext4_get_group_desc", - "failed to load group - " - "block_group = %u, group = %u, desc = %u", - block_group, group, offset); - goto errorout; - } + desc = (struct ext4_group_desc *)((PCHAR)sbi->s_gd[group].gd + + offset * EXT4_DESC_SIZE(sb)); + if (bh) { + atomic_inc(&sbi->s_gd[group].bh->b_count); + *bh = sbi->s_gd[group].bh; + } + } _SEH2_FINALLY { + /* do cleanup */ + } _SEH2_END; - desc = (struct ext4_group_desc *)(gb->b_data + - offset * EXT4_DESC_SIZE(sb)); - if (bh) - *bh = gb; - else - fini_bh(&gb); - -errorout: - return desc; } + /** * ext4_count_free_blocks() -- count filesystem free blocks * @sb: superblock @@ -2670,7 +2760,8 @@ printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: " "Checksum for group %u failed (%u!=%u)\n", i, le16_to_cpu(ext4_group_desc_csum(sbi, i, - gdp)), le16_to_cpu(gdp->bg_checksum)); + gdp)), + le16_to_cpu(gdp->bg_checksum)); if (!IsVcbReadOnly(Vcb)) { __brelse(bh); return 0; Index: drivers/filesystems/ext2/src/ext4/ext4_extents.c =================================================================== --- drivers/filesystems/ext2/src/ext4/ext4_extents.c (révision 71375) +++ drivers/filesystems/ext2/src/ext4/ext4_extents.c (copie de travail) @@ -23,6 +23,7 @@ #pragma warning(disable: 4244) #endif + /* * used by extent splitting. */ @@ -1098,6 +1099,77 @@ return err; } +static int ext4_ext_shrink_indepth(void *icb, + handle_t *handle, + struct inode *inode, + unsigned int flags, + int *shrinked) +{ + struct ext4_extent_header *eh, *neh; + struct ext4_extent_idx *ix; + struct buffer_head *bh = NULL; + ext4_fsblk_t block; + int err = 0, depth = ext_depth(inode); + int neh_entries; + *shrinked = 0; + + if (!depth) + return 0; + + eh = ext_inode_hdr(inode); + if (le16_to_cpu(eh->eh_entries) != 1) + return 0; + + ix = EXT_FIRST_INDEX(eh); + block = ext4_idx_pblock(ix); + bh = extents_bread(inode->i_sb, block); + if (!bh) + goto out; + + /* set size of new block */ + neh = ext_block_hdr(bh); + neh_entries = le16_to_cpu(neh->eh_entries); + if (!neh->eh_depth && + neh_entries > ext4_ext_space_root(inode, 0)) + goto out; + + if (neh->eh_depth && + neh_entries > ext4_ext_space_root_idx(inode, 0)) + goto out; + + /* old root could have indexes or leaves + * so calculate e_max right way */ + if (neh->eh_depth) + eh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0)); + else + eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0)); + + eh->eh_magic = cpu_to_le16(EXT4_EXT_MAGIC); + eh->eh_entries = neh_entries; + if (neh->eh_depth) { + memmove(EXT_FIRST_INDEX(eh), + EXT_FIRST_INDEX(neh), + sizeof(struct ext4_extent_idx) * neh_entries); + } else { + memmove(EXT_FIRST_EXTENT(eh), + EXT_FIRST_EXTENT(neh), + sizeof(struct ext4_extent) * neh_entries); + } + le16_add_cpu(&eh->eh_depth, -1); + + ext4_mark_inode_dirty(icb, handle, inode); + *shrinked = 1; +out: + if (bh) + extents_brelse(bh); + + if (*shrinked) + ext4_free_blocks(icb, handle, inode, NULL, + block, 1, flags); + + return err; +} + /* * ext4_ext_create_new_leaf: * finds empty index and adds new leaf. @@ -1355,29 +1427,25 @@ * with leaves. */ ext4_lblk_t -ext4_ext_next_allocated_block(struct ext4_ext_path *path) +ext4_ext_next_allocated_block(struct ext4_ext_path *path, int at) { - int depth; - - depth = path->p_depth; - - if (depth == 0 && path->p_ext == NULL) + if (at == 0 && !path->p_ext && !path->p_idx) return EXT_MAX_BLOCKS; - while (depth >= 0) { - if (depth == path->p_depth) { + while (at >= 0) { + if (at == path->p_depth) { /* leaf */ - if (path[depth].p_ext && - path[depth].p_ext != - EXT_LAST_EXTENT(path[depth].p_hdr)) - return le32_to_cpu(path[depth].p_ext[1].ee_block); + if (path[at].p_ext && + path[at].p_ext != + EXT_LAST_EXTENT(path[at].p_hdr)) + return le32_to_cpu(path[at].p_ext[1].ee_block); } else { /* index */ - if (path[depth].p_idx != - EXT_LAST_INDEX(path[depth].p_hdr)) - return le32_to_cpu(path[depth].p_idx[1].ei_block); + if (path[at].p_idx != + EXT_LAST_INDEX(path[at].p_hdr)) + return le32_to_cpu(path[at].p_idx[1].ei_block); } - depth--; + at--; } return EXT_MAX_BLOCKS; @@ -1414,12 +1482,14 @@ /* * ext4_ext_correct_indexes: - * if leaf gets modified and modified extent is first in the leaf, + * if leaf/node gets modified and modified extent/index + * is first in the leaf/node, * then we have to correct all indexes above. - * TODO: do we need to correct tree in all cases? */ -static int ext4_ext_correct_indexes(void *icb, handle_t *handle, struct inode *inode, - struct ext4_ext_path *path) +static int ext4_ext_correct_indexes(void *icb, handle_t *handle, + struct inode *inode, + struct ext4_ext_path *path, + int at) { struct ext4_extent_header *eh; int depth = ext_depth(inode); @@ -1427,49 +1497,49 @@ __le32 border; int k, err = 0; - eh = path[depth].p_hdr; - ex = path[depth].p_ext; + assert(at >= 0); + if (!at) + return 0; - if (unlikely(ex == NULL || eh == NULL)) { - EXT4_ERROR_INODE(inode, - "ex %p == NULL or eh %p == NULL", ex, eh); - return -EIO; - } + if (depth == at) { + eh = path[at].p_hdr; + ex = path[at].p_ext; - if (depth == 0) { - /* there is no tree at all */ - return 0; - } + if (ex == NULL || eh == NULL) + return -EIO; - if (ex != EXT_FIRST_EXTENT(eh)) { - /* we correct tree if first leaf got modified only */ - return 0; + if (at == 0) { + /* there is no tree at all */ + return 0; + } + + if (ex != EXT_FIRST_EXTENT(eh)) { + /* we correct tree if first leaf got modified only */ + return 0; + } + + k = at - 1; + border = path[at].p_ext->ee_block; + path[k].p_idx->ei_block = border; + err = ext4_ext_dirty(icb, handle, inode, path + k); + if (err) + return err; + + } else { + border = path[at].p_idx->ei_block; + k = at; } - /* - * TODO: we need correction if border is smaller than current one - */ - k = depth - 1; - border = path[depth].p_ext->ee_block; - err = ext4_ext_get_access(icb, handle, inode, path + k); - if (err) - return err; - path[k].p_idx->ei_block = border; - err = ext4_ext_dirty(icb, handle, inode, path + k); - if (err) - return err; - - while (k--) { + while (k) { /* change all left-side indexes */ - if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr)) + if (path[k].p_idx != EXT_FIRST_INDEX(path[k].p_hdr)) break; - err = ext4_ext_get_access(icb, handle, inode, path + k); + path[k-1].p_idx->ei_block = border; + err = ext4_ext_dirty(icb, handle, inode, path + k-1); if (err) break; - path[k].p_idx->ei_block = border; - err = ext4_ext_dirty(icb, handle, inode, path + k); - if (err) - break; + + k--; } return err; @@ -1844,9 +1914,11 @@ if (!(gb_flags & EXT4_GET_BLOCKS_PRE_IO)) ext4_ext_try_to_merge(icb, handle, inode, path, nearex); + depth = ext_depth(inode); /* time to correct all indexes above */ - err = ext4_ext_correct_indexes(icb, handle, inode, path); + err = ext4_ext_correct_indexes(icb, handle, + inode, path, depth); if (err) goto cleanup; @@ -1880,156 +1952,351 @@ return ret; } -static int ext4_remove_blocks(void *icb, handle_t *handle, struct inode *inode, - struct ext4_extent *ex, - unsigned long from, unsigned long to) +static void ext4_ext_remove_blocks( + void *icb, + handle_t *handle, + struct inode *inode, struct ext4_extent *ex, + ext4_lblk_t from, ext4_lblk_t to) { - struct buffer_head *bh; - int i; + int len = to - from + 1; + ext4_lblk_t num; + ext4_fsblk_t start; + num = from - le32_to_cpu(ex->ee_block); + start = ext4_ext_pblock(ex) + num; + ext_debug("Freeing %lu at %I64u, %d\n", from, start, len); + ext4_free_blocks(icb, handle, inode, NULL, + start, len, 0); +} - if (from >= le32_to_cpu(ex->ee_block) - && to == le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex) - 1) { - /* tail removal */ - unsigned long num, start; - num = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex) - from; - start = ext4_ext_pblock(ex) + ext4_ext_get_actual_len(ex) - num; - ext4_free_blocks(icb, handle, inode, NULL, start, num, 0); - } else if (from == le32_to_cpu(ex->ee_block) - && to <= le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex) - 1) { +static int ext4_ext_remove_idx(void *icb, + handle_t *handle, + struct inode *inode, + struct ext4_ext_path *path, + int depth) +{ + int err, i = depth; + ext4_fsblk_t leaf; + + /* free index block */ + leaf = ext4_idx_pblock(path[i].p_idx); + + if (path[i].p_idx != EXT_LAST_INDEX(path[i].p_hdr)) { + int len = EXT_LAST_INDEX(path[i].p_hdr) - path[i].p_idx; + memmove(path[i].p_idx, path[i].p_idx + 1, + len * sizeof(struct ext4_extent_idx)); + } + + le16_add_cpu(&path[i].p_hdr->eh_entries, -1); + err = ext4_ext_dirty(icb, handle, inode, path + i); + if (err) + return err; + + ext_debug("IDX: Freeing %lu at %I64u, %d\n", + le32_to_cpu(path[i].p_idx->ei_block), leaf, 1); + ext4_free_blocks(icb, handle, inode, NULL, + leaf, 1, 0); + return err; +} + +static int ext4_ext_amalgamate(void *icb, + handle_t *handle, + struct inode *inode, + struct ext4_ext_path *path, + int at) +{ + int new_entries, right_entries; + int depth = ext_depth(inode); + struct ext4_ext_path *right_path = NULL; + ext4_lblk_t now; + int ret = 0; + if (!at) + return 0; + + now = ext4_ext_next_allocated_block(path, at - 1); + if (now == EXT_MAX_BLOCKS) + goto out; + + right_path = ext4_find_extent(inode, now, NULL, 0); + if (IS_ERR(right_path)) { + ret = PTR_ERR(right_path); + right_path = NULL; + goto out; + } + + right_entries = le16_to_cpu(right_path[at].p_hdr->eh_entries); + new_entries = le16_to_cpu(path[at].p_hdr->eh_entries) + + right_entries; + if (new_entries > path[at].p_hdr->eh_max) { + ret = 0; + goto out; + } + if (at == depth) { + struct ext4_extent *last_ex = EXT_LAST_EXTENT(path[at].p_hdr); + memmove(last_ex + 1, + EXT_FIRST_EXTENT(right_path[at].p_hdr), + right_entries * sizeof(struct ext4_extent)); } else { + struct ext4_extent_idx *last_ix = EXT_LAST_INDEX(path[at].p_hdr); + memmove(last_ix + 1, + EXT_FIRST_INDEX(right_path[at].p_hdr), + right_entries * sizeof(struct ext4_extent_idx)); } - return 0; + path[at].p_hdr->eh_entries = cpu_to_le16(new_entries); + right_path[at].p_hdr->eh_entries = 0; + ext4_ext_dirty(icb, handle, inode, path + at); + + /* + * remove the empty node from index block above. + */ + depth = at; + while (depth > 0) { + struct ext4_extent_header *eh = right_path[depth].p_hdr; + if (eh->eh_entries == 0 && right_path[depth].p_bh != NULL) { + ext4_ext_drop_refs(right_path + depth); + ret = ext4_ext_remove_idx(icb, handle, inode, right_path, depth - 1); + if (ret) + goto out; + + } else + break; + + depth--; + } + ret = ext4_ext_correct_indexes(icb, handle, + inode, right_path, depth); +out: + if (right_path) { + ext4_ext_drop_refs(right_path); + kfree(right_path); + } + + return ret; } +static int ext4_ext_balance(void *icb, + handle_t *handle, + struct inode *inode, + struct ext4_ext_path **path, + int at) +{ + int ret, shrinked = 0; + int depth = at; + + while (depth > 0) { + ret = ext4_ext_amalgamate(icb, handle, + inode, *path, depth); + if (ret) + goto out; + + depth--; + } + do { + ret = ext4_ext_shrink_indepth(icb, handle, + inode, 0, &shrinked); + } while (!ret && shrinked); + +out: + return ret; +} + /* - * routine removes index from the index block - * it's used in truncate case only. thus all requests are for - * last index in the block only + * NOTE: After removal, path should not be reused. */ -int ext4_ext_rm_idx(void *icb, handle_t *handle, struct inode *inode, - struct ext4_ext_path *path) +int ext4_ext_remove_extent(void *icb, + handle_t *handle, + struct inode *inode, struct ext4_ext_path **path) { - int err; - ext4_fsblk_t leaf; + int len; + int err = 0; + ext4_lblk_t start; + uint16_t new_entries; + int depth = ext_depth(inode); + struct ext4_extent *ex = (*path)[depth].p_ext, + *ex2 = ex + 1; + struct ext4_extent_header *eh = (*path)[depth].p_hdr; + if (!ex) + return -EINVAL; - /* free index block */ - path--; - leaf = ext4_idx_pblock(path->p_idx); - BUG_ON(path->p_hdr->eh_entries == 0); - if ((err = ext4_ext_get_access(icb, handle, inode, path))) - return err; - path->p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(path->p_hdr->eh_entries)-1); - if ((err = ext4_ext_dirty(icb, handle, inode, path))) - return err; - ext4_free_blocks(icb, handle, inode, NULL, leaf, 1, 0); + start = le32_to_cpu(ex->ee_block); + len = ext4_ext_get_actual_len(ex); + new_entries = le16_to_cpu(eh->eh_entries) - 1; + + ext4_ext_remove_blocks(icb, handle, + inode, ex, start, start + len - 1); + if (ex2 <= EXT_LAST_EXTENT(eh)) + memmove(ex, ex2, + (EXT_LAST_EXTENT(eh) - ex2 + 1) * sizeof(struct ext4_extent)); + eh->eh_entries = cpu_to_le16(new_entries); + + ext4_ext_dirty(icb, handle, inode, (*path) + depth); + + /* + * If the node is free, then we should + * remove it from index block above. + */ + while (depth > 0) { + eh = (*path)[depth].p_hdr; + if (eh->eh_entries == 0 && (*path)[depth].p_bh != NULL) { + ext4_ext_drop_refs((*path) + depth); + err = ext4_ext_remove_idx(icb, handle, + inode, *path, depth - 1); + if (err) + break; + + } else + break; + + depth--; + } + err = ext4_ext_correct_indexes(icb, handle, + inode, *path, depth); + + if ((*path)->p_hdr->eh_entries == 0) { + /* + * truncate to zero freed all the tree, + * so we need to correct eh_depth + */ + ext_inode_hdr(inode)->eh_depth = 0; + ext_inode_hdr(inode)->eh_max = + cpu_to_le16(ext4_ext_space_root(inode, 0)); + err = ext4_ext_dirty(icb, handle, inode, *path); + } + err = ext4_ext_balance(icb, handle, inode, path, depth); + return err; } -static int -ext4_ext_rm_leaf(void *icb, handle_t *handle, struct inode *inode, - struct ext4_ext_path *path, unsigned long start) +int __ext4_ext_truncate(void *icb, + handle_t *handle, + struct inode *inode, + ext4_lblk_t from, ext4_lblk_t to) { - int err = 0, correct_index = 0; - int depth = ext_depth(inode), credits; - struct ext4_extent_header *eh; - unsigned a, b, block, num; - unsigned long ex_ee_block; - unsigned short ex_ee_len; + int depth = ext_depth(inode), ret = -EIO; struct ext4_extent *ex; + struct ext4_ext_path *path = NULL, *npath; + ext4_lblk_t now = from; - /* the header must be checked already in ext4_ext_remove_space() */ - if (!path[depth].p_hdr) - path[depth].p_hdr = ext_block_hdr(path[depth].p_bh); - eh = path[depth].p_hdr; - BUG_ON(eh == NULL); + if (to < from) + return -EINVAL; - /* find where to start removing */ - ex = EXT_LAST_EXTENT(eh); + npath = ext4_find_extent(inode, from, &path, 0); + if (IS_ERR(npath)) + goto out; - ex_ee_block = le32_to_cpu(ex->ee_block); - ex_ee_len = ext4_ext_get_actual_len(ex); + path = npath; + ex = path[depth].p_ext; + if (!ex) + goto out; - while (ex >= EXT_FIRST_EXTENT(eh) && - ex_ee_block + ex_ee_len > start) { - path[depth].p_ext = ex; + if (from < le32_to_cpu(ex->ee_block) && + to < le32_to_cpu(ex->ee_block)) { + ret = 0; + goto out; + } + /* If we do remove_space inside the range of an extent */ + if ((le32_to_cpu(ex->ee_block) < from) && + (to < le32_to_cpu(ex->ee_block) + + ext4_ext_get_actual_len(ex) - 1)) { - a = ex_ee_block > start ? ex_ee_block : start; - b = (unsigned long long)ex_ee_block + ex_ee_len - 1 < - EXT_MAX_BLOCKS ? ex_ee_block + ex_ee_len - 1 : EXT_MAX_BLOCKS; + struct ext4_extent newex; + int unwritten = ext4_ext_is_unwritten(ex); + ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); + int len = ext4_ext_get_actual_len(ex); + ext4_fsblk_t newblock = + to + 1 - ee_block + ext4_ext_pblock(ex); + ex->ee_len = cpu_to_le16(from - ee_block); + if (unwritten) + ext4_ext_mark_unwritten(ex); - if (a != ex_ee_block && b != ex_ee_block + ex_ee_len - 1) { - block = 0; - num = 0; - BUG(); - } else if (a != ex_ee_block) { - /* remove tail of the extent */ - block = ex_ee_block; - num = a - block; - } else if (b != ex_ee_block + ex_ee_len - 1) { - /* remove head of the extent */ - block = a; - num = b - a; - /* there is no "make a hole" API yet */ - BUG(); - } else { - /* remove whole extent: excellent! */ - block = ex_ee_block; - num = 0; - BUG_ON(a != ex_ee_block); - BUG_ON(b != ex_ee_block + ex_ee_len - 1); - } + ext4_ext_dirty(icb, handle, inode, path + depth); - /* at present, extent can't cross block group */ - /* leaf + bitmap + group desc + sb + inode */ - credits = 5; - if (ex == EXT_FIRST_EXTENT(eh)) { - correct_index = 1; - credits += (ext_depth(inode)) + 1; - } + ext4_ext_remove_blocks(icb, handle, + inode, + ex, from, to); - /*handle = ext4_ext_journal_restart(icb, handle, credits);*/ - /*if (IS_ERR(icb, handle)) {*/ - /*err = PTR_ERR(icb, handle);*/ - /*goto out;*/ - /*}*/ + newex.ee_block = cpu_to_le32(to + 1); + newex.ee_len = cpu_to_le16(ee_block + len - 1 - to); + ext4_ext_store_pblock(&newex, newblock); + if (unwritten) + ext4_ext_mark_unwritten(&newex); - err = ext4_ext_get_access(icb, handle, inode, path + depth); - if (err) + ret = ext4_ext_insert_extent(icb, handle, + inode, &path, &newex, 0); + goto out; + } + if (le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex) - 1 < from) { + now = ext4_ext_next_allocated_block(path, depth); + npath = ext4_find_extent(inode, now, &path, 0); + if (IS_ERR(npath)) goto out; - err = ext4_remove_blocks(icb, handle, inode, ex, a, b); - if (err) - goto out; + path = npath; + ex = path[depth].p_ext; + } + while (ex && + le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex) - 1 >= now && + le32_to_cpu(ex->ee_block) <= to) { + int len, new_len = 0; + int unwritten; + ext4_lblk_t start, new_start; + ext4_fsblk_t newblock; - if (num == 0) { - /* this extent is removed entirely mark slot unused */ - ext4_ext_store_pblock(ex, 0); - eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)-1); + new_start = start = le32_to_cpu(ex->ee_block); + len = ext4_ext_get_actual_len(ex); + newblock = ext4_ext_pblock(ex); + if (start < from) { + len -= from - start; + new_len = from - start; + start = from; + } else { + if (start + len - 1 > to) { + new_len = start + len - 1 - to; + len -= new_len; + new_start = to + 1; + newblock += to + 1 - start; + } } - ex->ee_block = cpu_to_le32(block); - ex->ee_len = cpu_to_le16(num); + now = ext4_ext_next_allocated_block(path, depth); + if (!new_len) { + ret = ext4_ext_remove_extent(icb, handle, + inode, &path); + if (ret) + goto out; - err = ext4_ext_dirty(icb, handle, inode, path + depth); - if (err) + } else { + ext4_ext_remove_blocks(icb, handle, + inode, + ex, start, start + len - 1); + ex->ee_block = cpu_to_le32(new_start); + unwritten = ext4_ext_is_unwritten(ex); + ex->ee_len = cpu_to_le16(new_len); + ext4_ext_store_pblock(ex, newblock); + if (unwritten) + ext4_ext_mark_unwritten(ex); + + ext4_ext_dirty(icb, handle, + inode, path + depth); + } + npath = ext4_find_extent(inode, now, &path, 0); + if (IS_ERR(npath)) goto out; - ex--; - ex_ee_block = le32_to_cpu(ex->ee_block); - ex_ee_len = ext4_ext_get_actual_len(ex); + path = npath; + depth = ext_depth(inode); + ex = path[depth].p_ext; } +out: + if (path) { + ext4_ext_drop_refs(path); + kfree(path); + } - if (correct_index && eh->eh_entries) - err = ext4_ext_correct_indexes(icb, handle, inode, path); + if (IS_ERR(npath)) + ret = PTR_ERR(npath); - /* if this leaf is free, then we should - * remove it from index block above */ - if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL) - err = ext4_ext_rm_idx(icb, handle, inode, path + depth); - -out: - return err; + return ret; } /* @@ -2171,138 +2438,6 @@ return err; } -/* - * returns 1 if current index have to be freed (even partial) - */ -static inline int -ext4_ext_more_to_rm(struct ext4_ext_path *path) -{ - BUG_ON(path->p_idx == NULL); - - if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr)) - return 0; - - /* - * if truncate on deeper level happened it it wasn't partial - * so we have to consider current index for truncation - */ - if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block) - return 0; - return 1; -} - -int ext4_ext_remove_space(void *icb, struct inode *inode, unsigned long start) -{ -#ifndef __REACTOS__ - struct super_block *sb = inode->i_sb; -#endif - int depth = ext_depth(inode); - struct ext4_ext_path *path; - handle_t *handle = NULL; - int i = 0, err = 0; - - /* probably first extent we're gonna free will be last in block */ - /*handle = ext4_journal_start(inode, depth + 1);*/ - /*if (IS_ERR(icb, handle))*/ - /*return PTR_ERR(icb, handle);*/ - - /* - * we start scanning from right side freeing all the blocks - * after i_size and walking into the deep - */ - path = kmalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_KERNEL); - if (path == NULL) { - ext4_journal_stop(icb, handle); - return -ENOMEM; - } - memset(path, 0, sizeof(struct ext4_ext_path) * (depth + 1)); - path[0].p_hdr = ext_inode_hdr(inode); - if (ext4_ext_check_inode(inode)) { - err = -EIO; - goto out; - } - path[0].p_depth = depth; - - while (i >= 0 && err == 0) { - if (i == depth) { - /* this is leaf block */ - err = ext4_ext_rm_leaf(icb, handle, inode, path, start); - /* root level have p_bh == NULL, extents_brelse() eats this */ - extents_brelse(path[i].p_bh); - path[i].p_bh = NULL; - i--; - continue; - } - - /* this is index block */ - if (!path[i].p_hdr) { - path[i].p_hdr = ext_block_hdr(path[i].p_bh); - } - - if (!path[i].p_idx) { - /* this level hasn't touched yet */ - path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr); - path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1; - } else { - /* we've already was here, see at next index */ - path[i].p_idx--; - } - - if (ext4_ext_more_to_rm(path + i)) { - struct buffer_head *bh; - /* go to the next level */ - memset(path + i + 1, 0, sizeof(*path)); - bh = read_extent_tree_block(inode, ext4_idx_pblock(path[i].p_idx), path[0].p_depth - (i + 1), 0); - if (IS_ERR(bh)) { - /* should we reset i_size? */ - err = -EIO; - break; - } - path[i+1].p_bh = bh; - - /* put actual number of indexes to know is this - * number got changed at the next iteration */ - path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries); - i++; - } else { - /* we finish processing this index, go up */ - if (path[i].p_hdr->eh_entries == 0 && i > 0) { - /* index is empty, remove it - * handle must be already prepared by the - * truncatei_leaf() */ - err = ext4_ext_rm_idx(icb, handle, inode, path + i); - } - /* root level have p_bh == NULL, extents_brelse() eats this */ - extents_brelse(path[i].p_bh); - path[i].p_bh = NULL; - i--; - } - } - - /* TODO: flexible tree reduction should be here */ - if (path->p_hdr->eh_entries == 0) { - /* - * truncate to zero freed all the tree - * so, we need to correct eh_depth - */ - err = ext4_ext_get_access(icb, handle, inode, path); - if (err == 0) { - ext_inode_hdr(inode)->eh_depth = 0; - ext_inode_hdr(inode)->eh_max = - cpu_to_le16(ext4_ext_space_root(inode, 0)); - err = ext4_ext_dirty(icb, handle, inode, path); - } - } -out: - if (path) { - ext4_ext_drop_refs(path); - kfree(path); - } - ext4_journal_stop(icb, handle); - - return err; -} - int ext4_ext_tree_init(void *icb, handle_t *handle, struct inode *inode) { struct ext4_extent_header *eh; @@ -2441,7 +2576,7 @@ /* find next allocated block so that we know how many * blocks we can allocate without ovelapping next extent */ - next = ext4_ext_next_allocated_block(path); + next = ext4_ext_next_allocated_block(path, depth); BUG_ON(next <= iblock); allocated = next - iblock; if (flags & EXT4_GET_BLOCKS_PRE_IO && max_blocks > EXT_UNWRITTEN_MAX_LEN) @@ -2504,7 +2639,8 @@ int ext4_ext_truncate(void *icb, struct inode *inode, unsigned long start) { - int ret = ext4_ext_remove_space(icb, inode, start); + int ret = __ext4_ext_truncate(icb, NULL, inode, + start, EXT_MAX_BLOCKS); /* Save modifications on i_blocks field of the inode. */ if (!ret) Index: drivers/filesystems/ext2/src/fastio.c =================================================================== --- drivers/filesystems/ext2/src/fastio.c (révision 71375) +++ drivers/filesystems/ext2/src/fastio.c (copie de travail) @@ -17,6 +17,9 @@ /* DEFINITIONS *************************************************************/ +#define FASTIO_DEBUG_LEVEL DL_NVR + + #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE, Ext2FastIoRead) @@ -213,30 +216,34 @@ _SEH2_LEAVE; } - if (ExAcquireResourceExclusiveLite(&Fcb->MainResource, Wait)) - Locked = TRUE; - else + if (!ExAcquireResourceSharedLite(Fcb->Header.Resource, Wait)) { _SEH2_LEAVE; + } + Locked = TRUE; if (IsWritingToEof(*FileOffset) || + Fcb->Header.ValidDataLength.QuadPart < FileOffset->QuadPart + Length || Fcb->Header.FileSize.QuadPart < FileOffset->QuadPart + Length ) { Status = FALSE; _SEH2_LEAVE; } + if (Locked) { + ExReleaseResourceLite(Fcb->Header.Resource); + Locked = FALSE; + } + Status = FsRtlCopyWrite(FileObject, FileOffset, Length, Wait, LockKey, Buffer, IoStatus, DeviceObject); if (Status) { if (IoStatus) Length = (ULONG)IoStatus->Information; - if (Fcb->Header.ValidDataLength.QuadPart < FileOffset->QuadPart + Length) - Fcb->Header.ValidDataLength.QuadPart = FileOffset->QuadPart + Length; } } _SEH2_FINALLY { if (Locked) { - ExReleaseResourceLite(&Fcb->MainResource); + ExReleaseResourceLite(Fcb->Header.Resource); } FsRtlExitFileSystem(); @@ -981,3 +988,144 @@ return bResult; } + + +VOID +NTAPI +Ext2AcquireForCreateSection ( + IN PFILE_OBJECT FileObject +) + +{ + PEXT2_FCB Fcb = FileObject->FsContext; + + if (Fcb->Header.Resource != NULL) { + ExAcquireResourceExclusiveLite(Fcb->Header.Resource, TRUE); + } + + DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireForCreateSection: Fcb=%p\n", Fcb)); +} + +VOID +NTAPI +Ext2ReleaseForCreateSection ( + IN PFILE_OBJECT FileObject +) +{ + PEXT2_FCB Fcb = FileObject->FsContext; + + DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseForCreateSection: Fcb=%p\n", Fcb)); + + if (Fcb->Header.Resource != NULL) { + ExReleaseResourceLite(Fcb->Header.Resource); + } +} + + +NTSTATUS +NTAPI +Ext2AcquireFileForModWrite ( + IN PFILE_OBJECT FileObject, + IN PLARGE_INTEGER EndingOffset, + OUT PERESOURCE *ResourceToRelease, + IN PDEVICE_OBJECT DeviceObject +) + +{ + BOOLEAN ResourceAcquired = FALSE; + + PEXT2_FCB Fcb = FileObject->FsContext; + + *ResourceToRelease = Fcb->Header.Resource; + ResourceAcquired = ExAcquireResourceExclusiveLite(*ResourceToRelease, FALSE); + if (!ResourceAcquired) { + *ResourceToRelease = NULL; + } + + DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireFileForModWrite: Fcb=%p Acquired=%d\n", + Fcb, ResourceAcquired)); + + return (ResourceAcquired ? STATUS_SUCCESS : STATUS_CANT_WAIT); +} + +NTSTATUS +NTAPI +Ext2ReleaseFileForModWrite ( + IN PFILE_OBJECT FileObject, + IN PERESOURCE ResourceToRelease, + IN PDEVICE_OBJECT DeviceObject +) +{ + PEXT2_FCB Fcb = FileObject->FsContext; + + DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseFileForModWrite: Fcb=%p\n", Fcb)); + + if (ResourceToRelease != NULL) { + ASSERT(ResourceToRelease == Fcb->Header.Resource); + ExReleaseResourceLite(ResourceToRelease); + } else { + DbgBreak(); + } + + return STATUS_SUCCESS; +} + +NTSTATUS +NTAPI +Ext2AcquireFileForCcFlush ( + IN PFILE_OBJECT FileObject, + IN PDEVICE_OBJECT DeviceObject +) +{ + PEXT2_FCB Fcb = FileObject->FsContext; + + if (Fcb->Header.Resource != NULL) { + ExAcquireResourceExclusiveLite(Fcb->Header.Resource, TRUE); + } + + DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireFileForCcFlush: Fcb=%p\n", Fcb)); + + return STATUS_SUCCESS; +} + +NTSTATUS +NTAPI +Ext2ReleaseFileForCcFlush ( + IN PFILE_OBJECT FileObject, + IN PDEVICE_OBJECT DeviceObject +) +{ + PEXT2_FCB Fcb = FileObject->FsContext; + + DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseFileForCcFlush: Fcb=%p\n", Fcb)); + + if (Fcb->Header.Resource != NULL) { + ExReleaseResourceLite(Fcb->Header.Resource); + } + + return STATUS_SUCCESS; +} + + +NTSTATUS +NTAPI +Ext2PreAcquireForCreateSection( + IN PFS_FILTER_CALLBACK_DATA cd, + OUT PVOID *cc + ) +{ + PEXT2_FCB Fcb = (PEXT2_FCB)cd->FileObject->FsContext; + NTSTATUS status; + + ASSERT(cd->Operation == FS_FILTER_ACQUIRE_FOR_SECTION_SYNCHRONIZATION); + ExAcquireResourceExclusiveLite(Fcb->Header.Resource, TRUE); + if (cd->Parameters.AcquireForSectionSynchronization.SyncType != SyncTypeCreateSection) { + status = STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY; + } else if (Fcb->ShareAccess.Writers == 0) { + status = STATUS_FILE_LOCKED_WITH_ONLY_READERS; + } else { + status = STATUS_FILE_LOCKED_WITH_WRITERS; + } + + return status; +} Index: drivers/filesystems/ext2/src/fileinfo.c =================================================================== --- drivers/filesystems/ext2/src/fileinfo.c (révision 71375) +++ drivers/filesystems/ext2/src/fileinfo.c (copie de travail) @@ -554,13 +554,6 @@ VcbMainResourceAcquired = TRUE; } - if (IsVcbReadOnly(Vcb)) { - if (FileInformationClass != FilePositionInformation) { - Status = STATUS_MEDIA_WRITE_PROTECTED; - _SEH2_LEAVE; - } - } - if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) { Status = STATUS_ACCESS_DENIED; _SEH2_LEAVE; @@ -596,6 +589,17 @@ Mcb = Fcb->Mcb; } + if (FileInformationClass != FilePositionInformation) { + if (IsVcbReadOnly(Vcb)) { + Status = STATUS_MEDIA_WRITE_PROTECTED; + _SEH2_LEAVE; + } + if (!Ext2CheckFileAccess(Vcb, Mcb, Ext2FileCanWrite)) { + Status = STATUS_ACCESS_DENIED; + _SEH2_LEAVE; + } + } + if ( !IsDirectory(Fcb) && !FlagOn(Fcb->Flags, FCB_PAGE_FILE) && ((FileInformationClass == FileEndOfFileInformation) || (FileInformationClass == FileValidDataLengthInformation) || @@ -1289,8 +1293,9 @@ DEBUG(DL_INF, ( "Ext2SetDispositionInformation: Removing %wZ.\n", &Mcb->FullName)); - /* always allow deleting on symlinks */ - if (Ccb->SymLink == NULL) { + if (Ccb->SymLink || IsInodeSymLink(&Mcb->Inode)) { + /* always allow deleting on symlinks */ + } else { status = Ext2IsFileRemovable(IrpContext, Vcb, Fcb, Ccb); } Index: drivers/filesystems/ext2/src/flush.c =================================================================== --- drivers/filesystems/ext2/src/flush.c (révision 71375) +++ drivers/filesystems/ext2/src/flush.c (copie de travail) @@ -81,6 +81,9 @@ DEBUG(DL_INF, ( "Ext2FlushVolume: Flushing Vcb ...\n")); + /* discard buffer_headers for group_desc */ + Ext2DropGroup(Vcb); + ExAcquireSharedStarveExclusive(&Vcb->PagingIoResource, TRUE); ExReleaseResourceLite(&Vcb->PagingIoResource); Index: drivers/filesystems/ext2/src/fsctl.c =================================================================== --- drivers/filesystems/ext2/src/fsctl.c (révision 71375) +++ drivers/filesystems/ext2/src/fsctl.c (copie de travail) @@ -1422,7 +1422,8 @@ _SEH2_TRY { - if (!Mcb || !IsInodeSymLink(&Mcb->Inode)) { + if (!Mcb || !IsInodeSymLink(&Mcb->Inode) || + !IsFlagOn(Ccb->Flags, CCB_OPEN_REPARSE_POINT)) { Status = STATUS_NOT_A_REPARSE_POINT; _SEH2_LEAVE; } @@ -1567,7 +1568,6 @@ return Status; } - NTSTATUS Ext2SetReparsePoint (IN PEXT2_IRP_CONTEXT IrpContext) { @@ -1673,8 +1673,23 @@ } } + /* free all data blocks of the inode (to be set as symlink) */ + { + LARGE_INTEGER zero = {0}; + Status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &zero); + } + + /* decrease dir count of group desc and vcb stat */ + if (S_ISDIR(Mcb->Inode.i_mode)) { + + ULONG group = (Mcb->Inode.i_ino - 1) / INODES_PER_GROUP; + Ext2UpdateGroupDirStat(IrpContext, Vcb, group); + + /* drop extra reference for dir inode */ + ext3_dec_count(&Mcb->Inode); + } + /* overwrite inode mode as type SYMLINK */ - Mcb->Inode.i_mode = S_IFLNK | S_IRWXUGO; Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode); SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_REPARSE_POINT); @@ -1681,7 +1696,8 @@ Status = Ext2WriteSymlink(IrpContext, Vcb, Mcb, OemNameBuffer, OemNameLength, &BytesWritten); if (NT_SUCCESS(Status)) { - Status = Ext2SetFileType(IrpContext, Vcb, ParentDcb, Mcb); + Ext2SetFileType(IrpContext, Vcb, ParentDcb, Mcb, + S_IFLNK | S_IRWXUGO); } } _SEH2_FINALLY { @@ -1799,7 +1815,8 @@ } } - if (!Mcb) { + if (!Mcb || !IsInodeSymLink(&Mcb->Inode) || + !IsFlagOn(Ccb->Flags, CCB_OPEN_REPARSE_POINT)) { Status = STATUS_NOT_A_REPARSE_POINT; _SEH2_LEAVE; } @@ -1825,16 +1842,10 @@ if (!NT_SUCCESS(Status)) { _SEH2_LEAVE; } - if (IsFlagOn(SUPER_BLOCK->s_feature_incompat, EXT4_FEATURE_INCOMPAT_EXTENTS)) { - SetFlag(Mcb->Inode.i_flags, EXT4_EXTENTS_FL); - } - ClearFlag(Mcb->FileAttr, FILE_ATTRIBUTE_REPARSE_POINT); - ClearFlag(Mcb->Inode.i_flags, S_IFLNK); - Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode); - if (NT_SUCCESS(Status)) { - Status = Ext2SetFileType(IrpContext, Vcb, ParentDcb, Mcb); - } + /* inode is to be removed */ + SetFlag(Ccb->Flags, CCB_DELETE_ON_CLOSE); + } _SEH2_FINALLY { if (MainResourceAcquired) { @@ -2702,6 +2713,9 @@ FlushBeforePurge = FALSE; } + /* discard buffer_headers for group_desc */ + Ext2DropGroup(Vcb); + FcbListEntry= NULL; InitializeListHead(&FcbList); Index: drivers/filesystems/ext2/src/init.c =================================================================== --- drivers/filesystems/ext2/src/init.c (révision 71375) +++ drivers/filesystems/ext2/src/init.c (copie de travail) @@ -33,6 +33,7 @@ #ifdef ALLOC_PRAGMA #pragma alloc_text(INIT, Ext2QueryGlobalParameters) +#pragma alloc_text(INIT, Ext2QueryRegistrySettings) #pragma alloc_text(INIT, DriverEntry) #if EXT2_UNLOAD #pragma alloc_text(PAGE, DriverUnload) @@ -99,140 +100,250 @@ #endif -BOOLEAN -Ext2QueryGlobalParameters( IN PUNICODE_STRING RegistryPath) +NTSTATUS +NTAPI +Ext2RegistryQueryCallback( + IN PWSTR ValueName, + IN ULONG ValueType, + IN PVOID ValueData, + IN ULONG ValueLength, + IN PVOID Context, + IN PVOID EntryContext + ) { - NTSTATUS Status; - UNICODE_STRING ParameterPath; - RTL_QUERY_REGISTRY_TABLE QueryTable[2]; + ULONG i = 0; + BYTE *s, *t; - ULONG WritingSupport = 0; - ULONG CheckingBitmap = 0; - ULONG Ext3ForceWriting = 0; - ULONG AutoMount = 0; + if (NULL == ValueName || NULL == ValueData) + return STATUS_SUCCESS; - UNICODE_STRING UniName; - ANSI_STRING AnsiName; + if (ValueType == REG_DWORD && wcslen(ValueName) == wcslen(WRITING_SUPPORT) && + _wcsnicmp(ValueName, WRITING_SUPPORT, wcslen(WRITING_SUPPORT)) == 0) { - WCHAR UniBuffer[CODEPAGE_MAXLEN]; - USHORT Buffer[HIDINGPAT_LEN]; + if (ValueData && ValueLength == sizeof(DWORD)) { + if (*((PULONG)ValueData)) { + SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); + } else { + ClearLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); + } + } + } else if (ValueType == REG_DWORD && wcslen(ValueName) == wcslen(CHECKING_BITMAP) && + _wcsnicmp(ValueName, CHECKING_BITMAP, wcslen(CHECKING_BITMAP)) == 0) { - ParameterPath.Length = 0; + if (ValueData && ValueLength == sizeof(DWORD)) { + if (*((PULONG)ValueData)) { + SetLongFlag(Ext2Global->Flags, EXT2_CHECKING_BITMAP); + } else { + ClearLongFlag(Ext2Global->Flags, EXT2_CHECKING_BITMAP); + } + } + } else if (ValueType == REG_DWORD && wcslen(ValueName) == wcslen(EXT3_FORCEWRITING) && + _wcsnicmp(ValueName, EXT3_FORCEWRITING, wcslen(EXT3_FORCEWRITING)) == 0) { - ParameterPath.MaximumLength = - RegistryPath->Length + sizeof(PARAMETERS_KEY) + sizeof(WCHAR); + if (ValueData && ValueLength == sizeof(DWORD)) { + if (*((PULONG)ValueData)) { + SetLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); + SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); + } else { + ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); + } + } + } else if (ValueType == REG_DWORD && wcslen(ValueName) == wcslen(AUTO_MOUNT) && + _wcsnicmp(ValueName, AUTO_MOUNT, wcslen(AUTO_MOUNT)) == 0) { - ParameterPath.Buffer = - (PWSTR) Ext2AllocatePool( - PagedPool, - ParameterPath.MaximumLength, - 'LG2E' - ); + if (ValueData && ValueLength == sizeof(DWORD)) { + if (*((PULONG)ValueData)) { + SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); + } else { + ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); + } + } + } else if (ValueType == REG_SZ && wcslen(ValueName) == wcslen(CODEPAGE_NAME) && + _wcsnicmp(ValueName, CODEPAGE_NAME, wcslen(CODEPAGE_NAME)) == 0) { - if (!ParameterPath.Buffer) { - DbgBreak(); - DEBUG(DL_ERR, ( "Ex2QueryParameters: failed to allocate Parameters...\n")); - return FALSE; + if (ValueData && ValueLength <= sizeof(WCHAR) * CODEPAGE_MAXLEN) { + RtlCopyMemory(&Ext2Global->Codepage.PageName[0], + ValueData, ValueLength); + } + } else if (ValueType == REG_SZ && wcslen(ValueName) == wcslen(HIDING_PREFIX) && + _wcsnicmp(ValueName, HIDING_PREFIX, wcslen(HIDING_PREFIX)) == 0) { + + if (ValueData && ValueLength <= sizeof(WCHAR) * HIDINGPAT_LEN) { + RtlCopyMemory(&Ext2Global->wHidingPrefix[0], + ValueData, ValueLength); + } + } else if (ValueType == REG_SZ && wcslen(ValueName) == wcslen(HIDING_SUFFIX) && + _wcsnicmp(ValueName, HIDING_SUFFIX, wcslen(HIDING_SUFFIX)) == 0) { + + if (ValueData && ValueLength <= sizeof(WCHAR) * HIDINGPAT_LEN) { + RtlCopyMemory(&Ext2Global->wHidingSuffix[0], + ValueData, ValueLength); + } } - RtlCopyUnicodeString(&ParameterPath, RegistryPath); - RtlAppendUnicodeToString(&ParameterPath, PARAMETERS_KEY); - /* querying value of WritingSupport */ - RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2); + return STATUS_SUCCESS; +} - QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; +NTSTATUS +Ext2QueryGlobalParameters(IN PUNICODE_STRING RegistryPath) +{ + RTL_QUERY_REGISTRY_TABLE QueryTable[8]; + int i = 0; + NTSTATUS Status; + + RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 8); + + /* + * 1 writing support + */ + QueryTable[i].Flags = 0; QueryTable[0].Name = WRITING_SUPPORT; - QueryTable[0].EntryContext = &WritingSupport; + QueryTable[i].DefaultType = REG_NONE; + QueryTable[i].DefaultLength = 0; + QueryTable[i].DefaultData = NULL; + QueryTable[i].EntryContext = NULL; + QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback; + i++; - Status = RtlQueryRegistryValues( - RTL_REGISTRY_ABSOLUTE, - ParameterPath.Buffer, - &QueryTable[0], - NULL, - NULL ); + /* + * 2 checking bitmap + */ + QueryTable[i].Flags = 0; + QueryTable[i].Name = CHECKING_BITMAP; + QueryTable[i].DefaultType = REG_NONE; + QueryTable[i].DefaultLength = 0; + QueryTable[i].DefaultData = NULL; + QueryTable[i].EntryContext = NULL; + QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback; + i++; - DEBUG(DL_ERR, ( "Ext2QueryParameters: WritingSupport=%xh\n", WritingSupport)); + /* + * 3 force writing + */ + QueryTable[i].Flags = 0; + QueryTable[i].Name = EXT3_FORCEWRITING; + QueryTable[i].DefaultType = REG_NONE; + QueryTable[i].DefaultLength = 0; + QueryTable[i].DefaultData = NULL; + QueryTable[i].EntryContext = NULL; + QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback; + i++; - /* querying value of CheckingBitmap */ - RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2); - QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; - QueryTable[0].Name = CHECKING_BITMAP; - QueryTable[0].EntryContext = &CheckingBitmap; + /* + * 4 automount + */ + QueryTable[i].Flags = 0; + QueryTable[i].Name = AUTO_MOUNT; + QueryTable[i].DefaultType = REG_NONE; + QueryTable[i].DefaultLength = 0; + QueryTable[i].DefaultData = NULL; + QueryTable[i].EntryContext = NULL; + QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback; + i++; - Status = RtlQueryRegistryValues( - RTL_REGISTRY_ABSOLUTE, - ParameterPath.Buffer, - &QueryTable[0], - NULL, - NULL ); + /* + * 5 codepage + */ + QueryTable[i].Flags = 0; + QueryTable[i].Name = CODEPAGE_NAME; + QueryTable[i].DefaultType = REG_NONE; + QueryTable[i].DefaultLength = 0; + QueryTable[i].DefaultData = NULL; + QueryTable[i].EntryContext = NULL; + QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback; + i++; - DEBUG(DL_ERR, ( "Ext2QueryParameters: CheckingBitmap=%xh\n", CheckingBitmap)); + /* + * 6 hidden prefix + */ + QueryTable[i].Flags = 0; + QueryTable[i].Name = HIDING_PREFIX; + QueryTable[i].DefaultType = REG_NONE; + QueryTable[i].DefaultLength = 0; + QueryTable[i].DefaultData = NULL; + QueryTable[i].EntryContext = NULL; + QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback; + i++; - /* querying value of Ext3ForceWriting */ - RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2); - QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; - QueryTable[0].Name = EXT3_FORCEWRITING; - QueryTable[0].EntryContext = &Ext3ForceWriting; + /* + * 7 hidden suffix + */ + QueryTable[i].Flags = 0; + QueryTable[i].Name = HIDING_SUFFIX; + QueryTable[i].DefaultType = REG_NONE; + QueryTable[i].DefaultLength = 0; + QueryTable[i].DefaultData = NULL; + QueryTable[i].EntryContext = NULL; + QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback; + i++; + Status = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE, - ParameterPath.Buffer, + RegistryPath->Buffer, &QueryTable[0], NULL, - NULL ); + NULL + ); - DEBUG(DL_ERR, ( "Ext2QueryParameters: Ext3ForceWriting=%xh\n", Ext3ForceWriting)); + return NT_SUCCESS(Status); +} - /* querying value of AutoMount */ - RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2); +BOOLEAN +Ext2QueryRegistrySettings(IN PUNICODE_STRING RegistryPath) +{ + UNICODE_STRING ParameterPath; + UNICODE_STRING UniName; + ANSI_STRING AnsiName; - QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; - QueryTable[0].Name = AUTO_MOUNT; - QueryTable[0].EntryContext = &AutoMount; + ULONG WritingSupport = 0; + ULONG CheckingBitmap = 0; + ULONG Ext3ForceWriting = 0; + ULONG AutoMount = 0; - Status = RtlQueryRegistryValues( - RTL_REGISTRY_ABSOLUTE, - ParameterPath.Buffer, - &QueryTable[0], - NULL, - NULL ); + WCHAR UniBuffer[CODEPAGE_MAXLEN]; + USHORT Buffer[HIDINGPAT_LEN]; - SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); - if (NT_SUCCESS(Status) && AutoMount == 0) { - ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); + NTSTATUS Status; + + ParameterPath.Length = 0; + ParameterPath.MaximumLength = + RegistryPath->Length + sizeof(PARAMETERS_KEY) + sizeof(WCHAR); + ParameterPath.Buffer = + (PWSTR) Ext2AllocatePool( + PagedPool, + ParameterPath.MaximumLength, + 'LG2E' + ); + if (!ParameterPath.Buffer) { + DbgBreak(); + DEBUG(DL_ERR, ( "Ex2QueryParameters: failed to allocate Parameters...\n")); + return FALSE; } - DEBUG(DL_ERR, ( "Ext2QueryParameters: AutoMount=%xh\n", AutoMount)); + RtlCopyUnicodeString(&ParameterPath, RegistryPath); + RtlAppendUnicodeToString(&ParameterPath, PARAMETERS_KEY); - /* querying codepage */ - RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2); - QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; - QueryTable[0].Name = CODEPAGE_NAME; - QueryTable[0].EntryContext = &(UniName); - UniName.MaximumLength = CODEPAGE_MAXLEN * sizeof(WCHAR); - UniName.Length = 0; - UniName.Buffer = (PWSTR)UniBuffer; + /* enable automount of ext2/3/4 volumes */ + SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT); - Status = RtlQueryRegistryValues( - RTL_REGISTRY_ABSOLUTE, - ParameterPath.Buffer, - &QueryTable[0], - NULL, - NULL ); + /* query parameter settings from registry */ + Ext2QueryGlobalParameters(&ParameterPath); - if (NT_SUCCESS(Status)) { - DEBUG(DL_ERR, ( "Ext2QueryParameters: Ext2CodePage=%wZ\n", &UniName)); + /* set global codepage settings */ + if (wcslen(&Ext2Global->Codepage.PageName[0])) { + UniName.Length = sizeof(WCHAR) * wcslen(&Ext2Global->Codepage.PageName[0]); + UniName.MaximumLength = CODEPAGE_MAXLEN * sizeof(WCHAR); + UniName.Buffer = &Ext2Global->Codepage.PageName[0]; AnsiName.MaximumLength = CODEPAGE_MAXLEN; AnsiName.Length = 0; - AnsiName.Buffer = &(Ext2Global->Codepage.AnsiName[0]); - + AnsiName.Buffer = &Ext2Global->Codepage.AnsiName[0]; Status = RtlUnicodeStringToAnsiString( &AnsiName, &UniName, FALSE); - if (!NT_SUCCESS(Status)) { DEBUG(DL_ERR, ( "Ext2QueryParameters: Wrong CodePage %wZ ...\n", &UniName)); RtlCopyMemory(&(Ext2Global->Codepage.AnsiName[0]),"default\0", 8); @@ -243,25 +354,13 @@ } Ext2Global->Codepage.AnsiName[CODEPAGE_MAXLEN - 1] = 0; - /* querying name hiding patterns: prefix*/ - RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2); - QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; - QueryTable[0].Name = HIDING_PREFIX; - QueryTable[0].EntryContext = &(UniName); - UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR); - UniName.Length = 0; - UniName.Buffer = Buffer; - Status = RtlQueryRegistryValues( - RTL_REGISTRY_ABSOLUTE, - ParameterPath.Buffer, - &QueryTable[0], - NULL, - NULL ); - - if (NT_SUCCESS(Status)) { - DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingPrefix=%wZ\n", &UniName)); - AnsiName.MaximumLength =HIDINGPAT_LEN; + /* set global hidden prefix pattern */ + if (wcslen(&Ext2Global->wHidingPrefix[0])) { + UniName.Length = sizeof(WCHAR) * wcslen(&Ext2Global->wHidingPrefix[0]); + UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR); + UniName.Buffer = &Ext2Global->wHidingPrefix[0]; + AnsiName.MaximumLength = HIDINGPAT_LEN; AnsiName.Length = 0; AnsiName.Buffer = &(Ext2Global->sHidingPrefix[0]); @@ -279,26 +378,12 @@ } Ext2Global->sHidingPrefix[HIDINGPAT_LEN - 1] = 0; - /* querying name hiding patterns: suffix */ - RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 2); - QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; - QueryTable[0].Name = HIDING_SUFFIX; - QueryTable[0].EntryContext = &(UniName); - UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR); - UniName.Length = 0; - UniName.Buffer = Buffer; - Status = RtlQueryRegistryValues( - RTL_REGISTRY_ABSOLUTE, - ParameterPath.Buffer, - &QueryTable[0], - NULL, - NULL - ); - - if (NT_SUCCESS(Status)) { - - DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingSuffix=%wZ\n", &UniName)); + /* set global hidden suffix pattern */ + if (wcslen(&Ext2Global->wHidingSuffix[0])) { + UniName.Length = sizeof(WCHAR) * wcslen(&Ext2Global->wHidingSuffix[0]); + UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR); + UniName.Buffer = &Ext2Global->wHidingSuffix[0]; AnsiName.MaximumLength = HIDINGPAT_LEN; AnsiName.Length = 0; AnsiName.Buffer = &(Ext2Global->sHidingSuffix[0]); @@ -317,29 +402,6 @@ } Ext2Global->sHidingPrefix[HIDINGPAT_LEN - 1] = 0; - { - if (WritingSupport) { - SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); - } else { - ClearLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); - } - - if (CheckingBitmap) { - SetLongFlag(Ext2Global->Flags, EXT2_CHECKING_BITMAP); - } else { - ClearLongFlag(Ext2Global->Flags, EXT2_CHECKING_BITMAP); - } - - if (Ext3ForceWriting) { - DEBUG(DL_WRN, ("Ext2Fsd -- Warning: Ext3ForceWriting enabled !!!\n")); - - SetLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); - SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING); - } else { - ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING); - } - } - Ext2Global->RegistryPath.Buffer = ParameterPath.Buffer; Ext2Global->RegistryPath.Length = 0; Ext2Global->RegistryPath.MaximumLength = ParameterPath.MaximumLength; @@ -360,6 +422,23 @@ ) #endif +VOID +Ext2EresourceAlignmentChecking() +{ + /* Verify ERESOURCE alignment in structures */ + CL_ASSERT((FIELD_OFFSET(EXT2_GLOBAL, Resource) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_VCB, MainResource) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_VCB, PagingIoResource) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_VCB, MetaInode) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_VCB, MetaBlock) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_VCB, McbLock) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_VCB, bd.bd_bh_lock) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_VCB, sbi.s_gd_lock) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_FCBVCB, MainResource) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_FCBVCB, PagingIoResource) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_FCB, MainResource) & 7) == 0); + CL_ASSERT((FIELD_OFFSET(EXT2_FCB, PagingIoResource) & 7) == 0); +} /* * NAME: DriverEntry @@ -384,7 +463,6 @@ PFAST_IO_DISPATCH FastIoDispatch; PCACHE_MANAGER_CALLBACKS CacheManagerCallbacks; - LARGE_INTEGER Timeout; NTSTATUS Status; int rc = 0; @@ -391,17 +469,6 @@ BOOLEAN linux_lib_inited = FALSE; BOOLEAN journal_module_inited = FALSE; - /* Verify ERESOURCE alignment in structures */ - ASSERT((FIELD_OFFSET(EXT2_GLOBAL, Resource) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_VCB, MainResource) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_VCB, PagingIoResource) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_VCB, MetaLock) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_VCB, McbLock) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_FCBVCB, MainResource) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_FCBVCB, PagingIoResource) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_FCB, MainResource) & 7) == 0); - ASSERT((FIELD_OFFSET(EXT2_FCB, PagingIoResource) & 7) == 0); - /* Verity super block ... */ ASSERT(sizeof(EXT2_SUPER_BLOCK) == 1024); ASSERT(FIELD_OFFSET(EXT2_SUPER_BLOCK, s_magic) == 56); @@ -454,12 +521,8 @@ InitializeListHead(&(Ext2Global->VcbList)); ExInitializeResourceLite(&(Ext2Global->Resource)); - /* Reaper thread engine event */ - KeInitializeEvent(&Ext2Global->Reaper.Engine, - SynchronizationEvent, FALSE); - /* query registry settings */ - Ext2QueryGlobalParameters(RegistryPath); + Ext2QueryRegistrySettings(RegistryPath); /* create Ext2Fsd cdrom fs deivce */ RtlInitUnicodeString(&DeviceName, CDROM_NAME); @@ -494,21 +557,18 @@ } /* start resource reaper thread */ - Status= Ext2StartReaperThread(); + Status= Ext2StartReaper( + &Ext2Global->McbReaper, + Ext2McbReaperThread); if (!NT_SUCCESS(Status)) { goto errorout; } - /* make sure Reaperthread is started */ - Timeout.QuadPart = (LONGLONG)-10*1000*1000*10; /* 10 seconds */ - Status = KeWaitForSingleObject( - &(Ext2Global->Reaper.Engine), - Executive, - KernelMode, - FALSE, - &Timeout - ); - if (Status != STATUS_SUCCESS) { - Status = STATUS_INSUFFICIENT_RESOURCES; + + Status= Ext2StartReaper( + &Ext2Global->bhReaper, + Ext2bhReaperThread); + if (!NT_SUCCESS(Status)) { + Ext2StopReaper(&Ext2Global->McbReaper); goto errorout; } @@ -564,12 +624,16 @@ FastIoDispatch->FastIoUnlockAll = Ext2FastIoUnlockAll; FastIoDispatch->FastIoUnlockAllByKey = Ext2FastIoUnlockAllByKey; FastIoDispatch->FastIoQueryNetworkOpenInfo = Ext2FastIoQueryNetworkOpenInfo; + FastIoDispatch->AcquireForModWrite = Ext2AcquireFileForModWrite; FastIoDispatch->ReleaseForModWrite = Ext2ReleaseFileForModWrite; + FastIoDispatch->AcquireForModWrite = Ext2AcquireFileForModWrite; + FastIoDispatch->ReleaseForModWrite = Ext2ReleaseFileForModWrite; FastIoDispatch->AcquireForCcFlush = Ext2AcquireFileForCcFlush; FastIoDispatch->ReleaseForCcFlush = Ext2ReleaseFileForCcFlush; FastIoDispatch->AcquireFileForNtCreateSection = Ext2AcquireForCreateSection; FastIoDispatch->ReleaseFileForNtCreateSection = Ext2ReleaseForCreateSection; + DriverObject->FastIoDispatch = FastIoDispatch; // @@ -633,7 +697,20 @@ Ext2Global->CacheManagerNoOpCallbacks.AcquireForReadAhead = Ext2NoOpAcquire; Ext2Global->CacheManagerNoOpCallbacks.ReleaseFromReadAhead = Ext2NoOpRelease; + +#ifndef _WIN2K_TARGET_ // + // Initialize FS Filter callbacks + // + + RtlZeroMemory(&Ext2Global->FilterCallbacks, sizeof(FS_FILTER_CALLBACKS)); + Ext2Global->FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS); + Ext2Global->FilterCallbacks.PreAcquireForSectionSynchronization = Ext2PreAcquireForCreateSection; + FsRtlRegisterFileSystemFilterCallbacks(DriverObject, &Ext2Global->FilterCallbacks ); + +#endif + + // // Initialize the global data // Index: drivers/filesystems/ext2/src/linux.c =================================================================== --- drivers/filesystems/ext2/src/linux.c (révision 71375) +++ drivers/filesystems/ext2/src/linux.c (copie de travail) @@ -329,10 +329,16 @@ struct buffer_head * bh = NULL; bh = kmem_cache_alloc(g_jbh.bh_cache, GFP_NOFS); if (bh) { + atomic_inc(&g_jbh.bh_count); + atomic_inc(&g_jbh.bh_acount); + memset(bh, 0, sizeof(struct buffer_head)); + InitializeListHead(&bh->b_link); + KeQuerySystemTime(&bh->b_ts_creat); DEBUG(DL_BH, ("bh=%p allocated.\n", bh)); INC_MEM_COUNT(PS_BUFF_HEAD, bh, sizeof(struct buffer_head)); } + return bh; } @@ -344,13 +350,9 @@ DEBUG(DL_BH, ("bh=%p mdl=%p (Flags:%xh VA:%p) released.\n", bh, bh->b_mdl, bh->b_mdl->MdlFlags, bh->b_mdl->MappedSystemVa)); - if (IsFlagOn(bh->b_mdl->MdlFlags, MDL_PAGES_LOCKED)) { - /* MmUnlockPages will release it's VA */ - MmUnlockPages(bh->b_mdl); - } else if (IsFlagOn(bh->b_mdl->MdlFlags, MDL_MAPPED_TO_SYSTEM_VA)) { + if (IsFlagOn(bh->b_mdl->MdlFlags, MDL_MAPPED_TO_SYSTEM_VA)) { MmUnmapLockedPages(bh->b_mdl->MappedSystemVa, bh->b_mdl); } - Ext2DestroyMdl(bh->b_mdl); } if (bh->b_bcb) { @@ -360,6 +362,7 @@ DEBUG(DL_BH, ("bh=%p freed.\n", bh)); DEC_MEM_COUNT(PS_BUFF_HEAD, bh, sizeof(struct buffer_head)); kmem_cache_free(g_jbh.bh_cache, bh); + atomic_dec(&g_jbh.bh_count); } } @@ -436,7 +439,6 @@ PVOID bcb = NULL; PVOID ptr = NULL; - KIRQL irql = 0; struct list_head *entry; /* allocate buffer_head and initialize it */ @@ -449,15 +451,15 @@ } /* search the bdev bh list */ - spin_lock_irqsave(&bdev->bd_bh_lock, irql); + ExAcquireSharedStarveExclusive(&bdev->bd_bh_lock, TRUE); tbh = buffer_head_search(bdev, block); if (tbh) { bh = tbh; get_bh(bh); - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + ExReleaseResourceLite(&bdev->bd_bh_lock); goto errorout; } - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + ExReleaseResourceLite(&bdev->bd_bh_lock); bh = new_buffer_head(); if (!bh) { @@ -467,8 +469,6 @@ bh->b_blocknr = block; bh->b_size = size; bh->b_data = NULL; - atomic_inc(&g_jbh.bh_count); - atomic_inc(&g_jbh.bh_acount); again: @@ -499,7 +499,7 @@ set_buffer_uptodate(bh); } - bh->b_mdl = Ext2CreateMdl(ptr, TRUE, bh->b_size, IoModifyAccess); + bh->b_mdl = Ext2CreateMdl(ptr, bh->b_size, IoModifyAccess); if (bh->b_mdl) { /* muse map the PTE to NonCached zone. journal recovery will access the PTE under spinlock: DISPATCH_LEVEL IRQL */ @@ -506,6 +506,7 @@ bh->b_data = MmMapLockedPagesSpecifyCache( bh->b_mdl, KernelMode, MmNonCached, NULL,FALSE, HighPagePriority); + /* bh->b_data = MmMapLockedPages(bh->b_mdl, KernelMode); */ } if (!bh->b_mdl || !bh->b_data) { free_buffer_head(bh); @@ -518,8 +519,7 @@ DEBUG(DL_BH, ("getblk: Vcb=%p bhcount=%u block=%u bh=%p mdl=%p (Flags:%xh VA:%p)\n", Vcb, atomic_read(&g_jbh.bh_count), block, bh, bh->b_mdl, bh->b_mdl->MdlFlags, bh->b_data)); - spin_lock_irqsave(&bdev->bd_bh_lock, irql); - + ExAcquireResourceExclusiveLite(&bdev->bd_bh_lock, TRUE); /* do search again here */ tbh = buffer_head_search(bdev, block); if (tbh) { @@ -526,13 +526,15 @@ free_buffer_head(bh); bh = tbh; get_bh(bh); - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + RemoveEntryList(&bh->b_link); + InitializeListHead(&bh->b_link); + ExReleaseResourceLite(&bdev->bd_bh_lock); goto errorout; - } else + } else { buffer_head_insert(bdev, bh); + } + ExReleaseResourceLite(&bdev->bd_bh_lock); - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); - /* we get it */ errorout: @@ -602,7 +604,7 @@ } struct buffer_head * -get_block_bh( +get_block_bh_pin( struct block_device * bdev, sector_t block, unsigned long size, @@ -612,7 +614,6 @@ PEXT2_VCB Vcb = bdev->bd_priv; LARGE_INTEGER offset; - KIRQL irql = 0; struct list_head *entry; /* allocate buffer_head and initialize it */ @@ -625,15 +626,15 @@ } /* search the bdev bh list */ - spin_lock_irqsave(&bdev->bd_bh_lock, irql); + ExAcquireSharedStarveExclusive(&bdev->bd_bh_lock, TRUE); tbh = buffer_head_search(bdev, block); if (tbh) { bh = tbh; get_bh(bh); - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + ExReleaseResourceLite(&bdev->bd_bh_lock); goto errorout; } - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + ExReleaseResourceLite(&bdev->bd_bh_lock); bh = new_buffer_head(); if (!bh) { @@ -643,8 +644,6 @@ bh->b_blocknr = block; bh->b_size = size; bh->b_data = NULL; - atomic_inc(&g_jbh.bh_count); - atomic_inc(&g_jbh.bh_acount); again: @@ -656,7 +655,7 @@ &offset, bh->b_size, FALSE, - PIN_WAIT | PIN_EXCLUSIVE, + PIN_WAIT, &bh->b_bcb, (PVOID *)&bh->b_data)) { Ext2Sleep(100); @@ -675,34 +674,35 @@ set_buffer_uptodate(bh); } + if (bh->b_bcb) + CcSetBcbOwnerPointer(bh->b_bcb, (PVOID)((ERESOURCE_THREAD)bh | 0x3)); + if (!bh->b_data) { free_buffer_head(bh); bh = NULL; goto errorout; } - get_bh(bh); - CcSetBcbOwnerPointer(bh->b_bcb, (PVOID)((ERESOURCE_THREAD)bh | 0x3)); DEBUG(DL_BH, ("getblk: Vcb=%p bhcount=%u block=%u bh=%p ptr=%p.\n", Vcb, atomic_read(&g_jbh.bh_count), block, bh, bh->b_data)); - spin_lock_irqsave(&bdev->bd_bh_lock, irql); - + ExAcquireResourceExclusiveLite(&bdev->bd_bh_lock, TRUE); /* do search again here */ tbh = buffer_head_search(bdev, block); if (tbh) { get_bh(tbh); - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + ExReleaseResourceLite(&bdev->bd_bh_lock); free_buffer_head(bh); bh = tbh; + RemoveEntryList(&bh->b_link); + InitializeListHead(&bh->b_link); goto errorout; } else { buffer_head_insert(bdev, bh); } + ExReleaseResourceLite(&bdev->bd_bh_lock); - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); - /* we get it */ errorout: @@ -709,7 +709,7 @@ return bh; } -int submit_bh(int rw, struct buffer_head *bh) +int submit_bh_pin(int rw, struct buffer_head *bh) { struct block_device *bdev = bh->b_bdev; PEXT2_VCB Vcb = bdev->bd_priv; @@ -744,7 +744,44 @@ return 0; } +#if 0 + struct buffer_head * +get_block_bh( + struct block_device * bdev, + sector_t block, + unsigned long size, + int zero +) +{ + return get_block_bh_mdl(bdev, block, size, zero); +} + +int submit_bh(int rw, struct buffer_head *bh) +{ + return submit_bh_mdl(rw, bh); +} + +#else + +struct buffer_head * +get_block_bh( + struct block_device * bdev, + sector_t block, + unsigned long size, + int zero +) +{ + return get_block_bh_pin(bdev, block, size, zero); +} + +int submit_bh(int rw, struct buffer_head *bh) +{ + return submit_bh_pin(rw, bh); +} +#endif + +struct buffer_head * __getblk( struct block_device * bdev, sector_t block, @@ -758,7 +795,6 @@ { struct block_device *bdev = bh->b_bdev; PEXT2_VCB Vcb = (PEXT2_VCB)bdev->bd_priv; - KIRQL irql = 0; ASSERT(Vcb->Identifier.Type == EXT2VCB); @@ -767,20 +803,30 @@ ll_rw_block(WRITE, 1, &bh); } - spin_lock_irqsave(&bdev->bd_bh_lock, irql); - if (!atomic_dec_and_test(&bh->b_count)) { - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + if (1 == atomic_read(&bh->b_count)) { + } else if (atomic_dec_and_test(&bh->b_count)) { + atomic_inc(&bh->b_count); + } else { return; } + + ExAcquireResourceExclusiveLite(&bdev->bd_bh_lock, TRUE); + if (atomic_dec_and_test(&bh->b_count)) { + ASSERT(0 == atomic_read(&bh->b_count)); + } else { + ExReleaseResourceLite(&bdev->bd_bh_lock); + return; + } buffer_head_remove(bdev, bh); - spin_unlock_irqrestore(&bdev->bd_bh_lock, irql); + KeQuerySystemTime(&bh->b_ts_drop); + InsertTailList(&Vcb->bd.bd_bh_free, &bh->b_link); + KeClearEvent(&Vcb->bd.bd_bh_notify); + ExReleaseResourceLite(&bdev->bd_bh_lock); + KeSetEvent(&Ext2Global->bhReaper.Wait, 0, FALSE); DEBUG(DL_BH, ("brelse: cnt=%u size=%u blk=%10.10xh bh=%p ptr=%p\n", atomic_read(&g_jbh.bh_count) - 1, bh->b_size, bh->b_blocknr, bh, bh->b_data )); - - free_buffer_head(bh); - atomic_dec(&g_jbh.bh_count); } @@ -863,10 +909,7 @@ int sync_blockdev(struct block_device *bdev) { PEXT2_VCB Vcb = (PEXT2_VCB) bdev->bd_priv; - - if (0 == atomic_read(&g_jbh.bh_count)) { - Ext2FlushVolume(NULL, Vcb, FALSE); - } + Ext2FlushVolume(NULL, Vcb, FALSE); return 0; } Index: drivers/filesystems/ext2/src/memory.c =================================================================== --- drivers/filesystems/ext2/src/memory.c (révision 71375) +++ drivers/filesystems/ext2/src/memory.c (copie de travail) @@ -31,7 +31,8 @@ #pragma alloc_text(PAGE, Ext2DestroyVcb) #pragma alloc_text(PAGE, Ext2SyncUninitializeCacheMap) #pragma alloc_text(PAGE, Ext2ReaperThread) -#pragma alloc_text(PAGE, Ext2StartReaperThread) +#pragma alloc_text(PAGE, Ext2StartReaper) +#pragma alloc_text(PAGE, Ext2StopReaper) #endif PEXT2_IRP_CONTEXT @@ -1404,7 +1405,7 @@ /* need wake the reaper thread if there are many Mcb allocated */ if (Ext2Global->PerfStat.Current.Mcb > (((ULONG)Ext2Global->MaxDepth) * 4)) { - KeSetEvent(&Ext2Global->Reaper.Wait, 0, FALSE); + KeSetEvent(&Ext2Global->McbReaper.Wait, 0, FALSE); } /* allocate Mcb from LookasideList */ @@ -1982,7 +1983,7 @@ VOID Ext2ParseRegistryVolumeParams( IN PUNICODE_STRING Params, - OUT PEXT2_VOLUME_PROPERTY2 Property + OUT PEXT2_VOLUME_PROPERTY3 Property ) { WCHAR Codepage[CODEPAGE_MAXLEN]; @@ -1990,11 +1991,15 @@ WCHAR Suffix[HIDINGPAT_LEN]; USHORT MountPoint[4]; UCHAR DrvLetter[4]; + WCHAR wUID[8], wGID[8], wEUID[8], wEGID[8]; + CHAR sUID[8], sGID[8], sEUID[8], sEGID[8]; BOOLEAN bWriteSupport = FALSE, bCheckBitmap = FALSE, bCodeName = FALSE, bMountPoint = FALSE; + BOOLEAN bUID = 0, bGID = 0, bEUID = 0, bEGID = 0; + struct { PWCHAR Name; /* parameters name */ PBOOLEAN bExist; /* is it contained in params */ @@ -2020,6 +2025,11 @@ {MOUNT_POINT, &bMountPoint, 4, &MountPoint[0], &DrvLetter[0]}, + {UID, &bUID, 8, &wUID[0], &sUID[0],}, + {GID, &bGID, 8, &wGID[0], &sGID[0]}, + {EUID, &bEUID, 8, &wEUID[0], &sEUID[0]}, + {EGID, &bEGID, 8, &wEGID[0], &sEGID[0]}, + /* end */ {NULL, NULL, 0, NULL} }; @@ -2032,9 +2042,9 @@ RtlZeroMemory(MountPoint, sizeof(USHORT) * 4); RtlZeroMemory(DrvLetter, sizeof(CHAR) * 4); - RtlZeroMemory(Property, sizeof(EXT2_VOLUME_PROPERTY2)); + RtlZeroMemory(Property, sizeof(EXT2_VOLUME_PROPERTY3)); Property->Magic = EXT2_VOLUME_PROPERTY_MAGIC; - Property->Command = APP_CMD_SET_PROPERTY2; + Property->Command = APP_CMD_SET_PROPERTY3; for (i=0; ParamPattern[i].Name != NULL; i++) { @@ -2095,6 +2105,22 @@ Property->DrvLetter = DrvLetter[0]; Property->DrvLetter |= 0x80; } + + if (bUID && bGID) { + SetFlag(Property->Flags2, EXT2_VPROP3_USERIDS); + sUID[7] = sGID[7] = sEUID[7] = sEGID[7] = 0; + Property->uid = (USHORT)atoi(sUID); + Property->gid = (USHORT)atoi(sGID); + if (bEUID) { + Property->euid = (USHORT)atoi(sEUID); + Property->egid = (USHORT)atoi(sEGID); + Property->EIDS = TRUE; + } else { + Property->EIDS = FALSE; + } + } else { + ClearFlag(Property->Flags2, EXT2_VPROP3_USERIDS); + } } NTSTATUS @@ -2107,7 +2133,7 @@ if (NT_SUCCESS(Status)) { /* set Vcb settings from registery */ - EXT2_VOLUME_PROPERTY2 Property; + EXT2_VOLUME_PROPERTY3 Property; Ext2ParseRegistryVolumeParams(&VolumeParams, &Property); Ext2ProcessVolumeProperty(Vcb, &Property, sizeof(Property)); @@ -2141,7 +2167,7 @@ memcpy(Vcb->Codepage.AnsiName, Ext2Global->Codepage.AnsiName, CODEPAGE_MAXLEN); Vcb->Codepage.PageTable = Ext2Global->Codepage.PageTable; - if ((Vcb->bHidingPrefix = Ext2Global->bHidingPrefix) != 0) { + if (Vcb->bHidingPrefix == Ext2Global->bHidingPrefix) { RtlCopyMemory( Vcb->sHidingPrefix, Ext2Global->sHidingPrefix, HIDINGPAT_LEN); @@ -2150,7 +2176,7 @@ HIDINGPAT_LEN); } - if ((Vcb->bHidingSuffix = Ext2Global->bHidingSuffix) != 0) { + if (Vcb->bHidingSuffix == Ext2Global->bHidingSuffix) { RtlCopyMemory( Vcb->sHidingSuffix, Ext2Global->sHidingSuffix, HIDINGPAT_LEN); @@ -2247,6 +2273,7 @@ BOOLEAN NotifySyncInitialized = FALSE; BOOLEAN ExtentsInitialized = FALSE; BOOLEAN InodeLookasideInitialized = FALSE; + BOOLEAN GroupLoaded = FALSE; _SEH2_TRY { @@ -2293,8 +2320,10 @@ /* initialize eresources */ ExInitializeResourceLite(&Vcb->MainResource); ExInitializeResourceLite(&Vcb->PagingIoResource); - ExInitializeResourceLite(&Vcb->MetaLock); + ExInitializeResourceLite(&Vcb->MetaInode); + ExInitializeResourceLite(&Vcb->MetaBlock); ExInitializeResourceLite(&Vcb->McbLock); + ExInitializeResourceLite(&Vcb->sbi.s_gd_lock); #ifndef _WIN2K_TARGET_ ExInitializeFastMutex(&Vcb->Mutex); FsRtlSetupAdvancedHeader(&Vcb->Header, &Vcb->Mutex); @@ -2367,15 +2396,7 @@ /* initialize UUID and serial number */ if (Ext2IsNullUuid(sb->s_uuid)) { ExUuidCreate((UUID *)sb->s_uuid); - } else { - /* query parameters from registry */ - if (!NT_SUCCESS(Ext2PerformRegistryVolumeParams(Vcb))) { - /* don't mount this volume */ - Status = STATUS_UNRECOGNIZED_VOLUME; - _SEH2_LEAVE; - } } - Vpb->SerialNumber = ((ULONG*)sb->s_uuid)[0] + ((ULONG*)sb->s_uuid)[1] + ((ULONG*)sb->s_uuid)[2] + @@ -2471,7 +2492,10 @@ Vcb->bd.bd_volume = Vcb->Volume; Vcb->bd.bd_priv = (void *) Vcb; memset(&Vcb->bd.bd_bh_root, 0, sizeof(struct rb_root)); - spin_lock_init(&Vcb->bd.bd_bh_lock); + InitializeListHead(&Vcb->bd.bd_bh_free); + ExInitializeResourceLite(&Vcb->bd.bd_bh_lock); + KeInitializeEvent(&Vcb->bd.bd_bh_notify, + NotificationEvent, TRUE); Vcb->bd.bd_bh_cache = kmem_cache_create("bd_bh_buffer", Vcb->BlockSize, 0, 0, NULL); if (!Vcb->bd.bd_bh_cache) { @@ -2600,6 +2624,7 @@ Status = STATUS_UNSUCCESSFUL; _SEH2_LEAVE; } + GroupLoaded = TRUE; /* recovery journal since it's ext3 */ if (Vcb->IsExt3fs) { @@ -2656,6 +2681,10 @@ /* get anything doen, then refer target device */ ObReferenceObject(Vcb->TargetDeviceObject); + + /* query parameters from registry */ + Ext2PerformRegistryVolumeParams(Vcb); + SetLongFlag(Vcb->Flags, VCB_INITIALIZED); } _SEH2_FINALLY { @@ -2671,9 +2700,11 @@ } if (ExtentsInitialized) { - Ext2DropGroup(Vcb); - if (Vcb->bd.bd_bh_cache) + if (Vcb->bd.bd_bh_cache) { + if (GroupLoaded) + Ext2PutGroup(Vcb); kmem_cache_destroy(Vcb->bd.bd_bh_cache); + } FsRtlUninitializeLargeMcb(&(Vcb->Extents)); } @@ -2690,7 +2721,9 @@ if (VcbResourceInitialized) { ExDeleteResourceLite(&Vcb->McbLock); - ExDeleteResourceLite(&Vcb->MetaLock); + ExDeleteResourceLite(&Vcb->MetaInode); + ExDeleteResourceLite(&Vcb->MetaBlock); + ExDeleteResourceLite(&Vcb->sbi.s_gd_lock); ExDeleteResourceLite(&Vcb->MainResource); ExDeleteResourceLite(&Vcb->PagingIoResource); } @@ -2752,6 +2785,7 @@ if (Vcb->bd.bd_bh_cache) kmem_cache_destroy(Vcb->bd.bd_bh_cache); + ExDeleteResourceLite(&Vcb->bd.bd_bh_lock); if (Vcb->SuperBlock) { Ext2FreePool(Vcb->SuperBlock, EXT2_SB_MAGIC); @@ -2770,7 +2804,9 @@ ExDeleteNPagedLookasideList(&(Vcb->InodeLookasideList)); ExDeleteResourceLite(&Vcb->McbLock); - ExDeleteResourceLite(&Vcb->MetaLock); + ExDeleteResourceLite(&Vcb->MetaInode); + ExDeleteResourceLite(&Vcb->MetaBlock); + ExDeleteResourceLite(&Vcb->sbi.s_gd_lock); ExDeleteResourceLite(&Vcb->PagingIoResource); ExDeleteResourceLite(&Vcb->MainResource); @@ -2935,16 +2971,11 @@ /* Reaper thread to release unused Mcb blocks */ VOID NTAPI -Ext2ReaperThread( +Ext2McbReaperThread( PVOID Context ) { - BOOLEAN GlobalAcquired = FALSE; - - BOOLEAN DidNothing = TRUE; - BOOLEAN LastState = TRUE; - BOOLEAN WaitLock; - + PEXT2_REAPER Reaper = Context; PLIST_ENTRY List = NULL; LARGE_INTEGER Timeout; @@ -2953,13 +2984,19 @@ ULONG i, NumOfMcbs; + BOOLEAN GlobalAcquired = FALSE; + + BOOLEAN DidNothing = TRUE; + BOOLEAN LastState = TRUE; + BOOLEAN WaitLock; + _SEH2_TRY { /* wake up DirverEntry */ - KeSetEvent(&Ext2Global->Reaper.Engine, 0, FALSE); + KeSetEvent(&Reaper->Engine, 0, FALSE); /* now process looping */ - while (TRUE) { + while (!IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP)) { WaitLock = FALSE; @@ -3002,7 +3039,7 @@ /* wait until it is waken or it times out */ KeWaitForSingleObject( - &(Ext2Global->Reaper.Wait), + &Reaper->Wait, Executive, KernelMode, FALSE, @@ -3009,6 +3046,9 @@ &Timeout ); + if (IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP)) + break; + DidNothing = TRUE; /* acquire global exclusive lock */ @@ -3047,6 +3087,8 @@ if (GlobalAcquired) { ExReleaseResourceLite(&Ext2Global->Resource); } + + KeSetEvent(&Reaper->Engine, 0, FALSE); } _SEH2_END; PsTerminateSystemThread(STATUS_SUCCESS); @@ -3053,19 +3095,153 @@ } +/* get the first Mcb record in Vcb->McbList */ + +BOOLEAN +Ext2QueryUnusedBH(PEXT2_VCB Vcb, PLIST_ENTRY head) +{ + struct buffer_head *bh = NULL; + PLIST_ENTRY list = NULL; + LARGE_INTEGER now; + BOOLEAN wake = FALSE; + + KeQuerySystemTime(&now); + + ExAcquireResourceExclusiveLite(&Vcb->bd.bd_bh_lock, TRUE); + while (!IsListEmpty(&Vcb->bd.bd_bh_free)) { + list = RemoveHeadList(&Vcb->bd.bd_bh_free); + bh = CONTAINING_RECORD(list, struct buffer_head, b_link); + if (atomic_read(&bh->b_count)) { + InitializeListHead(&bh->b_link); + continue; + } + + if ( IsFlagOn(Vcb->Flags, VCB_BEING_DROPPED) || + (bh->b_ts_drop.QuadPart + (LONGLONG)10*1000*1000*15) > now.QuadPart || + (bh->b_ts_creat.QuadPart + (LONGLONG)10*1000*1000*180) > now.QuadPart) { + InsertTailList(head, &bh->b_link); + } else { + InsertHeadList(&Vcb->bd.bd_bh_free, &bh->b_link); + break; + } + } + wake = IsListEmpty(&Vcb->bd.bd_bh_free); + ExReleaseResourceLite(&Vcb->bd.bd_bh_lock); + + if (wake) + KeSetEvent(&Vcb->bd.bd_bh_notify, 0, FALSE); + + return IsFlagOn(Vcb->Flags, VCB_BEING_DROPPED); +} + + +/* Reaper thread to release unused buffer heads */ +VOID +NTAPI +Ext2bhReaperThread( + PVOID Context +) +{ + PEXT2_REAPER Reaper = Context; + PEXT2_VCB Vcb = NULL; + LIST_ENTRY List, *Link; + LARGE_INTEGER Timeout; + + BOOLEAN GlobalAcquired = FALSE; + BOOLEAN DidNothing = FALSE; + BOOLEAN NonWait = FALSE; + + _SEH2_TRY { + + /* wake up DirverEntry */ + KeSetEvent(&Reaper->Engine, 0, FALSE); + + /* now process looping */ + while (!IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP)) { + + /* wait until it is waken or it times out */ + if (NonWait) { + Timeout.QuadPart = (LONGLONG)-10*1000*10; + NonWait = FALSE; + } else if (DidNothing) { + Timeout.QuadPart = Timeout.QuadPart * 2; + } else { + Timeout.QuadPart = (LONGLONG)-10*1000*1000*10; /* 10 seconds */ + } + KeWaitForSingleObject( + &Reaper->Wait, + Executive, + KernelMode, + FALSE, + &Timeout + ); + + if (IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP)) + break; + + InitializeListHead(&List); + + /* acquire global exclusive lock */ + ExAcquireResourceSharedLite(&Ext2Global->Resource, TRUE); + GlobalAcquired = TRUE; + /* search all Vcb to get unused resources freed to system */ + for (Link = Ext2Global->VcbList.Flink; + Link != &(Ext2Global->VcbList); + Link = Link->Flink ) { + + Vcb = CONTAINING_RECORD(Link, EXT2_VCB, Next); + if (Ext2QueryUnusedBH(Vcb, &List)) + NonWait = TRUE; + } + if (GlobalAcquired) { + ExReleaseResourceLite(&Ext2Global->Resource); + GlobalAcquired = FALSE; + } + + DidNothing = IsListEmpty(&List); + while (!IsListEmpty(&List)) { + struct buffer_head *bh; + Link = RemoveHeadList(&List); + bh = CONTAINING_RECORD(Link, struct buffer_head, b_link); + ASSERT(0 == atomic_read(&bh->b_count)); + free_buffer_head(bh); + } + } + + } _SEH2_FINALLY { + + if (GlobalAcquired) { + ExReleaseResourceLite(&Ext2Global->Resource); + } + + KeSetEvent(&Reaper->Engine, 0, FALSE); + } _SEH2_END; + + PsTerminateSystemThread(STATUS_SUCCESS); +} + NTSTATUS -Ext2StartReaperThread() +Ext2StartReaper(PEXT2_REAPER Reaper, EXT2_REAPER_RELEASE Free) { NTSTATUS status = STATUS_SUCCESS; OBJECT_ATTRIBUTES oa; HANDLE handle = 0; + LARGE_INTEGER timeout; + Reaper->Free = Free; + /* initialize wait event */ KeInitializeEvent( - &Ext2Global->Reaper.Wait, + &Reaper->Wait, SynchronizationEvent, FALSE ); + /* Reaper thread engine event */ + KeInitializeEvent( + &Reaper->Engine, + SynchronizationEvent, FALSE + ); + /* initialize oa */ InitializeObjectAttributes( &oa, @@ -3083,13 +3259,46 @@ &oa, NULL, NULL, - Ext2ReaperThread, - NULL + Free, + (PVOID)Reaper ); if (NT_SUCCESS(status)) { ZwClose(handle); + + /* make sure Reaperthread is started */ + timeout.QuadPart = (LONGLONG)-10*1000*1000*2; /* 2 seconds */ + status = KeWaitForSingleObject( + &Reaper->Engine, + Executive, + KernelMode, + FALSE, + &timeout + ); + if (status != STATUS_SUCCESS) { + status = STATUS_INSUFFICIENT_RESOURCES; + } } return status; } + + +VOID +NTAPI +Ext2StopReaper(PEXT2_REAPER Reaper) +{ + LARGE_INTEGER timeout; + + Reaper->Flags |= EXT2_REAPER_FLAG_STOP; + KeSetEvent(&Reaper->Wait, 0, FALSE); + + /* make sure Reaperthread is started */ + timeout.QuadPart = (LONGLONG)-10*1000*1000*2; /* 2 seconds */ + KeWaitForSingleObject( + &Reaper->Engine, + Executive, + KernelMode, + FALSE, + &timeout); +} Index: drivers/filesystems/ext2/src/read.c =================================================================== --- drivers/filesystems/ext2/src/read.c (révision 71375) +++ drivers/filesystems/ext2/src/read.c (copie de travail) @@ -582,7 +582,7 @@ } else { - if (Nocache) { + if (Nocache && Ccb != NULL && Fcb->SectionObject.DataSectionObject) { if (!ExAcquireResourceExclusiveLite( &Fcb->MainResource, @@ -592,15 +592,24 @@ } MainResourceAcquired = TRUE; - if (FileObject->SectionObjectPointer->DataSectionObject != NULL) { - CcFlushCache( FileObject->SectionObjectPointer, - &ByteOffset, - Length, - &Irp->IoStatus ); - if (!NT_SUCCESS(Irp->IoStatus.Status)) - _SEH2_LEAVE; + CcFlushCache(&Fcb->SectionObject, + &ByteOffset, + Length, + &Irp->IoStatus ); + if (!NT_SUCCESS(Irp->IoStatus.Status)) + _SEH2_LEAVE; + ClearLongFlag(Fcb->Flags, FCB_FILE_MODIFIED); + + if (ExAcquireResourceExclusiveLite(&(Fcb->PagingIoResource), TRUE)) { + ExReleaseResourceLite(&(Fcb->PagingIoResource)); } + CcPurgeCacheSection( &Fcb->SectionObject, + NULL, + 0, + FALSE ); + ExConvertExclusiveToShared(&Fcb->MainResource); + } else { if (!ExAcquireResourceSharedLite( Index: drivers/filesystems/ext2/src/write.c =================================================================== --- drivers/filesystems/ext2/src/write.c (révision 71375) +++ drivers/filesystems/ext2/src/write.c (copie de travail) @@ -936,6 +936,11 @@ } else { + if (!Ext2CheckFileAccess(Vcb, Fcb->Mcb, Ext2FileCanWrite)) { + Status = STATUS_ACCESS_DENIED; + _SEH2_LEAVE; + } + if (IsDirectory(Fcb)) { _SEH2_LEAVE; }