Ros-diffs December 2017

ros-diffs@reactos.org

26 participants
355 discussions

[reactos] 63/72: [NTFS] - Allow for creating a file when the index root gets too large and needs to be moved into an index record. Add some helper functions. +AllocateIndexNode() - Allocates a new index record in an index allocation. +CreateDummyKey() - Creates the final B_TREE_KEY for a B_TREE_FILENAME_NODE. Also creates the associated index entry. GetSizeOfIndexEntries() - Sums the size of each index entry in every key in a B-Tree node. +SetIndexEntryVCN() - Sets the VCN of a given IndexEntry.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=88a7c3d14b5f74300baac… commit 88a7c3d14b5f74300baacff3486b377901c2467f Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Tue Aug 15 19:57:55 2017 +0000 [NTFS] - Allow for creating a file when the index root gets too large and needs to be moved into an index record. Add some helper functions. +AllocateIndexNode() - Allocates a new index record in an index allocation. +CreateDummyKey() - Creates the final B_TREE_KEY for a B_TREE_FILENAME_NODE. Also creates the associated index entry. GetSizeOfIndexEntries() - Sums the size of each index entry in every key in a B-Tree node. +SetIndexEntryVCN() - Sets the VCN of a given IndexEntry. NtfsInsertKey() - Handle instance when the index root grows too large. If it does, add its contents to a new sub-node, and replace contents with a dummy-key whose child is the new node. UpdateIndexAllocation() - Update index entry if a key has just been assigned a child allocation. UpdateIndexNode() - Make sure the node exists on disk, and allocate an index record for it if it doesn't. svn path=/branches/GSoC_2016/NTFS/; revision=75557 --- drivers/filesystems/ntfs/btree.c | 520 ++++++++++++++++++++++++++++++++++++--- drivers/filesystems/ntfs/mft.c | 35 ++- drivers/filesystems/ntfs/ntfs.h | 8 +- 3 files changed, 519 insertions(+), 44 deletions(-) diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index 648111d9c0..727c147a2a 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -80,6 +80,237 @@ PrintAllVCNs(PDEVICE_EXTENSION Vcb, ExFreePoolWithTag(Buffer, TAG_NTFS); } +/** +* @name AllocateIndexNode +* @implemented +* +* Allocates a new index record in an index allocation. +* +* @param DeviceExt +* Pointer to the target DEVICE_EXTENSION describing the volume the node will be created on. +* +* @param FileRecord +* Pointer to a copy of the file record containing the index. +* +* @param IndexBufferSize +* Size of an index record for this index, in bytes. Commonly defined as 4096. +* +* @param IndexAllocationCtx +* Pointer to an NTFS_ATTR_CONTEXT describing the index allocation attribute the node will be assigned to. +* +* @param IndexAllocationOffset +* Offset of the index allocation attribute relative to the file record. +* +* @param NewVCN +* Pointer to a ULONGLONG which will receive the VCN of the newly-assigned index record +* +* @returns +* STATUS_SUCCESS in case of success. +* STATUS_NOT_IMPLEMENTED if there's no $I30 bitmap attribute in the file record. +* +* @remarks +* AllocateIndexNode() doesn't write any data to the index record it creates. Called by UpdateIndexNode(). +* Don't call PrintAllVCNs() or NtfsDumpFileRecord() after calling AllocateIndexNode() before UpdateIndexNode() finishes. +*/ +NTSTATUS +AllocateIndexNode(PDEVICE_EXTENSION DeviceExt, + PFILE_RECORD_HEADER FileRecord, + ULONG IndexBufferSize, + PNTFS_ATTR_CONTEXT IndexAllocationCtx, + ULONG IndexAllocationOffset, + PULONGLONG NewVCN) +{ + NTSTATUS Status; + PNTFS_ATTR_CONTEXT BitmapCtx; + ULONGLONG IndexAllocationLength, BitmapLength; + ULONG BitmapOffset; + ULONGLONG NextNodeNumber; + PCHAR *BitmapMem; + ULONG *BitmapPtr; + RTL_BITMAP Bitmap; + ULONG BytesWritten; + ULONG BytesNeeded; + LARGE_INTEGER DataSize; + + DPRINT1("AllocateIndexNode(%p, %p, %lu, %p, %lu, %p) called.\n", DeviceExt, + FileRecord, + IndexBufferSize, + IndexAllocationCtx, + IndexAllocationOffset, + NewVCN); + + // Get the length of the attribute allocation + IndexAllocationLength = AttributeDataLength(IndexAllocationCtx->pRecord); + + // Find the bitmap attribute for the index + Status = FindAttribute(DeviceExt, + FileRecord, + AttributeBitmap, + L"$I30", + 4, + &BitmapCtx, + &BitmapOffset); + if (!NT_SUCCESS(Status)) + { + DPRINT1("FIXME: Need to add bitmap attribute!\n"); + return STATUS_NOT_IMPLEMENTED; + } + + // Get the length of the bitmap attribute + BitmapLength = AttributeDataLength(BitmapCtx->pRecord); + + NextNodeNumber = IndexAllocationLength / DeviceExt->NtfsInfo.BytesPerIndexRecord; + + // TODO: Find unused allocation in bitmap and use that space first + + // Add another bit to bitmap + + // See how many bytes we need to store the amount of bits we'll have + BytesNeeded = NextNodeNumber / 8; + if (NextNodeNumber % 8 != 0) + BytesNeeded++; + + // Windows seems to allocate the bitmap in 8-byte chunks to keep any bytes from being wasted on padding + ALIGN_UP(BytesNeeded, ATTR_RECORD_ALIGNMENT); + + // Do we need to enlarge the bitmap? + if (BytesNeeded > BitmapLength) + { + // TODO: handle synchronization issues that could occur from changing the directory's file record + // Change bitmap size + DataSize.QuadPart = BytesNeeded; + Status = SetResidentAttributeDataLength(DeviceExt, + BitmapCtx, + BitmapOffset, + FileRecord, + &DataSize); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to set length of bitmap attribute!\n"); + ReleaseAttributeContext(BitmapCtx); + return Status; + } + } + + // Enlarge Index Allocation attribute + DataSize.QuadPart = IndexAllocationLength + IndexBufferSize; + Status = SetNonResidentAttributeDataLength(DeviceExt, + IndexAllocationCtx, + IndexAllocationOffset, + FileRecord, + &DataSize); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to set length of index allocation!\n"); + ReleaseAttributeContext(BitmapCtx); + return Status; + } + + // Update file record on disk + Status = UpdateFileRecord(DeviceExt, IndexAllocationCtx->FileMFTIndex, FileRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to update file record!\n"); + ReleaseAttributeContext(BitmapCtx); + return Status; + } + + // Allocate memory for the bitmap. RtlInitializeBitmap() wants a pointer that's ULONG-aligned + BitmapMem = ExAllocatePoolWithTag(NonPagedPool, BytesNeeded + sizeof(ULONG) - 1, TAG_NTFS); + BitmapPtr = (PULONG)ALIGN_UP_BY((ULONG_PTR)BitmapMem, sizeof(ULONG)); + + RtlZeroMemory(BitmapPtr, BytesNeeded); + + // Read the existing bitmap data + Status = ReadAttribute(DeviceExt, BitmapCtx, 0, (PCHAR)BitmapPtr, BitmapLength); + + // Initialize bitmap + RtlInitializeBitMap(&Bitmap, BitmapPtr, BytesNeeded); + + // Set the bit for the new index record + RtlSetBits(&Bitmap, NextNodeNumber, 1); + + // Write the new bitmap attribute + Status = WriteAttribute(DeviceExt, + BitmapCtx, + 0, + (const PUCHAR)BitmapPtr, + BytesNeeded, + &BytesWritten, + FileRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Unable to write to $I30 bitmap attribute!\n"); + } + + // Calculate VCN of new node number + *NewVCN = NextNodeNumber * (IndexBufferSize / DeviceExt->NtfsInfo.BytesPerCluster); + + ExFreePoolWithTag(BitmapMem, TAG_NTFS); + ReleaseAttributeContext(BitmapCtx); + + return Status; +} + +/** +* @name CreateDummyKey +* @implemented +* +* Creates the final B_TREE_KEY for a B_TREE_FILENAME_NODE. Also creates the associated index entry. +* +* @param HasChildNode +* BOOLEAN to indicate if this key will have a LesserChild. +* +* @return +* The newly-created key. +*/ +PB_TREE_KEY +CreateDummyKey(BOOLEAN HasChildNode) +{ + PINDEX_ENTRY_ATTRIBUTE NewIndexEntry; + PB_TREE_KEY NewDummyKey; + + // Calculate max size of a dummy key + ULONG EntrySize = ALIGN_UP_BY(FIELD_OFFSET(INDEX_ENTRY_ATTRIBUTE, FileName), 8); + EntrySize += sizeof(ULONGLONG); // for VCN + + // Create the index entry for the key + NewIndexEntry = ExAllocatePoolWithTag(NonPagedPool, EntrySize, TAG_NTFS); + if (!NewIndexEntry) + { + DPRINT1("Couldn't allocate memory for dummy key index entry!\n"); + return NULL; + } + + RtlZeroMemory(NewIndexEntry, EntrySize); + + if (HasChildNode) + { + NewIndexEntry->Flags = NTFS_INDEX_ENTRY_NODE | NTFS_INDEX_ENTRY_END; + } + else + { + NewIndexEntry->Flags = NTFS_INDEX_ENTRY_END; + EntrySize -= sizeof(ULONGLONG); // no VCN + } + + NewIndexEntry->Length = EntrySize; + + // Create the key + NewDummyKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); + if (!NewDummyKey) + { + DPRINT1("Unable to allocate dummy key!\n"); + ExFreePoolWithTag(NewIndexEntry, TAG_NTFS); + return NULL; + } + RtlZeroMemory(NewDummyKey, sizeof(B_TREE_KEY)); + + NewDummyKey->IndexEntry = NewIndexEntry; + + return NewDummyKey; +} + /** * @name CompareTreeKeys * @implemented @@ -500,6 +731,42 @@ CreateBTreeFromIndex(PDEVICE_EXTENSION Vcb, return STATUS_SUCCESS; } +/** +* @name GetSizeOfIndexEntries +* @implemented +* +* Sums the size of each index entry in every key in a B-Tree node. +* +* @param Node +* Pointer to a B_TREE_FILENAME_NODE. The size of this node's index entries will be returned. +* +* @returns +* The sum of the sizes of every index entry for each key in the B-Tree node. +* +* @remarks +* Gets only the size of the index entries; doesn't include the size of any headers that would be added to an index record. +*/ +ULONG +GetSizeOfIndexEntries(PB_TREE_FILENAME_NODE Node) +{ + // Start summing the total size of this node's entries + ULONG NodeSize = 0; + + // Walk through the list of Node Entries + PB_TREE_KEY CurrentKey = Node->FirstKey; + ULONG i; + for (i = 0; i < Node->KeyCount; i++) + { + ASSERT(CurrentKey->IndexEntry->Length != 0); + + // Add the length of the current node + NodeSize += CurrentKey->IndexEntry->Length; + CurrentKey = CurrentKey->NextKey; + } + + return NodeSize; +} + /** * @name CreateIndexRootFromBTree * @implemented @@ -686,6 +953,33 @@ CreateIndexBufferFromBTreeNode(PDEVICE_EXTENSION DeviceExt, return Status; } +/** +* @name SetIndexEntryVCN +* @implemented +* +* Sets the VCN of a given IndexEntry. +* +* @param IndexEntry +* Pointer to an INDEX_ENTRY_ATTRIBUTE structure that will have its VCN set. +* +* @param VCN +* VCN to store in the index entry. +* +* @remarks +* The index entry must have enough memory allocated to store the VCN, and must have the NTFS_INDEX_ENTRY_NODE flag set. +* The VCN of an index entry is stored at the very end of the structure, after the filename attribute. Since the filename +* attribute can be a variable size, this function makes setting this member easy. +*/ +VOID +SetIndexEntryVCN(PINDEX_ENTRY_ATTRIBUTE IndexEntry, ULONGLONG VCN) +{ + PULONGLONG Destination = (PULONGLONG)((ULONG_PTR)IndexEntry + IndexEntry->Length - sizeof(ULONGLONG)); + + ASSERT(IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE); + + *Destination = VCN; +} + NTSTATUS UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt, PB_TREE Tree, @@ -698,13 +992,20 @@ UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt, NTSTATUS Status; BOOLEAN HasIndexAllocation = FALSE; ULONG i; + ULONG IndexAllocationOffset; - DPRINT1("UpdateIndexAllocations() called.\n"); + DPRINT1("UpdateIndexAllocation() called.\n"); - Status = FindAttribute(DeviceExt, FileRecord, AttributeIndexAllocation, L"$I30", 4, &IndexAllocationContext, NULL); + Status = FindAttribute(DeviceExt, FileRecord, AttributeIndexAllocation, L"$I30", 4, &IndexAllocationContext, &IndexAllocationOffset); if (NT_SUCCESS(Status)) + { HasIndexAllocation = TRUE; + PrintAllVCNs(DeviceExt, + IndexAllocationContext, + IndexBufferSize); + } + // TODO: Handle bitmap BitmapContext = NULL; @@ -719,48 +1020,112 @@ UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt, DPRINT1("FIXME: Need to add index allocation\n"); return STATUS_NOT_IMPLEMENTED; } - else + + Status = UpdateIndexNode(DeviceExt, FileRecord, CurrentKey->LesserChild, IndexBufferSize, IndexAllocationContext, IndexAllocationOffset, BitmapContext); + if (!NT_SUCCESS(Status)) { - Status = UpdateIndexNode(DeviceExt, CurrentKey->LesserChild, IndexBufferSize, IndexAllocationContext, BitmapContext); - if (!NT_SUCCESS(Status)) + DPRINT1("ERROR: Failed to update index node!\n"); + ReleaseAttributeContext(IndexAllocationContext); + return Status; + } + + // Is the Index Entry large enough to store the VCN? + if (!CurrentKey->IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE) + { + // Allocate memory for the larger index entry + PINDEX_ENTRY_ATTRIBUTE NewEntry = ExAllocatePoolWithTag(NonPagedPool, + CurrentKey->IndexEntry->Length + sizeof(ULONGLONG), + TAG_NTFS); + if (!NewEntry) { - DPRINT1("ERROR: Failed to update index node!\n"); - ReleaseAttributeContext(IndexAllocationContext); - return Status; + DPRINT1("ERROR: Unable to allocate memory for new index entry!\n"); + if (HasIndexAllocation) + ReleaseAttributeContext(IndexAllocationContext); + return STATUS_INSUFFICIENT_RESOURCES; } + + // Copy the old entry to the new one + RtlCopyMemory(NewEntry, CurrentKey->IndexEntry, CurrentKey->IndexEntry->Length); + + NewEntry->Length += sizeof(ULONGLONG); + + // Free the old memory + ExFreePoolWithTag(CurrentKey->IndexEntry, TAG_NTFS); + + CurrentKey->IndexEntry = NewEntry; + CurrentKey->IndexEntry->Flags |= NTFS_INDEX_ENTRY_NODE; } + // Update the VCN stored in the index entry of CurrentKey + SetIndexEntryVCN(CurrentKey->IndexEntry, CurrentKey->LesserChild->NodeNumber); + } CurrentKey = CurrentKey->NextKey; } - if(HasIndexAllocation) + if (HasIndexAllocation) + { + PrintAllVCNs(DeviceExt, + IndexAllocationContext, + IndexBufferSize); + ReleaseAttributeContext(IndexAllocationContext); + } return STATUS_SUCCESS; } NTSTATUS UpdateIndexNode(PDEVICE_EXTENSION DeviceExt, + PFILE_RECORD_HEADER FileRecord, PB_TREE_FILENAME_NODE Node, ULONG IndexBufferSize, PNTFS_ATTR_CONTEXT IndexAllocationContext, + ULONG IndexAllocationOffset, PNTFS_ATTR_CONTEXT BitmapContext) { ULONG i; PB_TREE_KEY CurrentKey = Node->FirstKey; NTSTATUS Status; - DPRINT1("UpdateIndexNode(%p, %p, %lu, %p, %p) called for index node with VCN %I64u\n", DeviceExt, Node, IndexBufferSize, IndexAllocationContext, BitmapContext, Node->NodeNumber); + DPRINT1("UpdateIndexNode(%p, %p, %p, %lu, %p, %lu, %p) called for index node with VCN %I64u\n", + DeviceExt, + FileRecord, + Node, + IndexBufferSize, + IndexAllocationContext, + IndexAllocationOffset, + BitmapContext, + Node->NodeNumber); // Do we need to write this node to disk? if (Node->DiskNeedsUpdating) { ULONGLONG NodeOffset; ULONG LengthWritten; + PINDEX_BUFFER IndexBuffer; + + // Does the node need to be assigned a VCN? + if (!Node->ExistsOnDisk) + { + // Allocate the node + Status = AllocateIndexNode(DeviceExt, + FileRecord, + IndexBufferSize, + IndexAllocationContext, + IndexAllocationOffset, + &Node->NodeNumber); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to allocate index record in index allocation!\n"); + return Status; + } + + Node->ExistsOnDisk = TRUE; + } // Allocate memory for an index buffer - PINDEX_BUFFER IndexBuffer = ExAllocatePoolWithTag(NonPagedPool, IndexBufferSize, TAG_NTFS); + IndexBuffer = ExAllocatePoolWithTag(NonPagedPool, IndexBufferSize, TAG_NTFS); if (!IndexBuffer) { DPRINT1("ERROR: Failed to allocate %lu bytes for index buffer!\n", IndexBufferSize); @@ -780,7 +1145,7 @@ UpdateIndexNode(PDEVICE_EXTENSION DeviceExt, NodeOffset = GetAllocationOffsetFromVCN(DeviceExt, IndexBufferSize, Node->NodeNumber); // Write the buffer to the index allocation - Status = WriteAttribute(DeviceExt, IndexAllocationContext, NodeOffset, (const PUCHAR)IndexBuffer, IndexBufferSize, &LengthWritten, NULL); + Status = WriteAttribute(DeviceExt, IndexAllocationContext, NodeOffset, (const PUCHAR)IndexBuffer, IndexBufferSize, &LengthWritten, FileRecord); if (!NT_SUCCESS(Status) || LengthWritten != IndexBufferSize) { DPRINT1("ERROR: Failed to update index allocation!\n"); @@ -806,7 +1171,7 @@ UpdateIndexNode(PDEVICE_EXTENSION DeviceExt, if (CurrentKey->LesserChild) { // Update the child node on disk - Status = UpdateIndexNode(DeviceExt, CurrentKey->LesserChild, IndexBufferSize, IndexAllocationContext, BitmapContext); + Status = UpdateIndexNode(DeviceExt, FileRecord, CurrentKey->LesserChild, IndexBufferSize, IndexAllocationContext, IndexAllocationOffset, BitmapContext); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Failed to update child node!\n"); @@ -996,6 +1361,9 @@ GetAllocationOffsetFromVCN(PDEVICE_EXTENSION DeviceExt, * * Inserts a FILENAME_ATTRIBUTE into a B-Tree node. * +* @param Tree +* Pointer to the B_TREE the key (filename attribute) is being inserted into. +* * @param FileReference * Reference number to the file being added. This will be a combination of the MFT index and update sequence number. * @@ -1009,27 +1377,35 @@ GetAllocationOffsetFromVCN(PDEVICE_EXTENSION DeviceExt, * Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE * if an application created the file with the FILE_FLAG_POSIX_SEMANTICS flag. * +* @param MaxIndexRootSize +* The maximum size, in bytes, of node entries that can be stored in the index root before it will grow too large for +* the file record. This number is just the size of the entries, without any headers for the attribute or index root. +* * @remarks * A node is always sorted, with the least comparable filename stored first and a dummy key to mark the end. */ NTSTATUS -NtfsInsertKey(ULONGLONG FileReference, +NtfsInsertKey(PB_TREE Tree, + ULONGLONG FileReference, PFILENAME_ATTRIBUTE FileNameAttribute, PB_TREE_FILENAME_NODE Node, - BOOLEAN CaseSensitive) + BOOLEAN CaseSensitive, + ULONG MaxIndexRootSize) { PB_TREE_KEY NewKey, CurrentKey, PreviousKey; - NTSTATUS Status = STATUS_SUCCESS; + NTSTATUS Status = STATUS_SUCCESS; ULONG NodeSize; ULONG AllocatedNodeSize; ULONG MaxNodeSizeWithoutHeader; ULONG i; - DPRINT1("NtfsInsertKey(0x%I64x, %p, %p, %s)\n", + DPRINT1("NtfsInsertKey(%p, 0x%I64x, %p, %p, %s, %lu)\n", + Tree, FileReference, FileNameAttribute, Node, - CaseSensitive ? "TRUE" : "FALSE"); + CaseSensitive ? "TRUE" : "FALSE", + MaxIndexRootSize); // Create the key for the filename attribute NewKey = CreateBTreeKeyFromFilename(FileReference, FileNameAttribute); @@ -1044,6 +1420,11 @@ NtfsInsertKey(ULONGLONG FileReference, // Should the New Key go before the current key? LONG Comparison = CompareTreeKeys(NewKey, CurrentKey, CaseSensitive); + if (Comparison == 0) + { + DPRINT1("\t\tComparison == 0: %.*S\n", NewKey->IndexEntry->FileName.NameLength, NewKey->IndexEntry->FileName.Name); + DPRINT1("\t\tComparison == 0: %.*S\n", CurrentKey->IndexEntry->FileName.NameLength, CurrentKey->IndexEntry->FileName.Name); + } ASSERT(Comparison != 0); // Is NewKey < CurrentKey? @@ -1054,7 +1435,14 @@ NtfsInsertKey(ULONGLONG FileReference, if (CurrentKey->LesserChild) { // Insert the key into the child node - Status = NtfsInsertKey(FileReference, FileNameAttribute, CurrentKey->LesserChild, CaseSensitive); + Status = NtfsInsertKey(Tree, FileReference, FileNameAttribute, CurrentKey->LesserChild, CaseSensitive, 0); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to insert key.\n"); + ExFreePoolWithTag(NewKey, TAG_NTFS); + return Status; + } + } else { @@ -1078,25 +1466,89 @@ NtfsInsertKey(ULONGLONG FileReference, CurrentKey = CurrentKey->NextKey; } - // Is the node larger than its allocated size? - NodeSize = 0; - CurrentKey = Node->FirstKey; - for (i = 0; i < Node->KeyCount; i++) + // Determine how much space the index entries will need + NodeSize = GetSizeOfIndexEntries(Node); + + // Is Node the root node? + if (Node == Tree->RootNode) { - NodeSize += CurrentKey->IndexEntry->Length; - CurrentKey = CurrentKey->NextKey; - } + // Is the index root too large for the file record? + if (NodeSize > MaxIndexRootSize) + { + PB_TREE_FILENAME_NODE NewSubNode, NewIndexRoot; + PB_TREE_KEY DummyKey; + + DPRINT1("Collapsing Index Root into sub-node.\n") ; + + DumpBTree(Tree); + + // Create a new node that will hold the keys currently in index root + NewSubNode = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_FILENAME_NODE), TAG_NTFS); + if (!NewSubNode) + { + DPRINT1("ERROR: Couldn't allocate memory for new sub-node.\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + RtlZeroMemory(NewSubNode, sizeof(B_TREE_FILENAME_NODE)); + + // Copy the applicable data from the old index root node + NewSubNode->KeyCount = Node->KeyCount; + NewSubNode->FirstKey = Node->FirstKey; + NewSubNode->DiskNeedsUpdating = TRUE; + + // Create a new dummy key, and make the new node it's child + DummyKey = CreateDummyKey(TRUE); + if (!DummyKey) + { + DPRINT1("ERROR: Couldn't allocate memory for new root node.\n"); + ExFreePoolWithTag(NewSubNode, TAG_NTFS); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Make the new node a child of the dummy key + DummyKey->LesserChild = NewSubNode; + + // Create a new index root node + NewIndexRoot = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_FILENAME_NODE), TAG_NTFS); + if (!NewIndexRoot) + { + DPRINT1("ERROR: Couldn't allocate memory for new index root.\n"); + ExFreePoolWithTag(NewSubNode, TAG_NTFS); + ExFreePoolWithTag(DummyKey, TAG_NTFS); + return STATUS_INSUFFICIENT_RESOURCES; + } + RtlZeroMemory(NewIndexRoot, sizeof(B_TREE_FILENAME_NODE)); + + NewIndexRoot->DiskNeedsUpdating = TRUE; + + // Insert the dummy key into the new node + NewIndexRoot->FirstKey = DummyKey; + NewIndexRoot->KeyCount = 1; + NewIndexRoot->DiskNeedsUpdating = TRUE; + NewIndexRoot->ExistsOnDisk = TRUE; - // TEMPTEMP: TODO: MATH - AllocatedNodeSize = 0xfe8; - MaxNodeSizeWithoutHeader = AllocatedNodeSize - 0x28; + // Make the new node the Tree's root node + Tree->RootNode = NewIndexRoot; - if (NodeSize > MaxNodeSizeWithoutHeader) + DumpBTree(Tree); + + return STATUS_SUCCESS; + } + } + else { - DPRINT1("FIXME: Splitting a node is still a WIP!\n"); - //SplitBTreeNode(NULL, Node); - //DumpBTree(Tree); - return STATUS_NOT_IMPLEMENTED; + // TEMPTEMP: TODO: MATH + AllocatedNodeSize = 0xfe8; + MaxNodeSizeWithoutHeader = AllocatedNodeSize - 0x28; + + // Has the node grown larger than its allocated size? + if (NodeSize > MaxNodeSizeWithoutHeader) + { + DPRINT1("FIXME: Splitting a node is still a WIP!\n"); + //SplitBTreeNode(NULL, Node); + //DumpBTree(Tree); + return STATUS_NOT_IMPLEMENTED; + } } // NewEntry and NewKey will be destroyed later by DestroyBTree() diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index aeee447e33..0cd2767efb 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -2056,9 +2056,10 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, ULONG LengthWritten; PINDEX_ROOT_ATTRIBUTE NewIndexRoot; ULONG AttributeLength; + PNTFS_ATTR_RECORD NextAttribute; PB_TREE NewTree; ULONG BtreeIndexLength; - ULONG MaxIndexSize; + ULONG MaxIndexRootSize; // Allocate memory for the parent directory ParentFileRecord = ExAllocatePoolWithTag(NonPagedPool, @@ -2100,11 +2101,29 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, } // Find the maximum index size given what the file record can hold - MaxIndexSize = DeviceExt->NtfsInfo.BytesPerFileRecord - - IndexRootOffset - - IndexRootContext->pRecord->Resident.ValueOffset - - FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) - - (sizeof(ULONG) * 2); + // First, find the max index size assuming index root is the last attribute + MaxIndexRootSize = DeviceExt->NtfsInfo.BytesPerFileRecord // Start with the size of a file record + - IndexRootOffset // Subtract the length of everything that comes before index root + - IndexRootContext->pRecord->Resident.ValueOffset // Subtract the length of the attribute header for index root + - FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) // Subtract the length of the index header for index root + - (sizeof(ULONG) * 2); // Subtract the length of the file record end marker and padding + + // Are there attributes after this one? + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset + IndexRootContext->pRecord->Length); + if (NextAttribute->Type != AttributeEnd) + { + // Find the length of all attributes after this one, not counting the end marker + ULONG LengthOfAttributes = 0; + PNTFS_ATTR_RECORD CurrentAttribute = NextAttribute; + while (CurrentAttribute->Type != AttributeEnd) + { + LengthOfAttributes += CurrentAttribute->Length; + CurrentAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)CurrentAttribute + CurrentAttribute->Length); + } + + // Leave room for the existing attributes + MaxIndexRootSize -= LengthOfAttributes; + } // Allocate memory for the index root data I30IndexRootLength = AttributeDataLength(IndexRootContext->pRecord); @@ -2146,7 +2165,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, DumpBTree(NewTree); // Insert the key for the file we're adding - Status = NtfsInsertKey(FileReferenceNumber, FilenameAttribute, NewTree->RootNode, CaseSensitive); + Status = NtfsInsertKey(NewTree, FileReferenceNumber, FilenameAttribute, NewTree->RootNode, CaseSensitive, MaxIndexRootSize); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Failed to insert key into B-Tree!\n"); @@ -2172,7 +2191,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, } // Create the Index Root from the B*Tree - Status = CreateIndexRootFromBTree(DeviceExt, NewTree, MaxIndexSize, &NewIndexRoot, &BtreeIndexLength); + Status = CreateIndexRootFromBTree(DeviceExt, NewTree, MaxIndexRootSize, &NewIndexRoot, &BtreeIndexLength); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Failed to create Index root from B-Tree!\n"); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 4d436a699e..030b777c22 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -728,10 +728,12 @@ GetAllocationOffsetFromVCN(PDEVICE_EXTENSION DeviceExt, ULONGLONG Vcn); NTSTATUS -NtfsInsertKey(ULONGLONG FileReference, +NtfsInsertKey(PB_TREE Tree, + ULONGLONG FileReference, PFILENAME_ATTRIBUTE FileNameAttribute, PB_TREE_FILENAME_NODE Node, - BOOLEAN CaseSensitive); + BOOLEAN CaseSensitive, + ULONG MaxIndexRootSize); NTSTATUS UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt, @@ -741,9 +743,11 @@ UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt, NTSTATUS UpdateIndexNode(PDEVICE_EXTENSION DeviceExt, + PFILE_RECORD_HEADER FileRecord, PB_TREE_FILENAME_NODE Node, ULONG IndexBufferSize, PNTFS_ATTR_CONTEXT IndexAllocationContext, + ULONG IndexAllocationOffset, PNTFS_ATTR_CONTEXT BitmapContext); /* close.c */

7 years

[reactos] 62/72: [NTFS] - Allow for resizing an attribute in the middle of a file record. Add a helper function and minor improvements: AddRun() - Allow for resizing the size of the data runs when the attribute isn't the last in the file record. Fix some comments. CreateIndexBufferFromBTreeNode(), CreateIndexRootFromBTree - Fix math of IndexSize when checking if the index buffer is too large. InternalSetResidentAttributeLength() - Allow changing the length of an attribute in the middle of a file

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d484d91eba5724f885cf6… commit d484d91eba5724f885cf6662e9e8bd87c99d561b Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Tue Aug 15 19:32:20 2017 +0000 [NTFS] - Allow for resizing an attribute in the middle of a file record. Add a helper function and minor improvements: AddRun() - Allow for resizing the size of the data runs when the attribute isn't the last in the file record. Fix some comments. CreateIndexBufferFromBTreeNode(), CreateIndexRootFromBTree - Fix math of IndexSize when checking if the index buffer is too large. InternalSetResidentAttributeLength() - Allow changing the length of an attribute in the middle of a file record. Adjust the position of every attribute after the one being resized. +MoveAttributes() - Moves a block of attributes to a new location in the file Record. PrintAllVCNs() - Add consideration for an index allocation with a size of 0. WriteAttribute() - Add optional parameter for a pointer to the file record being written to. If passed a file record, WriteAttribute() will skip reading the file record from disk, and will update the file record in memory before returning. This helps callers that use the file record after writing an attribute to stay in-sync with what's on disk. svn path=/branches/GSoC_2016/NTFS/; revision=75554 --- drivers/filesystems/ntfs/attrib.c | 47 +++++--- drivers/filesystems/ntfs/btree.c | 26 +++-- drivers/filesystems/ntfs/mft.c | 234 +++++++++++++++++++++++++------------ drivers/filesystems/ntfs/ntfs.h | 12 +- drivers/filesystems/ntfs/rw.c | 2 +- drivers/filesystems/ntfs/volinfo.c | 2 +- 6 files changed, 219 insertions(+), 104 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 8618862344..e6d3483553 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -352,18 +352,35 @@ AddRun(PNTFS_VCB Vcb, PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); PNTFS_ATTR_RECORD NewRecord; - DataRunMaxLength += Vcb->NtfsInfo.BytesPerFileRecord - NextAttributeOffset - (sizeof(ULONG) * 2); + // Add free space at the end of the file record to DataRunMaxLength + DataRunMaxLength += Vcb->NtfsInfo.BytesPerFileRecord - FileRecord->BytesInUse; - // Can we move the end of the attribute? - if (NextAttribute->Type != AttributeEnd || DataRunMaxLength < RunBufferSize - 1) + // Can we resize the attribute? + if (DataRunMaxLength < RunBufferSize) { - 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); + DPRINT1("FIXME: Need to create attribute list! Max Data Run Length available: %d, RunBufferSize: %d\n", DataRunMaxLength, RunBufferSize); ExFreePoolWithTag(RunBuffer, TAG_NTFS); return STATUS_NOT_IMPLEMENTED; } + // Are there more attributes after the one we're resizing? + if (NextAttribute->Type != AttributeEnd) + { + PNTFS_ATTR_RECORD FinalAttribute; + + // Calculate where to move the trailing attributes + ULONG_PTR MoveTo = (ULONG_PTR)DestinationAttribute + AttrContext->pRecord->NonResident.MappingPairsOffset + RunBufferSize; + MoveTo = ALIGN_UP_BY(MoveTo, ATTR_RECORD_ALIGNMENT); + + DPRINT1("Moving attribute(s) after this one starting with type 0x%lx\n", NextAttribute->Type); + + // Move the trailing attributes; FinalAttribute will point to the end marker + FinalAttribute = MoveAttributes(Vcb, NextAttribute, NextAttributeOffset, MoveTo); + + // set the file record end + SetFileRecordEnd(FileRecord, FinalAttribute, FILE_RECORD_END); + } + // calculate position of end markers NextAttributeOffset = AttrOffset + AttrContext->pRecord->NonResident.MappingPairsOffset + RunBufferSize; NextAttributeOffset = ALIGN_UP_BY(NextAttributeOffset, ATTR_RECORD_ALIGNMENT); @@ -371,20 +388,24 @@ AddRun(PNTFS_VCB Vcb, // Update the length of the destination attribute DestinationAttribute->Length = NextAttributeOffset - AttrOffset; - // Create a new copy of the attribute + // Create a new copy of the attribute record NewRecord = ExAllocatePoolWithTag(NonPagedPool, DestinationAttribute->Length, TAG_NTFS); RtlCopyMemory(NewRecord, AttrContext->pRecord, AttrContext->pRecord->Length); NewRecord->Length = DestinationAttribute->Length; - // Free the old copy of the attribute, which won't be large enough + // Free the old copy of the attribute record, which won't be large enough ExFreePoolWithTag(AttrContext->pRecord, TAG_NTFS); // Set the attribute context's record to the new copy AttrContext->pRecord = NewRecord; - // End the file record - NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); - SetFileRecordEnd(FileRecord, NextAttribute, FILE_RECORD_END); + // if NextAttribute is the AttributeEnd marker + if (NextAttribute->Type == AttributeEnd) + { + // End the file record + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); + SetFileRecordEnd(FileRecord, NextAttribute, FILE_RECORD_END); + } } // Update HighestVCN @@ -397,7 +418,7 @@ AddRun(PNTFS_VCB Vcb, RunBuffer, RunBufferSize); - // Update the attribute copy in the attribute context + // Update the attribute record in the attribute context RtlCopyMemory((PVOID)((ULONG_PTR)AttrContext->pRecord + AttrContext->pRecord->NonResident.MappingPairsOffset), RunBuffer, RunBufferSize); @@ -827,7 +848,7 @@ FreeClusters(PNTFS_VCB Vcb, } // update $BITMAP file on disk - Status = WriteAttribute(Vcb, DataContext, 0, BitmapData, (ULONG)BitmapDataSize, &LengthWritten); + Status = WriteAttribute(Vcb, DataContext, 0, BitmapData, (ULONG)BitmapDataSize, &LengthWritten, FileRecord); if (!NT_SUCCESS(Status)) { ReleaseAttributeContext(DataContext); diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index dbbf3f9f87..648111d9c0 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -46,6 +46,12 @@ PrintAllVCNs(PDEVICE_EXTENSION Vcb, ULONGLONG i; int Count = 0; + if (BufferSize == 0) + { + DPRINT1("Index Allocation is empty.\n"); + return; + } + Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferSize, TAG_NTFS); BytesRead = ReadAttribute(Vcb, IndexAllocationContext, 0, (PCHAR)Buffer, BufferSize); @@ -281,10 +287,10 @@ CreateBTreeNodeFromIndexNode(PDEVICE_EXTENSION Vcb, { DPRINT1("TODO: Only a node with a single-level is supported right now!\n"); // Needs debugging: - /*CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, + CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, IndexRoot, IndexAllocationAttributeCtx, - CurrentNodeEntry);*/ + CurrentKey->IndexEntry); } CurrentKey = NextKey; @@ -300,10 +306,10 @@ CreateBTreeNodeFromIndexNode(PDEVICE_EXTENSION Vcb, { DPRINT1("TODO: Only a node with a single-level is supported right now!\n"); // Needs debugging: - /*CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, - IndexRoot, - IndexAllocationAttributeCtx, - CurrentNodeEntry);*/ + CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, + IndexRoot, + IndexAllocationAttributeCtx, + CurrentKey->IndexEntry); } break; @@ -575,7 +581,6 @@ CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt, { // Would adding the current entry to the index increase the index size beyond the limit we've set? ULONG IndexSize = FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) - + NewIndexRoot->Header.FirstEntryOffset + NewIndexRoot->Header.TotalSizeOfEntries + CurrentNodeEntry->Length; if (IndexSize > MaxIndexSize) @@ -649,7 +654,6 @@ CreateIndexBufferFromBTreeNode(PDEVICE_EXTENSION DeviceExt, { // Would adding the current entry to the index increase the node size beyond the allocation size? ULONG IndexSize = FIELD_OFFSET(INDEX_BUFFER, Header) - + IndexBuffer->Header.FirstEntryOffset + IndexBuffer->Header.TotalSizeOfEntries + CurrentNodeEntry->Length; if (IndexSize > BufferSize) @@ -776,7 +780,7 @@ UpdateIndexNode(PDEVICE_EXTENSION DeviceExt, NodeOffset = GetAllocationOffsetFromVCN(DeviceExt, IndexBufferSize, Node->NodeNumber); // Write the buffer to the index allocation - Status = WriteAttribute(DeviceExt, IndexAllocationContext, NodeOffset, (const PUCHAR)IndexBuffer, IndexBufferSize, &LengthWritten); + Status = WriteAttribute(DeviceExt, IndexAllocationContext, NodeOffset, (const PUCHAR)IndexBuffer, IndexBufferSize, &LengthWritten, NULL); if (!NT_SUCCESS(Status) || LengthWritten != IndexBufferSize) { DPRINT1("ERROR: Failed to update index allocation!\n"); @@ -945,10 +949,10 @@ DumpBTreeNode(PB_TREE_FILENAME_NODE Node, ULONG Number, ULONG Depth) ULONG i; for (i = 0; i < Depth; i++) DbgPrint(" "); - DbgPrint("Node #%d, Depth %d, has %d keys\n", Number, Depth, Node->KeyCount); + DbgPrint("Node #%d, Depth %d, has %d key%s\n", Number, Depth, Node->KeyCount, Node->KeyCount == 1 ? "" : "s"); CurrentKey = Node->FirstKey; - for (i = 0; i < Node->KeyCount; i++) + for (i = 1; i <= Node->KeyCount; i++) { DumpBTreeKey(CurrentKey, i, Depth); CurrentKey = CurrentKey->NextKey; diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 23f802dfca..aeee447e33 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -351,7 +351,7 @@ IncreaseMftSize(PDEVICE_EXTENSION Vcb, BOOLEAN CanWait) } // Write out the new bitmap - Status = WriteAttribute(Vcb, BitmapContext, BitmapOffset, BitmapBuffer, BitmapSize.LowPart, &LengthWritten); + Status = WriteAttribute(Vcb, BitmapContext, BitmapOffset, BitmapBuffer, BitmapSize.LowPart, &LengthWritten, Vcb->MasterFileTable); if (!NT_SUCCESS(Status)) { ExReleaseResourceLite(&(Vcb->DirResource)); @@ -369,17 +369,72 @@ IncreaseMftSize(PDEVICE_EXTENSION Vcb, BOOLEAN CanWait) return STATUS_SUCCESS; } +/** +* @name MoveAttributes +* @implemented +* +* Moves a block of attributes to a new location in the file Record. The attribute at FirstAttributeToMove +* and every attribute after that will be moved to MoveTo. +* +* @param DeviceExt +* Pointer to the DEVICE_EXTENSION (VCB) of the target volume. +* +* @param FirstAttributeToMove +* Pointer to the first NTFS_ATTR_RECORD that needs to be moved. This pointer must reside within a file record. +* +* @param FirstAttributeOffset +* Offset of FirstAttributeToMove relative to the beginning of the file record. +* +* @param MoveTo +* ULONG_PTR with the memory location that will be the new location of the first attribute being moved. +* +* @return +* The new location of the final attribute (i.e. AttributeEnd marker). +*/ +PNTFS_ATTR_RECORD +MoveAttributes(PDEVICE_EXTENSION DeviceExt, + PNTFS_ATTR_RECORD FirstAttributeToMove, + ULONG FirstAttributeOffset, + ULONG_PTR MoveTo) +{ + // Get the size of all attributes after this one + ULONG MemBlockSize = 0; + PNTFS_ATTR_RECORD CurrentAttribute = FirstAttributeToMove; + ULONG CurrentOffset = FirstAttributeOffset; + PNTFS_ATTR_RECORD FinalAttribute; + + while (CurrentAttribute->Type != AttributeEnd && CurrentOffset < DeviceExt->NtfsInfo.BytesPerFileRecord) + { + CurrentOffset += CurrentAttribute->Length; + MemBlockSize += CurrentAttribute->Length; + CurrentAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)CurrentAttribute + CurrentAttribute->Length); + } + + FinalAttribute = (PNTFS_ATTR_RECORD)(MoveTo + MemBlockSize); + MemBlockSize += sizeof(ULONG) * 2; // Add the AttributeEnd and file record end + + ASSERT(MemBlockSize % ATTR_RECORD_ALIGNMENT == 0); + + // Move the attributes after this one + RtlMoveMemory((PCHAR)MoveTo, FirstAttributeToMove, MemBlockSize); + + return FinalAttribute; +} + NTSTATUS -InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, +InternalSetResidentAttributeLength(PDEVICE_EXTENSION DeviceExt, + PNTFS_ATTR_CONTEXT AttrContext, PFILE_RECORD_HEADER FileRecord, ULONG AttrOffset, ULONG DataSize) { PNTFS_ATTR_RECORD Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); + PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)Destination + Destination->Length); + PNTFS_ATTR_RECORD FinalAttribute; + ULONG OldAttributeLength = Destination->Length; ULONG NextAttributeOffset; - USHORT ValueOffset; - DPRINT("InternalSetResidentAttributeLength( %p, %p, %lu, %lu )\n", AttrContext, FileRecord, AttrOffset, DataSize); + DPRINT1("InternalSetResidentAttributeLength( %p, %p, %p, %lu, %lu )\n", DeviceExt, AttrContext, FileRecord, AttrOffset, DataSize); ASSERT(!AttrContext->pRecord->IsNonResident); @@ -390,30 +445,46 @@ InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, Destination->Length = ALIGN_UP_BY(DataSize + AttrContext->pRecord->Resident.ValueOffset, ATTR_RECORD_ALIGNMENT); NextAttributeOffset = AttrOffset + Destination->Length; - // Ensure FileRecord has an up-to-date copy of the attribute - ValueOffset = AttrContext->pRecord->Resident.ValueOffset; - RtlCopyMemory((PCHAR)((ULONG_PTR)FileRecord + AttrOffset + ValueOffset), - (PCHAR)((ULONG_PTR)AttrContext->pRecord + ValueOffset), - min(DataSize, AttrContext->pRecord->Resident.ValueLength)); + // Ensure NextAttributeOffset is aligned to an 8-byte boundary + ASSERT(NextAttributeOffset % ATTR_RECORD_ALIGNMENT == 0); - // Free the old copy of the attribute in the context, as it will be the wrong length - ExFreePoolWithTag(AttrContext->pRecord, TAG_NTFS); + // Will the new attribute be larger than the old one? + if (Destination->Length > OldAttributeLength) + { + // Free the old copy of the attribute in the context, as it will be the wrong length + ExFreePoolWithTag(AttrContext->pRecord, TAG_NTFS); - // Create a new copy of the attribute for the context - AttrContext->pRecord = ExAllocatePoolWithTag(NonPagedPool, Destination->Length, TAG_NTFS); - if (!AttrContext->pRecord) + // Create a new copy of the attribute record for the context + AttrContext->pRecord = ExAllocatePoolWithTag(NonPagedPool, Destination->Length, TAG_NTFS); + if (!AttrContext->pRecord) + { + DPRINT1("Unable to allocate memory for attribute!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + RtlZeroMemory((PVOID)((ULONG_PTR)AttrContext->pRecord + OldAttributeLength), Destination->Length - OldAttributeLength); + RtlCopyMemory(AttrContext->pRecord, Destination, OldAttributeLength); + } + + // Are there attributes after this one that need to be moved? + if (NextAttribute->Type != AttributeEnd) { - DPRINT1("Unable to allocate memory for attribute!\n"); - return STATUS_INSUFFICIENT_RESOURCES; + // Move the attributes after this one + FinalAttribute = MoveAttributes(DeviceExt, NextAttribute, NextAttributeOffset, (ULONG_PTR)Destination + Destination->Length); + } + else + { + // advance to the final "attribute," adjust for the changed length of the attribute we're resizing + FinalAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute - OldAttributeLength + Destination->Length); } - RtlCopyMemory(AttrContext->pRecord, Destination, Destination->Length); - // Ensure NextAttributeOffset is aligned to an 8-byte boundary - ASSERT(NextAttributeOffset % ATTR_RECORD_ALIGNMENT == 0); - - // advance Destination to the final "attribute" and set the file record end - Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)Destination + Destination->Length); - SetFileRecordEnd(FileRecord, Destination, FILE_RECORD_END); + // Update pRecord's length + AttrContext->pRecord->Length = Destination->Length; + AttrContext->pRecord->Resident.ValueLength = DataSize; + + // set the file record end + SetFileRecordEnd(FileRecord, FinalAttribute, FILE_RECORD_END); + + //NtfsDumpFileRecord(DeviceExt, FileRecord); return STATUS_SUCCESS; } @@ -519,6 +590,9 @@ SetFileRecordEnd(PFILE_RECORD_HEADER FileRecord, PNTFS_ATTR_RECORD AttrEnd, ULONG EndMarker) { + // Ensure AttrEnd is aligned on an 8-byte boundary, relative to FileRecord + ASSERT(((ULONG_PTR)AttrEnd - (ULONG_PTR)FileRecord) % ATTR_RECORD_ALIGNMENT == 0); + // mark the end of attributes AttrEnd->Type = AttributeEnd; @@ -841,7 +915,7 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, // restore the back-up attribute, if we made one if (AttribDataSize.QuadPart > 0) { - Status = WriteAttribute(Vcb, AttrContext, 0, AttribData, AttribDataSize.QuadPart, &LengthWritten); + Status = WriteAttribute(Vcb, AttrContext, 0, AttribData, AttribDataSize.QuadPart, &LengthWritten, FileRecord); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Unable to write attribute data to non-resident clusters during migration!\n"); @@ -855,19 +929,10 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, } } } - else if (DataSize->LowPart < AttrContext->pRecord->Resident.ValueLength) - { - // we need to decrease the length - if (NextAttribute->Type != AttributeEnd) - { - DPRINT1("FIXME: Don't know how to decrease length of resident attribute unless it's the final attribute!\n"); - return STATUS_NOT_IMPLEMENTED; - } - } // set the new length of the resident attribute (if we didn't migrate it) if (!AttrContext->pRecord->IsNonResident) - return InternalSetResidentAttributeLength(AttrContext, FileRecord, AttrOffset, DataSize->LowPart); + return InternalSetResidentAttributeLength(Vcb, AttrContext, FileRecord, AttrOffset, DataSize->LowPart); return STATUS_SUCCESS; } @@ -1102,6 +1167,12 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, * @param RealLengthWritten * Pointer to a ULONG which will receive how much data was written, in bytes * +* @param FileRecord +* Optional pointer to a FILE_RECORD_HEADER that contains a copy of the file record +* being written to. Can be NULL, in which case the file record will be read from disk. +* If not-null, WriteAttribute() will skip reading from disk, and FileRecord +* will be updated with the newly-written attribute before the function returns. +* * @return * STATUS_SUCCESS if successful, an error code otherwise. STATUS_NOT_IMPLEMENTED if * writing to a sparse file. @@ -1117,7 +1188,8 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, ULONGLONG Offset, const PUCHAR Buffer, ULONG Length, - PULONG RealLengthWritten) + PULONG RealLengthWritten, + PFILE_RECORD_HEADER FileRecord) { ULONGLONG LastLCN; PUCHAR DataRun; @@ -1129,12 +1201,13 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, NTSTATUS Status; PUCHAR SourceBuffer = Buffer; LONGLONG StartingOffset; + BOOLEAN FileRecordAllocated = FALSE; //TEMPTEMP PUCHAR TempBuffer; - DPRINT("WriteAttribute(%p, %p, %I64u, %p, %lu, %p)\n", Vcb, Context, Offset, Buffer, Length, RealLengthWritten); + DPRINT("WriteAttribute(%p, %p, %I64u, %p, %lu, %p, %p)\n", Vcb, Context, Offset, Buffer, Length, RealLengthWritten, FileRecord); *RealLengthWritten = 0; @@ -1143,7 +1216,10 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, { ULONG AttributeOffset; PNTFS_ATTR_CONTEXT FoundContext; - PFILE_RECORD_HEADER FileRecord; + PNTFS_ATTR_RECORD Destination; + + // Ensure requested data is within the bounds of the attribute + ASSERT(Offset + Length <= Context->pRecord->Resident.ValueLength); if (Offset + Length > Context->pRecord->Resident.ValueLength) { @@ -1151,16 +1227,21 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, return STATUS_INVALID_PARAMETER; } - FileRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); - - if (!FileRecord) + // Do we need to read the file record? + if (FileRecord == NULL) { - DPRINT1("Error: Couldn't allocate file record!\n"); - return STATUS_NO_MEMORY; - } + FileRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + if (!FileRecord) + { + DPRINT1("Error: Couldn't allocate file record!\n"); + return STATUS_NO_MEMORY; + } + + FileRecordAllocated = TRUE; - // read the file record - ReadFileRecord(Vcb, Context->FileMFTIndex, FileRecord); + // read the file record + ReadFileRecord(Vcb, Context->FileMFTIndex, FileRecord); + } // find where to write the attribute data to Status = FindAttribute(Vcb, FileRecord, @@ -1173,28 +1254,37 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Couldn't find matching attribute!\n"); - ExFreePoolWithTag(FileRecord, TAG_NTFS); + if(FileRecordAllocated) + ExFreePoolWithTag(FileRecord, TAG_NTFS); return Status; } + Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttributeOffset); + DPRINT("Offset: %I64u, AttributeOffset: %u, ValueOffset: %u\n", Offset, AttributeOffset, Context->pRecord->Resident.ValueLength); - Offset += AttributeOffset + Context->pRecord->Resident.ValueOffset; - - if (Offset + Length > Vcb->NtfsInfo.BytesPerFileRecord) + + // Will we be writing past the end of the allocated file record? + if (Offset + Length + AttributeOffset + Context->pRecord->Resident.ValueOffset > Vcb->NtfsInfo.BytesPerFileRecord) { DPRINT1("DRIVER ERROR: Data being written extends past end of file record!\n"); ReleaseAttributeContext(FoundContext); - ExFreePoolWithTag(FileRecord, TAG_NTFS); + if (FileRecordAllocated) + ExFreePoolWithTag(FileRecord, TAG_NTFS); return STATUS_INVALID_PARAMETER; } - // copy the data being written into the file record - RtlCopyMemory((PCHAR)FileRecord + Offset, Buffer, Length); + // copy the data being written into the file record. We cast Offset to ULONG, which is safe because it's range has been verified. + RtlCopyMemory((PCHAR)((ULONG_PTR)Destination + Context->pRecord->Resident.ValueOffset + (ULONG)Offset), Buffer, Length); Status = UpdateFileRecord(Vcb, Context->FileMFTIndex, FileRecord); + // Update the context's copy of the resident attribute + ASSERT(Context->pRecord->Length == Destination->Length); + RtlCopyMemory((PVOID)Context->pRecord, Destination, Context->pRecord->Length); + ReleaseAttributeContext(FoundContext); - ExFreePoolWithTag(FileRecord, TAG_NTFS); + if (FileRecordAllocated) + ExFreePoolWithTag(FileRecord, TAG_NTFS); if (NT_SUCCESS(Status)) *RealLengthWritten = Length; @@ -1519,7 +1609,7 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, { // we need to write the index root attribute back to disk ULONG LengthWritten; - Status = WriteAttribute(Vcb, IndexRootCtx, 0, (PUCHAR)IndexRecord, AttributeDataLength(IndexRootCtx->pRecord), &LengthWritten); + Status = WriteAttribute(Vcb, IndexRootCtx, 0, (PUCHAR)IndexRecord, AttributeDataLength(IndexRootCtx->pRecord), &LengthWritten, MftRecord); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Couldn't update Index Root!\n"); @@ -1661,7 +1751,7 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, break; } - Status = WriteAttribute(Vcb, IndexAllocationCtx, RecordOffset, (const PUCHAR)IndexRecord, IndexBlockSize, &Written); + Status = WriteAttribute(Vcb, IndexAllocationCtx, RecordOffset, (const PUCHAR)IndexRecord, IndexBlockSize, &Written, MftRecord); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR Performing write!\n"); @@ -1714,7 +1804,13 @@ UpdateFileRecord(PDEVICE_EXTENSION Vcb, AddFixupArray(Vcb, &FileRecord->Ntfs); // write the file record to the master file table - Status = WriteAttribute(Vcb, Vcb->MFTContext, MftIndex * Vcb->NtfsInfo.BytesPerFileRecord, (const PUCHAR)FileRecord, Vcb->NtfsInfo.BytesPerFileRecord, &BytesWritten); + Status = WriteAttribute(Vcb, + Vcb->MFTContext, + MftIndex * Vcb->NtfsInfo.BytesPerFileRecord, + (const PUCHAR)FileRecord, + Vcb->NtfsInfo.BytesPerFileRecord, + &BytesWritten, + FileRecord); if (!NT_SUCCESS(Status)) { @@ -1882,7 +1978,7 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, BitmapData[2] = SystemReservedBits; // write the bitmap back to the MFT's $Bitmap attribute - Status = WriteAttribute(DeviceExt, BitmapContext, 0, BitmapData, BitmapDataSize, &LengthWritten); + Status = WriteAttribute(DeviceExt, BitmapContext, 0, BitmapData, BitmapDataSize, &LengthWritten, FileRecord); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR encountered when writing $Bitmap attribute!\n"); @@ -1958,10 +2054,8 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, ULONG IndexRootOffset; ULONGLONG I30IndexRootLength; ULONG LengthWritten; - PNTFS_ATTR_RECORD DestinationAttribute; PINDEX_ROOT_ATTRIBUTE NewIndexRoot; ULONG AttributeLength; - PNTFS_ATTR_RECORD NextAttribute; PB_TREE NewTree; ULONG BtreeIndexLength; ULONG MaxIndexSize; @@ -2065,7 +2159,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, DumpBTree(NewTree); - // Convert B*Tree back to Index + // Convert B*Tree back to Index, starting with the index allocation Status = UpdateIndexAllocation(DeviceExt, NewTree, I30IndexRoot->SizeOfEntry, ParentFileRecord); if (!NT_SUCCESS(Status)) { @@ -2103,22 +2197,9 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, if (AttributeLength != IndexRootContext->pRecord->Resident.ValueLength) { - DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset); - - // Find the attribute (or attribute-end marker) after the index root - NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); - if (NextAttribute->Type != AttributeEnd) - { - DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n"); - ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return STATUS_NOT_IMPLEMENTED; - } - // Update the length of the attribute in the file record of the parent directory - Status = InternalSetResidentAttributeLength(IndexRootContext, + Status = InternalSetResidentAttributeLength(DeviceExt, + IndexRootContext, ParentFileRecord, IndexRootOffset, AttributeLength); @@ -2153,7 +2234,8 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, 0, (PUCHAR)NewIndexRoot, AttributeLength, - &LengthWritten); + &LengthWritten, + ParentFileRecord); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Unable to write new index root attribute to parent directory!\n"); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 668815ddd5..4d436a699e 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -954,17 +954,25 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, ULONGLONG Offset, const PUCHAR Buffer, ULONG Length, - PULONG LengthWritten); + PULONG LengthWritten, + PFILE_RECORD_HEADER FileRecord); ULONGLONG AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord); NTSTATUS -InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, +InternalSetResidentAttributeLength(PDEVICE_EXTENSION DeviceExt, + PNTFS_ATTR_CONTEXT AttrContext, PFILE_RECORD_HEADER FileRecord, ULONG AttrOffset, ULONG DataSize); +PNTFS_ATTR_RECORD +MoveAttributes(PDEVICE_EXTENSION DeviceExt, + PNTFS_ATTR_RECORD FirstAttributeToMove, + ULONG FirstAttributeOffset, + ULONG_PTR MoveTo); + NTSTATUS SetAttributeDataLength(PFILE_OBJECT FileObject, PNTFS_FCB Fcb, diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 2c21f3a449..94d05de9ae 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -478,7 +478,7 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, DPRINT("Length: %lu\tWriteOffset: %lu\tStreamSize: %I64u\n", Length, WriteOffset, StreamSize); // Write the data to the attribute - Status = WriteAttribute(DeviceExt, DataContext, WriteOffset, Buffer, Length, LengthWritten); + Status = WriteAttribute(DeviceExt, DataContext, WriteOffset, Buffer, Length, LengthWritten, FileRecord); // Did the write fail? if (!NT_SUCCESS(Status)) diff --git a/drivers/filesystems/ntfs/volinfo.c b/drivers/filesystems/ntfs/volinfo.c index d1efa4c269..6b7e598819 100644 --- a/drivers/filesystems/ntfs/volinfo.c +++ b/drivers/filesystems/ntfs/volinfo.c @@ -196,7 +196,7 @@ NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt, } - Status = WriteAttribute(DeviceExt, DataContext, 0, BitmapData, (ULONG)BitmapDataSize, &LengthWritten); + Status = WriteAttribute(DeviceExt, DataContext, 0, BitmapData, (ULONG)BitmapDataSize, &LengthWritten, BitmapRecord); ReleaseAttributeContext(DataContext);

7 years

[reactos] 61/72: [NTFS] - Refactor to allow the copy of the attribute stored in NTFS_ATTR_CONTEXT to have a dynamic length; change Record member from an NTFS_ATTR_RECORD to a PNTFS_ATTR_RECORD. Rename it pRecord to reinforce the change. Fix some bugs related to the record size changing. -PrepareAttributeContext() - update to allocate memory for pRecord. Don't assume allocations are succeeding. -ReleaseAttributeContext() - update to free memory for pRecord. -InternalSetResidentAttributeLength() -

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=4dfcd1d58295e72486625… commit 4dfcd1d58295e72486625ab6063a3d5bf3e59a2c Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun Aug 6 02:54:15 2017 +0000 [NTFS] - Refactor to allow the copy of the attribute stored in NTFS_ATTR_CONTEXT to have a dynamic length; change Record member from an NTFS_ATTR_RECORD to a PNTFS_ATTR_RECORD. Rename it pRecord to reinforce the change. Fix some bugs related to the record size changing. -PrepareAttributeContext() - update to allocate memory for pRecord. Don't assume allocations are succeeding. -ReleaseAttributeContext() - update to free memory for pRecord. -InternalSetResidentAttributeLength() - Increase size of AttrContext->pRecord as needed. Update to return an NTSTATUS. -SetResidentAttributeDataLength() - Fix bug that could occur when migrating resident attributes to non-resident if AttrContext->pRecord is too small for the new attribute. -AddRun() - Fix a bug by reallocating AttrContext->pRecord if the record needs to be enlarged. svn path=/branches/GSoC_2016/NTFS/; revision=75493 --- drivers/filesystems/ntfs/attrib.c | 58 ++++++--- drivers/filesystems/ntfs/btree.c | 4 +- drivers/filesystems/ntfs/dirctl.c | 4 +- drivers/filesystems/ntfs/fcb.c | 2 +- drivers/filesystems/ntfs/finfo.c | 4 +- drivers/filesystems/ntfs/fsctl.c | 8 +- drivers/filesystems/ntfs/mft.c | 236 ++++++++++++++++++++++++------------- drivers/filesystems/ntfs/ntfs.h | 4 +- drivers/filesystems/ntfs/rw.c | 8 +- drivers/filesystems/ntfs/volinfo.c | 4 +- 10 files changed, 214 insertions(+), 118 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index a6bc9a8aca..8618862344 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -303,17 +303,17 @@ AddRun(PNTFS_VCB Vcb, NTSTATUS Status; int DataRunMaxLength; PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); - ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; + ULONG NextAttributeOffset = AttrOffset + AttrContext->pRecord->Length; ULONGLONG NextVBN = 0; PUCHAR RunBuffer; ULONG RunBufferSize; - if (!AttrContext->Record.IsNonResident) + if (!AttrContext->pRecord->IsNonResident) return STATUS_INVALID_PARAMETER; - if (AttrContext->Record.NonResident.AllocatedSize != 0) - NextVBN = AttrContext->Record.NonResident.HighestVCN + 1; + if (AttrContext->pRecord->NonResident.AllocatedSize != 0) + NextVBN = AttrContext->pRecord->NonResident.HighestVCN + 1; // Add newly-assigned clusters to mcb _SEH2_TRY @@ -344,12 +344,14 @@ AddRun(PNTFS_VCB Vcb, ConvertLargeMCBToDataRuns(&AttrContext->DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferSize); // 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; + DataRunMaxLength = AttrContext->pRecord->Length - AttrContext->pRecord->NonResident.MappingPairsOffset; // Do we need to extend the attribute (or convert to attribute list)? if (DataRunMaxLength < RunBufferSize) { PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); + PNTFS_ATTR_RECORD NewRecord; + DataRunMaxLength += Vcb->NtfsInfo.BytesPerFileRecord - NextAttributeOffset - (sizeof(ULONG) * 2); // Can we move the end of the attribute? @@ -363,12 +365,22 @@ AddRun(PNTFS_VCB Vcb, } // calculate position of end markers - NextAttributeOffset = AttrOffset + AttrContext->Record.NonResident.MappingPairsOffset + RunBufferSize; + NextAttributeOffset = AttrOffset + AttrContext->pRecord->NonResident.MappingPairsOffset + RunBufferSize; NextAttributeOffset = ALIGN_UP_BY(NextAttributeOffset, ATTR_RECORD_ALIGNMENT); - // Update the length + // Update the length of the destination attribute DestinationAttribute->Length = NextAttributeOffset - AttrOffset; - AttrContext->Record.Length = DestinationAttribute->Length; + + // Create a new copy of the attribute + NewRecord = ExAllocatePoolWithTag(NonPagedPool, DestinationAttribute->Length, TAG_NTFS); + RtlCopyMemory(NewRecord, AttrContext->pRecord, AttrContext->pRecord->Length); + NewRecord->Length = DestinationAttribute->Length; + + // Free the old copy of the attribute, which won't be large enough + ExFreePoolWithTag(AttrContext->pRecord, TAG_NTFS); + + // Set the attribute context's record to the new copy + AttrContext->pRecord = NewRecord; // End the file record NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); @@ -377,14 +389,19 @@ AddRun(PNTFS_VCB Vcb, // Update HighestVCN DestinationAttribute->NonResident.HighestVCN = - AttrContext->Record.NonResident.HighestVCN = max(NextVBN - 1 + RunLength, - AttrContext->Record.NonResident.HighestVCN); + AttrContext->pRecord->NonResident.HighestVCN = max(NextVBN - 1 + RunLength, + AttrContext->pRecord->NonResident.HighestVCN); // Write data runs to destination attribute RtlCopyMemory((PVOID)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), RunBuffer, RunBufferSize); + // Update the attribute copy in the attribute context + RtlCopyMemory((PVOID)((ULONG_PTR)AttrContext->pRecord + AttrContext->pRecord->NonResident.MappingPairsOffset), + RunBuffer, + RunBufferSize); + // Update the file record Status = UpdateFileRecord(Vcb, AttrContext->FileMFTIndex, FileRecord); @@ -723,7 +740,7 @@ FreeClusters(PNTFS_VCB Vcb, ULONG ClustersLeftToFree = ClustersToFree; PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); - ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; + ULONG NextAttributeOffset = AttrOffset + AttrContext->pRecord->Length; PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); PUCHAR RunBuffer; @@ -736,7 +753,7 @@ FreeClusters(PNTFS_VCB Vcb, RTL_BITMAP Bitmap; ULONG LengthWritten; - if (!AttrContext->Record.IsNonResident) + if (!AttrContext->pRecord->IsNonResident) { return STATUS_INVALID_PARAMETER; } @@ -767,7 +784,7 @@ FreeClusters(PNTFS_VCB Vcb, return 0; } - BitmapDataSize = AttributeDataLength(&DataContext->Record); + BitmapDataSize = AttributeDataLength(DataContext->pRecord); BitmapDataSize = min(BitmapDataSize, ULONG_MAX); ASSERT((BitmapDataSize * 8) >= Vcb->NtfsInfo.ClusterCount); BitmapData = ExAllocatePoolWithTag(NonPagedPool, ROUND_UP(BitmapDataSize, Vcb->NtfsInfo.BytesPerSector), TAG_NTFS); @@ -802,10 +819,10 @@ FreeClusters(PNTFS_VCB Vcb, // deallocate this cluster RtlClearBits(&Bitmap, LargeLbn, 1); } - FsRtlTruncateLargeMcb(&AttrContext->DataRunsMCB, AttrContext->Record.NonResident.HighestVCN); + FsRtlTruncateLargeMcb(&AttrContext->DataRunsMCB, AttrContext->pRecord->NonResident.HighestVCN); // decrement HighestVCN, but don't let it go below 0 - AttrContext->Record.NonResident.HighestVCN = min(AttrContext->Record.NonResident.HighestVCN, AttrContext->Record.NonResident.HighestVCN - 1); + AttrContext->pRecord->NonResident.HighestVCN = min(AttrContext->pRecord->NonResident.HighestVCN, AttrContext->pRecord->NonResident.HighestVCN - 1); ClustersLeftToFree--; } @@ -837,7 +854,7 @@ FreeClusters(PNTFS_VCB Vcb, ConvertLargeMCBToDataRuns(&AttrContext->DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferSize); // Update HighestVCN - DestinationAttribute->NonResident.HighestVCN = AttrContext->Record.NonResident.HighestVCN; + DestinationAttribute->NonResident.HighestVCN = AttrContext->pRecord->NonResident.HighestVCN; // Write data runs to destination attribute RtlCopyMemory((PVOID)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), @@ -848,9 +865,12 @@ FreeClusters(PNTFS_VCB Vcb, if (NextAttribute->Type == AttributeEnd) { // update attribute length - AttrContext->Record.Length = ALIGN_UP_BY(AttrContext->Record.NonResident.MappingPairsOffset + RunBufferSize, + DestinationAttribute->Length = ALIGN_UP_BY(AttrContext->pRecord->NonResident.MappingPairsOffset + RunBufferSize, ATTR_RECORD_ALIGNMENT); - DestinationAttribute->Length = AttrContext->Record.Length; + + ASSERT(DestinationAttribute->Length <= AttrContext->pRecord->Length); + + AttrContext->pRecord->Length = DestinationAttribute->Length; // write end markers NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); @@ -893,7 +913,7 @@ InternalReadNonResidentAttributes(PFIND_ATTR_CONTXT Context) } ListContext = PrepareAttributeContext(Attribute); - ListSize = AttributeDataLength(&ListContext->Record); + ListSize = AttributeDataLength(ListContext->pRecord); if (ListSize > 0xFFFFFFFF) { ReleaseAttributeContext(ListContext); diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index c1a907e8fe..dbbf3f9f87 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -41,7 +41,7 @@ PrintAllVCNs(PDEVICE_EXTENSION Vcb, { ULONGLONG CurrentOffset = 0; PINDEX_BUFFER CurrentNode, Buffer; - ULONGLONG BufferSize = AttributeDataLength(&IndexAllocationContext->Record); + ULONGLONG BufferSize = AttributeDataLength(IndexAllocationContext->pRecord); ULONG BytesRead; ULONGLONG i; int Count = 0; @@ -393,7 +393,7 @@ CreateBTreeFromIndex(PDEVICE_EXTENSION Vcb, Tree->RootNode = RootNode; // Make sure we won't try reading past the attribute-end - if (FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) + IndexRoot->Header.TotalSizeOfEntries > IndexRootContext->Record.Resident.ValueLength) + if (FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) + IndexRoot->Header.TotalSizeOfEntries > IndexRootContext->pRecord->Resident.ValueLength) { DPRINT1("Filesystem corruption detected!\n"); DestroyBTree(Tree); diff --git a/drivers/filesystems/ntfs/dirctl.c b/drivers/filesystems/ntfs/dirctl.c index 98294b4791..61316cb77d 100644 --- a/drivers/filesystems/ntfs/dirctl.c +++ b/drivers/filesystems/ntfs/dirctl.c @@ -49,8 +49,8 @@ NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt, Status = FindAttribute(DeviceExt, FileRecord, AttributeData, Stream, StreamLength, &DataContext, NULL); if (NT_SUCCESS(Status)) { - Size = AttributeDataLength(&DataContext->Record); - Allocated = AttributeAllocatedLength(&DataContext->Record); + Size = AttributeDataLength(DataContext->pRecord); + Allocated = AttributeAllocatedLength(DataContext->pRecord); ReleaseAttributeContext(DataContext); } diff --git a/drivers/filesystems/ntfs/fcb.c b/drivers/filesystems/ntfs/fcb.c index fe79511bb3..f8057ee2ff 100644 --- a/drivers/filesystems/ntfs/fcb.c +++ b/drivers/filesystems/ntfs/fcb.c @@ -756,7 +756,7 @@ NtfsReadFCBAttribute(PNTFS_VCB Vcb, return Status; } - AttrLength = AttributeDataLength(&AttrCtxt->Record); + AttrLength = AttributeDataLength(AttrCtxt->pRecord); *Data = ExAllocatePoolWithTag(NonPagedPool, AttrLength, TAG_NTFS); if (*Data == NULL) { diff --git a/drivers/filesystems/ntfs/finfo.c b/drivers/filesystems/ntfs/finfo.c index 37debba2ca..fb7df5f4d4 100644 --- a/drivers/filesystems/ntfs/finfo.c +++ b/drivers/filesystems/ntfs/finfo.c @@ -631,7 +631,7 @@ NtfsSetEndOfFile(PNTFS_FCB Fcb, } // Get the size of the data attribute - CurrentFileSize.QuadPart = AttributeDataLength(&DataContext->Record); + CurrentFileSize.QuadPart = AttributeDataLength(DataContext->pRecord); // Are we enlarging the attribute? if (NewFileSize->QuadPart > CurrentFileSize.QuadPart) @@ -673,7 +673,7 @@ NtfsSetEndOfFile(PNTFS_FCB Fcb, FileName.Length = FileNameAttribute->NameLength * sizeof(WCHAR); FileName.MaximumLength = FileName.Length; - AllocationSize = AttributeAllocatedLength(&DataContext->Record); + AllocationSize = AttributeAllocatedLength(DataContext->pRecord); Status = UpdateFileNameRecord(Fcb->Vcb, ParentMFTId, diff --git a/drivers/filesystems/ntfs/fsctl.c b/drivers/filesystems/ntfs/fsctl.c index 8acdd64e16..76337ec448 100644 --- a/drivers/filesystems/ntfs/fsctl.c +++ b/drivers/filesystems/ntfs/fsctl.c @@ -341,9 +341,9 @@ NtfsGetVolumeData(PDEVICE_OBJECT DeviceObject, /* Get volume name */ Status = FindAttribute(DeviceExt, VolumeRecord, AttributeVolumeName, L"", 0, &AttrCtxt, NULL); - if (NT_SUCCESS(Status) && AttrCtxt->Record.Resident.ValueLength != 0) + if (NT_SUCCESS(Status) && AttrCtxt->pRecord->Resident.ValueLength != 0) { - Attribute = &AttrCtxt->Record; + Attribute = AttrCtxt->pRecord; DPRINT("Data length %lu\n", AttributeDataLength(Attribute)); NtfsInfo->VolumeLabelLength = min (Attribute->Resident.ValueLength, MAXIMUM_VOLUME_LABEL_LENGTH); @@ -382,9 +382,9 @@ NtfsGetVolumeData(PDEVICE_OBJECT DeviceObject, /* Get volume information */ Status = FindAttribute(DeviceExt, VolumeRecord, AttributeVolumeInformation, L"", 0, &AttrCtxt, NULL); - if (NT_SUCCESS(Status) && AttrCtxt->Record.Resident.ValueLength != 0) + if (NT_SUCCESS(Status) && AttrCtxt->pRecord->Resident.ValueLength != 0) { - Attribute = &AttrCtxt->Record; + Attribute = AttrCtxt->pRecord; DPRINT("Data length %lu\n", AttributeDataLength (Attribute)); VolumeInfo = (PVOID)((ULONG_PTR)Attribute + Attribute->Resident.ValueOffset); diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 83c966972a..23f802dfca 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -42,15 +42,32 @@ PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord) PNTFS_ATTR_CONTEXT Context; Context = ExAllocatePoolWithTag(NonPagedPool, - FIELD_OFFSET(NTFS_ATTR_CONTEXT, Record) + AttrRecord->Length, + sizeof(NTFS_ATTR_CONTEXT), TAG_NTFS); - RtlCopyMemory(&Context->Record, AttrRecord, AttrRecord->Length); + if(!Context) + { + DPRINT1("Error: Unable to allocate memory for context!\n"); + return NULL; + } + + // Allocate memory for a copy of the attribute + Context->pRecord = ExAllocatePoolWithTag(NonPagedPool, AttrRecord->Length, TAG_NTFS); + if(!Context->pRecord) + { + DPRINT1("Error: Unable to allocate memory for attribute record!\n"); + ExFreePoolWithTag(Context, TAG_NTFS); + return NULL; + } + + // Copy the attribute + RtlCopyMemory(Context->pRecord, AttrRecord, AttrRecord->Length); + if (AttrRecord->IsNonResident) { LONGLONG DataRunOffset; ULONGLONG DataRunLength; ULONGLONG NextVBN = 0; - PUCHAR DataRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset; + PUCHAR DataRun = (PUCHAR)((ULONG_PTR)Context->pRecord + Context->pRecord->NonResident.MappingPairsOffset); Context->CacheRun = DataRun; Context->CacheRunOffset = 0; @@ -74,6 +91,7 @@ PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord) if (!NT_SUCCESS(ConvertDataRunsToLargeMCB(DataRun, &Context->DataRunsMCB, &NextVBN))) { DPRINT1("Unable to convert data runs to MCB!\n"); + ExFreePoolWithTag(Context->pRecord, TAG_NTFS); ExFreePoolWithTag(Context, TAG_NTFS); return NULL; } @@ -86,11 +104,14 @@ PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord) VOID ReleaseAttributeContext(PNTFS_ATTR_CONTEXT Context) { - if (Context->Record.IsNonResident) + if (Context->pRecord->IsNonResident) { FsRtlUninitializeLargeMcb(&Context->DataRunsMCB); } + if(Context->pRecord) + ExFreePoolWithTag(Context->pRecord, TAG_NTFS); + ExFreePoolWithTag(Context, TAG_NTFS); } @@ -245,10 +266,10 @@ IncreaseMftSize(PDEVICE_EXTENSION Vcb, BOOLEAN CanWait) } // Get size of Bitmap Attribute - BitmapSize.QuadPart = AttributeDataLength(&BitmapContext->Record); + BitmapSize.QuadPart = AttributeDataLength(BitmapContext->pRecord); // Calculate the new mft size - DataSize.QuadPart = AttributeDataLength(&(Vcb->MFTContext->Record)) + DataSizeDifference; + DataSize.QuadPart = AttributeDataLength(Vcb->MFTContext->pRecord) + DataSizeDifference; // Determine how many bytes will make up the bitmap BitmapBytes = DataSize.QuadPart / Vcb->NtfsInfo.BytesPerFileRecord / 8; @@ -301,7 +322,7 @@ IncreaseMftSize(PDEVICE_EXTENSION Vcb, BOOLEAN CanWait) { // Set the new bitmap size BitmapSize.QuadPart += BitmapSizeDifference; - if (BitmapContext->Record.IsNonResident) + if (BitmapContext->pRecord->IsNonResident) Status = SetNonResidentAttributeDataLength(Vcb, BitmapContext, BitmapOffset, Vcb->MasterFileTable, &BitmapSize); else Status = SetResidentAttributeDataLength(Vcb, BitmapContext, BitmapOffset, Vcb->MasterFileTable, &BitmapSize); @@ -348,7 +369,7 @@ IncreaseMftSize(PDEVICE_EXTENSION Vcb, BOOLEAN CanWait) return STATUS_SUCCESS; } -VOID +NTSTATUS InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, PFILE_RECORD_HEADER FileRecord, ULONG AttrOffset, @@ -356,32 +377,45 @@ InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, { PNTFS_ATTR_RECORD Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); ULONG NextAttributeOffset; + USHORT ValueOffset; DPRINT("InternalSetResidentAttributeLength( %p, %p, %lu, %lu )\n", AttrContext, FileRecord, AttrOffset, DataSize); - ASSERT(!AttrContext->Record.IsNonResident); + ASSERT(!AttrContext->pRecord->IsNonResident); - // update ValueLength Field - AttrContext->Record.Resident.ValueLength = + // Update ValueLength Field Destination->Resident.ValueLength = DataSize; - // calculate the record length and end marker offset - AttrContext->Record.Length = - Destination->Length = DataSize + AttrContext->Record.Resident.ValueOffset; - NextAttributeOffset = AttrOffset + AttrContext->Record.Length; + // Calculate the record length and end marker offset + Destination->Length = ALIGN_UP_BY(DataSize + AttrContext->pRecord->Resident.ValueOffset, ATTR_RECORD_ALIGNMENT); + NextAttributeOffset = AttrOffset + Destination->Length; - // Ensure NextAttributeOffset is aligned to an 8-byte boundary - if (NextAttributeOffset % 8 != 0) + // Ensure FileRecord has an up-to-date copy of the attribute + ValueOffset = AttrContext->pRecord->Resident.ValueOffset; + RtlCopyMemory((PCHAR)((ULONG_PTR)FileRecord + AttrOffset + ValueOffset), + (PCHAR)((ULONG_PTR)AttrContext->pRecord + ValueOffset), + min(DataSize, AttrContext->pRecord->Resident.ValueLength)); + + // Free the old copy of the attribute in the context, as it will be the wrong length + ExFreePoolWithTag(AttrContext->pRecord, TAG_NTFS); + + // Create a new copy of the attribute for the context + AttrContext->pRecord = ExAllocatePoolWithTag(NonPagedPool, Destination->Length, TAG_NTFS); + if (!AttrContext->pRecord) { - USHORT Padding = ATTR_RECORD_ALIGNMENT - (NextAttributeOffset % ATTR_RECORD_ALIGNMENT); - NextAttributeOffset += Padding; - AttrContext->Record.Length += Padding; - Destination->Length += Padding; + DPRINT1("Unable to allocate memory for attribute!\n"); + return STATUS_INSUFFICIENT_RESOURCES; } + RtlCopyMemory(AttrContext->pRecord, Destination, Destination->Length); + + // Ensure NextAttributeOffset is aligned to an 8-byte boundary + ASSERT(NextAttributeOffset % ATTR_RECORD_ALIGNMENT == 0); // advance Destination to the final "attribute" and set the file record end Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)Destination + Destination->Length); SetFileRecordEnd(FileRecord, Destination, FILE_RECORD_END); + + return STATUS_SUCCESS; } /** @@ -408,7 +442,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, DataSize->QuadPart); // are we truncating the file? - if (DataSize->QuadPart < AttributeDataLength(&AttrContext->Record)) + if (DataSize->QuadPart < AttributeDataLength(AttrContext->pRecord)) { if (!MmCanFileBeTruncated(FileObject->SectionObjectPointer, DataSize)) { @@ -417,7 +451,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, } } - if (AttrContext->Record.IsNonResident) + if (AttrContext->pRecord->IsNonResident) { Status = SetNonResidentAttributeDataLength(Fcb->Vcb, AttrContext, @@ -448,8 +482,8 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, if (NT_SUCCESS(Status)) { - if (AttrContext->Record.IsNonResident) - Fcb->RFCB.AllocationSize.QuadPart = AttrContext->Record.NonResident.AllocatedSize; + if (AttrContext->pRecord->IsNonResident) + Fcb->RFCB.AllocationSize.QuadPart = AttrContext->pRecord->NonResident.AllocatedSize; else Fcb->RFCB.AllocationSize = *DataSize; Fcb->RFCB.FileSize = *DataSize; @@ -538,12 +572,12 @@ SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, ULONG BytesPerCluster = 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; + ULONG ExistingClusters = AttrContext->pRecord->NonResident.AllocatedSize / BytesPerCluster; - ASSERT(AttrContext->Record.IsNonResident); + ASSERT(AttrContext->pRecord->IsNonResident); // do we need to increase the allocation size? - if (AttrContext->Record.NonResident.AllocatedSize < AllocationSize) + if (AttrContext->pRecord->NonResident.AllocatedSize < AllocationSize) { ULONG ClustersNeeded = (AllocationSize / BytesPerCluster) - ExistingClusters; LARGE_INTEGER LastClusterInDataRun; @@ -557,7 +591,7 @@ SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, else { if (!FsRtlLookupLargeMcbEntry(&AttrContext->DataRunsMCB, - (LONGLONG)AttrContext->Record.NonResident.HighestVCN, + (LONGLONG)AttrContext->pRecord->NonResident.HighestVCN, (PLONGLONG)&LastClusterInDataRun.QuadPart, NULL, NULL, @@ -567,13 +601,13 @@ SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, DPRINT1("Error looking up final large MCB entry!\n"); // Most likely, HighestVCN went above the largest mapping - DPRINT1("Highest VCN of record: %I64u\n", AttrContext->Record.NonResident.HighestVCN); + DPRINT1("Highest VCN of record: %I64u\n", AttrContext->pRecord->NonResident.HighestVCN); return STATUS_INVALID_PARAMETER; } } DPRINT("LastClusterInDataRun: %I64u\n", LastClusterInDataRun.QuadPart); - DPRINT("Highest VCN of record: %I64u\n", AttrContext->Record.NonResident.HighestVCN); + DPRINT("Highest VCN of record: %I64u\n", AttrContext->pRecord->NonResident.HighestVCN); while (ClustersNeeded > 0) { @@ -601,7 +635,7 @@ SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, LastClusterInDataRun.LowPart = NextAssignedCluster + AssignedClusters - 1; } } - else if (AttrContext->Record.NonResident.AllocatedSize > AllocationSize) + else if (AttrContext->pRecord->NonResident.AllocatedSize > AllocationSize) { // shrink allocation size ULONG ClustersToFree = ExistingClusters - (AllocationSize / BytesPerCluster); @@ -610,9 +644,9 @@ SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, // TODO: is the file compressed, encrypted, or sparse? - AttrContext->Record.NonResident.AllocatedSize = AllocationSize; - AttrContext->Record.NonResident.DataSize = DataSize->QuadPart; - AttrContext->Record.NonResident.InitializedSize = DataSize->QuadPart; + AttrContext->pRecord->NonResident.AllocatedSize = AllocationSize; + AttrContext->pRecord->NonResident.DataSize = DataSize->QuadPart; + AttrContext->pRecord->NonResident.InitializedSize = DataSize->QuadPart; DestinationAttribute->NonResident.AllocatedSize = AllocationSize; DestinationAttribute->NonResident.DataSize = DataSize->QuadPart; @@ -667,18 +701,18 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, NTSTATUS Status; // find the next attribute - ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; + ULONG NextAttributeOffset = AttrOffset + AttrContext->pRecord->Length; PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((PCHAR)FileRecord + NextAttributeOffset); - ASSERT(!AttrContext->Record.IsNonResident); + ASSERT(!AttrContext->pRecord->IsNonResident); //NtfsDumpFileAttributes(Vcb, FileRecord); // Do we need to increase the data length? - if (DataSize->QuadPart > AttrContext->Record.Resident.ValueLength) + if (DataSize->QuadPart > AttrContext->pRecord->Resident.ValueLength) { // There's usually padding at the end of a record. Do we need to extend past it? - ULONG MaxValueLength = AttrContext->Record.Length - AttrContext->Record.Resident.ValueOffset; + ULONG MaxValueLength = AttrContext->pRecord->Length - AttrContext->pRecord->Resident.ValueOffset; if (MaxValueLength < DataSize->LowPart) { // If this is the last attribute, we could move the end marker to the very end of the file record @@ -688,14 +722,16 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, { // convert attribute to non-resident PNTFS_ATTR_RECORD Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); + PNTFS_ATTR_RECORD NewRecord; LARGE_INTEGER AttribDataSize; PVOID AttribData; + ULONG NewRecordLength; ULONG EndAttributeOffset; ULONG LengthWritten; DPRINT1("Converting attribute to non-resident.\n"); - AttribDataSize.QuadPart = AttrContext->Record.Resident.ValueLength; + AttribDataSize.QuadPart = AttrContext->pRecord->Resident.ValueLength; // Is there existing data we need to back-up? if (AttribDataSize.QuadPart > 0) @@ -719,23 +755,43 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, // Start by turning this attribute into a 0-length, non-resident attribute, then enlarge it. + // The size of a 0-length, non-resident attribute will be 0x41 + the size of the attribute name, aligned to an 8-byte boundary + NewRecordLength = ALIGN_UP_BY(0x41 + (AttrContext->pRecord->NameLength * sizeof(WCHAR)), ATTR_RECORD_ALIGNMENT); + + // Create a new attribute record that will store the 0-length, non-resident attribute + NewRecord = ExAllocatePoolWithTag(NonPagedPool, NewRecordLength, TAG_NTFS); + // Zero out the NonResident structure - RtlZeroMemory(&AttrContext->Record.NonResident.LowestVCN, - FIELD_OFFSET(NTFS_ATTR_RECORD, NonResident.CompressedSize) - FIELD_OFFSET(NTFS_ATTR_RECORD, NonResident.LowestVCN)); - RtlZeroMemory(&Destination->NonResident.LowestVCN, - FIELD_OFFSET(NTFS_ATTR_RECORD, NonResident.CompressedSize) - FIELD_OFFSET(NTFS_ATTR_RECORD, NonResident.LowestVCN)); + RtlZeroMemory(NewRecord, NewRecordLength); + + // Copy the data that's common to both non-resident and resident attributes + RtlCopyMemory(NewRecord, AttrContext->pRecord, FIELD_OFFSET(NTFS_ATTR_RECORD, Resident.ValueLength)); + + // if there's a name + if (AttrContext->pRecord->NameLength != 0) + { + // copy the name + // An attribute name will be located at offset 0x18 for a resident attribute, 0x40 for non-resident + RtlCopyMemory((PCHAR)((ULONG_PTR)NewRecord + 0x40), + (PCHAR)((ULONG_PTR)AttrContext->pRecord + 0x18), + AttrContext->pRecord->NameLength * sizeof(WCHAR)); + } - // update the mapping pairs offset, which will be 0x40 + length in bytes of the name - AttrContext->Record.NonResident.MappingPairsOffset = Destination->NonResident.MappingPairsOffset = 0x40 + (Destination->NameLength * 2); + // update the mapping pairs offset, which will be 0x40 (size of a non-resident header) + length in bytes of the name + NewRecord->NonResident.MappingPairsOffset = 0x40 + (AttrContext->pRecord->NameLength * sizeof(WCHAR)); // update the end of the file record // calculate position of end markers (1 byte for empty data run) - EndAttributeOffset = AttrOffset + AttrContext->Record.NonResident.MappingPairsOffset + 1; + EndAttributeOffset = AttrOffset + NewRecord->NonResident.MappingPairsOffset + 1; EndAttributeOffset = ALIGN_UP_BY(EndAttributeOffset, ATTR_RECORD_ALIGNMENT); // Update the length - Destination->Length = EndAttributeOffset - AttrOffset; - AttrContext->Record.Length = Destination->Length; + NewRecord->Length = EndAttributeOffset - AttrOffset; + + ASSERT(NewRecord->Length == NewRecordLength); + + // Copy the new attribute record into the file record + RtlCopyMemory(Destination, NewRecord, NewRecord->Length); // Update the file record end SetFileRecordEnd(FileRecord, @@ -756,7 +812,7 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, } _SEH2_END; // Mark the attribute as non-resident (we wait until after we know the LargeMcb was initialized) - AttrContext->Record.IsNonResident = Destination->IsNonResident = 1; + NewRecord->IsNonResident = Destination->IsNonResident = 1; // Update file record on disk Status = UpdateFileRecord(Vcb, AttrContext->FileMFTIndex, FileRecord); @@ -768,6 +824,10 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, return Status; } + // Now we need to free the old copy of the attribute record in the context and replace it with the new one + ExFreePoolWithTag(AttrContext->pRecord, TAG_NTFS); + AttrContext->pRecord = NewRecord; + // Now we can treat the attribute as non-resident and enlarge it normally Status = SetNonResidentAttributeDataLength(Vcb, AttrContext, AttrOffset, FileRecord, DataSize); if (!NT_SUCCESS(Status)) @@ -795,7 +855,7 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, } } } - else if (DataSize->LowPart < AttrContext->Record.Resident.ValueLength) + else if (DataSize->LowPart < AttrContext->pRecord->Resident.ValueLength) { // we need to decrease the length if (NextAttribute->Type != AttributeEnd) @@ -806,8 +866,8 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, } // set the new length of the resident attribute (if we didn't migrate it) - if (!AttrContext->Record.IsNonResident) - InternalSetResidentAttributeLength(AttrContext, FileRecord, AttrOffset, DataSize->LowPart); + if (!AttrContext->pRecord->IsNonResident) + return InternalSetResidentAttributeLength(AttrContext, FileRecord, AttrOffset, DataSize->LowPart); return STATUS_SUCCESS; } @@ -832,13 +892,19 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, //TEMPTEMP PUCHAR TempBuffer; - if (!Context->Record.IsNonResident) + if (!Context->pRecord->IsNonResident) { - if (Offset > Context->Record.Resident.ValueLength) + // We need to truncate Offset to a ULONG for pointer arithmetic + // The check below should ensure that Offset is well within the range of 32 bits + ULONG LittleOffset = (ULONG)Offset; + + // Ensure that offset isn't beyond the end of the attribute + if (Offset > Context->pRecord->Resident.ValueLength) return 0; - if (Offset + Length > Context->Record.Resident.ValueLength) - Length = (ULONG)(Context->Record.Resident.ValueLength - Offset); - RtlCopyMemory(Buffer, (PCHAR)&Context->Record + Context->Record.Resident.ValueOffset + Offset, Length); + if (Offset + Length > Context->pRecord->Resident.ValueLength) + Length = (ULONG)(Context->pRecord->Resident.ValueLength - Offset); + + RtlCopyMemory(Buffer, (PVOID)((ULONG_PTR)Context->pRecord + Context->pRecord->Resident.ValueOffset + LittleOffset), Length); return Length; } @@ -996,7 +1062,7 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, } /* if Disk */ // TEMPTEMP - if (Context->Record.IsNonResident) + if (Context->pRecord->IsNonResident) ExFreePoolWithTag(TempBuffer, TAG_NTFS); Context->CacheRun = DataRun; @@ -1073,13 +1139,13 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, *RealLengthWritten = 0; // is this a resident attribute? - if (!Context->Record.IsNonResident) + if (!Context->pRecord->IsNonResident) { ULONG AttributeOffset; PNTFS_ATTR_CONTEXT FoundContext; PFILE_RECORD_HEADER FileRecord; - if (Offset + Length > Context->Record.Resident.ValueLength) + if (Offset + Length > Context->pRecord->Resident.ValueLength) { DPRINT1("DRIVER ERROR: Attribute is too small!\n"); return STATUS_INVALID_PARAMETER; @@ -1098,9 +1164,9 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, // find where to write the attribute data to Status = FindAttribute(Vcb, FileRecord, - Context->Record.Type, - (PCWSTR)((PCHAR)&Context->Record + Context->Record.NameOffset), - Context->Record.NameLength, + Context->pRecord->Type, + (PCWSTR)((ULONG_PTR)Context->pRecord + Context->pRecord->NameOffset), + Context->pRecord->NameLength, &FoundContext, &AttributeOffset); @@ -1111,8 +1177,8 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, return Status; } - DPRINT("Offset: %I64u, AttributeOffset: %u, ValueOffset: %u\n", Offset, AttributeOffset, Context->Record.Resident.ValueLength); - Offset += AttributeOffset + Context->Record.Resident.ValueOffset; + DPRINT("Offset: %I64u, AttributeOffset: %u, ValueOffset: %u\n", Offset, AttributeOffset, Context->pRecord->Resident.ValueLength); + Offset += AttributeOffset + Context->pRecord->Resident.ValueOffset; if (Offset + Length > Vcb->NtfsInfo.BytesPerFileRecord) { @@ -1320,7 +1386,7 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, } // end while (Length > 0) [more data to write] // TEMPTEMP - if (Context->Record.IsNonResident) + if (Context->pRecord->IsNonResident) ExFreePoolWithTag(TempBuffer, TAG_NTFS); Context->CacheRun = DataRun; @@ -1419,7 +1485,7 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, return STATUS_INSUFFICIENT_RESOURCES; } - Status = ReadAttribute(Vcb, IndexRootCtx, 0, IndexRecord, AttributeDataLength(&IndexRootCtx->Record)); + Status = ReadAttribute(Vcb, IndexRootCtx, 0, IndexRecord, AttributeDataLength(IndexRootCtx->pRecord)); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Failed to read Index Root!\n"); @@ -1453,7 +1519,7 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, { // we need to write the index root attribute back to disk ULONG LengthWritten; - Status = WriteAttribute(Vcb, IndexRootCtx, 0, (PUCHAR)IndexRecord, AttributeDataLength(&IndexRootCtx->Record), &LengthWritten); + Status = WriteAttribute(Vcb, IndexRootCtx, 0, (PUCHAR)IndexRecord, AttributeDataLength(IndexRootCtx->pRecord), &LengthWritten); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Couldn't update Index Root!\n"); @@ -1551,7 +1617,7 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, return Status; } - IndexAllocationSize = AttributeDataLength(&IndexAllocationCtx->Record); + IndexAllocationSize = AttributeDataLength(IndexAllocationCtx->pRecord); Status = STATUS_OBJECT_PATH_NOT_FOUND; for (RecordOffset = 0; RecordOffset < IndexAllocationSize; RecordOffset += IndexBlockSize) { @@ -1747,7 +1813,7 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, } // allocate a buffer for the $Bitmap attribute - BitmapDataSize = AttributeDataLength(&BitmapContext->Record); + BitmapDataSize = AttributeDataLength(BitmapContext->pRecord); BitmapData = ExAllocatePoolWithTag(NonPagedPool, BitmapDataSize, TAG_NTFS); if (!BitmapData) { @@ -1772,7 +1838,7 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, BitmapData[2] = 0xff; // Calculate bit count - BitmapBits.QuadPart = AttributeDataLength(&(DeviceExt->MFTContext->Record)) / + BitmapBits.QuadPart = AttributeDataLength(DeviceExt->MFTContext->pRecord) / DeviceExt->NtfsInfo.BytesPerFileRecord; if (BitmapBits.HighPart != 0) { @@ -1942,12 +2008,12 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, // Find the maximum index size given what the file record can hold MaxIndexSize = DeviceExt->NtfsInfo.BytesPerFileRecord - IndexRootOffset - - IndexRootContext->Record.Resident.ValueOffset + - IndexRootContext->pRecord->Resident.ValueOffset - FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) - (sizeof(ULONG) * 2); // Allocate memory for the index root data - I30IndexRootLength = AttributeDataLength(&IndexRootContext->Record); + I30IndexRootLength = AttributeDataLength(IndexRootContext->pRecord); I30IndexRoot = ExAllocatePoolWithTag(NonPagedPool, I30IndexRootLength, TAG_NTFS); if (!I30IndexRoot) { @@ -2035,7 +2101,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, // $ATTRIBUTE_LIST's. AttributeLength = NewIndexRoot->Header.AllocatedSize + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header); - if (AttributeLength != IndexRootContext->Record.Resident.ValueLength) + if (AttributeLength != IndexRootContext->pRecord->Resident.ValueLength) { DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset); @@ -2052,10 +2118,20 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, } // Update the length of the attribute in the file record of the parent directory - InternalSetResidentAttributeLength(IndexRootContext, - ParentFileRecord, - IndexRootOffset, - AttributeLength); + Status = InternalSetResidentAttributeLength(IndexRootContext, + ParentFileRecord, + IndexRootOffset, + AttributeLength); + if (!NT_SUCCESS(Status)) + { + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + DPRINT1("ERROR: Unable to set resident attribute length!\n"); + return Status; + } + } NT_ASSERT(ParentFileRecord->BytesInUse <= DeviceExt->NtfsInfo.BytesPerFileRecord); @@ -2295,7 +2371,7 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, return Status; } - IndexAllocationSize = AttributeDataLength(&IndexAllocationCtx->Record); + IndexAllocationSize = AttributeDataLength(IndexAllocationCtx->pRecord); Status = STATUS_OBJECT_PATH_NOT_FOUND; for (RecordOffset = 0; RecordOffset < IndexAllocationSize; RecordOffset += IndexBlockSize) { diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 42168be1ab..668815ddd5 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -480,7 +480,7 @@ typedef struct _NTFS_ATTR_CONTEXT ULONGLONG CacheRunCurrentOffset; LARGE_MCB DataRunsMCB; ULONGLONG FileMFTIndex; - NTFS_ATTR_RECORD Record; + PNTFS_ATTR_RECORD pRecord; } NTFS_ATTR_CONTEXT, *PNTFS_ATTR_CONTEXT; #define FCB_CACHE_INITIALIZED 0x0001 @@ -959,7 +959,7 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, ULONGLONG AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord); -VOID +NTSTATUS InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, PFILE_RECORD_HEADER FileRecord, ULONG AttrOffset, diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index cb4646495f..2c21f3a449 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -126,7 +126,7 @@ NtfsReadFile(PDEVICE_EXTENSION DeviceExt, return Status; } - StreamSize = AttributeDataLength(&DataContext->Record); + StreamSize = AttributeDataLength(DataContext->pRecord); if (ReadOffset >= StreamSize) { DPRINT1("Reading beyond stream end!\n"); @@ -149,7 +149,7 @@ NtfsReadFile(PDEVICE_EXTENSION DeviceExt, /* do we need to extend RealLength by one sector? */ if (RealLength + RealReadOffset < ReadOffset + Length) { - if (RealReadOffset + RealLength + DeviceExt->NtfsInfo.BytesPerSector <= AttributeAllocatedLength(&DataContext->Record)) + if (RealReadOffset + RealLength + DeviceExt->NtfsInfo.BytesPerSector <= AttributeAllocatedLength(DataContext->pRecord)) RealLength += DeviceExt->NtfsInfo.BytesPerSector; } @@ -413,7 +413,7 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, } // Get the size of the stream on disk - StreamSize = AttributeDataLength(&DataContext->Record); + StreamSize = AttributeDataLength(DataContext->pRecord); DPRINT("WriteOffset: %lu\tStreamSize: %I64u\n", WriteOffset, StreamSize); @@ -442,7 +442,7 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, return Status; } - AllocationSize = AttributeAllocatedLength(&DataContext->Record); + AllocationSize = AttributeAllocatedLength(DataContext->pRecord); // 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 diff --git a/drivers/filesystems/ntfs/volinfo.c b/drivers/filesystems/ntfs/volinfo.c index 1a577d45e2..d1efa4c269 100644 --- a/drivers/filesystems/ntfs/volinfo.c +++ b/drivers/filesystems/ntfs/volinfo.c @@ -69,7 +69,7 @@ NtfsGetFreeClusters(PDEVICE_EXTENSION DeviceExt) return 0; } - BitmapDataSize = AttributeDataLength(&DataContext->Record); + BitmapDataSize = AttributeDataLength(DataContext->pRecord); ASSERT((BitmapDataSize * 8) >= DeviceExt->NtfsInfo.ClusterCount); BitmapData = ExAllocatePoolWithTag(NonPagedPool, ROUND_UP(BitmapDataSize, DeviceExt->NtfsInfo.BytesPerSector), TAG_NTFS); if (BitmapData == NULL) @@ -144,7 +144,7 @@ NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt, return Status; } - BitmapDataSize = AttributeDataLength(&DataContext->Record); + BitmapDataSize = AttributeDataLength(DataContext->pRecord); BitmapDataSize = min(BitmapDataSize, 0xffffffff); ASSERT((BitmapDataSize * 8) >= DeviceExt->NtfsInfo.ClusterCount); BitmapData = ExAllocatePoolWithTag(NonPagedPool, ROUND_UP(BitmapDataSize, DeviceExt->NtfsInfo.BytesPerSector), TAG_NTFS);

7 years

[reactos] 60/72: [NTFS] - Fix index entries storing the wrong allocated file size when the file is resident. Fix a typo in a DPRINT.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f2e47474f0cb3cd2d60ee… commit f2e47474f0cb3cd2d60ee8068a5040b998c82325 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Aug 4 17:58:06 2017 +0000 [NTFS] - Fix index entries storing the wrong allocated file size when the file is resident. Fix a typo in a DPRINT. svn path=/branches/GSoC_2016/NTFS/; revision=75479 --- drivers/filesystems/ntfs/finfo.c | 4 ++-- drivers/filesystems/ntfs/mft.c | 4 ++-- drivers/filesystems/ntfs/rw.c | 5 ++--- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/drivers/filesystems/ntfs/finfo.c b/drivers/filesystems/ntfs/finfo.c index aee8aa51e2..37debba2ca 100644 --- a/drivers/filesystems/ntfs/finfo.c +++ b/drivers/filesystems/ntfs/finfo.c @@ -597,7 +597,7 @@ NtfsSetEndOfFile(PNTFS_FCB Fcb, DPRINT("Found record for %wS\n", Fcb->ObjectName); - CurrentFileSize.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&CurrentFileSize); + CurrentFileSize.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, NULL); // Are we trying to decrease the file size? if (NewFileSize->QuadPart < CurrentFileSize.QuadPart) @@ -673,7 +673,7 @@ NtfsSetEndOfFile(PNTFS_FCB Fcb, FileName.Length = FileNameAttribute->NameLength * sizeof(WCHAR); FileName.MaximumLength = FileName.Length; - AllocationSize = ROUND_UP(NewFileSize->QuadPart, Fcb->Vcb->NtfsInfo.BytesPerCluster); + AllocationSize = AttributeAllocatedLength(&DataContext->Record); Status = UpdateFileNameRecord(Fcb->Vcb, ParentMFTId, diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 1df31aee0c..83c966972a 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -173,7 +173,7 @@ AttributeAllocatedLength(PNTFS_ATTR_RECORD AttrRecord) if (AttrRecord->IsNonResident) return AttrRecord->NonResident.AllocatedSize; else - return AttrRecord->Resident.ValueLength; + return ALIGN_UP_BY(AttrRecord->Resident.ValueLength, ATTR_RECORD_ALIGNMENT); } @@ -399,7 +399,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, { NTSTATUS Status = STATUS_SUCCESS; - DPRINT1("SetAttributeDataLenth(%p, %p, %p, %lu, %p, %I64u)\n", + DPRINT1("SetAttributeDataLength(%p, %p, %p, %lu, %p, %I64u)\n", FileObject, Fcb, AttrContext, diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 7ef808f8c2..cb4646495f 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -432,11 +432,8 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, DataSize.QuadPart = WriteOffset + Length; - AllocationSize = ROUND_UP(DataSize.QuadPart, Fcb->Vcb->NtfsInfo.BytesPerCluster); - // set the attribute data length Status = SetAttributeDataLength(FileObject, Fcb, DataContext, AttributeOffset, FileRecord, &DataSize); - if (!NT_SUCCESS(Status)) { ReleaseAttributeContext(DataContext); @@ -445,6 +442,8 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, return Status; } + AllocationSize = AttributeAllocatedLength(&DataContext->Record); + // 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] 59/72: [NTFS] - Add some improvements to B-Tree support. Add preliminary support for trees of arbitrary depth. Add support for creating files in directories which have an index allocation, provided there aren't too many files and the node doesn't need to be split. -CreateBTreeFromIndex() - Fix memory allocation; allocate sizeof(B_TREE_KEY) bytes for the key, not the size of the pointer. Add support for child nodes. Update parameter list. -CreateIndexRootFromBTree() - Update Header->Fla

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=92d1f92a6134c70c80e87… commit 92d1f92a6134c70c80e87d10dd79f3a80da70ffa Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Thu Jul 27 19:52:33 2017 +0000 [NTFS] - Add some improvements to B-Tree support. Add preliminary support for trees of arbitrary depth. Add support for creating files in directories which have an index allocation, provided there aren't too many files and the node doesn't need to be split. -CreateBTreeFromIndex() - Fix memory allocation; allocate sizeof(B_TREE_KEY) bytes for the key, not the size of the pointer. Add support for child nodes. Update parameter list. -CreateIndexRootFromBTree() - Update Header->Flags if any of index root's keys have sub-nodes. +CreateIndexBufferFromBTreeNode() - Converts a B-Tree node to an index buffer to be written to the index allocation. +UpdateIndexAllocation() - Updates all of the stale nodes in an index allocation based on a PB_TREE. +UpdateIndexNode() - Writes a B-Tree node into the index allocation. +CreateBTreeKeyFromFilename() - Creates a PB_TREE_KEY based on a FILENAME_ATTRIBUTE. -DestroyBTreeKey() - Destroy a child node, if present. -DumpBTreeKey() - Dump a child node, if present. -DumpBTreeNode() - Include Node->KeyCount in output. -NtfsAddFilenameToDirectory() - Call UpdateIndexAllocation() prior to CreateIndexRootFromBTree(). -Update B_TREE_FILENAME_NODE with members to keep track of its existence on disk. svn path=/branches/GSoC_2016/NTFS/; revision=75428 --- drivers/filesystems/ntfs/btree.c | 581 +++++++++++++++++++++++++++++++++++---- drivers/filesystems/ntfs/mft.c | 20 +- drivers/filesystems/ntfs/ntfs.h | 29 +- 3 files changed, 570 insertions(+), 60 deletions(-) diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index f4bdf909a1..c1a907e8fe 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -42,12 +42,13 @@ PrintAllVCNs(PDEVICE_EXTENSION Vcb, ULONGLONG CurrentOffset = 0; PINDEX_BUFFER CurrentNode, Buffer; ULONGLONG BufferSize = AttributeDataLength(&IndexAllocationContext->Record); + ULONG BytesRead; ULONGLONG i; int Count = 0; Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferSize, TAG_NTFS); - ULONG BytesRead = ReadAttribute(Vcb, IndexAllocationContext, 0, (PCHAR)Buffer, BufferSize); + BytesRead = ReadAttribute(Vcb, IndexAllocationContext, 0, (PCHAR)Buffer, BufferSize); ASSERT(BytesRead = BufferSize); @@ -152,6 +153,175 @@ CompareTreeKeys(PB_TREE_KEY Key1, PB_TREE_KEY Key2, BOOLEAN CaseSensitive) return Comparison; } +PB_TREE_FILENAME_NODE +CreateBTreeNodeFromIndexNode(PDEVICE_EXTENSION Vcb, + PINDEX_ROOT_ATTRIBUTE IndexRoot, + PNTFS_ATTR_CONTEXT IndexAllocationAttributeCtx, + PINDEX_ENTRY_ATTRIBUTE NodeEntry) +{ + PB_TREE_FILENAME_NODE NewNode; + PINDEX_ENTRY_ATTRIBUTE CurrentNodeEntry; + PINDEX_ENTRY_ATTRIBUTE FirstNodeEntry; + ULONG CurrentEntryOffset = 0; + PINDEX_BUFFER NodeBuffer; + ULONG IndexBufferSize = Vcb->NtfsInfo.BytesPerIndexRecord; + PULONGLONG NodeNumber; + PB_TREE_KEY CurrentKey; + NTSTATUS Status; + ULONGLONG IndexNodeOffset; + ULONG BytesRead; + + if (IndexAllocationAttributeCtx == NULL) + { + DPRINT1("ERROR: Couldn't find index allocation attribute even though there should be one!\n"); + return NULL; + } + + // Get the node number from the end of the node entry + NodeNumber = (PULONGLONG)((ULONG_PTR)NodeEntry + NodeEntry->Length - sizeof(ULONGLONG)); + + // Create the new tree node + DPRINT1("About to allocate %ld for NewNode\n", sizeof(B_TREE_FILENAME_NODE)); + NewNode = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_FILENAME_NODE), TAG_NTFS); + if (!NewNode) + { + DPRINT1("ERROR: Couldn't allocate memory for new filename node.\n"); + return NULL; + } + RtlZeroMemory(NewNode, sizeof(B_TREE_FILENAME_NODE)); + + // Create the first key + CurrentKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); + if (!CurrentKey) + { + DPRINT1("ERROR: Failed to allocate memory for key!\n"); + ExFreePoolWithTag(NewNode, TAG_NTFS); + return NULL; + } + RtlZeroMemory(CurrentKey, sizeof(B_TREE_KEY)); + NewNode->FirstKey = CurrentKey; + + // Allocate memory for the node buffer + NodeBuffer = ExAllocatePoolWithTag(NonPagedPool, IndexBufferSize, TAG_NTFS); + if (!NodeBuffer) + { + DPRINT1("ERROR: Couldn't allocate memory for node buffer!\n"); + ExFreePoolWithTag(CurrentKey, TAG_NTFS); + ExFreePoolWithTag(NewNode, TAG_NTFS); + return NULL; + } + + // Calculate offset into index allocation + IndexNodeOffset = GetAllocationOffsetFromVCN(Vcb, IndexBufferSize, *NodeNumber); + + // TODO: Confirm index bitmap has this node marked as in-use + + // Read the node + BytesRead = ReadAttribute(Vcb, + IndexAllocationAttributeCtx, + IndexNodeOffset, + (PCHAR)NodeBuffer, + IndexBufferSize); + + ASSERT(BytesRead == IndexBufferSize); + NT_ASSERT(NodeBuffer->Ntfs.Type == NRH_INDX_TYPE); + NT_ASSERT(NodeBuffer->VCN == *NodeNumber); + + // Apply the fixup array to the node buffer + Status = FixupUpdateSequenceArray(Vcb, &NodeBuffer->Ntfs); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't apply fixup array to index node buffer!\n"); + ExFreePoolWithTag(NodeBuffer, TAG_NTFS); + ExFreePoolWithTag(CurrentKey, TAG_NTFS); + ExFreePoolWithTag(NewNode, TAG_NTFS); + return NULL; + } + + // Walk through the index and create keys for all the entries + FirstNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)(&NodeBuffer->Header) + + NodeBuffer->Header.FirstEntryOffset); + CurrentNodeEntry = FirstNodeEntry; + while (CurrentEntryOffset < NodeBuffer->Header.TotalSizeOfEntries) + { + // Allocate memory for the current entry + CurrentKey->IndexEntry = ExAllocatePoolWithTag(NonPagedPool, CurrentNodeEntry->Length, TAG_NTFS); + if (!CurrentKey->IndexEntry) + { + DPRINT1("ERROR: Couldn't allocate memory for next key!\n"); + DestroyBTreeNode(NewNode); + ExFreePoolWithTag(NodeBuffer, TAG_NTFS); + return NULL; + } + + NewNode->KeyCount++; + + // If this isn't the last entry + if (!(CurrentNodeEntry->Flags & NTFS_INDEX_ENTRY_END)) + { + // Create the next key + PB_TREE_KEY NextKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); + if (!NextKey) + { + DPRINT1("ERROR: Couldn't allocate memory for next key!\n"); + DestroyBTreeNode(NewNode); + ExFreePoolWithTag(NodeBuffer, TAG_NTFS); + return NULL; + } + RtlZeroMemory(NextKey, sizeof(B_TREE_KEY)); + + // Add NextKey to the end of the list + CurrentKey->NextKey = NextKey; + + // Copy the current entry to its key + RtlCopyMemory(CurrentKey->IndexEntry, CurrentNodeEntry, CurrentNodeEntry->Length); + + // See if the current key has a sub-node + if (CurrentKey->IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE) + { + DPRINT1("TODO: Only a node with a single-level is supported right now!\n"); + // Needs debugging: + /*CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, + IndexRoot, + IndexAllocationAttributeCtx, + CurrentNodeEntry);*/ + } + + CurrentKey = NextKey; + } + else + { + // Copy the final entry to its key + RtlCopyMemory(CurrentKey->IndexEntry, CurrentNodeEntry, CurrentNodeEntry->Length); + CurrentKey->NextKey = NULL; + + // See if the current key has a sub-node + if (CurrentKey->IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE) + { + DPRINT1("TODO: Only a node with a single-level is supported right now!\n"); + // Needs debugging: + /*CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, + IndexRoot, + IndexAllocationAttributeCtx, + CurrentNodeEntry);*/ + } + + break; + } + + // Advance to the next entry + CurrentEntryOffset += CurrentNodeEntry->Length; + CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)CurrentNodeEntry + CurrentNodeEntry->Length); + } + + NewNode->NodeNumber = *NodeNumber; + NewNode->ExistsOnDisk = TRUE; + + ExFreePoolWithTag(NodeBuffer, TAG_NTFS); + + return NewNode; +} + /** * @name CreateBTreeFromIndex * @implemented @@ -172,7 +342,10 @@ CompareTreeKeys(PB_TREE_KEY Key1, PB_TREE_KEY Key2, BOOLEAN CaseSensitive) * Allocates memory for the entire tree. Caller is responsible for destroying the tree with DestroyBTree(). */ NTSTATUS -CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, +CreateBTreeFromIndex(PDEVICE_EXTENSION Vcb, + PFILE_RECORD_HEADER FileRecordWithIndex, + /*PCWSTR IndexName,*/ + PNTFS_ATTR_CONTEXT IndexRootContext, PINDEX_ROOT_ATTRIBUTE IndexRoot, PB_TREE *NewTree) { @@ -181,8 +354,10 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, PB_TREE_FILENAME_NODE RootNode = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_FILENAME_NODE), TAG_NTFS); PB_TREE_KEY CurrentKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); ULONG CurrentOffset = IndexRoot->Header.FirstEntryOffset; + PNTFS_ATTR_CONTEXT IndexAllocationContext = NULL; + NTSTATUS Status; - DPRINT1("CreateBTreeFromIndex(%p, %p, %p)\n", IndexRootContext, IndexRoot, NewTree); + DPRINT1("CreateBTreeFromIndex(%p, %p)\n", IndexRoot, NewTree); if (!Tree || !RootNode || !CurrentKey) { @@ -200,6 +375,19 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, RtlZeroMemory(RootNode, sizeof(B_TREE_FILENAME_NODE)); RtlZeroMemory(CurrentKey, sizeof(B_TREE_KEY)); + // See if the file record has an attribute allocation + Status = FindAttribute(Vcb, + FileRecordWithIndex, + AttributeIndexAllocation, + L"$I30", + 4, + &IndexAllocationContext, + NULL); + if (!NT_SUCCESS(Status)) + IndexAllocationContext = NULL; + else + PrintAllVCNs(Vcb, IndexAllocationContext, IndexRoot->SizeOfEntry); + // Setup the Tree RootNode->FirstKey = CurrentKey; Tree->RootNode = RootNode; @@ -235,7 +423,7 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, if (!(CurrentNodeEntry->Flags & NTFS_INDEX_ENTRY_END)) { // Create the next key - PB_TREE_KEY NextKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(PB_TREE_KEY), TAG_NTFS); + PB_TREE_KEY NextKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); if (!NextKey) { DPRINT1("ERROR: Couldn't allocate memory for next key!\n"); @@ -243,7 +431,7 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, return STATUS_INSUFFICIENT_RESOURCES; } - RtlZeroMemory(NextKey, sizeof(PB_TREE_KEY)); + RtlZeroMemory(NextKey, sizeof(B_TREE_KEY)); // Add NextKey to the end of the list CurrentKey->NextKey = NextKey; @@ -251,12 +439,20 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, // Copy the current entry to its key RtlCopyMemory(CurrentKey->IndexEntry, CurrentNodeEntry, CurrentNodeEntry->Length); - // Make sure this B-Tree is only one level deep (flat list) + // Does this key have a sub-node? if (CurrentKey->IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE) { - DPRINT1("TODO: Only directories with single-level B-Trees are supported right now!\n"); - DestroyBTree(Tree); - return STATUS_NOT_IMPLEMENTED; + // Create the child node + CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, + IndexRoot, + IndexAllocationContext, + CurrentKey->IndexEntry); + if (!CurrentKey->LesserChild) + { + DPRINT1("ERROR: Couldn't create child node!\n"); + DestroyBTree(Tree); + return STATUS_NOT_IMPLEMENTED; + } } // Advance to the next entry @@ -270,12 +466,20 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, RtlCopyMemory(CurrentKey->IndexEntry, CurrentNodeEntry, CurrentNodeEntry->Length); CurrentKey->NextKey = NULL; - // Make sure this B-Tree is only one level deep (flat list) + // Does this key have a sub-node? if (CurrentKey->IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE) { - DPRINT1("TODO: Only directories with single-level B-Trees are supported right now!\n"); - DestroyBTree(Tree); - return STATUS_NOT_IMPLEMENTED; + // Create the child node + CurrentKey->LesserChild = CreateBTreeNodeFromIndexNode(Vcb, + IndexRoot, + IndexAllocationContext, + CurrentKey->IndexEntry); + if (!CurrentKey->LesserChild) + { + DPRINT1("ERROR: Couldn't create child node!\n"); + DestroyBTree(Tree); + return STATUS_NOT_IMPLEMENTED; + } } break; @@ -284,6 +488,9 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, *NewTree = Tree; + if (IndexAllocationContext) + ReleaseAttributeContext(IndexAllocationContext); + return STATUS_SUCCESS; } @@ -387,6 +594,10 @@ CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt, CurrentNodeEntry->KeyLength, CurrentNodeEntry->Length); + // Does the current key have any sub-nodes? + if (CurrentKey->LesserChild) + NewIndexRoot->Header.Flags = INDEX_ROOT_LARGE; + // Add Length of Current Entry to Total Size of Entries NewIndexRoot->Header.TotalSizeOfEntries += CurrentNodeEntry->Length; @@ -404,13 +615,253 @@ CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt, return STATUS_SUCCESS; } +NTSTATUS +CreateIndexBufferFromBTreeNode(PDEVICE_EXTENSION DeviceExt, + PB_TREE_FILENAME_NODE Node, + ULONG BufferSize, + PINDEX_BUFFER IndexBuffer) +{ + ULONG i; + PB_TREE_KEY CurrentKey; + PINDEX_ENTRY_ATTRIBUTE CurrentNodeEntry; + NTSTATUS Status; + + // TODO: Fix magic, do math + RtlZeroMemory(IndexBuffer, BufferSize); + IndexBuffer->Ntfs.Type = NRH_INDX_TYPE; + IndexBuffer->Ntfs.UsaOffset = 0x28; + IndexBuffer->Ntfs.UsaCount = 9; + + // TODO: Check bitmap for VCN + ASSERT(Node->ExistsOnDisk); + IndexBuffer->VCN = Node->NodeNumber; + + IndexBuffer->Header.FirstEntryOffset = 0x28; + IndexBuffer->Header.AllocatedSize = BufferSize - FIELD_OFFSET(INDEX_BUFFER, Header); + + // Start summing the total size of this node's entries + IndexBuffer->Header.TotalSizeOfEntries = IndexBuffer->Header.FirstEntryOffset; + + CurrentKey = Node->FirstKey; + CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)&(IndexBuffer->Header) + + IndexBuffer->Header.FirstEntryOffset); + for (i = 0; i < Node->KeyCount; i++) + { + // Would adding the current entry to the index increase the node size beyond the allocation size? + ULONG IndexSize = FIELD_OFFSET(INDEX_BUFFER, Header) + + IndexBuffer->Header.FirstEntryOffset + + IndexBuffer->Header.TotalSizeOfEntries + + CurrentNodeEntry->Length; + if (IndexSize > BufferSize) + { + DPRINT1("TODO: Adding file would require creating a new node!\n"); + return STATUS_NOT_IMPLEMENTED; + } + + ASSERT(CurrentKey->IndexEntry->Length != 0); + + // Copy the index entry + RtlCopyMemory(CurrentNodeEntry, CurrentKey->IndexEntry, CurrentKey->IndexEntry->Length); + + DPRINT1("Index Node Entry Stream Length: %u\nIndex Node Entry Length: %u\n", + CurrentNodeEntry->KeyLength, + CurrentNodeEntry->Length); + + // Add Length of Current Entry to Total Size of Entries + IndexBuffer->Header.TotalSizeOfEntries += CurrentNodeEntry->Length; + + // TODO: Check for child nodes + + // Go to the next node entry + CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)CurrentNodeEntry + CurrentNodeEntry->Length); + CurrentKey = CurrentKey->NextKey; + } + + Status = AddFixupArray(DeviceExt, &IndexBuffer->Ntfs); + + return Status; +} + +NTSTATUS +UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt, + PB_TREE Tree, + ULONG IndexBufferSize, + PFILE_RECORD_HEADER FileRecord) +{ + // Find the index allocation and bitmap + PNTFS_ATTR_CONTEXT IndexAllocationContext, BitmapContext; + PB_TREE_KEY CurrentKey; + NTSTATUS Status; + BOOLEAN HasIndexAllocation = FALSE; + ULONG i; + + DPRINT1("UpdateIndexAllocations() called.\n"); + + Status = FindAttribute(DeviceExt, FileRecord, AttributeIndexAllocation, L"$I30", 4, &IndexAllocationContext, NULL); + if (NT_SUCCESS(Status)) + HasIndexAllocation = TRUE; + + // TODO: Handle bitmap + BitmapContext = NULL; + + // Walk through the root node and update all the sub-nodes + CurrentKey = Tree->RootNode->FirstKey; + for (i = 0; i < Tree->RootNode->KeyCount; i++) + { + if (CurrentKey->LesserChild) + { + if (!HasIndexAllocation) + { + DPRINT1("FIXME: Need to add index allocation\n"); + return STATUS_NOT_IMPLEMENTED; + } + else + { + Status = UpdateIndexNode(DeviceExt, CurrentKey->LesserChild, IndexBufferSize, IndexAllocationContext, BitmapContext); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to update index node!\n"); + ReleaseAttributeContext(IndexAllocationContext); + return Status; + } + } + + } + CurrentKey = CurrentKey->NextKey; + } + + if(HasIndexAllocation) + ReleaseAttributeContext(IndexAllocationContext); + + return STATUS_SUCCESS; +} + +NTSTATUS +UpdateIndexNode(PDEVICE_EXTENSION DeviceExt, + PB_TREE_FILENAME_NODE Node, + ULONG IndexBufferSize, + PNTFS_ATTR_CONTEXT IndexAllocationContext, + PNTFS_ATTR_CONTEXT BitmapContext) +{ + ULONG i; + PB_TREE_KEY CurrentKey = Node->FirstKey; + NTSTATUS Status; + + DPRINT1("UpdateIndexNode(%p, %p, %lu, %p, %p) called for index node with VCN %I64u\n", DeviceExt, Node, IndexBufferSize, IndexAllocationContext, BitmapContext, Node->NodeNumber); + + // Do we need to write this node to disk? + if (Node->DiskNeedsUpdating) + { + ULONGLONG NodeOffset; + ULONG LengthWritten; + + // Allocate memory for an index buffer + PINDEX_BUFFER IndexBuffer = ExAllocatePoolWithTag(NonPagedPool, IndexBufferSize, TAG_NTFS); + if (!IndexBuffer) + { + DPRINT1("ERROR: Failed to allocate %lu bytes for index buffer!\n", IndexBufferSize); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Create the index buffer we'll be writing to disk to represent this node + Status = CreateIndexBufferFromBTreeNode(DeviceExt, Node, IndexBufferSize, IndexBuffer); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to create index buffer from node!\n"); + ExFreePoolWithTag(IndexBuffer, TAG_NTFS); + return Status; + } + + // Get Offset of index buffer in index allocation + NodeOffset = GetAllocationOffsetFromVCN(DeviceExt, IndexBufferSize, Node->NodeNumber); + + // Write the buffer to the index allocation + Status = WriteAttribute(DeviceExt, IndexAllocationContext, NodeOffset, (const PUCHAR)IndexBuffer, IndexBufferSize, &LengthWritten); + if (!NT_SUCCESS(Status) || LengthWritten != IndexBufferSize) + { + DPRINT1("ERROR: Failed to update index allocation!\n"); + ExFreePoolWithTag(IndexBuffer, TAG_NTFS); + if (!NT_SUCCESS(Status)) + return Status; + else + return STATUS_END_OF_FILE; + } + + Node->DiskNeedsUpdating = FALSE; + + // Free the index buffer + ExFreePoolWithTag(IndexBuffer, TAG_NTFS); + } + + // Walk through the node and look for children to update + for (i = 0; i < Node->KeyCount; i++) + { + ASSERT(CurrentKey); + + // If there's a child node + if (CurrentKey->LesserChild) + { + // Update the child node on disk + Status = UpdateIndexNode(DeviceExt, CurrentKey->LesserChild, IndexBufferSize, IndexAllocationContext, BitmapContext); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to update child node!\n"); + return Status; + } + } + + CurrentKey = CurrentKey->NextKey; + } + + return STATUS_SUCCESS; +} + +PB_TREE_KEY +CreateBTreeKeyFromFilename(ULONGLONG FileReference, PFILENAME_ATTRIBUTE FileNameAttribute) +{ + PB_TREE_KEY NewKey; + ULONG AttributeSize = GetFileNameAttributeLength(FileNameAttribute); + ULONG EntrySize = ALIGN_UP_BY(AttributeSize + FIELD_OFFSET(INDEX_ENTRY_ATTRIBUTE, FileName), 8); + + // Create a new Index Entry for the file + PINDEX_ENTRY_ATTRIBUTE NewEntry = ExAllocatePoolWithTag(NonPagedPool, EntrySize, TAG_NTFS); + if (!NewEntry) + { + DPRINT1("ERROR: Failed to allocate memory for Index Entry!\n"); + return NULL; + } + + // Setup the Index Entry + RtlZeroMemory(NewEntry, EntrySize); + NewEntry->Data.Directory.IndexedFile = FileReference; + NewEntry->Length = EntrySize; + NewEntry->KeyLength = AttributeSize; + + // Copy the FileNameAttribute + RtlCopyMemory(&NewEntry->FileName, FileNameAttribute, AttributeSize); + + // Setup the New Key + NewKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); + if (!NewKey) + { + DPRINT1("ERROR: Failed to allocate memory for new key!\n"); + ExFreePoolWithTag(NewEntry, TAG_NTFS); + return NULL; + } + NewKey->IndexEntry = NewEntry; + NewKey->NextKey = NULL; + + return NewKey; +} + VOID DestroyBTreeKey(PB_TREE_KEY Key) { if (Key->IndexEntry) ExFreePoolWithTag(Key->IndexEntry, TAG_NTFS); - // We'll destroy Key->LesserChild here after we start using it + if (Key->LesserChild) + DestroyBTreeNode(Key->LesserChild); ExFreePoolWithTag(Key, TAG_NTFS); } @@ -473,6 +924,18 @@ DumpBTreeKey(PB_TREE_KEY Key, ULONG Number, ULONG Depth) { DbgPrint(" (Dummy Key)\n"); } + + // Is there a child node? + if (Key->IndexEntry->Flags & NTFS_INDEX_ENTRY_NODE) + { + if (Key->LesserChild) + DumpBTreeNode(Key->LesserChild, Number, Depth + 1); + else + { + // This will be an assert once nodes with arbitrary depth are debugged + DPRINT1("DRIVER ERROR: No Key->LesserChild despite Key->IndexEntry->Flags indicating this is a node!\n"); + } + } } VOID @@ -482,7 +945,7 @@ DumpBTreeNode(PB_TREE_FILENAME_NODE Node, ULONG Number, ULONG Depth) ULONG i; for (i = 0; i < Depth; i++) DbgPrint(" "); - DbgPrint("Node #%d, Depth %d\n", Number, Depth); + DbgPrint("Node #%d, Depth %d, has %d keys\n", Number, Depth, Node->KeyCount); CurrentKey = Node->FirstKey; for (i = 0; i < Node->KeyCount; i++) @@ -551,46 +1014,23 @@ NtfsInsertKey(ULONGLONG FileReference, PB_TREE_FILENAME_NODE Node, BOOLEAN CaseSensitive) { - // Calculate size of Attribute and Index Entry - ULONG AttributeSize = GetFileNameAttributeLength(FileNameAttribute); - ULONG EntrySize = ALIGN_UP_BY(AttributeSize + FIELD_OFFSET(INDEX_ENTRY_ATTRIBUTE, FileName), 8); - PINDEX_ENTRY_ATTRIBUTE NewEntry; PB_TREE_KEY NewKey, CurrentKey, PreviousKey; + NTSTATUS Status = STATUS_SUCCESS; + ULONG NodeSize; + ULONG AllocatedNodeSize; + ULONG MaxNodeSizeWithoutHeader; ULONG i; - DPRINT1("NtfsInsertKey(0x%02I64, %p, %p, %s)\n", + DPRINT1("NtfsInsertKey(0x%I64x, %p, %p, %s)\n", FileReference, FileNameAttribute, Node, CaseSensitive ? "TRUE" : "FALSE"); - // Create a new Index Entry for the file - NewEntry = ExAllocatePoolWithTag(NonPagedPool, EntrySize, TAG_NTFS); - if (!NewEntry) - { - DPRINT1("ERROR: Failed to allocate memory for Index Entry!\n"); - return STATUS_INSUFFICIENT_RESOURCES; - } - - // Setup the Index Entry - RtlZeroMemory(NewEntry, EntrySize); - NewEntry->Data.Directory.IndexedFile = FileReference; - NewEntry->Length = EntrySize; - NewEntry->KeyLength = AttributeSize; - - // Copy the FileNameAttribute - RtlCopyMemory(&NewEntry->FileName, FileNameAttribute, AttributeSize); - - // Setup the New Key - NewKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); + // Create the key for the filename attribute + NewKey = CreateBTreeKeyFromFilename(FileReference, FileNameAttribute); if (!NewKey) - { - DPRINT1("ERROR: Failed to allocate memory for new key!\n"); - ExFreePoolWithTag(NewEntry, TAG_NTFS); return STATUS_INSUFFICIENT_RESOURCES; - } - NewKey->IndexEntry = NewEntry; - NewKey->NextKey = NULL; // Find where to insert the key CurrentKey = Node->FirstKey; @@ -605,24 +1045,57 @@ NtfsInsertKey(ULONGLONG FileReference, // Is NewKey < CurrentKey? if (Comparison < 0) { - // Insert New Key before Current Key - NewKey->NextKey = CurrentKey; - // was CurrentKey the first key? - if (CurrentKey == Node->FirstKey) - Node->FirstKey = NewKey; + // Does CurrentKey have a sub-node? + if (CurrentKey->LesserChild) + { + // Insert the key into the child node + Status = NtfsInsertKey(FileReference, FileNameAttribute, CurrentKey->LesserChild, CaseSensitive); + } else - PreviousKey->NextKey = NewKey; - break; + { + // Insert New Key before Current Key + NewKey->NextKey = CurrentKey; + + // Increase KeyCount and mark node as dirty + Node->KeyCount++; + Node->DiskNeedsUpdating = TRUE; + + // was CurrentKey the first key? + if (CurrentKey == Node->FirstKey) + Node->FirstKey = NewKey; + else + PreviousKey->NextKey = NewKey; + break; + } } PreviousKey = CurrentKey; CurrentKey = CurrentKey->NextKey; } - Node->KeyCount++; + // Is the node larger than its allocated size? + NodeSize = 0; + CurrentKey = Node->FirstKey; + for (i = 0; i < Node->KeyCount; i++) + { + NodeSize += CurrentKey->IndexEntry->Length; + CurrentKey = CurrentKey->NextKey; + } + + // TEMPTEMP: TODO: MATH + AllocatedNodeSize = 0xfe8; + MaxNodeSizeWithoutHeader = AllocatedNodeSize - 0x28; + + if (NodeSize > MaxNodeSizeWithoutHeader) + { + DPRINT1("FIXME: Splitting a node is still a WIP!\n"); + //SplitBTreeNode(NULL, Node); + //DumpBTree(Tree); + return STATUS_NOT_IMPLEMENTED; + } // NewEntry and NewKey will be destroyed later by DestroyBTree() - return STATUS_SUCCESS; + return Status; } \ No newline at end of file diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 928839edd7..1df31aee0c 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -1969,7 +1969,11 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, } // Convert the index to a B*Tree - Status = CreateBTreeFromIndex(IndexRootContext, I30IndexRoot, &NewTree); + Status = CreateBTreeFromIndex(DeviceExt, + ParentFileRecord, + IndexRootContext, + I30IndexRoot, + &NewTree); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Failed to create B-Tree from Index!\n"); @@ -1995,7 +1999,19 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, DumpBTree(NewTree); - // Convert B*Tree back to Index Root + // Convert B*Tree back to Index + Status = UpdateIndexAllocation(DeviceExt, NewTree, I30IndexRoot->SizeOfEntry, ParentFileRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to update index allocation from B-Tree!\n"); + DestroyBTree(NewTree); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + // Create the Index Root from the B*Tree Status = CreateIndexRootFromBTree(DeviceExt, NewTree, MaxIndexSize, &NewIndexRoot, &BtreeIndexLength); if (!NT_SUCCESS(Status)) { diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 39c33210fc..42168be1ab 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -406,20 +406,26 @@ typedef struct FILENAME_ATTRIBUTE FileName; } INDEX_ENTRY_ATTRIBUTE, *PINDEX_ENTRY_ATTRIBUTE; +struct _B_TREE_FILENAME_NODE; +typedef struct _B_TREE_FILENAME_NODE B_TREE_FILENAME_NODE; + // Keys are arranged in nodes as an ordered, linked list typedef struct _B_TREE_KEY { struct _B_TREE_KEY *NextKey; - // PB_TREE_FILENAME_NODE LesserChild; // we aren't worried about multi-level trees yet - PINDEX_ENTRY_ATTRIBUTE IndexEntry; // must be last member for FIELD_OFFSET + B_TREE_FILENAME_NODE *LesserChild; // Child-Node. All the keys in this node will be sorted before IndexEntry + PINDEX_ENTRY_ATTRIBUTE IndexEntry; // must be last member for FIELD_OFFSET }B_TREE_KEY, *PB_TREE_KEY; // Every Node is just an ordered list of keys. // Sub-nodes can be found attached to a key (if they exist). // A key's sub-node precedes that key in the ordered list. -typedef struct +typedef struct _B_TREE_FILENAME_NODE { ULONG KeyCount; + BOOLEAN ExistsOnDisk; + BOOLEAN DiskNeedsUpdating; + ULONGLONG NodeNumber; PB_TREE_KEY FirstKey; } B_TREE_FILENAME_NODE, *PB_TREE_FILENAME_NODE; @@ -688,7 +694,9 @@ CompareTreeKeys(PB_TREE_KEY Key1, BOOLEAN CaseSensitive); NTSTATUS -CreateBTreeFromIndex(/*PDEVICE_EXTENSION Vcb,*/ +CreateBTreeFromIndex(PDEVICE_EXTENSION Vcb, + PFILE_RECORD_HEADER FileRecordWithIndex, + /*PCWSTR IndexName,*/ PNTFS_ATTR_CONTEXT IndexRootContext, PINDEX_ROOT_ATTRIBUTE IndexRoot, PB_TREE *NewTree); @@ -725,6 +733,19 @@ NtfsInsertKey(ULONGLONG FileReference, PB_TREE_FILENAME_NODE Node, BOOLEAN CaseSensitive); +NTSTATUS +UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt, + PB_TREE Tree, + ULONG IndexBufferSize, + PFILE_RECORD_HEADER FileRecord); + +NTSTATUS +UpdateIndexNode(PDEVICE_EXTENSION DeviceExt, + PB_TREE_FILENAME_NODE Node, + ULONG IndexBufferSize, + PNTFS_ATTR_CONTEXT IndexAllocationContext, + PNTFS_ATTR_CONTEXT BitmapContext); + /* close.c */ NTSTATUS

