Ros-diffs December 2017

ros-diffs@reactos.org

26 participants
355 discussions

[reactos] 23/72: [NTFS] Add some fixes to attrib.c, as suggested by Pierre Schweitzer: *ConvertLargeMCBToDataRuns() - Use MS portable type, ULONG, for variable i. *FreeClusters(), AddRun() - Check for invalid parameter before allocating memory, and confirm the memory is allocated. *ConvertDataRunsToLargeMCB(), AddRun() - Avoid code duplication by using ExRaiseStatus() in try block, and return accurate status via _SEH2_GetExceptionCode().

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8b893c8e30a6ea0fa46f7… commit 8b893c8e30a6ea0fa46f745810f6c6d2eb6f6feb Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Mon Aug 22 08:11:12 2016 +0000 [NTFS] Add some fixes to attrib.c, as suggested by Pierre Schweitzer: *ConvertLargeMCBToDataRuns() - Use MS portable type, ULONG, for variable i. *FreeClusters(), AddRun() - Check for invalid parameter before allocating memory, and confirm the memory is allocated. *ConvertDataRunsToLargeMCB(), AddRun() - Avoid code duplication by using ExRaiseStatus() in try block, and return accurate status via _SEH2_GetExceptionCode(). svn path=/branches/GSoC_2016/NTFS/; revision=72422 --- drivers/filesystems/ntfs/attrib.c | 39 +++++++++++++++++++++++++-------------- 1 file changed, 25 insertions(+), 14 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 61f2d6fa7a..b65a6b8b50 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -62,7 +62,9 @@ * * @return * STATUS_SUCCESS on success. STATUS_INVALID_PARAMETER if AttrContext describes a resident attribute. -* STATUS_INSUFFICIENT_RESOURCES if ConvertDataRunsToLargeMCB() fails. +* STATUS_INSUFFICIENT_RESOURCES if ConvertDataRunsToLargeMCB() fails or if we fail to allocate a +* buffer for the new data runs. +* STATUS_INSUFFICIENT_RESOURCES or STATUS_UNSUCCESSFUL if FsRtlAddLargeMcbEntry() fails. * STATUS_BUFFER_TOO_SMALL if ConvertLargeMCBToDataRuns() fails. * STATUS_NOT_IMPLEMENTED if we need to migrate the attribute to an attribute list (TODO). * @@ -95,6 +97,11 @@ AddRun(PNTFS_VCB Vcb, return STATUS_INVALID_PARAMETER; RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + if (!RunBuffer) + { + DPRINT1("ERROR: Couldn't allocate memory for data runs!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } // Convert the data runs to a map control block Status = ConvertDataRunsToLargeMCB(DataRun, &DataRunsMCB, &NextVBN); @@ -112,14 +119,12 @@ AddRun(PNTFS_VCB Vcb, NextAssignedCluster, RunLength)) { - FsRtlUninitializeLargeMcb(&DataRunsMCB); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); - return STATUS_INSUFFICIENT_RESOURCES; + ExRaiseStatus(STATUS_UNSUCCESSFUL); } } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { FsRtlUninitializeLargeMcb(&DataRunsMCB); ExFreePoolWithTag(RunBuffer, TAG_NTFS); - _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES); + _SEH2_YIELD(_SEH2_GetExceptionCode()); } _SEH2_END; @@ -200,7 +205,7 @@ AddRun(PNTFS_VCB Vcb, * Pointer to an unitialized LARGE_MCB structure. * * @return -* STATUS_SUCCESS on success, STATUS_INSUFFICIENT_RESOURCES if we fail to +* STATUS_SUCCESS on success, STATUS_INSUFFICIENT_RESOURCES or STATUS_UNSUCCESSFUL if we fail to * initialize the mcb or add an entry. * * @remarks @@ -223,7 +228,7 @@ ConvertDataRunsToLargeMCB(PUCHAR DataRun, _SEH2_TRY{ FsRtlInitializeLargeMcb(DataRunsMCB, NonPagedPool); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { - _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES); + _SEH2_YIELD(return _SEH2_GetExceptionCode()); } _SEH2_END; while (*DataRun != 0) @@ -242,12 +247,11 @@ ConvertDataRunsToLargeMCB(PUCHAR DataRun, DataRunStartLCN, DataRunLength)) { - FsRtlUninitializeLargeMcb(DataRunsMCB); - return STATUS_INSUFFICIENT_RESOURCES; + ExRaiseStatus(STATUS_UNSUCCESSFUL); } } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { FsRtlUninitializeLargeMcb(DataRunsMCB); - _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES); + _SEH2_YIELD(return _SEH2_GetExceptionCode()); } _SEH2_END; } @@ -292,7 +296,7 @@ ConvertLargeMCBToDataRuns(PLARGE_MCB DataRunsMCB, LONGLONG DataRunOffset; ULONGLONG LastLCN = 0; LONGLONG Vbn, Lbn, Count; - int i; + ULONG i; DPRINT("\t[Vbn, Lbn, Count]\n"); @@ -436,7 +440,8 @@ FindRun(PNTFS_ATTR_RECORD NresAttr, * @return * STATUS_SUCCESS on success. STATUS_INVALID_PARAMETER if AttrContext describes a resident attribute, * or if the caller requested more clusters be freed than the attribute has been allocated. -* STATUS_INSUFFICIENT_RESOURCES if ConvertDataRunsToLargeMCB() fails. +* STATUS_INSUFFICIENT_RESOURCES if allocating a buffer for the data runs fails or +* if ConvertDataRunsToLargeMCB() fails. * STATUS_BUFFER_TOO_SMALL if ConvertLargeMCBToDataRuns() fails. * * @@ -460,7 +465,7 @@ FreeClusters(PNTFS_VCB Vcb, ULONGLONG NextVBN = AttrContext->Record.NonResident.LowestVCN; // Allocate some memory for the RunBuffer - PUCHAR RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + PUCHAR RunBuffer; ULONG RunBufferOffset = 0; PFILE_RECORD_HEADER BitmapRecord; @@ -472,10 +477,16 @@ FreeClusters(PNTFS_VCB Vcb, if (!AttrContext->Record.IsNonResident) { - ExFreePoolWithTag(RunBuffer, TAG_NTFS); return STATUS_INVALID_PARAMETER; } + RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + if (!RunBuffer) + { + DPRINT1("ERROR: Couldn't allocate memory for data runs!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + // Convert the data runs to a map control block Status = ConvertDataRunsToLargeMCB(DataRun, &DataRunsMCB, &NextVBN); if (!NT_SUCCESS(Status))

7 years

[reactos] 22/72: [NTFS] +FreeClusters(). Fix a DPRINT.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=920e2f02161f08274a271… commit 920e2f02161f08274a27186b3dfa2e27e16203ad Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Tue Jul 19 15:31:22 2016 +0000 [NTFS] +FreeClusters(). Fix a DPRINT. svn path=/branches/GSoC_2016/NTFS/; revision=71968 --- drivers/filesystems/ntfs/attrib.c | 202 ++++++++++++++++++++++++++++++++++++++ drivers/filesystems/ntfs/mft.c | 18 ++-- drivers/filesystems/ntfs/ntfs.h | 7 ++ 3 files changed, 215 insertions(+), 12 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index e0c41fa0e4..61f2d6fa7a 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -409,6 +409,208 @@ FindRun(PNTFS_ATTR_RECORD NresAttr, return TRUE; } +/** +* @name FreeClusters +* @implemented +* +* Shrinks the allocation size of a non-resident attribute by a given number of clusters. +* Frees the clusters from the volume's $BITMAP file as well as the attribute's data runs. +* +* @param Vcb +* Pointer to an NTFS_VCB for the destination volume. +* +* @param AttrContext +* Pointer to an NTFS_ATTR_CONTEXT describing the attribute from which the clusters will be freed. +* +* @param AttrOffset +* Byte offset of the destination attribute relative to its file record. +* +* @param FileRecord +* Pointer to a complete copy of the file record containing the attribute. Must be at least +* Vcb->NtfsInfo.BytesPerFileRecord bytes long. +* +* @param ClustersToFree +* Number of clusters that should be freed from the end of the data stream. Must be no more +* Than the number of clusters assigned to the attribute (HighestVCN + 1). +* +* @return +* STATUS_SUCCESS on success. STATUS_INVALID_PARAMETER if AttrContext describes a resident attribute, +* or if the caller requested more clusters be freed than the attribute has been allocated. +* STATUS_INSUFFICIENT_RESOURCES if ConvertDataRunsToLargeMCB() fails. +* STATUS_BUFFER_TOO_SMALL if ConvertLargeMCBToDataRuns() fails. +* +* +*/ +NTSTATUS +FreeClusters(PNTFS_VCB Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + ULONG ClustersToFree) +{ + NTSTATUS Status = STATUS_SUCCESS; + ULONG ClustersLeftToFree = ClustersToFree; + + // convert data runs to mcb + PUCHAR DataRun = (PUCHAR)&AttrContext->Record + AttrContext->Record.NonResident.MappingPairsOffset; + PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); + LARGE_MCB DataRunsMCB; + ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; + PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); + ULONGLONG NextVBN = AttrContext->Record.NonResident.LowestVCN; + + // Allocate some memory for the RunBuffer + PUCHAR RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + ULONG RunBufferOffset = 0; + + PFILE_RECORD_HEADER BitmapRecord; + PNTFS_ATTR_CONTEXT DataContext; + ULONGLONG BitmapDataSize; + PUCHAR BitmapData; + RTL_BITMAP Bitmap; + ULONG LengthWritten; + + if (!AttrContext->Record.IsNonResident) + { + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return STATUS_INVALID_PARAMETER; + } + + // Convert the data runs to a map control block + Status = ConvertDataRunsToLargeMCB(DataRun, &DataRunsMCB, &NextVBN); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Unable to convert data runs to MCB (probably ran out of memory)!\n"); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return Status; + } + + BitmapRecord = ExAllocatePoolWithTag(NonPagedPool, + Vcb->NtfsInfo.BytesPerFileRecord, + TAG_NTFS); + if (BitmapRecord == NULL) + { + DPRINT1("Error: Unable to allocate memory for bitmap file record!\n"); + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return STATUS_NO_MEMORY; + } + + Status = ReadFileRecord(Vcb, NTFS_FILE_BITMAP, BitmapRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Error: Unable to read file record for bitmap!\n"); + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(BitmapRecord, TAG_NTFS); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return 0; + } + + Status = FindAttribute(Vcb, BitmapRecord, AttributeData, L"", 0, &DataContext, NULL); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Error: Unable to find data attribute for bitmap file!\n"); + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(BitmapRecord, TAG_NTFS); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return 0; + } + + BitmapDataSize = AttributeDataLength(&DataContext->Record); + BitmapDataSize = min(BitmapDataSize, 0xffffffff); + ASSERT((BitmapDataSize * 8) >= Vcb->NtfsInfo.ClusterCount); + BitmapData = ExAllocatePoolWithTag(NonPagedPool, ROUND_UP(BitmapDataSize, Vcb->NtfsInfo.BytesPerSector), TAG_NTFS); + if (BitmapData == NULL) + { + DPRINT1("Error: Unable to allocate memory for bitmap file data!\n"); + ReleaseAttributeContext(DataContext); + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(BitmapRecord, TAG_NTFS); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return 0; + } + + ReadAttribute(Vcb, DataContext, 0, (PCHAR)BitmapData, (ULONG)BitmapDataSize); + + RtlInitializeBitMap(&Bitmap, (PULONG)BitmapData, Vcb->NtfsInfo.ClusterCount); + + // free clusters in $BITMAP file + while (ClustersLeftToFree > 0) + { + LONGLONG LargeVbn, LargeLbn; + + if (!FsRtlLookupLastLargeMcbEntry(&DataRunsMCB, &LargeVbn, &LargeLbn)) + { + Status = STATUS_INVALID_PARAMETER; + DPRINT1("DRIVER ERROR: FreeClusters called to free %lu clusters, which is %lu more clusters than are assigned to attribute!", + ClustersToFree, + ClustersLeftToFree); + break; + } + + if( LargeLbn != -1) + { + // deallocate this cluster + RtlClearBits(&Bitmap, LargeLbn, 1); + } + FsRtlTruncateLargeMcb(&DataRunsMCB, AttrContext->Record.NonResident.HighestVCN); + AttrContext->Record.NonResident.HighestVCN = min(AttrContext->Record.NonResident.HighestVCN, AttrContext->Record.NonResident.HighestVCN - 1); + ClustersLeftToFree--; + } + + // update $BITMAP file on disk + Status = WriteAttribute(Vcb, DataContext, 0, BitmapData, (ULONG)BitmapDataSize, &LengthWritten); + if (!NT_SUCCESS(Status)) + { + ReleaseAttributeContext(DataContext); + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ExFreePoolWithTag(BitmapRecord, TAG_NTFS); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return Status; + } + + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ExFreePoolWithTag(BitmapRecord, TAG_NTFS); + + // Convert the map control block back to encoded data runs + ConvertLargeMCBToDataRuns(&DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferOffset); + + // Update HighestVCN + DestinationAttribute->NonResident.HighestVCN = AttrContext->Record.NonResident.HighestVCN; + + // Write data runs to destination attribute + RtlCopyMemory((PVOID)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), + RunBuffer, + RunBufferOffset); + + if (NextAttribute->Type == AttributeEnd) + { + // update attribute length + AttrContext->Record.Length = ALIGN_UP_BY(AttrContext->Record.NonResident.MappingPairsOffset + RunBufferOffset, 8); + DestinationAttribute->Length = AttrContext->Record.Length; + + // write end markers + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); + NextAttribute->Type = AttributeEnd; + NextAttribute->Length = FILE_RECORD_END; + + // update file record length + FileRecord->BytesInUse = AttrOffset + DestinationAttribute->Length + (sizeof(ULONG) * 2); + } + + // Update the file record + Status = UpdateFileRecord(Vcb, AttrContext->FileMFTIndex, FileRecord); + + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + + NtfsDumpDataRuns((PUCHAR)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), 0); + + return Status; +} + static NTSTATUS InternalReadNonResidentAttributes(PFIND_ATTR_CONTXT Context) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 7b3dcb8d37..f3ac3182dc 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -225,6 +225,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, PLARGE_INTEGER DataSize) { NTSTATUS Status = STATUS_SUCCESS; + ULONG BytesPerCluster = Fcb->Vcb->NtfsInfo.BytesPerCluster; // are we truncating the file? if (DataSize->QuadPart < AttributeDataLength(&AttrContext->Record)) @@ -238,14 +239,13 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, if (AttrContext->Record.IsNonResident) { - ULONG BytesPerCluster = Fcb->Vcb->NtfsInfo.BytesPerCluster; ULONGLONG AllocationSize = ROUND_UP(DataSize->QuadPart, BytesPerCluster); PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); + ULONG ExistingClusters = AttrContext->Record.NonResident.AllocatedSize / BytesPerCluster; // do we need to increase the allocation size? if (AttrContext->Record.NonResident.AllocatedSize < AllocationSize) { - ULONG ExistingClusters = AttrContext->Record.NonResident.AllocatedSize / BytesPerCluster; ULONG ClustersNeeded = (AllocationSize / BytesPerCluster) - ExistingClusters; LARGE_INTEGER LastClusterInDataRun; ULONG NextAssignedCluster; @@ -284,15 +284,9 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, } else if (AttrContext->Record.NonResident.AllocatedSize > AllocationSize) { - // shrink allocation size (TODO) - if (AllocationSize == 0) - { - // hack for notepad.exe - PUCHAR DataRuns = (PUCHAR)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset); - *DataRuns = 0; - DestinationAttribute->NonResident.HighestVCN = - AttrContext->Record.NonResident.HighestVCN = 0; - } + // shrink allocation size + ULONG ClustersToFree = ExistingClusters - (AllocationSize / BytesPerCluster); + Status = FreeClusters(Fcb->Vcb, AttrContext, AttrOffset, FileRecord, ClustersToFree); } // TODO: is the file compressed, encrypted, or sparse? @@ -1098,7 +1092,7 @@ UpdateFileRecord(PDEVICE_EXTENSION Vcb, if (!NT_SUCCESS(Status)) { - DPRINT1("UpdateFileRecord failed: %I64u written, %u expected\n", BytesWritten, Vcb->NtfsInfo.BytesPerFileRecord); + DPRINT1("UpdateFileRecord failed: %I64u written, %lu expected\n", BytesWritten, Vcb->NtfsInfo.BytesPerFileRecord); } // remove the fixup array (so the file record pointer can still be used) diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index bc6a8d9089..29a6c2af00 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -584,6 +584,13 @@ FindNextAttribute(PFIND_ATTR_CONTXT Context, VOID FindCloseAttribute(PFIND_ATTR_CONTXT Context); +NTSTATUS +FreeClusters(PNTFS_VCB Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + ULONG ClustersToFree); + /* blockdev.c */ NTSTATUS

7 years

[reactos] 21/72: [NTFS] Address some minor issues with attrib.c: Fix gcc build. Fix formatting.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ed1b4bf9bc62b44408fda… commit ed1b4bf9bc62b44408fda66f3cbfb427b2e5cdab Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun Jul 17 14:04:01 2016 +0000 [NTFS] Address some minor issues with attrib.c: Fix gcc build. Fix formatting. svn path=/branches/GSoC_2016/NTFS/; revision=71957 --- drivers/filesystems/ntfs/attrib.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 61d8c8ab8f..e0c41fa0e4 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -89,7 +89,7 @@ AddRun(PNTFS_VCB Vcb, // Allocate some memory for the RunBuffer PUCHAR RunBuffer; - int RunBufferOffset = 0; + ULONG RunBufferOffset = 0; if (!AttrContext->Record.IsNonResident) return STATUS_INVALID_PARAMETER; @@ -108,7 +108,7 @@ AddRun(PNTFS_VCB Vcb, // Add newly-assigned clusters to mcb _SEH2_TRY{ if (!FsRtlAddLargeMcbEntry(&DataRunsMCB, - NextVBN, + NextVBN, NextAssignedCluster, RunLength)) { @@ -217,8 +217,6 @@ ConvertDataRunsToLargeMCB(PUCHAR DataRun, LONGLONG DataRunOffset; ULONGLONG DataRunLength; LONGLONG DataRunStartLCN; - ULONGLONG NextCluster; - ULONGLONG LastLCN = 0; // Initialize the MCB, potentially catch an exception @@ -237,8 +235,6 @@ ConvertDataRunsToLargeMCB(PUCHAR DataRun, // Normal data run. DataRunStartLCN = LastLCN + DataRunOffset; LastLCN = DataRunStartLCN; - NextCluster = LastLCN + DataRunLength; - _SEH2_TRY{ if (!FsRtlAddLargeMcbEntry(DataRunsMCB, @@ -295,14 +291,14 @@ ConvertLargeMCBToDataRuns(PLARGE_MCB DataRunsMCB, ULONG RunBufferOffset = 0; LONGLONG DataRunOffset; ULONGLONG LastLCN = 0; - LONGLONG Vbn, Lbn, Count; + int i; DPRINT("\t[Vbn, Lbn, Count]\n"); // convert each mcb entry to a data run - for (int i = 0; FsRtlGetNextLargeMcbEntry(DataRunsMCB, i, &Vbn, &Lbn, &Count); i++) + for (i = 0; FsRtlGetNextLargeMcbEntry(DataRunsMCB, i, &Vbn, &Lbn, &Count); i++) { UCHAR DataRunOffsetSize = 0; UCHAR DataRunLengthSize = 0;

7 years

[reactos] 20/72: [NTFS] *AddRun() - Don't leak RunBuffer when encountering errors. Handle exception from FsRtlAddLargeMcbEntry().

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d09e1398f83d71a7940ed… commit d09e1398f83d71a7940ed02ee68e63fff2756cbc Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Jul 15 15:27:04 2016 +0000 [NTFS] *AddRun() - Don't leak RunBuffer when encountering errors. Handle exception from FsRtlAddLargeMcbEntry(). svn path=/branches/GSoC_2016/NTFS/; revision=71945 --- drivers/filesystems/ntfs/attrib.c | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 3cf40d8341..61d8c8ab8f 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -88,25 +88,40 @@ AddRun(PNTFS_VCB Vcb, ULONGLONG NextVBN = AttrContext->Record.NonResident.LowestVCN; // Allocate some memory for the RunBuffer - PUCHAR RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + PUCHAR RunBuffer; int RunBufferOffset = 0; if (!AttrContext->Record.IsNonResident) return STATUS_INVALID_PARAMETER; + RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + // Convert the data runs to a map control block Status = ConvertDataRunsToLargeMCB(DataRun, &DataRunsMCB, &NextVBN); if (!NT_SUCCESS(Status)) { DPRINT1("Unable to convert data runs to MCB (probably ran out of memory)!\n"); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); return Status; } // Add newly-assigned clusters to mcb - FsRtlAddLargeMcbEntry(&DataRunsMCB, - NextVBN, - NextAssignedCluster, - RunLength); + _SEH2_TRY{ + if (!FsRtlAddLargeMcbEntry(&DataRunsMCB, + NextVBN, + NextAssignedCluster, + RunLength)) + { + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + return STATUS_INSUFFICIENT_RESOURCES; + } + } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { + FsRtlUninitializeLargeMcb(&DataRunsMCB); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES); + } _SEH2_END; + // Convert the map control block back to encoded data runs ConvertLargeMCBToDataRuns(&DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferOffset);

7 years

[reactos] 19/72: [NTFS] Implement AddRun(). Add support functions and documentation. +ConvertDataRunsToLargeMCB() +ConvertLargeMCBToDataRuns() *SetAttributeDataLength(), *NtfsWriteFile() - Update for AddRun() implementation. Add hack to SetAttributeDataLength() to allow notepad.exe to save files until freeing clusters is implemented.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=afe40eb054267a365cc6c… commit afe40eb054267a365cc6ca8142f48870a49839ea Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Thu Jul 14 15:20:48 2016 +0000 [NTFS] Implement AddRun(). Add support functions and documentation. +ConvertDataRunsToLargeMCB() +ConvertLargeMCBToDataRuns() *SetAttributeDataLength(), *NtfsWriteFile() - Update for AddRun() implementation. Add hack to SetAttributeDataLength() to allow notepad.exe to save files until freeing clusters is implemented. svn path=/branches/GSoC_2016/NTFS/; revision=71942 --- drivers/filesystems/ntfs/attrib.c | 298 +++++++++++++++++++++++++++++++++++++- drivers/filesystems/ntfs/mft.c | 35 +++-- drivers/filesystems/ntfs/ntfs.h | 16 +- drivers/filesystems/ntfs/rw.c | 16 ++ 4 files changed, 352 insertions(+), 13 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index f34072d8a5..3cf40d8341 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -35,17 +35,309 @@ /* FUNCTIONS ****************************************************************/ +/** +* @name AddRun +* @implemented +* +* Adds a run of allocated clusters to a non-resident attribute. +* +* @param Vcb +* Pointer to an NTFS_VCB for the destination volume. +* +* @param AttrContext +* Pointer to an NTFS_ATTR_CONTEXT describing the destination attribute. +* +* @param AttrOffset +* Byte offset of the destination attribute relative to its file record. +* +* @param FileRecord +* Pointer to a complete copy of the file record containing the destination attribute. Must be at least +* Vcb->NtfsInfo.BytesPerFileRecord bytes long. +* +* @param NextAssignedCluster +* Logical cluster number of the start of the data run being added. +* +* @param RunLength +* How many clusters are in the data run being added. Can't be 0. +* +* @return +* STATUS_SUCCESS on success. STATUS_INVALID_PARAMETER if AttrContext describes a resident attribute. +* STATUS_INSUFFICIENT_RESOURCES if ConvertDataRunsToLargeMCB() fails. +* STATUS_BUFFER_TOO_SMALL if ConvertLargeMCBToDataRuns() fails. +* STATUS_NOT_IMPLEMENTED if we need to migrate the attribute to an attribute list (TODO). +* +* @remarks +* Clusters should have been allocated previously with NtfsAllocateClusters(). +* +* +*/ NTSTATUS -AddRun(PNTFS_ATTR_CONTEXT AttrContext, +AddRun(PNTFS_VCB Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, ULONGLONG NextAssignedCluster, ULONG RunLength) { - UNIMPLEMENTED; + NTSTATUS Status; + PUCHAR DataRun = (PUCHAR)&AttrContext->Record + AttrContext->Record.NonResident.MappingPairsOffset; + int DataRunMaxLength; + PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); + LARGE_MCB DataRunsMCB; + ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; + ULONGLONG NextVBN = AttrContext->Record.NonResident.LowestVCN; + + // Allocate some memory for the RunBuffer + PUCHAR RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + int RunBufferOffset = 0; if (!AttrContext->Record.IsNonResident) return STATUS_INVALID_PARAMETER; - return STATUS_NOT_IMPLEMENTED; + // Convert the data runs to a map control block + Status = ConvertDataRunsToLargeMCB(DataRun, &DataRunsMCB, &NextVBN); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Unable to convert data runs to MCB (probably ran out of memory)!\n"); + return Status; + } + + // Add newly-assigned clusters to mcb + FsRtlAddLargeMcbEntry(&DataRunsMCB, + NextVBN, + NextAssignedCluster, + RunLength); + + // Convert the map control block back to encoded data runs + ConvertLargeMCBToDataRuns(&DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferOffset); + + // Get the amount of free space between the start of the of the first data run and the attribute end + DataRunMaxLength = AttrContext->Record.Length - AttrContext->Record.NonResident.MappingPairsOffset; + + // Do we need to extend the attribute (or convert to attribute list)? + if (DataRunMaxLength < RunBufferOffset) + { + PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); + DataRunMaxLength += Vcb->NtfsInfo.BytesPerFileRecord - NextAttributeOffset - (sizeof(ULONG) * 2); + + // Can we move the end of the attribute? + if (NextAttribute->Type != AttributeEnd || DataRunMaxLength < RunBufferOffset - 1) + { + DPRINT1("FIXME: Need to create attribute list! Max Data Run Length available: %d\n", DataRunMaxLength); + if (NextAttribute->Type != AttributeEnd) + DPRINT1("There's another attribute after this one with type %0xlx\n", NextAttribute->Type); + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + FsRtlUninitializeLargeMcb(&DataRunsMCB); + return STATUS_NOT_IMPLEMENTED; + } + + // calculate position of end markers + NextAttributeOffset = AttrOffset + AttrContext->Record.NonResident.MappingPairsOffset + RunBufferOffset; + NextAttributeOffset = ALIGN_UP_BY(NextAttributeOffset, 8); + + // Write the end markers + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); + NextAttribute->Type = AttributeEnd; + NextAttribute->Length = FILE_RECORD_END; + + // Update the length + DestinationAttribute->Length = NextAttributeOffset - AttrOffset; + AttrContext->Record.Length = DestinationAttribute->Length; + + // We need to increase the FileRecord size + FileRecord->BytesInUse = NextAttributeOffset + (sizeof(ULONG) * 2); + } + + // NOTE: from this point on the original attribute record will contain invalid data in it's runbuffer + // TODO: Elegant fix? Could we free the old Record and allocate a new one without issue? + + // Update HighestVCN + DestinationAttribute->NonResident.HighestVCN = + AttrContext->Record.NonResident.HighestVCN = max(NextVBN - 1 + RunLength, + AttrContext->Record.NonResident.HighestVCN); + + // Write data runs to destination attribute + RtlCopyMemory((PVOID)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), + RunBuffer, + RunBufferOffset); + + // Update the file record + Status = UpdateFileRecord(Vcb, AttrContext->FileMFTIndex, FileRecord); + + ExFreePoolWithTag(RunBuffer, TAG_NTFS); + FsRtlUninitializeLargeMcb(&DataRunsMCB); + + NtfsDumpDataRuns((PUCHAR)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), 0); + + return Status; +} + +/** +* @name ConvertDataRunsToLargeMCB +* @implemented +* +* Converts binary data runs to a map control block. +* +* @param DataRun +* Pointer to the run data +* +* @param DataRunsMCB +* Pointer to an unitialized LARGE_MCB structure. +* +* @return +* STATUS_SUCCESS on success, STATUS_INSUFFICIENT_RESOURCES if we fail to +* initialize the mcb or add an entry. +* +* @remarks +* Initializes the LARGE_MCB pointed to by DataRunsMCB. If this function succeeds, you +* need to call FsRtlUninitializeLargeMcb() when you're done with DataRunsMCB. This +* function will ensure the LargeMCB has been unitialized in case of failure. +* +*/ +NTSTATUS +ConvertDataRunsToLargeMCB(PUCHAR DataRun, + PLARGE_MCB DataRunsMCB, + PULONGLONG pNextVBN) +{ + LONGLONG DataRunOffset; + ULONGLONG DataRunLength; + LONGLONG DataRunStartLCN; + ULONGLONG NextCluster; + + ULONGLONG LastLCN = 0; + + // Initialize the MCB, potentially catch an exception + _SEH2_TRY{ + FsRtlInitializeLargeMcb(DataRunsMCB, NonPagedPool); + } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { + _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES); + } _SEH2_END; + + while (*DataRun != 0) + { + DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength); + + if (DataRunOffset != -1) + { + // Normal data run. + DataRunStartLCN = LastLCN + DataRunOffset; + LastLCN = DataRunStartLCN; + NextCluster = LastLCN + DataRunLength; + + + _SEH2_TRY{ + if (!FsRtlAddLargeMcbEntry(DataRunsMCB, + *pNextVBN, + DataRunStartLCN, + DataRunLength)) + { + FsRtlUninitializeLargeMcb(DataRunsMCB); + return STATUS_INSUFFICIENT_RESOURCES; + } + } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { + FsRtlUninitializeLargeMcb(DataRunsMCB); + _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES); + } _SEH2_END; + + } + + *pNextVBN += DataRunLength; + } + + return STATUS_SUCCESS; +} + +/** +* @name ConvertLargeMCBToDataRuns +* @implemented +* +* Converts a map control block to a series of encoded data runs (used by non-resident attributes). +* +* @param DataRunsMCB +* Pointer to a LARGE_MCB structure describing the data runs. +* +* @param RunBuffer +* Pointer to the buffer that will receive the encoded data runs. +* +* @param MaxBufferSize +* Size of RunBuffer, in bytes. +* +* @param UsedBufferSize +* Pointer to a ULONG that will receive the size of the data runs in bytes. Can't be NULL. +* +* @return +* STATUS_SUCCESS on success, STATUS_BUFFER_TOO_SMALL if RunBuffer is too small to contain the +* complete output. +* +*/ +NTSTATUS +ConvertLargeMCBToDataRuns(PLARGE_MCB DataRunsMCB, + PUCHAR RunBuffer, + ULONG MaxBufferSize, + PULONG UsedBufferSize) +{ + NTSTATUS Status = STATUS_SUCCESS; + ULONG RunBufferOffset = 0; + LONGLONG DataRunOffset; + ULONGLONG LastLCN = 0; + + LONGLONG Vbn, Lbn, Count; + + + DPRINT("\t[Vbn, Lbn, Count]\n"); + + // convert each mcb entry to a data run + for (int i = 0; FsRtlGetNextLargeMcbEntry(DataRunsMCB, i, &Vbn, &Lbn, &Count); i++) + { + UCHAR DataRunOffsetSize = 0; + UCHAR DataRunLengthSize = 0; + UCHAR ControlByte = 0; + + // [vbn, lbn, count] + DPRINT("\t[%I64d, %I64d,%I64d]\n", Vbn, Lbn, Count); + + // TODO: check for holes and convert to sparse runs + DataRunOffset = Lbn - LastLCN; + LastLCN = Lbn; + + // now we need to determine how to represent DataRunOffset with the minimum number of bytes + DPRINT("Determining how many bytes needed to represent %I64x\n", DataRunOffset); + DataRunOffsetSize = GetPackedByteCount(DataRunOffset, TRUE); + DPRINT("%d bytes needed.\n", DataRunOffsetSize); + + // determine how to represent DataRunLengthSize with the minimum number of bytes + DPRINT("Determining how many bytes needed to represent %I64x\n", Count); + DataRunLengthSize = GetPackedByteCount(Count, TRUE); + DPRINT("%d bytes needed.\n", DataRunLengthSize); + + // ensure the next data run + end marker would be > Max buffer size + if (RunBufferOffset + 2 + DataRunLengthSize + DataRunOffsetSize > MaxBufferSize) + { + Status = STATUS_BUFFER_TOO_SMALL; + DPRINT1("FIXME: Ran out of room in buffer for data runs!\n"); + break; + } + + // pack and copy the control byte + ControlByte = (DataRunOffsetSize << 4) + DataRunLengthSize; + RunBuffer[RunBufferOffset++] = ControlByte; + + // copy DataRunLength + RtlCopyMemory(RunBuffer + RunBufferOffset, &Count, DataRunLengthSize); + RunBufferOffset += DataRunLengthSize; + + // copy DataRunOffset + RtlCopyMemory(RunBuffer + RunBufferOffset, &DataRunOffset, DataRunOffsetSize); + RunBufferOffset += DataRunOffsetSize; + } + + // End of data runs + RunBuffer[RunBufferOffset++] = 0; + + *UsedBufferSize = RunBufferOffset; + DPRINT("New Size of DataRuns: %ld\n", *UsedBufferSize); + + return Status; } PUCHAR diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 6263263dc8..7b3dcb8d37 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -211,6 +211,11 @@ InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, FileRecord->BytesInUse = NextAttributeOffset + (sizeof(ULONG) * 2); } +/** +* @parameter FileRecord +* Pointer to a file record. Must be a full record at least +* Fcb->Vcb->NtfsInfo.BytesPerFileRecord bytes large, not just the header. +*/ NTSTATUS SetAttributeDataLength(PFILE_OBJECT FileObject, PNTFS_FCB Fcb, @@ -235,6 +240,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, { ULONG BytesPerCluster = Fcb->Vcb->NtfsInfo.BytesPerCluster; ULONGLONG AllocationSize = ROUND_UP(DataSize->QuadPart, BytesPerCluster); + PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); // do we need to increase the allocation size? if (AttrContext->Record.NonResident.AllocatedSize < AllocationSize) @@ -265,7 +271,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, } // now we need to add the clusters we allocated to the data run - Status = AddRun(AttrContext, NextAssignedCluster, AssignedClusters); + Status = AddRun(Fcb->Vcb, AttrContext, AttrOffset, FileRecord, NextAssignedCluster, AssignedClusters); if (!NT_SUCCESS(Status)) { DPRINT1("Error: Unable to add data run!\n"); @@ -275,23 +281,34 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, ClustersNeeded -= AssignedClusters; LastClusterInDataRun.LowPart = NextAssignedCluster + AssignedClusters - 1; } - - DPRINT1("FixMe: Increasing allocation size is unimplemented!\n"); - return STATUS_NOT_IMPLEMENTED; + } + else if (AttrContext->Record.NonResident.AllocatedSize > AllocationSize) + { + // shrink allocation size (TODO) + if (AllocationSize == 0) + { + // hack for notepad.exe + PUCHAR DataRuns = (PUCHAR)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset); + *DataRuns = 0; + DestinationAttribute->NonResident.HighestVCN = + AttrContext->Record.NonResident.HighestVCN = 0; + } } // TODO: is the file compressed, encrypted, or sparse? // NOTE: we need to have acquired the main resource exclusively, as well as(?) the PagingIoResource - // TODO: update the allocated size on-disk - DPRINT("Allocated Size: %I64u\n", AttrContext->Record.NonResident.AllocatedSize); - + Fcb->RFCB.AllocationSize.QuadPart = AllocationSize; + AttrContext->Record.NonResident.AllocatedSize = AllocationSize; AttrContext->Record.NonResident.DataSize = DataSize->QuadPart; AttrContext->Record.NonResident.InitializedSize = DataSize->QuadPart; - // copy the attribute record back into the FileRecord - RtlCopyMemory((PCHAR)FileRecord + AttrOffset, &AttrContext->Record, AttrContext->Record.Length); + DestinationAttribute->NonResident.AllocatedSize = AllocationSize; + DestinationAttribute->NonResident.DataSize = DataSize->QuadPart; + DestinationAttribute->NonResident.InitializedSize = DataSize->QuadPart; + + DPRINT("Allocated Size: %I64u\n", DestinationAttribute->NonResident.AllocatedSize); } else { diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index f16153012e..bc6a8d9089 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -517,10 +517,24 @@ NtfsMarkIrpContextForQueue(PNTFS_IRP_CONTEXT IrpContext) //NtfsDumpAttribute(PATTRIBUTE Attribute); NTSTATUS -AddRun(PNTFS_ATTR_CONTEXT AttrContext, +AddRun(PNTFS_VCB Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, ULONGLONG NextAssignedCluster, ULONG RunLength); +NTSTATUS +ConvertDataRunsToLargeMCB(PUCHAR DataRun, + PLARGE_MCB DataRunsMCB, + PULONGLONG pNextVBN); + +NTSTATUS +ConvertLargeMCBToDataRuns(PLARGE_MCB DataRunsMCB, + PUCHAR RunBuffer, + ULONG MaxBufferSize, + PULONG UsedBufferSize); + PUCHAR DecodeRun(PUCHAR DataRun, LONGLONG *DataRunOffset, diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 5afb87e9e6..4db1c38815 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -432,6 +432,22 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, return Status; } + // at this point the record in DataContext may be stale, so we need to refresh it + ReleaseAttributeContext(DataContext); + + Status = FindAttribute(DeviceExt, + FileRecord, + AttributeData, + Fcb->Stream, + wcslen(Fcb->Stream), + &DataContext, + &AttributeOffset); + if (!NT_SUCCESS(Status)) + { + DPRINT1("DRIVER ERROR: Couldn't find $DATA attribute after setting size!\n"); + return Status; + } + // now we need to update this file's size in every directory index entry that references it // TODO: put this code in its own function and adapt it to work with every filename / hardlink // stored in the file record.

7 years

[reactos] 18/72: [NTFS] Various minor changes to fix GCC build.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a135ef5864a205c8f75fa… commit a135ef5864a205c8f75fa367cf3d0f0964a380ba Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Wed Jul 13 14:49:46 2016 +0000 [NTFS] Various minor changes to fix GCC build. svn path=/branches/GSoC_2016/NTFS/; revision=71922 --- drivers/filesystems/ntfs/mft.c | 4 ++-- drivers/filesystems/ntfs/volinfo.c | 7 ++++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index c7096cc5d8..6263263dc8 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -202,7 +202,7 @@ InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, } // advance Destination to the final "attribute" and write the end type - (ULONG_PTR)Destination += Destination->Length; + Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)Destination + Destination->Length); Destination->Type = AttributeEnd; // write the final marker (which shares the same offset and type as the Length field) @@ -245,7 +245,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, ULONG NextAssignedCluster; ULONG AssignedClusters; - NTSTATUS Status = GetLastClusterInDataRun(Fcb->Vcb, &AttrContext->Record, &LastClusterInDataRun.QuadPart); + NTSTATUS Status = GetLastClusterInDataRun(Fcb->Vcb, &AttrContext->Record, (PULONGLONG)&LastClusterInDataRun.QuadPart); DPRINT1("GetLastClusterInDataRun returned: %I64u\n", LastClusterInDataRun.QuadPart); DPRINT1("Highest VCN of record: %I64u\n", AttrContext->Record.NonResident.HighestVCN); diff --git a/drivers/filesystems/ntfs/volinfo.c b/drivers/filesystems/ntfs/volinfo.c index d1505a5fb2..338ea84750 100644 --- a/drivers/filesystems/ntfs/volinfo.c +++ b/drivers/filesystems/ntfs/volinfo.c @@ -114,9 +114,11 @@ NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt, PFILE_RECORD_HEADER BitmapRecord; PNTFS_ATTR_CONTEXT DataContext; ULONGLONG BitmapDataSize; - PCHAR BitmapData; + PUCHAR BitmapData; ULONGLONG FreeClusters = 0; RTL_BITMAP Bitmap; + ULONG AssignedRun; + ULONG LengthWritten; DPRINT1("NtfsAllocateClusters(%p, %lu, %lu, %p, %p)\n", DeviceExt, FirstDesiredCluster, DesiredClusters, FirstAssignedCluster, AssignedClusters); @@ -174,8 +176,7 @@ NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt, // TODO: Observe MFT reservation zone // Can we get one contiguous run? - ULONG AssignedRun = RtlFindClearBitsAndSet(&Bitmap, DesiredClusters, FirstDesiredCluster); - ULONG LengthWritten; + AssignedRun = RtlFindClearBitsAndSet(&Bitmap, DesiredClusters, FirstDesiredCluster); if (AssignedRun != 0xFFFFFFFF) {

7 years

[reactos] 17/72: [NTFS] Add support functions, fix warning from previous commit. +NtfsDumpDataRuns(), +NtfsDumpDataRunData() - Provide diagnostic output. +GetPackedByteCount() - Used to encode data runs.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=63e83c7ffc1f9cbde675c… commit 63e83c7ffc1f9cbde675cb2165861451e055598f Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Wed Jul 13 11:51:16 2016 +0000 [NTFS] Add support functions, fix warning from previous commit. +NtfsDumpDataRuns(), +NtfsDumpDataRunData() - Provide diagnostic output. +GetPackedByteCount() - Used to encode data runs. svn path=/branches/GSoC_2016/NTFS/; revision=71921 --- drivers/filesystems/ntfs/attrib.c | 136 ++++++++++++++++++++++++++++++++++++++ drivers/filesystems/ntfs/mft.c | 2 +- drivers/filesystems/ntfs/ntfs.h | 8 +++ 3 files changed, 145 insertions(+), 1 deletion(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index fc2463fee5..f34072d8a5 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -523,6 +523,72 @@ NtfsDumpAttribute(PDEVICE_EXTENSION Vcb, } +VOID NtfsDumpDataRunData(PUCHAR DataRun) +{ + UCHAR DataRunOffsetSize; + UCHAR DataRunLengthSize; + CHAR i; + + DbgPrint("%02x ", *DataRun); + + if (*DataRun == 0) + return; + + DataRunOffsetSize = (*DataRun >> 4) & 0xF; + DataRunLengthSize = *DataRun & 0xF; + + DataRun++; + for (i = 0; i < DataRunLengthSize; i++) + { + DbgPrint("%02x ", *DataRun); + DataRun++; + } + + for (i = 0; i < DataRunOffsetSize; i++) + { + DbgPrint("%02x ", *DataRun); + DataRun++; + } + + NtfsDumpDataRunData(DataRun); +} + + +VOID +NtfsDumpDataRuns(PVOID StartOfRun, + ULONGLONG CurrentLCN) +{ + PUCHAR DataRun = StartOfRun; + LONGLONG DataRunOffset; + ULONGLONG DataRunLength; + + if (CurrentLCN == 0) + { + DPRINT1("Dumping data runs.\n\tData:\n\t\t"); + NtfsDumpDataRunData(StartOfRun); + DbgPrint("\n\tRuns:\n\t\tOff\t\tLCN\t\tLength\n"); + } + + DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength); + + if (DataRunOffset != -1) + CurrentLCN += DataRunOffset; + + DbgPrint("\t\t%I64d\t", DataRunOffset); + if (DataRunOffset < 99999) + DbgPrint("\t"); + DbgPrint("%I64u\t", CurrentLCN); + if (CurrentLCN < 99999) + DbgPrint("\t"); + DbgPrint("%I64u\n", DataRunLength); + + if (*DataRun == 0) + DbgPrint("\t\t00\n"); + else + NtfsDumpDataRuns(DataRun, CurrentLCN); +} + + VOID NtfsDumpFileAttributes(PDEVICE_EXTENSION Vcb, PFILE_RECORD_HEADER FileRecord) @@ -574,6 +640,76 @@ GetFileNameFromRecord(PDEVICE_EXTENSION Vcb, return NULL; } +/** +* GetPackedByteCount +* Returns the minimum number of bytes needed to represent the value of a +* 64-bit number. Used to encode data runs. +*/ +UCHAR +GetPackedByteCount(LONGLONG NumberToPack, + BOOLEAN IsSigned) +{ + int bytes = 0; + if (!IsSigned) + { + if (NumberToPack >= 0x0100000000000000) + return 8; + if (NumberToPack >= 0x0001000000000000) + return 7; + if (NumberToPack >= 0x0000010000000000) + return 6; + if (NumberToPack >= 0x0000000100000000) + return 5; + if (NumberToPack >= 0x0000000001000000) + return 4; + if (NumberToPack >= 0x0000000000010000) + return 3; + if (NumberToPack >= 0x0000000000000100) + return 2; + return 1; + } + + if (NumberToPack > 0) + { + // we have to make sure the number that gets encoded won't be interpreted as negative + if (NumberToPack >= 0x0080000000000000) + return 8; + if (NumberToPack >= 0x0000800000000000) + return 7; + if (NumberToPack >= 0x0000008000000000) + return 6; + if (NumberToPack >= 0x0000000080000000) + return 5; + if (NumberToPack >= 0x0000000000800000) + return 4; + if (NumberToPack >= 0x0000000000008000) + return 3; + if (NumberToPack >= 0x0000000000000080) + return 2; + return 1; + } + else + { + // negative number + if (NumberToPack <= 0xff80000000000000) + return 8; + if (NumberToPack <= 0xffff800000000000) + return 7; + if (NumberToPack <= 0xffffff8000000000) + return 6; + if (NumberToPack <= 0xffffffff80000000) + return 5; + if (NumberToPack <= 0xffffffffff800000) + return 4; + if (NumberToPack <= 0xffffffffffff8000) + return 3; + if (NumberToPack <= 0xffffffffffffff80) + return 2; + return 1; + } + return bytes; +} + NTSTATUS GetLastClusterInDataRun(PDEVICE_EXTENSION Vcb, PNTFS_ATTR_RECORD Attribute, PULONGLONG LastCluster) { diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 3ef8291a73..c7096cc5d8 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -1085,7 +1085,7 @@ UpdateFileRecord(PDEVICE_EXTENSION Vcb, } // remove the fixup array (so the file record pointer can still be used) - FixupUpdateSequenceArray(Vcb, file); + FixupUpdateSequenceArray(Vcb, &file->Ntfs); return Status; } diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 238e6d5b2d..f16153012e 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -526,6 +526,10 @@ DecodeRun(PUCHAR DataRun, LONGLONG *DataRunOffset, ULONGLONG *DataRunLength); +VOID +NtfsDumpDataRuns(PVOID StartOfRun, + ULONGLONG CurrentLCN); + VOID NtfsDumpFileAttributes(PDEVICE_EXTENSION Vcb, PFILE_RECORD_HEADER FileRecord); @@ -539,6 +543,10 @@ GetFileNameFromRecord(PDEVICE_EXTENSION Vcb, PFILE_RECORD_HEADER FileRecord, UCHAR NameType); +UCHAR +GetPackedByteCount(LONGLONG NumberToPack, + BOOLEAN IsSigned); + NTSTATUS GetLastClusterInDataRun(PDEVICE_EXTENSION Vcb, PNTFS_ATTR_RECORD Attribute,

7 years

[reactos] 16/72: [NTFS] UpdateFileRecord() - Remove fixup array before returning.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=268a139e6386a6c38302d… commit 268a139e6386a6c38302d30d9a9289e07dd4ebc6 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Wed Jul 13 09:26:04 2016 +0000 [NTFS] UpdateFileRecord() - Remove fixup array before returning. svn path=/branches/GSoC_2016/NTFS/; revision=71920 --- drivers/filesystems/ntfs/mft.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index aa203bbe9d..3ef8291a73 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -1084,6 +1084,9 @@ UpdateFileRecord(PDEVICE_EXTENSION Vcb, DPRINT1("UpdateFileRecord failed: %I64u written, %u expected\n", BytesWritten, Vcb->NtfsInfo.BytesPerFileRecord); } + // remove the fixup array (so the file record pointer can still be used) + FixupUpdateSequenceArray(Vcb, file); + return Status; }

7 years

[reactos] 15/72: [NTFS] Add error-checking to InternalGetNextAttribute(); don't crash if CurrAttr->Length is invalid.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=7c576a836f635bc1a07fc… commit 7c576a836f635bc1a07fc7f310690a0424051382 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Tue Jul 12 09:57:16 2016 +0000 [NTFS] Add error-checking to InternalGetNextAttribute(); don't crash if CurrAttr->Length is invalid. svn path=/branches/GSoC_2016/NTFS/; revision=71897 --- drivers/filesystems/ntfs/attrib.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 80022f5957..fc2463fee5 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -181,6 +181,14 @@ InternalGetNextAttribute(PFIND_ATTR_CONTXT Context) } NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)Context->CurrAttr + Context->CurrAttr->Length); + + if (NextAttribute > Context->LastAttr || NextAttribute < Context->FirstAttr) + { + DPRINT1("Broken length: 0x%lx!\n", Context->CurrAttr->Length); + Context->CurrAttr = (PVOID)-1; + return NULL; + } + Context->Offset += ((ULONG_PTR)NextAttribute - (ULONG_PTR)Context->CurrAttr); Context->CurrAttr = NextAttribute;

7 years

[reactos] 14/72: [NTFS] Fix broken check for free disk space in NtfsAllocateClusters().

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=de5cff4b3753f1e3db605… commit de5cff4b3753f1e3db60595b0b757638a904d7c2 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Jul 8 12:05:19 2016 +0000 [NTFS] Fix broken check for free disk space in NtfsAllocateClusters(). svn path=/branches/GSoC_2016/NTFS/; revision=71858 --- drivers/filesystems/ntfs/volinfo.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/drivers/filesystems/ntfs/volinfo.c b/drivers/filesystems/ntfs/volinfo.c index 68a1050620..d1505a5fb2 100644 --- a/drivers/filesystems/ntfs/volinfo.c +++ b/drivers/filesystems/ntfs/volinfo.c @@ -162,8 +162,14 @@ NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt, RtlInitializeBitMap(&Bitmap, (PULONG)BitmapData, DeviceExt->NtfsInfo.ClusterCount); FreeClusters = RtlNumberOfClearBits(&Bitmap); - if( FreeClusters < DesiredClusters ) - Status = STATUS_DISK_FULL; + if (FreeClusters < DesiredClusters) + { + ReleaseAttributeContext(DataContext); + + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ExFreePoolWithTag(BitmapRecord, TAG_NTFS); + return STATUS_DISK_FULL; + } // TODO: Observe MFT reservation zone

7 years

← Newer
1
...
23
24
25
26
27
28
29
...
36
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs December 2017