7 years

[reactos] 58/72: [NTFS] - Add GetAllocationOffsetFromVCN() function, which was mistakenly left out of the last commit.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b1eab36f6bed95fd08de7… commit b1eab36f6bed95fd08de770d07645e933c29f729 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Thu Jul 27 18:34:23 2017 +0000 [NTFS] - Add GetAllocationOffsetFromVCN() function, which was mistakenly left out of the last commit. svn path=/branches/GSoC_2016/NTFS/; revision=75425 --- drivers/filesystems/ntfs/btree.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index 38fa9aefee..f4bdf909a1 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -511,6 +511,18 @@ DumpBTree(PB_TREE Tree) DumpBTreeNode(Tree->RootNode, 0, 0); } +// Calculates start of Index Buffer relative to the index allocation, given the node's VCN +ULONGLONG +GetAllocationOffsetFromVCN(PDEVICE_EXTENSION DeviceExt, + ULONG IndexBufferSize, + ULONGLONG Vcn) +{ + if (IndexBufferSize < DeviceExt->NtfsInfo.BytesPerCluster) + return Vcn * DeviceExt->NtfsInfo.BytesPerSector; + + return Vcn * DeviceExt->NtfsInfo.BytesPerCluster; +} + /** * @name NtfsInsertKey * @implemented

7 years

[reactos] 57/72: [NTFS] - Add some utility functions and improve some comments. Improve NtfsAddFilenameToDirectory(). +PrintAllVCNs() - Diagnostic function which prints VCN of every node in an index allocation. +GetAllocationOffsetFromVCN() - Calculates location of an index buffer from the node's VCN. +GetInfoClassName() - Gets a string representation of an info class enumeration, to speed up development of unimplemented classes. -NtfsSetInformation() & NtfsQueryInformation() - Use GetInfoClassN

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=5579428b4f1361481dae3… commit 5579428b4f1361481dae3ea0b901c0a915401148 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Thu Jul 27 18:22:24 2017 +0000 [NTFS] - Add some utility functions and improve some comments. Improve NtfsAddFilenameToDirectory(). +PrintAllVCNs() - Diagnostic function which prints VCN of every node in an index allocation. +GetAllocationOffsetFromVCN() - Calculates location of an index buffer from the node's VCN. +GetInfoClassName() - Gets a string representation of an info class enumeration, to speed up development of unimplemented classes. -NtfsSetInformation() & NtfsQueryInformation() - Use GetInfoClassName to report unhandled information classes. -CompareTreeKeys() - Add a comment and clarify some comments. -NtfsAddFilenameToDirectory() - Don't try to update the size of Index Root on disk if the attribute length hasn't changed. svn path=/branches/GSoC_2016/NTFS/; revision=75424 --- drivers/filesystems/ntfs/btree.c | 46 +++++++++++++- drivers/filesystems/ntfs/finfo.c | 128 ++++++++++++++++++++++++++++++++++++++- drivers/filesystems/ntfs/mft.c | 38 ++++++------ drivers/filesystems/ntfs/ntfs.h | 16 +++++ 4 files changed, 206 insertions(+), 22 deletions(-) diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index a7eacb3173..38fa9aefee 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -32,6 +32,47 @@ /* FUNCTIONS ****************************************************************/ +// TEMP FUNCTION for diagnostic purposes. +// Prints VCN of every node in an index allocation +VOID +PrintAllVCNs(PDEVICE_EXTENSION Vcb, + PNTFS_ATTR_CONTEXT IndexAllocationContext, + ULONG NodeSize) +{ + ULONGLONG CurrentOffset = 0; + PINDEX_BUFFER CurrentNode, Buffer; + ULONGLONG BufferSize = AttributeDataLength(&IndexAllocationContext->Record); + ULONGLONG i; + int Count = 0; + + Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferSize, TAG_NTFS); + + ULONG BytesRead = ReadAttribute(Vcb, IndexAllocationContext, 0, (PCHAR)Buffer, BufferSize); + + ASSERT(BytesRead = BufferSize); + + CurrentNode = Buffer; + + // loop through all the nodes + for (i = 0; i < BufferSize; i += NodeSize) + { + NTSTATUS Status = FixupUpdateSequenceArray(Vcb, &CurrentNode->Ntfs); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Fixing fixup failed!\n"); + continue; + } + + DPRINT1("Node #%d, VCN: %I64u\n", Count, CurrentNode->VCN); + + CurrentNode = (PINDEX_BUFFER)((ULONG_PTR)CurrentNode + NodeSize); + CurrentOffset += NodeSize; + Count++; + } + + ExFreePoolWithTag(Buffer, TAG_NTFS); +} + /** * @name CompareTreeKeys * @implemented @@ -62,6 +103,7 @@ CompareTreeKeys(PB_TREE_KEY Key1, PB_TREE_KEY Key2, BOOLEAN CaseSensitive) UNICODE_STRING Key1Name, Key2Name; LONG Comparison; + // Key1 must not be the final key (AKA the dummy key) ASSERT(!(Key1->IndexEntry->Flags & NTFS_INDEX_ENTRY_END)); // If Key2 is the "dummy key", key 1 will always come first @@ -89,7 +131,7 @@ CompareTreeKeys(PB_TREE_KEY Key1, PB_TREE_KEY Key2, BOOLEAN CaseSensitive) // Compare the names of the same length Comparison = RtlCompareUnicodeString(&Key1Name, &Key2Name, !CaseSensitive); - // If the truncated files are the same length, the shorter one comes first + // If the truncated names are the same length, the shorter one comes first if (Comparison == 0) return -1; } @@ -102,7 +144,7 @@ CompareTreeKeys(PB_TREE_KEY Key1, PB_TREE_KEY Key2, BOOLEAN CaseSensitive) // Compare the names of the same length Comparison = RtlCompareUnicodeString(&Key1Name, &Key2Name, !CaseSensitive); - // If the truncated files are the same length, the shorter one comes first + // If the truncated names are the same length, the shorter one comes first if (Comparison == 0) return 1; } diff --git a/drivers/filesystems/ntfs/finfo.c b/drivers/filesystems/ntfs/finfo.c index 323b85cf45..aee8aa51e2 100644 --- a/drivers/filesystems/ntfs/finfo.c +++ b/drivers/filesystems/ntfs/finfo.c @@ -289,6 +289,128 @@ NtfsGetSteamInformation(PNTFS_FCB Fcb, return Status; } +// Convert enum value to friendly name +const PCSTR +GetInfoClassName(FILE_INFORMATION_CLASS infoClass) +{ + const PCSTR fileInfoClassNames[] = { "???????", + "FileDirectoryInformation", + "FileFullDirectoryInformation", + "FileBothDirectoryInformation", + "FileBasicInformation", + "FileStandardInformation", + "FileInternalInformation", + "FileEaInformation", + "FileAccessInformation", + "FileNameInformation", + "FileRenameInformation", + "FileLinkInformation", + "FileNamesInformation", + "FileDispositionInformation", + "FilePositionInformation", + "FileFullEaInformation", + "FileModeInformation", + "FileAlignmentInformation", + "FileAllInformation", + "FileAllocationInformation", + "FileEndOfFileInformation", + "FileAlternateNameInformation", + "FileStreamInformation", + "FilePipeInformation", + "FilePipeLocalInformation", + "FilePipeRemoteInformation", + "FileMailslotQueryInformation", + "FileMailslotSetInformation", + "FileCompressionInformation", + "FileObjectIdInformation", + "FileCompletionInformation", + "FileMoveClusterInformation", + "FileQuotaInformation", + "FileReparsePointInformation", + "FileNetworkOpenInformation", + "FileAttributeTagInformation", + "FileTrackingInformation", + "FileIdBothDirectoryInformation", + "FileIdFullDirectoryInformation", + "FileValidDataLengthInformation", + "FileShortNameInformation", + "FileIoCompletionNotificationInformation", + "FileIoStatusBlockRangeInformation", + "FileIoPriorityHintInformation", + "FileSfioReserveInformation", + "FileSfioVolumeInformation", + "FileHardLinkInformation", + "FileProcessIdsUsingFileInformation", + "FileNormalizedNameInformation", + "FileNetworkPhysicalNameInformation", + "FileIdGlobalTxDirectoryInformation", + "FileIsRemoteDeviceInformation", + "FileAttributeCacheInformation", + "FileNumaNodeInformation", + "FileStandardLinkInformation", + "FileRemoteProtocolInformation", + "FileReplaceCompletionInformation", + "FileMaximumInformation", + "FileDirectoryInformation", + "FileFullDirectoryInformation", + "FileBothDirectoryInformation", + "FileBasicInformation", + "FileStandardInformation", + "FileInternalInformation", + "FileEaInformation", + "FileAccessInformation", + "FileNameInformation", + "FileRenameInformation", + "FileLinkInformation", + "FileNamesInformation", + "FileDispositionInformation", + "FilePositionInformation", + "FileFullEaInformation", + "FileModeInformation", + "FileAlignmentInformation", + "FileAllInformation", + "FileAllocationInformation", + "FileEndOfFileInformation", + "FileAlternateNameInformation", + "FileStreamInformation", + "FilePipeInformation", + "FilePipeLocalInformation", + "FilePipeRemoteInformation", + "FileMailslotQueryInformation", + "FileMailslotSetInformation", + "FileCompressionInformation", + "FileObjectIdInformation", + "FileCompletionInformation", + "FileMoveClusterInformation", + "FileQuotaInformation", + "FileReparsePointInformation", + "FileNetworkOpenInformation", + "FileAttributeTagInformation", + "FileTrackingInformation", + "FileIdBothDirectoryInformation", + "FileIdFullDirectoryInformation", + "FileValidDataLengthInformation", + "FileShortNameInformation", + "FileIoCompletionNotificationInformation", + "FileIoStatusBlockRangeInformation", + "FileIoPriorityHintInformation", + "FileSfioReserveInformation", + "FileSfioVolumeInformation", + "FileHardLinkInformation", + "FileProcessIdsUsingFileInformation", + "FileNormalizedNameInformation", + "FileNetworkPhysicalNameInformation", + "FileIdGlobalTxDirectoryInformation", + "FileIsRemoteDeviceInformation", + "FileAttributeCacheInformation", + "FileNumaNodeInformation", + "FileStandardLinkInformation", + "FileRemoteProtocolInformation", + "FileReplaceCompletionInformation", + "FileMaximumInformation" }; + return fileInfoClassNames[infoClass]; +} + /* * FUNCTION: Retrieve the specified file information */ @@ -376,12 +498,12 @@ NtfsQueryInformation(PNTFS_IRP_CONTEXT IrpContext) case FileAlternateNameInformation: case FileAllInformation: - DPRINT1("Unimplemented information class %u\n", FileInformationClass); + DPRINT1("Unimplemented information class: %s\n", GetInfoClassName(FileInformationClass)); Status = STATUS_NOT_IMPLEMENTED; break; default: - DPRINT1("Unimplemented information class %u\n", FileInformationClass); + DPRINT1("Unimplemented information class: %s\n", GetInfoClassName(FileInformationClass)); Status = STATUS_INVALID_PARAMETER; } @@ -645,7 +767,7 @@ NtfsSetInformation(PNTFS_IRP_CONTEXT IrpContext) // TODO: all other information classes default: - DPRINT1("FIXME: Unimplemented information class %u\n", FileInformationClass); + DPRINT1("FIXME: Unimplemented information class: %s\n", GetInfoClassName(FileInformationClass)); Status = STATUS_NOT_IMPLEMENTED; } diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 72953c0086..928839edd7 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -2018,25 +2018,29 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, // we must create an index allocation and index bitmap (TODO). Also TODO: support file records with // $ATTRIBUTE_LIST's. AttributeLength = NewIndexRoot->Header.AllocatedSize + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header); - DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset); - - // Find the attribute (or attribute-end marker) after the index root - NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); - if (NextAttribute->Type != AttributeEnd) + + if (AttributeLength != IndexRootContext->Record.Resident.ValueLength) { - DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n"); - ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return STATUS_NOT_IMPLEMENTED; - } + DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset); - // Update the length of the attribute in the file record of the parent directory - InternalSetResidentAttributeLength(IndexRootContext, - ParentFileRecord, - IndexRootOffset, - AttributeLength); + // Find the attribute (or attribute-end marker) after the index root + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); + if (NextAttribute->Type != AttributeEnd) + { + DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n"); + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return STATUS_NOT_IMPLEMENTED; + } + + // Update the length of the attribute in the file record of the parent directory + InternalSetResidentAttributeLength(IndexRootContext, + ParentFileRecord, + IndexRootOffset, + AttributeLength); + } NT_ASSERT(ParentFileRecord->BytesInUse <= DeviceExt->NtfsInfo.BytesPerFileRecord); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 9cbc4d5485..39c33210fc 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -208,6 +208,9 @@ typedef enum #define INDEX_ROOT_SMALL 0x0 #define INDEX_ROOT_LARGE 0x1 +#define INDEX_NODE_SMALL 0x0 +#define INDEX_NODE_LARGE 0x1 + #define NTFS_INDEX_ENTRY_NODE 1 #define NTFS_INDEX_ENTRY_END 2 @@ -700,9 +703,22 @@ CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt, VOID DestroyBTree(PB_TREE Tree); +VOID +DestroyBTreeNode(PB_TREE_FILENAME_NODE Node); + VOID DumpBTree(PB_TREE Tree); +VOID +DumpBTreeNode(PB_TREE_FILENAME_NODE Node, + ULONG Number, + ULONG Depth); + +ULONGLONG +GetAllocationOffsetFromVCN(PDEVICE_EXTENSION DeviceExt, + ULONG IndexBufferSize, + ULONGLONG Vcn); + NTSTATUS NtfsInsertKey(ULONGLONG FileReference, PFILENAME_ATTRIBUTE FileNameAttribute,

7 years

[reactos] 56/72: [NTFS] - After creating a new file, update creation disposition before calling NtfsCreateFile() recursively. This fixes creating a file via right-clicking in a folder.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9cef425464df506c5475a… commit 9cef425464df506c5475a47e3723f9de507f1341 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Thu Jul 27 11:35:50 2017 +0000 [NTFS] - After creating a new file, update creation disposition before calling NtfsCreateFile() recursively. This fixes creating a file via right-clicking in a folder. svn path=/branches/GSoC_2016/NTFS/; revision=75423 --- drivers/filesystems/ntfs/create.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index f5ca1027fc..a98afc67b7 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -580,8 +580,18 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, return Status; } - // Now we should be able to open the file - return NtfsCreateFile(DeviceObject, IrpContext); + // Before we open the file we just created, we need to change the disposition (upper 8 bits of ULONG) + // from create to open, since we already created the file + Stack->Parameters.Create.Options = (ULONG)FILE_OPEN << 24 | RequestedOptions; + + // Now we should be able to open the file using NtfsCreateFile() + Status = NtfsCreateFile(DeviceObject, IrpContext); + if (NT_SUCCESS(Status)) + { + // We need to change Irp->IoStatus.Information to reflect creation + Irp->IoStatus.Information = FILE_CREATED; + } + return Status; } }

7 years

[reactos] 55/72: [NTFS] - Fix some more issues, including remaining issues marked as "unresolved" from CR-123: -Add define for indexed flag for resident attributes, RA_INDEXED. -CreateBTreeFromIndex() - Don't try to read index entries beyond attribute length. -Move NtfsAddFileNameToDirectory() from dirctl.c to mft.c (no changes to function). -SetResidentAttributeDataLength() - Don't try to free AttribData if it hasn't been allocated. Cast IndexRecord to PUCHAR for WriteAttribute(), and cast Bitm

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=935fcd1b353a65d3af01e… commit 935fcd1b353a65d3af01e3f9061d3784f759cdbc Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Tue Jul 18 19:59:36 2017 +0000 [NTFS] - Fix some more issues, including remaining issues marked as "unresolved" from CR-123: -Add define for indexed flag for resident attributes, RA_INDEXED. -CreateBTreeFromIndex() - Don't try to read index entries beyond attribute length. -Move NtfsAddFileNameToDirectory() from dirctl.c to mft.c (no changes to function). -SetResidentAttributeDataLength() - Don't try to free AttribData if it hasn't been allocated. Cast IndexRecord to PUCHAR for WriteAttribute(), and cast BitmapData to PCHAR for ReadAttribute() (make gcc happy). -Replace magic number 16 with a define, NTFS_FILE_FIRST_USER_FILE. svn path=/branches/GSoC_2016/NTFS/; revision=75371 --- drivers/filesystems/ntfs/attrib.c | 2 +- drivers/filesystems/ntfs/btree.c | 30 +++-- drivers/filesystems/ntfs/create.c | 4 +- drivers/filesystems/ntfs/dirctl.c | 245 ------------------------------------ drivers/filesystems/ntfs/mft.c | 256 +++++++++++++++++++++++++++++++++++++- drivers/filesystems/ntfs/ntfs.h | 18 +-- 6 files changed, 284 insertions(+), 271 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index bd070c97ad..a6bc9a8aca 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -245,7 +245,7 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, AttributeAddress->Resident.ValueLength = FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + FilenameNoPath.Length; AttributeAddress->Resident.ValueOffset = ResidentHeaderLength; - AttributeAddress->Resident.Flags = 1; // indexed + AttributeAddress->Resident.Flags = RA_INDEXED; // move the attribute-end and file-record-end markers to the end of the file record AttributeAddress = (PNTFS_ATTR_RECORD)((ULONG_PTR)AttributeAddress + AttributeAddress->Length); diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index 179107272b..a7eacb3173 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -138,6 +138,7 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, PB_TREE Tree = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE), TAG_NTFS); PB_TREE_FILENAME_NODE RootNode = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_FILENAME_NODE), TAG_NTFS); PB_TREE_KEY CurrentKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); + ULONG CurrentOffset = IndexRoot->Header.FirstEntryOffset; DPRINT1("CreateBTreeFromIndex(%p, %p, %p)\n", IndexRootContext, IndexRoot, NewTree); @@ -161,11 +162,21 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, RootNode->FirstKey = CurrentKey; Tree->RootNode = RootNode; - // Create a key for each entry in the node + // Make sure we won't try reading past the attribute-end + if (FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) + IndexRoot->Header.TotalSizeOfEntries > IndexRootContext->Record.Resident.ValueLength) + { + DPRINT1("Filesystem corruption detected!\n"); + DestroyBTree(Tree); + return STATUS_FILE_CORRUPT_ERROR; + } + + // Start at the first node entry CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexRoot + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) + IndexRoot->Header.FirstEntryOffset); - while (TRUE) + + // Create a key for each entry in the node + while (CurrentOffset < IndexRoot->Header.TotalSizeOfEntries) { // Allocate memory for the current entry CurrentKey->IndexEntry = ExAllocatePoolWithTag(NonPagedPool, CurrentNodeEntry->Length, TAG_NTFS); @@ -207,6 +218,7 @@ CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, } // Advance to the next entry + CurrentOffset += CurrentNodeEntry->Length; CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)CurrentNodeEntry + CurrentNodeEntry->Length); CurrentKey = NextKey; } @@ -336,7 +348,7 @@ CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt, // Add Length of Current Entry to Total Size of Entries NewIndexRoot->Header.TotalSizeOfEntries += CurrentNodeEntry->Length; - // Go to the next node + // Go to the next node entry CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)CurrentNodeEntry + CurrentNodeEntry->Length); CurrentKey = CurrentKey->NextKey; @@ -533,16 +545,12 @@ NtfsInsertKey(ULONGLONG FileReference, { // Should the New Key go before the current key? LONG Comparison = CompareTreeKeys(NewKey, CurrentKey, CaseSensitive); - if (Comparison == 0) - { - DPRINT1("DRIVER ERROR: Asked to insert key into tree that already has it!\n"); - ExFreePoolWithTag(NewKey, TAG_NTFS); - ExFreePoolWithTag(NewEntry, TAG_NTFS); - return STATUS_INVALID_PARAMETER; - } + + ASSERT(Comparison != 0); + + // Is NewKey < CurrentKey? if (Comparison < 0) { - // NewKey is < CurrentKey // Insert New Key before Current Key NewKey->NextKey = CurrentKey; diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 30cc921095..f5ca1027fc 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -185,7 +185,7 @@ NtfsOpenFileById(PDEVICE_EXTENSION DeviceExt, DPRINT1("NtfsOpenFileById(%p, %p, %I64x, %p)\n", DeviceExt, FileObject, MftId, FoundFCB); - ASSERT(MftId < 0x10); + ASSERT(MftId < NTFS_FILE_FIRST_USER_FILE); if (MftId > 0xb) /* No entries are used yet beyond this */ { return STATUS_OBJECT_NAME_NOT_FOUND; @@ -375,7 +375,7 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, return STATUS_INVALID_PARAMETER; MFTId = (*(PULONGLONG)FileObject->FileName.Buffer) & NTFS_MFT_MASK; - if (MFTId < 0x10) + if (MFTId < NTFS_FILE_FIRST_USER_FILE) { Status = NtfsOpenFileById(DeviceExt, FileObject, MFTId, &Fcb); } diff --git a/drivers/filesystems/ntfs/dirctl.c b/drivers/filesystems/ntfs/dirctl.c index c41688ea2b..98294b4791 100644 --- a/drivers/filesystems/ntfs/dirctl.c +++ b/drivers/filesystems/ntfs/dirctl.c @@ -34,251 +34,6 @@ /* FUNCTIONS ****************************************************************/ -/** -* @name NtfsAddFilenameToDirectory -* @implemented -* -* Adds a $FILE_NAME attribute to a given directory index. -* -* @param DeviceExt -* Points to the target disk's DEVICE_EXTENSION. -* -* @param DirectoryMftIndex -* Mft index of the parent directory which will receive the file. -* -* @param FileReferenceNumber -* File reference of the file to be added to the directory. This is a combination of the -* Mft index and sequence number. -* -* @param FilenameAttribute -* Pointer to the FILENAME_ATTRIBUTE of the file being added to the directory. -* -* @param CaseSensitive -* Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE -* if an application created the file with the FILE_FLAG_POSIX_SEMANTICS flag. -* -* @return -* STATUS_SUCCESS on success. -* STATUS_INSUFFICIENT_RESOURCES if an allocation fails. -* STATUS_NOT_IMPLEMENTED if target address isn't at the end of the given file record. -* -* @remarks -* WIP - Can only support a few files in a directory. -* One FILENAME_ATTRIBUTE is added to the directory's index for each link to that file. So, each -* file which contains one FILENAME_ATTRIBUTE for a long name and another for the 8.3 name, will -* get both attributes added to its parent directory. -*/ -NTSTATUS -NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, - ULONGLONG DirectoryMftIndex, - ULONGLONG FileReferenceNumber, - PFILENAME_ATTRIBUTE FilenameAttribute, - BOOLEAN CaseSensitive) -{ - NTSTATUS Status = STATUS_SUCCESS; - PFILE_RECORD_HEADER ParentFileRecord; - PNTFS_ATTR_CONTEXT IndexRootContext; - PINDEX_ROOT_ATTRIBUTE I30IndexRoot; - ULONG IndexRootOffset; - ULONGLONG I30IndexRootLength; - ULONG LengthWritten; - PNTFS_ATTR_RECORD DestinationAttribute; - PINDEX_ROOT_ATTRIBUTE NewIndexRoot; - ULONG AttributeLength; - PNTFS_ATTR_RECORD NextAttribute; - PB_TREE NewTree; - ULONG BtreeIndexLength; - ULONG MaxIndexSize; - - // Allocate memory for the parent directory - ParentFileRecord = ExAllocatePoolWithTag(NonPagedPool, - DeviceExt->NtfsInfo.BytesPerFileRecord, - TAG_NTFS); - if (!ParentFileRecord) - { - DPRINT1("ERROR: Couldn't allocate memory for file record!\n"); - return STATUS_INSUFFICIENT_RESOURCES; - } - - // Open the parent directory - Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); - if (!NT_SUCCESS(Status)) - { - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - DPRINT1("ERROR: Couldn't read parent directory with index %I64u\n", - DirectoryMftIndex); - return Status; - } - - DPRINT1("Dumping old parent file record:\n"); - NtfsDumpFileRecord(DeviceExt, ParentFileRecord); - - // Find the index root attribute for the directory - Status = FindAttribute(DeviceExt, - ParentFileRecord, - AttributeIndexRoot, - L"$I30", - 4, - &IndexRootContext, - &IndexRootOffset); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Couldn't find $I30 $INDEX_ROOT attribute for parent directory with MFT #: %I64u!\n", - DirectoryMftIndex); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return Status; - } - - // Find the maximum index size given what the file record can hold - MaxIndexSize = DeviceExt->NtfsInfo.BytesPerFileRecord - - IndexRootOffset - - IndexRootContext->Record.Resident.ValueOffset - - FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) - - (sizeof(ULONG) * 2); - - // Allocate memory for the index root data - I30IndexRootLength = AttributeDataLength(&IndexRootContext->Record); - I30IndexRoot = ExAllocatePoolWithTag(NonPagedPool, I30IndexRootLength, TAG_NTFS); - if (!I30IndexRoot) - { - DPRINT1("ERROR: Couldn't allocate memory for index root attribute!\n"); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return STATUS_INSUFFICIENT_RESOURCES; - } - - // Read the Index Root - Status = ReadAttribute(DeviceExt, IndexRootContext, 0, (PCHAR)I30IndexRoot, I30IndexRootLength); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Couln't read index root attribute for Mft index #%I64u\n", DirectoryMftIndex); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return Status; - } - - // Convert the index to a B*Tree - Status = CreateBTreeFromIndex(IndexRootContext, I30IndexRoot, &NewTree); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Failed to create B-Tree from Index!\n"); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return Status; - } - - DumpBTree(NewTree); - - // Insert the key for the file we're adding - Status = NtfsInsertKey(FileReferenceNumber, FilenameAttribute, NewTree->RootNode, CaseSensitive); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Failed to insert key into B-Tree!\n"); - DestroyBTree(NewTree); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return Status; - } - - DumpBTree(NewTree); - - // Convert B*Tree back to Index Root - Status = CreateIndexRootFromBTree(DeviceExt, NewTree, MaxIndexSize, &NewIndexRoot, &BtreeIndexLength); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Failed to create Index root from B-Tree!\n"); - DestroyBTree(NewTree); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return Status; - } - - // We're done with the B-Tree now - DestroyBTree(NewTree); - - // Write back the new index root attribute to the parent directory file record - - // First, we need to resize the attribute. - // CreateIndexRootFromBTree() should have verified that the index root fits within MaxIndexSize. - // We can't set the size as we normally would, because if we extend past the file record, - // we must create an index allocation and index bitmap (TODO). Also TODO: support file records with - // $ATTRIBUTE_LIST's. - AttributeLength = NewIndexRoot->Header.AllocatedSize + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header); - DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset); - - // Find the attribute (or attribute-end marker) after the index root - NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); - if (NextAttribute->Type != AttributeEnd) - { - DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n"); - ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return STATUS_NOT_IMPLEMENTED; - } - - // Update the length of the attribute in the file record of the parent directory - InternalSetResidentAttributeLength(IndexRootContext, - ParentFileRecord, - IndexRootOffset, - AttributeLength); - - NT_ASSERT(ParentFileRecord->BytesInUse <= DeviceExt->NtfsInfo.BytesPerFileRecord); - - Status = UpdateFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Failed to update file record of directory with index: %llx\n", DirectoryMftIndex); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - return Status; - } - - // Write the new index root to disk - Status = WriteAttribute(DeviceExt, - IndexRootContext, - 0, - (PUCHAR)NewIndexRoot, - AttributeLength, - &LengthWritten); - if (!NT_SUCCESS(Status) ) - { - DPRINT1("ERROR: Unable to write new index root attribute to parent directory!\n"); - ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return Status; - } - - // re-read the parent file record, so we can dump it - Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Couldn't read parent directory after messing with it!\n"); - } - else - { - DPRINT1("Dumping new parent file record:\n"); - NtfsDumpFileRecord(DeviceExt, ParentFileRecord); - } - - // Cleanup - ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(IndexRootContext); - ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); - ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - - return Status; -} - ULONGLONG NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt, PFILE_RECORD_HEADER FileRecord, diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index ed531df173..72953c0086 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -750,7 +750,8 @@ SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { DPRINT1("Unable to create LargeMcb!\n"); - ExFreePoolWithTag(AttribData, TAG_NTFS); + if (AttribDataSize.QuadPart > 0) + ExFreePoolWithTag(AttribData, TAG_NTFS); _SEH2_YIELD(return _SEH2_GetExceptionCode()); } _SEH2_END; @@ -1452,7 +1453,7 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, { // we need to write the index root attribute back to disk ULONG LengthWritten; - Status = WriteAttribute(Vcb, IndexRootCtx, 0, IndexRecord, AttributeDataLength(&IndexRootCtx->Record), &LengthWritten); + Status = WriteAttribute(Vcb, IndexRootCtx, 0, (PUCHAR)IndexRecord, AttributeDataLength(&IndexRootCtx->Record), &LengthWritten); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Couldn't update Index Root!\n"); @@ -1514,7 +1515,7 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, while (IndexEntry < LastEntry && !(IndexEntry->Flags & NTFS_INDEX_ENTRY_END)) { - if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) > 0x10 && + if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) > NTFS_FILE_FIRST_USER_FILE && *CurrentEntry >= *StartEntry && IndexEntry->FileName.NameType != NTFS_FILE_NAME_DOS && CompareFileName(FileName, IndexEntry, DirSearch, CaseSensitive)) @@ -1755,7 +1756,7 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, } // read $Bitmap attribute - AttrBytesRead = ReadAttribute(DeviceExt, BitmapContext, 0, BitmapData, BitmapDataSize); + AttrBytesRead = ReadAttribute(DeviceExt, BitmapContext, 0, (PCHAR)BitmapData, BitmapDataSize); if (AttrBytesRead == 0) { @@ -1843,6 +1844,251 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, return Status; } +/** +* @name NtfsAddFilenameToDirectory +* @implemented +* +* Adds a $FILE_NAME attribute to a given directory index. +* +* @param DeviceExt +* Points to the target disk's DEVICE_EXTENSION. +* +* @param DirectoryMftIndex +* Mft index of the parent directory which will receive the file. +* +* @param FileReferenceNumber +* File reference of the file to be added to the directory. This is a combination of the +* Mft index and sequence number. +* +* @param FilenameAttribute +* Pointer to the FILENAME_ATTRIBUTE of the file being added to the directory. +* +* @param CaseSensitive +* Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE +* if an application created the file with the FILE_FLAG_POSIX_SEMANTICS flag. +* +* @return +* STATUS_SUCCESS on success. +* STATUS_INSUFFICIENT_RESOURCES if an allocation fails. +* STATUS_NOT_IMPLEMENTED if target address isn't at the end of the given file record. +* +* @remarks +* WIP - Can only support a few files in a directory. +* One FILENAME_ATTRIBUTE is added to the directory's index for each link to that file. So, each +* file which contains one FILENAME_ATTRIBUTE for a long name and another for the 8.3 name, will +* get both attributes added to its parent directory. +*/ +NTSTATUS +NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, + ULONGLONG DirectoryMftIndex, + ULONGLONG FileReferenceNumber, + PFILENAME_ATTRIBUTE FilenameAttribute, + BOOLEAN CaseSensitive) +{ + NTSTATUS Status = STATUS_SUCCESS; + PFILE_RECORD_HEADER ParentFileRecord; + PNTFS_ATTR_CONTEXT IndexRootContext; + PINDEX_ROOT_ATTRIBUTE I30IndexRoot; + ULONG IndexRootOffset; + ULONGLONG I30IndexRootLength; + ULONG LengthWritten; + PNTFS_ATTR_RECORD DestinationAttribute; + PINDEX_ROOT_ATTRIBUTE NewIndexRoot; + ULONG AttributeLength; + PNTFS_ATTR_RECORD NextAttribute; + PB_TREE NewTree; + ULONG BtreeIndexLength; + ULONG MaxIndexSize; + + // Allocate memory for the parent directory + ParentFileRecord = ExAllocatePoolWithTag(NonPagedPool, + DeviceExt->NtfsInfo.BytesPerFileRecord, + TAG_NTFS); + if (!ParentFileRecord) + { + DPRINT1("ERROR: Couldn't allocate memory for file record!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Open the parent directory + Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); + if (!NT_SUCCESS(Status)) + { + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + DPRINT1("ERROR: Couldn't read parent directory with index %I64u\n", + DirectoryMftIndex); + return Status; + } + + DPRINT1("Dumping old parent file record:\n"); + NtfsDumpFileRecord(DeviceExt, ParentFileRecord); + + // Find the index root attribute for the directory + Status = FindAttribute(DeviceExt, + ParentFileRecord, + AttributeIndexRoot, + L"$I30", + 4, + &IndexRootContext, + &IndexRootOffset); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't find $I30 $INDEX_ROOT attribute for parent directory with MFT #: %I64u!\n", + DirectoryMftIndex); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + // Find the maximum index size given what the file record can hold + MaxIndexSize = DeviceExt->NtfsInfo.BytesPerFileRecord + - IndexRootOffset + - IndexRootContext->Record.Resident.ValueOffset + - FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) + - (sizeof(ULONG) * 2); + + // Allocate memory for the index root data + I30IndexRootLength = AttributeDataLength(&IndexRootContext->Record); + I30IndexRoot = ExAllocatePoolWithTag(NonPagedPool, I30IndexRootLength, TAG_NTFS); + if (!I30IndexRoot) + { + DPRINT1("ERROR: Couldn't allocate memory for index root attribute!\n"); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Read the Index Root + Status = ReadAttribute(DeviceExt, IndexRootContext, 0, (PCHAR)I30IndexRoot, I30IndexRootLength); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couln't read index root attribute for Mft index #%I64u\n", DirectoryMftIndex); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + // Convert the index to a B*Tree + Status = CreateBTreeFromIndex(IndexRootContext, I30IndexRoot, &NewTree); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to create B-Tree from Index!\n"); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + DumpBTree(NewTree); + + // Insert the key for the file we're adding + Status = NtfsInsertKey(FileReferenceNumber, FilenameAttribute, NewTree->RootNode, CaseSensitive); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to insert key into B-Tree!\n"); + DestroyBTree(NewTree); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + DumpBTree(NewTree); + + // Convert B*Tree back to Index Root + Status = CreateIndexRootFromBTree(DeviceExt, NewTree, MaxIndexSize, &NewIndexRoot, &BtreeIndexLength); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to create Index root from B-Tree!\n"); + DestroyBTree(NewTree); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + // We're done with the B-Tree now + DestroyBTree(NewTree); + + // Write back the new index root attribute to the parent directory file record + + // First, we need to resize the attribute. + // CreateIndexRootFromBTree() should have verified that the index root fits within MaxIndexSize. + // We can't set the size as we normally would, because if we extend past the file record, + // we must create an index allocation and index bitmap (TODO). Also TODO: support file records with + // $ATTRIBUTE_LIST's. + AttributeLength = NewIndexRoot->Header.AllocatedSize + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header); + DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)ParentFileRecord + IndexRootOffset); + + // Find the attribute (or attribute-end marker) after the index root + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); + if (NextAttribute->Type != AttributeEnd) + { + DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n"); + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return STATUS_NOT_IMPLEMENTED; + } + + // Update the length of the attribute in the file record of the parent directory + InternalSetResidentAttributeLength(IndexRootContext, + ParentFileRecord, + IndexRootOffset, + AttributeLength); + + NT_ASSERT(ParentFileRecord->BytesInUse <= DeviceExt->NtfsInfo.BytesPerFileRecord); + + Status = UpdateFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to update file record of directory with index: %llx\n", DirectoryMftIndex); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + return Status; + } + + // Write the new index root to disk + Status = WriteAttribute(DeviceExt, + IndexRootContext, + 0, + (PUCHAR)NewIndexRoot, + AttributeLength, + &LengthWritten); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Unable to write new index root attribute to parent directory!\n"); + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + // re-read the parent file record, so we can dump it + Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't read parent directory after messing with it!\n"); + } + else + { + DPRINT1("Dumping new parent file record:\n"); + NtfsDumpFileRecord(DeviceExt, ParentFileRecord); + } + + // Cleanup + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(IndexRootContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + + return Status; +} + NTSTATUS AddFixupArray(PDEVICE_EXTENSION Vcb, PNTFS_RECORD_HEADER Record) @@ -1995,7 +2241,7 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, while (IndexEntry < LastEntry && !(IndexEntry->Flags & NTFS_INDEX_ENTRY_END)) { - if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) >= 0x10 && + if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) >= NTFS_FILE_FIRST_USER_FILE && *CurrentEntry >= *StartEntry && IndexEntry->FileName.NameType != NTFS_FILE_NAME_DOS && CompareFileName(FileName, IndexEntry, DirSearch, CaseSensitive)) diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index ddb876daf9..9cbc4d5485 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -193,6 +193,7 @@ typedef enum #define NTFS_FILE_QUOTA 9 #define NTFS_FILE_UPCASE 10 #define NTFS_FILE_EXTEND 11 +#define NTFS_FILE_FIRST_USER_FILE 16 #define NTFS_MFT_MASK 0x0000FFFFFFFFFFFFULL @@ -223,6 +224,9 @@ typedef enum #define NTFS_FILE_TYPE_COMPRESSED 0x800 #define NTFS_FILE_TYPE_DIRECTORY 0x10000000 +/* Indexed Flag in Resident attributes - still somewhat speculative */ +#define RA_INDEXED 0x01 + typedef struct { ULONG Type; /* Magic number 'FILE' */ @@ -740,13 +744,6 @@ NtfsDeviceControl(PNTFS_IRP_CONTEXT IrpContext); /* dirctl.c */ -NTSTATUS -NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, - ULONGLONG DirectoryMftIndex, - ULONGLONG FileReferenceNumber, - PFILENAME_ATTRIBUTE FilenameAttribute, - BOOLEAN CaseSensitive); - ULONGLONG NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt, PFILE_RECORD_HEADER FileRecord, @@ -888,6 +885,13 @@ NtfsFileSystemControl(PNTFS_IRP_CONTEXT IrpContext); /* mft.c */ +NTSTATUS +NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, + ULONGLONG DirectoryMftIndex, + ULONGLONG FileReferenceNumber, + PFILENAME_ATTRIBUTE FilenameAttribute, + BOOLEAN CaseSensitive); + NTSTATUS AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, PDEVICE_EXTENSION DeviceExt,

7 years

[reactos] 54/72: [NTFS] - Fix some formatting / style issues, per CR-123.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=430ce0a9e395ba1f98e44… commit 430ce0a9e395ba1f98e4417bd14286dd9eeac552 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Wed Jul 5 22:10:22 2017 +0000 [NTFS] - Fix some formatting / style issues, per CR-123. svn path=/branches/GSoC_2016/NTFS/; revision=75290 --- drivers/filesystems/ntfs/attrib.c | 5 +++-- drivers/filesystems/ntfs/btree.c | 4 +++- drivers/filesystems/ntfs/create.c | 4 ++-- drivers/filesystems/ntfs/fcb.c | 2 +- drivers/filesystems/ntfs/mft.c | 4 ++-- 5 files changed, 11 insertions(+), 8 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 7dcdabbea5..bd070c97ad 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -316,7 +316,8 @@ AddRun(PNTFS_VCB Vcb, NextVBN = AttrContext->Record.NonResident.HighestVCN + 1; // Add newly-assigned clusters to mcb - _SEH2_TRY{ + _SEH2_TRY + { if (!FsRtlAddLargeMcbEntry(&AttrContext->DataRunsMCB, NextVBN, NextAssignedCluster, @@ -796,7 +797,7 @@ FreeClusters(PNTFS_VCB Vcb, break; } - if( LargeLbn != -1) + if (LargeLbn != -1) { // deallocate this cluster RtlClearBits(&Bitmap, LargeLbn, 1); diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c index eff2b157ad..179107272b 100644 --- a/drivers/filesystems/ntfs/btree.c +++ b/drivers/filesystems/ntfs/btree.c @@ -77,7 +77,7 @@ CompareTreeKeys(PB_TREE_KEY Key1, PB_TREE_KEY Key2, BOOLEAN CaseSensitive) = Key2->IndexEntry->FileName.NameLength * sizeof(WCHAR); // Are the two keys the same length? - if(Key1Name.Length == Key2Name.Length) + if (Key1Name.Length == Key2Name.Length) return RtlCompareUnicodeString(&Key1Name, &Key2Name, !CaseSensitive); // Is Key1 shorter? @@ -416,7 +416,9 @@ DumpBTreeKey(PB_TREE_KEY Key, ULONG Number, ULONG Depth) DbgPrint(" '%wZ'\n", &FileName); } else + { DbgPrint(" (Dummy Key)\n"); + } } VOID diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 8274d97992..30cc921095 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -299,7 +299,7 @@ NtfsOpenFile(PDEVICE_EXTENSION DeviceExt, ParentFcb); } - if (!NT_SUCCESS (Status)) + if (!NT_SUCCESS(Status)) { DPRINT("Could not make a new FCB, status: %x\n", Status); @@ -347,7 +347,7 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, DeviceExt = DeviceObject->DeviceExtension; ASSERT(DeviceExt); - Stack = IoGetCurrentIrpStackLocation (Irp); + Stack = IoGetCurrentIrpStackLocation(Irp); ASSERT(Stack); RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff); diff --git a/drivers/filesystems/ntfs/fcb.c b/drivers/filesystems/ntfs/fcb.c index 5497b8001d..fe79511bb3 100644 --- a/drivers/filesystems/ntfs/fcb.c +++ b/drivers/filesystems/ntfs/fcb.c @@ -617,7 +617,7 @@ NtfsGetFCBForFile(PNTFS_VCB Vcb, #if 1 /* Trivial case, open of the root directory on volume */ - if (pFileName [0] == L'\0' || wcscmp(pFileName, L"\\") == 0) + if (pFileName[0] == L'\0' || wcscmp(pFileName, L"\\") == 0) { DPRINT("returning root FCB\n"); diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 87820e6457..ed531df173 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -448,7 +448,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, if (NT_SUCCESS(Status)) { - if(AttrContext->Record.IsNonResident) + if (AttrContext->Record.IsNonResident) Fcb->RFCB.AllocationSize.QuadPart = AttrContext->Record.NonResident.AllocatedSize; else Fcb->RFCB.AllocationSize = *DataSize; @@ -1319,7 +1319,7 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, } // end while (Length > 0) [more data to write] // TEMPTEMP - if(Context->Record.IsNonResident) + if (Context->Record.IsNonResident) ExFreePoolWithTag(TempBuffer, TAG_NTFS); Context->CacheRun = DataRun;

7 years

← Newer
1
...
19
20
21
22
23
24
25
...
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