Ros-diffs December 2017

ros-diffs@reactos.org

26 participants
355 discussions

[reactos] 43/72: [NTFS] - Begin to implement B-Trees. Allow for creating several new files in a directory. NtfsAddFilenameToDirectory() - Add CaseSensitive parameter. Update to use new B-Tree code: First, the index is read and converted to a B-Tree in memory. Next, a key for the new file is inserted into the tree. Finally, the tree is converted back to an index root attribute which is written to disk. +btree.c - Includes functions related to B-Trees (AKA B*Trees). ntfs.h - Added several structur

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=54f5c3b6ec26f1758b878… commit 54f5c3b6ec26f1758b878b901f4a2f3f9a1a47cc Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Wed Jun 28 03:45:52 2017 +0000 [NTFS] - Begin to implement B-Trees. Allow for creating several new files in a directory. NtfsAddFilenameToDirectory() - Add CaseSensitive parameter. Update to use new B-Tree code: First, the index is read and converted to a B-Tree in memory. Next, a key for the new file is inserted into the tree. Finally, the tree is converted back to an index root attribute which is written to disk. +btree.c - Includes functions related to B-Trees (AKA B*Trees). ntfs.h - Added several structures for representing B-Trees in memory. Known limitations: For simplicity, only trees with a depth of one are currently supported (i.e. an ordered list of filenames). Directories that have or will require an index allocation to store all their filenames are still TODO. As a consequence, the user will only be able to create about 6 files in a directory. svn path=/branches/GSoC_2016/NTFS/; revision=75223 --- drivers/filesystems/ntfs/CMakeLists.txt | 1 + drivers/filesystems/ntfs/attrib.c | 6 + drivers/filesystems/ntfs/btree.c | 520 ++++++++++++++++++++++++++++++++ drivers/filesystems/ntfs/create.c | 3 +- drivers/filesystems/ntfs/dirctl.c | 117 ++++--- drivers/filesystems/ntfs/ntfs.h | 61 +++- 6 files changed, 643 insertions(+), 65 deletions(-) diff --git a/drivers/filesystems/ntfs/CMakeLists.txt b/drivers/filesystems/ntfs/CMakeLists.txt index ff3b35f647..b9c72a72e7 100644 --- a/drivers/filesystems/ntfs/CMakeLists.txt +++ b/drivers/filesystems/ntfs/CMakeLists.txt @@ -1,6 +1,7 @@ list(APPEND SOURCE attrib.c + btree.c blockdev.c cleanup.c close.c diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 90e20d3819..239e1c0400 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -1566,6 +1566,12 @@ GetStandardInformationFromRecord(PDEVICE_EXTENSION Vcb, return NULL; } +ULONG GetFileNameAttributeLength(PFILENAME_ATTRIBUTE FileNameAttribute) +{ + ULONG Length = FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + (FileNameAttribute->NameLength * sizeof(WCHAR)); + return Length; +} + PFILENAME_ATTRIBUTE GetBestFileNameFromRecord(PDEVICE_EXTENSION Vcb, PFILE_RECORD_HEADER FileRecord) diff --git a/drivers/filesystems/ntfs/btree.c b/drivers/filesystems/ntfs/btree.c new file mode 100644 index 0000000000..604c02c290 --- /dev/null +++ b/drivers/filesystems/ntfs/btree.c @@ -0,0 +1,520 @@ +/* +* ReactOS kernel +* Copyright (C) 2002, 2017 ReactOS Team +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. +* +* COPYRIGHT: See COPYING in the top level directory +* PROJECT: ReactOS kernel +* FILE: drivers/filesystem/ntfs/btree.c +* PURPOSE: NTFS filesystem driver +* PROGRAMMERS: Trevor Thompson +*/ + +/* INCLUDES *****************************************************************/ + +#include "ntfs.h" + +#define NDEBUG +#include <debug.h> + +/* FUNCTIONS ****************************************************************/ + +/** +* @name CompareTreeKeys +* @implemented +* +* Compare two B_TREE_KEY's to determine their order in the tree. +* +* @param Key1 +* Pointer to a B_TREE_KEY that will be compared. +* +* @param Key2 +* Pointer to the other B_TREE_KEY that will be compared. +* +* @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. +* +* @returns +* 0 if the two keys are equal. +* < 0 if key1 is less thank key2 +* > 0 if key1 is greater than key2 +* +* @remarks +* Any other key is always less than the final (dummy) key in a node. +*/ +LONG +CompareTreeKeys(PB_TREE_KEY Key1, PB_TREE_KEY Key2, BOOLEAN CaseSensitive) +{ + UNICODE_STRING Key1Name, Key2Name; + + // If Key2 is the "dummy key", key 1 will always come first + if (Key2->NextKey == NULL) + return -1; + + // If Key1 is the "dummy key", key 2 will always come first + if (Key1->NextKey == NULL) + return 1; + + Key1Name.Buffer = Key1->IndexEntry->FileName.Name; + Key1Name.Length = Key1Name.MaximumLength + = Key1->IndexEntry->FileName.NameLength * sizeof(WCHAR); + + Key2Name.Buffer = Key2->IndexEntry->FileName.Name; + Key2Name.Length = Key2Name.MaximumLength + = Key2->IndexEntry->FileName.NameLength * sizeof(WCHAR); + + return RtlCompareUnicodeString(&Key1Name, &Key2Name, !CaseSensitive); +} + +/** +* @name CreateBTreeFromIndex +* @implemented +* +* Parse an index and create a B-Tree in memory from it. +* +* @param IndexRootContext +* Pointer to an NTFS_ATTR_CONTEXT that describes the location of the index root attribute. +* +* @param NewTree +* Pointer to a PB_TREE that will receive the pointer to a newly-created B-Tree. +* +* @returns +* STATUS_SUCCESS on success. +* STATUS_INSUFFICIENT_RESOURCES if an allocation fails. +* +* @remarks +* Allocates memory for the entire tree. Caller is responsible for destroying the tree with DestroyBTree(). +*/ +NTSTATUS +CreateBTreeFromIndex(PNTFS_ATTR_CONTEXT IndexRootContext, + PINDEX_ROOT_ATTRIBUTE IndexRoot, + PB_TREE *NewTree) +{ + PINDEX_ENTRY_ATTRIBUTE CurrentNodeEntry; + 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); + + DPRINT1("CreateBTreeFromIndex(%p, %p, %p)\n", IndexRootContext, IndexRoot, NewTree); + + if (!Tree || !RootNode || !CurrentKey) + { + DPRINT1("Couldn't allocate enough memory for B-Tree!\n"); + if (Tree) + ExFreePoolWithTag(Tree, TAG_NTFS); + if (CurrentKey) + ExFreePoolWithTag(CurrentKey, TAG_NTFS); + if (RootNode) + ExFreePoolWithTag(RootNode, TAG_NTFS); + return STATUS_INSUFFICIENT_RESOURCES; + } + + RtlZeroMemory(Tree, sizeof(B_TREE)); + RtlZeroMemory(RootNode, sizeof(B_TREE_FILENAME_NODE)); + RtlZeroMemory(CurrentKey, sizeof(B_TREE_KEY)); + + // Setup the Tree + RootNode->FirstKey = CurrentKey; + Tree->RootNode = RootNode; + + // Create a key for each entry in the node + CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexRoot + + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) + + IndexRoot->Header.FirstEntryOffset); + while (TRUE) + { + // 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"); + DestroyBTree(Tree); + return STATUS_INSUFFICIENT_RESOURCES; + } + + RootNode->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(PB_TREE_KEY), TAG_NTFS); + if (!NextKey) + { + DPRINT1("ERROR: Couldn't allocate memory for next key!\n"); + DestroyBTree(Tree); + return STATUS_INSUFFICIENT_RESOURCES; + } + + RtlZeroMemory(NextKey, sizeof(PB_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); + + // Make sure this B-Tree is only one level deep (flat list) + 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; + } + + // Advance to the next entry + CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)CurrentNodeEntry + CurrentNodeEntry->Length); + CurrentKey = NextKey; + } + else + { + // Copy the final entry to its key + RtlCopyMemory(CurrentKey->IndexEntry, CurrentNodeEntry, CurrentNodeEntry->Length); + CurrentKey->NextKey = NULL; + + // Make sure this B-Tree is only one level deep (flat list) + 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; + } + + break; + } + } + + *NewTree = Tree; + + return STATUS_SUCCESS; +} + +/** +* @name CreateIndexRootFromBTree +* @implemented +* +* Parse a B-Tree in memory and convert it into an index that can be written to disk. +* +* @param DeviceExt +* Pointer to the DEVICE_EXTENSION of the target drive. +* +* @param Tree +* Pointer to a B_TREE that describes the index to be written. +* +* @param MaxIndexSize +* Describes how large the index can be before it will take too much space in the file record. +* After reaching MaxIndexSize, an index can no longer be represented with just an index root +* attribute, and will require an index allocation and $I30 bitmap (TODO). +* +* @param IndexRoot +* Pointer to a PINDEX_ROOT_ATTRIBUTE that will receive a pointer to the newly-created index. +* +* @param Length +* Pointer to a ULONG which will receive the length of the new index root. +* +* @returns +* STATUS_SUCCESS on success. +* STATUS_INSUFFICIENT_RESOURCES if an allocation fails. +* STATUS_NOT_IMPLEMENTED if the new index can't fit within MaxIndexSize. +* +* @remarks +* If the function succeeds, it's the caller's responsibility to free IndexRoot with ExFreePoolWithTag(). +*/ +NTSTATUS +CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt, + PB_TREE Tree, + ULONG MaxIndexSize, + PINDEX_ROOT_ATTRIBUTE *IndexRoot, + ULONG *Length) +{ + PINDEX_ENTRY_ATTRIBUTE CurrentNodeEntry; + PINDEX_ROOT_ATTRIBUTE NewIndexRoot = ExAllocatePoolWithTag(NonPagedPool, + DeviceExt->NtfsInfo.BytesPerFileRecord, + TAG_NTFS); + + DPRINT1("CreateIndexRootFromBTree(%p, %p, 0x%lx, %p, %p)\n", DeviceExt, Tree, MaxIndexSize, IndexRoot, Length); + + if (!NewIndexRoot) + { + DPRINT1("Failed to allocate memory for Index Root!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Setup the new index root + RtlZeroMemory(NewIndexRoot, DeviceExt->NtfsInfo.BytesPerFileRecord); + + NewIndexRoot->AttributeType = AttributeFileName; + NewIndexRoot->CollationRule = COLLATION_FILE_NAME; + NewIndexRoot->SizeOfEntry = DeviceExt->NtfsInfo.BytesPerIndexRecord; + // If Bytes per index record is less than cluster size, clusters per index record becomes sectors per index + if (NewIndexRoot->SizeOfEntry < DeviceExt->NtfsInfo.BytesPerCluster) + NewIndexRoot->ClustersPerIndexRecord = NewIndexRoot->SizeOfEntry / DeviceExt->NtfsInfo.BytesPerSector; + else + NewIndexRoot->ClustersPerIndexRecord = NewIndexRoot->SizeOfEntry / DeviceExt->NtfsInfo.BytesPerCluster; + + // Setup the Index node header + NewIndexRoot->Header.FirstEntryOffset = sizeof(INDEX_HEADER_ATTRIBUTE); + NewIndexRoot->Header.Flags = INDEX_ROOT_SMALL; + + // Start summing the total size of this node's entries + NewIndexRoot->Header.TotalSizeOfEntries = NewIndexRoot->Header.FirstEntryOffset; + + // Setup each Node Entry + PB_TREE_KEY CurrentKey = Tree->RootNode->FirstKey; + CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)NewIndexRoot + + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header) + + NewIndexRoot->Header.FirstEntryOffset); + for (int i = 0; i < Tree->RootNode->KeyCount; i++) + { + // 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) + { + DPRINT1("TODO: Adding file would require creating an index allocation!\n"); + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + return STATUS_NOT_IMPLEMENTED; + } + + // Copy the index entry + if (CurrentKey->IndexEntry->Length > 0) + RtlCopyMemory(CurrentNodeEntry, CurrentKey->IndexEntry, CurrentKey->IndexEntry->Length); + else + DPRINT1("DRIVER ERROR: CurrentKey->IndexEntry->Length <= 0 !\n"); + + 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 + NewIndexRoot->Header.TotalSizeOfEntries += CurrentNodeEntry->Length; + + // Go to the next node + CurrentNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)CurrentNodeEntry + CurrentNodeEntry->Length); + + CurrentKey = CurrentKey->NextKey; + } + + NewIndexRoot->Header.AllocatedSize = NewIndexRoot->Header.TotalSizeOfEntries; + + *IndexRoot = NewIndexRoot; + *Length = NewIndexRoot->Header.AllocatedSize + FIELD_OFFSET(INDEX_ROOT_ATTRIBUTE, Header); + + return STATUS_SUCCESS; +} + +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 + + ExFreePoolWithTag(Key, TAG_NTFS); +} + +VOID +DestroyBTreeNode(PB_TREE_FILENAME_NODE Node) +{ + PB_TREE_KEY NextKey; + PB_TREE_KEY CurrentKey = Node->FirstKey; + for (int i = 0; i < Node->KeyCount; i++) + { + NT_ASSERT(CurrentKey); + NextKey = CurrentKey->NextKey; + DestroyBTreeKey(CurrentKey); + CurrentKey = NextKey; + } + + NT_ASSERT(NextKey == NULL); + + ExFreePoolWithTag(Node, TAG_NTFS); +} + +/** +* @name DestroyBTree +* @implemented +* +* Destroys a B-Tree. +* +* @param Tree +* Pointer to the B_TREE which will be destroyed. +* +* @remarks +* Destroys every bit of data stored in the tree. +*/ +VOID +DestroyBTree(PB_TREE Tree) +{ + DestroyBTreeNode(Tree->RootNode); + ExFreePoolWithTag(Tree, TAG_NTFS); +} + +VOID +DumpBTreeKey(PB_TREE_KEY Key, int Number, int Depth) +{ + for (int i = 0; i < Depth; i++) + DbgPrint(" "); + DbgPrint(" Key #%d", Number); + + if (!(Key->IndexEntry->Flags & NTFS_INDEX_ENTRY_END)) + { + UNICODE_STRING FileName; + FileName.Length = Key->IndexEntry->FileName.NameLength * 2; + FileName.MaximumLength = FileName.Length; + FileName.Buffer = Key->IndexEntry->FileName.Name; + DbgPrint(" '%wZ'\n", &FileName); + } + else + DbgPrint(" (Dummy Key)\n"); +} + +DumpBTreeNode(PB_TREE_FILENAME_NODE Node, int Number, int Depth) +{ + for (int i = 0; i < Depth; i++) + DbgPrint(" "); + DbgPrint("Node #%d, Depth %d\n", Number, Depth); + + PB_TREE_KEY CurrentKey = Node->FirstKey; + for (int i = 0; i < Node->KeyCount; i++) + { + DumpBTreeKey(CurrentKey, i, Depth); + CurrentKey = CurrentKey->NextKey; + } +} + +/** +* @name DumpBTree +* @implemented +* +* Displays a B-Tree. +* +* @param Tree +* Pointer to the B_TREE which will be displayed. +* +* @remarks +* Displays a diagnostic summary of a B_TREE. +*/ +VOID +DumpBTree(PB_TREE Tree) +{ + DbgPrint("B_TREE @ %p\n", Tree); + DumpBTreeNode(Tree->RootNode, 0, 0); +} + +/** +* @name NtfsInsertKey +* @implemented +* +* Inserts a FILENAME_ATTRIBUTE into a B-Tree node. +* +* @param FileReference +* Reference number to the file being added. This will be a combination of the MFT index and update sequence number. +* +* @param FileNameAttribute +* Pointer to a FILENAME_ATTRIBUTE which is the data for the key that will be added to the tree. A copy will be made. +* +* @param Node +* Pointer to a B_TREE_FILENAME_NODE into which a new key will be inserted, in order. +* +* @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. +* +* @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, + PFILENAME_ATTRIBUTE FileNameAttribute, + 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; + + DPRINT1("NtfsInsertKey(0x%02I64, %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 + PB_TREE_KEY NewKey = ExAllocatePoolWithTag(NonPagedPool, sizeof(B_TREE_KEY), TAG_NTFS); + NewKey->IndexEntry = NewEntry; + NewKey->NextKey = NULL; + + // Find where to insert the key + PB_TREE_KEY CurrentKey = Node->FirstKey; + PB_TREE_KEY PreviousKey = NULL; + for (int i = 0; i < Node->KeyCount; i++) + { + // 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; + } + if (Comparison < 0) + { + // NewKey is < CurrentKey + // Insert New Key before Current Key + NewKey->NextKey = CurrentKey; + + // was CurrentKey the first key? + if (CurrentKey == Node->FirstKey) + Node->FirstKey = NewKey; + else + PreviousKey->NextKey = NewKey; + break; + } + + PreviousKey = CurrentKey; + CurrentKey = CurrentKey->NextKey; + } + + Node->KeyCount++; + + // NewEntry and NewKey will be destroyed later by DestroyBTree() + + return STATUS_SUCCESS; +} \ No newline at end of file diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index f52cd7d187..586da89b36 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -747,7 +747,8 @@ NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, Status = NtfsAddFilenameToDirectory(DeviceExt, ParentMftIndex, FileMftIndex, - FilenameAttribute); + FilenameAttribute, + CaseSensitive); } ExFreePoolWithTag(FileRecord, TAG_NTFS); diff --git a/drivers/filesystems/ntfs/dirctl.c b/drivers/filesystems/ntfs/dirctl.c index 4d19052ac9..ba7231dc80 100644 --- a/drivers/filesystems/ntfs/dirctl.c +++ b/drivers/filesystems/ntfs/dirctl.c @@ -53,13 +53,17 @@ * @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 an empty directory. +* 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. @@ -68,7 +72,8 @@ NTSTATUS NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, ULONGLONG DirectoryMftIndex, ULONGLONG FileReferenceNumber, - PFILENAME_ATTRIBUTE FilenameAttribute) + PFILENAME_ATTRIBUTE FilenameAttribute, + BOOLEAN CaseSensitive) { NTSTATUS Status = STATUS_SUCCESS; PFILE_RECORD_HEADER ParentFileRecord; @@ -76,12 +81,14 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, PINDEX_ROOT_ATTRIBUTE I30IndexRoot; ULONG IndexRootOffset; ULONGLONG I30IndexRootLength; - PINDEX_ENTRY_ATTRIBUTE IndexNodeEntry; 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, @@ -122,9 +129,15 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, return Status; } - I30IndexRootLength = AttributeDataLength(&IndexRootContext->Record); + // 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 = (PINDEX_ROOT_ATTRIBUTE)ExAllocatePoolWithTag(NonPagedPool, I30IndexRootLength, TAG_NTFS); if (!I30IndexRoot) { @@ -144,82 +157,59 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, return Status; } - // Make sure it's empty (temporarily) - IndexNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)I30IndexRoot + I30IndexRoot->Header.FirstEntryOffset + 0x10); - if (IndexNodeEntry->Data.Directory.IndexedFile != 0 || IndexNodeEntry->Flags != 2) + // Convert the index to a B*Tree + Status = CreateBTreeFromIndex(IndexRootContext, I30IndexRoot, &NewTree); + if (!NT_SUCCESS(Status)) { - DPRINT1("FIXME: File-creation is only supported in empty directories right now! Be patient! :)\n"); + DPRINT1("ERROR: Failed to create B-Tree from Index!\n"); ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return STATUS_NOT_IMPLEMENTED; + return Status; } - - // Now we need to setup a new index root attribute to replace the old one - NewIndexRoot = ExAllocatePoolWithTag(NonPagedPool, DeviceExt->NtfsInfo.BytesPerIndexRecord, TAG_NTFS); - if (!NewIndexRoot) + + DumpBTree(NewTree); + + // Insert the key for the file we're adding + Status = NtfsInsertKey(FileReferenceNumber, FilenameAttribute, NewTree->RootNode, CaseSensitive); + if (!NT_SUCCESS(Status)) { - DPRINT1("ERROR: Unable to allocate memory for new index root attribute!\n"); + DPRINT1("ERROR: Failed to insert key into B-Tree!\n"); + DestroyBTree(NewTree); ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); - return STATUS_INSUFFICIENT_RESOURCES; + return Status; } + + DumpBTree(NewTree); - // Setup the new index record - RtlZeroMemory(NewIndexRoot, DeviceExt->NtfsInfo.BytesPerIndexRecord); // shouldn't be necessary but aids in debugging - - NewIndexRoot->AttributeType = AttributeFileName; - NewIndexRoot->CollationRule = COLLATION_FILE_NAME; - NewIndexRoot->SizeOfEntry = DeviceExt->NtfsInfo.BytesPerIndexRecord; - // If Bytes per index record is less than cluster size, clusters per index record becomes sectors per index - if(NewIndexRoot->SizeOfEntry < DeviceExt->NtfsInfo.BytesPerCluster) - NewIndexRoot->ClustersPerIndexRecord = NewIndexRoot->SizeOfEntry / DeviceExt->NtfsInfo.BytesPerSector; - else - NewIndexRoot->ClustersPerIndexRecord = NewIndexRoot->SizeOfEntry / DeviceExt->NtfsInfo.BytesPerCluster; - - // Setup the Index node header - NewIndexRoot->Header.FirstEntryOffset = 0x10; - NewIndexRoot->Header.Flags = INDEX_ROOT_SMALL; - // still need to calculate sizes - - // The first index node entry will be for the filename we're adding - IndexNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)NewIndexRoot + NewIndexRoot->Header.FirstEntryOffset + 0x10); - IndexNodeEntry->Data.Directory.IndexedFile = FileReferenceNumber; - IndexNodeEntry->Flags = INDEX_ROOT_SMALL; - IndexNodeEntry->KeyLength = FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + (2 * FilenameAttribute->NameLength); - IndexNodeEntry->Length = ALIGN_UP_BY(IndexNodeEntry->KeyLength, 8) + FIELD_OFFSET(INDEX_ENTRY_ATTRIBUTE, FileName); - - // Now we can calculate the Node length (temp logic) - NewIndexRoot->Header.TotalSizeOfEntries = NewIndexRoot->Header.FirstEntryOffset + IndexNodeEntry->Length + 0x10; - NewIndexRoot->Header.AllocatedSize = NewIndexRoot->Header.TotalSizeOfEntries; - - DPRINT1("New Index Node Entry Stream Length: %u\nNew Inde Node Entry Length: %u\n", - IndexNodeEntry->KeyLength, - IndexNodeEntry->Length); - - // copy over the attribute proper - RtlCopyMemory(&IndexNodeEntry->FileName, FilenameAttribute, IndexNodeEntry->KeyLength); - - // Now setup the dummy key - IndexNodeEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexNodeEntry + IndexNodeEntry->Length); - - IndexNodeEntry->Data.Directory.IndexedFile = 0; - IndexNodeEntry->Length = 0x10; - IndexNodeEntry->KeyLength = 0; - IndexNodeEntry->Flags = NTFS_INDEX_ENTRY_END; - - // This is when we'd normally setup the length (already done above) + // 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 make sure the attribute is large enough. + // 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) { @@ -230,24 +220,27 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, 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; } - // Update the parent directory with the new index root + // Write the new index root to disk Status = WriteAttribute(DeviceExt, IndexRootContext, 0, diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index d738ef5fe2..3e01f469a4 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -395,6 +395,28 @@ typedef struct FILENAME_ATTRIBUTE FileName; } INDEX_ENTRY_ATTRIBUTE, *PINDEX_ENTRY_ATTRIBUTE; +// 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_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 +{ + int KeyCount; + PB_TREE_KEY FirstKey; +} B_TREE_FILENAME_NODE, *PB_TREE_FILENAME_NODE; + +typedef struct +{ + PB_TREE_FILENAME_NODE RootNode; +} B_TREE, *PB_TREE; + typedef struct { ULONGLONG Unknown1; @@ -559,6 +581,8 @@ DecodeRun(PUCHAR DataRun, LONGLONG *DataRunOffset, ULONGLONG *DataRunLength); +ULONG GetFileNameAttributeLength(PFILENAME_ATTRIBUTE FileNameAttribute); + VOID NtfsDumpDataRuns(PVOID StartOfRun, ULONGLONG CurrentLCN); @@ -645,6 +669,38 @@ NtfsDeviceIoControl(IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN Override); +/* btree.c */ + +LONG +CompareTreeKeys(PB_TREE_KEY Key1, + PB_TREE_KEY Key2, + BOOLEAN CaseSensitive); + +NTSTATUS +CreateBTreeFromIndex(/*PDEVICE_EXTENSION Vcb,*/ + PNTFS_ATTR_CONTEXT IndexRootContext, + PINDEX_ROOT_ATTRIBUTE IndexRoot, + PB_TREE *NewTree); + +NTSTATUS +CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt, + PB_TREE Tree, + ULONG MaxIndexSize, + PINDEX_ROOT_ATTRIBUTE *IndexRoot, + ULONG *Length); + +VOID +DestroyBTree(PB_TREE Tree); + +VOID +DumpBTree(PB_TREE Tree); + +NTSTATUS +NtfsInsertKey(ULONGLONG FileReference, + PFILENAME_ATTRIBUTE FileNameAttribute, + PB_TREE_FILENAME_NODE Node, + BOOLEAN CaseSensitive); + /* close.c */ NTSTATUS @@ -683,8 +739,9 @@ NtfsDeviceControl(PNTFS_IRP_CONTEXT IrpContext); NTSTATUS NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, ULONGLONG DirectoryMftIndex, - ULONGLONG FileMftIndex, - PFILENAME_ATTRIBUTE FilenameAttribute); + ULONGLONG FileReferenceNumber, + PFILENAME_ATTRIBUTE FilenameAttribute, + BOOLEAN CaseSensitive); ULONGLONG NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt,

7 years

[reactos] 42/72: [NTFS] - Add some minor fixes and improvements: Improve, add, or fix some DPRINTs. In particular, ULONG's should use %lu, not %u. Also, don't be silent about filesystem corruption. NtfsFindMftRecord() - move CaseSensitive parameter before output parameter in parameter list.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=38c947b7abde91ce68d27… commit 38c947b7abde91ce68d27e5f18553ca2f1747274 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Mon Jun 26 05:17:08 2017 +0000 [NTFS] - Add some minor fixes and improvements: Improve, add, or fix some DPRINTs. In particular, ULONG's should use %lu, not %u. Also, don't be silent about filesystem corruption. NtfsFindMftRecord() - move CaseSensitive parameter before output parameter in parameter list. svn path=/branches/GSoC_2016/NTFS/; revision=75199 --- drivers/filesystems/ntfs/attrib.c | 6 ++--- drivers/filesystems/ntfs/blockdev.c | 4 +-- drivers/filesystems/ntfs/mft.c | 54 ++++++++++++++++++++++++++++--------- drivers/filesystems/ntfs/ntfs.h | 4 +-- drivers/filesystems/ntfs/rw.c | 4 +-- 5 files changed, 50 insertions(+), 22 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 7669008f99..90e20d3819 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -188,8 +188,8 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, &Current, &FirstEntry, FALSE, - &CurrentMFTIndex, - CaseSensitive); + CaseSensitive, + &CurrentMFTIndex); if (!NT_SUCCESS(Status)) break; @@ -1173,7 +1173,7 @@ NtfsDumpIndexRootAttribute(PNTFS_ATTR_RECORD Attribute) while (currentOffset < IndexRootAttr->Header.TotalSizeOfEntries) { PINDEX_ENTRY_ATTRIBUTE currentIndexExtry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexRootAttr + 0x10 + currentOffset); - DbgPrint(" Index Node Entry %u", currentNode++); + DbgPrint(" Index Node Entry %lu", currentNode++); if (currentIndexExtry->Flags & NTFS_INDEX_ENTRY_NODE) DbgPrint(" (Branch)"); else diff --git a/drivers/filesystems/ntfs/blockdev.c b/drivers/filesystems/ntfs/blockdev.c index 1ae67e52d7..70658b03c3 100644 --- a/drivers/filesystems/ntfs/blockdev.c +++ b/drivers/filesystems/ntfs/blockdev.c @@ -52,7 +52,7 @@ NtfsReadDisk(IN PDEVICE_OBJECT DeviceObject, BOOLEAN AllocatedBuffer = FALSE; PUCHAR ReadBuffer = Buffer; - DPRINT("NtfsReadDisk(%p, %I64x, %u, %u, %p, %d)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer, Override); + DPRINT("NtfsReadDisk(%p, %I64x, %lu, %lu, %p, %d)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer, Override); KeInitializeEvent(&Event, NotificationEvent, @@ -176,7 +176,7 @@ NtfsWriteDisk(IN PDEVICE_OBJECT DeviceObject, BOOLEAN AllocatedBuffer = FALSE; PUCHAR TempBuffer = NULL; - DPRINT("NtfsWriteDisk(%p, %I64x, %u, %u, %p)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer); + DPRINT("NtfsWriteDisk(%p, %I64x, %lu, %lu, %p)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer); if (Length == 0) return STATUS_SUCCESS; diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index e83c33e6de..6ffe8d53ad 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -119,7 +119,7 @@ FindAttribute(PDEVICE_EXTENSION Vcb, FIND_ATTR_CONTXT Context; PNTFS_ATTR_RECORD Attribute; - DPRINT("FindAttribute(%p, %p, 0x%x, %S, %u, %p)\n", Vcb, MftRecord, Type, Name, NameLength, AttrCtx); + DPRINT("FindAttribute(%p, %p, 0x%x, %S, %lu, %p, %p)\n", Vcb, MftRecord, Type, Name, NameLength, AttrCtx, Offset); Found = FALSE; Status = FindFirstAttribute(&Context, Vcb, MftRecord, FALSE, &Attribute); @@ -396,6 +396,14 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, { NTSTATUS Status = STATUS_SUCCESS; + DPRINT1("SetAttributeDataLenth(%p, %p, %p, %lu, %p, %I64u)\n", + FileObject, + Fcb, + AttrContext, + AttrOffset, + FileRecord, + DataSize->QuadPart); + // are we truncating the file? if (DataSize->QuadPart < AttributeDataLength(&AttrContext->Record)) { @@ -1336,7 +1344,7 @@ ReadFileRecord(PDEVICE_EXTENSION Vcb, BytesRead = ReadAttribute(Vcb, Vcb->MFTContext, index * Vcb->NtfsInfo.BytesPerFileRecord, (PCHAR)file, Vcb->NtfsInfo.BytesPerFileRecord); if (BytesRead != Vcb->NtfsInfo.BytesPerFileRecord) { - DPRINT1("ReadFileRecord failed: %I64u read, %u expected\n", BytesRead, Vcb->NtfsInfo.BytesPerFileRecord); + DPRINT1("ReadFileRecord failed: %I64u read, %lu expected\n", BytesRead, Vcb->NtfsInfo.BytesPerFileRecord); return STATUS_PARTIAL_COPY; } @@ -1370,11 +1378,11 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, NTSTATUS Status; ULONG CurrentEntry = 0; - DPRINT("UpdateFileNameRecord(%p, %I64d, %wZ, %u, %I64u, %I64u, %s)\n", + DPRINT("UpdateFileNameRecord(%p, %I64d, %wZ, %s, %I64u, %I64u, %s)\n", Vcb, ParentMFTIndex, FileName, - DirSearch, + DirSearch ? "TRUE" : "FALSE", NewDataSize, NewAllocationSize, CaseSensitive ? "TRUE" : "FALSE"); @@ -1466,7 +1474,20 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, ULONGLONG IndexAllocationSize; PINDEX_BUFFER IndexBuffer; - DPRINT("UpdateIndexEntrySize(%p, %p, %p, %u, %p, %p, %wZ, %u, %u, %u, %I64u, %I64u)\n", Vcb, MftRecord, IndexRecord, IndexBlockSize, FirstEntry, LastEntry, FileName, *StartEntry, *CurrentEntry, DirSearch, NewDataSize, NewAllocatedSize); + DPRINT("UpdateIndexEntrySize(%p, %p, %p, %lu, %p, %p, %wZ, %lu, %lu, %s, %I64u, %I64u, %s)\n", + Vcb, + MftRecord, + IndexRecord, + IndexBlockSize, + FirstEntry, + LastEntry, + FileName, + *StartEntry, + *CurrentEntry, + DirSearch ? "TRUE" : "FALSE", + NewDataSize, + NewAllocatedSize, + CaseSensitive ? "TRUE" : "FALSE"); // find the index entry responsible for the file we're trying to update IndexEntry = FirstEntry; @@ -1933,7 +1954,7 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, ULONGLONG IndexAllocationSize; PINDEX_BUFFER IndexBuffer; - DPRINT("BrowseIndexEntries(%p, %p, %p, %u, %p, %p, %wZ, %u, %u, %s, %s, %p)\n", + DPRINT("BrowseIndexEntries(%p, %p, %p, %lu, %p, %p, %wZ, %lu, %lu, %s, %s, %p)\n", Vcb, MftRecord, IndexRecord, @@ -1981,7 +2002,7 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, Status = FindAttribute(Vcb, MftRecord, AttributeIndexAllocation, L"$I30", 4, &IndexAllocationCtx, NULL); if (!NT_SUCCESS(Status)) { - DPRINT("Corrupted filesystem!\n"); + DPRINT1("Corrupted filesystem!\n"); return Status; } @@ -2031,8 +2052,8 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, PUNICODE_STRING FileName, PULONG FirstEntry, BOOLEAN DirSearch, - ULONGLONG *OutMFTIndex, - BOOLEAN CaseSensitive) + BOOLEAN CaseSensitive, + ULONGLONG *OutMFTIndex) { PFILE_RECORD_HEADER MftRecord; PNTFS_ATTR_CONTEXT IndexRootCtx; @@ -2042,7 +2063,14 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, NTSTATUS Status; ULONG CurrentEntry = 0; - DPRINT("NtfsFindMftRecord(%p, %I64d, %wZ, %u, %u, %p)\n", Vcb, MFTIndex, FileName, *FirstEntry, DirSearch, OutMFTIndex); + DPRINT("NtfsFindMftRecord(%p, %I64d, %wZ, %lu, %s, %s, %p)\n", + Vcb, + MFTIndex, + FileName, + *FirstEntry, + DirSearch ? "TRUE" : "FALSE", + CaseSensitive ? "TRUE" : "FALSE", + OutMFTIndex); MftRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, @@ -2129,7 +2157,7 @@ NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, { DPRINT("Current: %wZ\n", &Current); - Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, &Current, &FirstEntry, FALSE, &CurrentMFTIndex, CaseSensitive); + Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, &Current, &FirstEntry, FALSE, CaseSensitive, &CurrentMFTIndex); if (!NT_SUCCESS(Status)) { return Status; @@ -2222,7 +2250,7 @@ NtfsFindFileAt(PDEVICE_EXTENSION Vcb, { NTSTATUS Status; - DPRINT("NtfsFindFileAt(%p, %wZ, %u, %p, %p, %I64x, %s)\n", + DPRINT("NtfsFindFileAt(%p, %wZ, %lu, %p, %p, %I64x, %s)\n", Vcb, SearchPattern, *FirstEntry, @@ -2231,7 +2259,7 @@ NtfsFindFileAt(PDEVICE_EXTENSION Vcb, CurrentMFTIndex, (CaseSensitive ? "TRUE" : "FALSE")); - Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, SearchPattern, FirstEntry, TRUE, &CurrentMFTIndex, CaseSensitive); + Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, SearchPattern, FirstEntry, TRUE, CaseSensitive, &CurrentMFTIndex); if (!NT_SUCCESS(Status)) { DPRINT("NtfsFindFileAt: NtfsFindMftRecord() failed with status 0x%08lx\n", Status); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index b2633c0dd8..d738ef5fe2 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -1003,8 +1003,8 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, PUNICODE_STRING FileName, PULONG FirstEntry, BOOLEAN DirSearch, - ULONGLONG *OutMFTIndex, - BOOLEAN CaseSensitive); + BOOLEAN CaseSensitive, + ULONGLONG *OutMFTIndex); /* misc.c */ diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 1cfdd7fde2..215269a25c 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -60,7 +60,7 @@ NtfsReadFile(PDEVICE_EXTENSION DeviceExt, PCHAR ReadBuffer = (PCHAR)Buffer; ULONGLONG StreamSize; - DPRINT1("NtfsReadFile(%p, %p, %p, %u, %u, %x, %p)\n", DeviceExt, FileObject, Buffer, Length, ReadOffset, IrpFlags, LengthRead); + DPRINT1("NtfsReadFile(%p, %p, %p, %lu, %lu, %lx, %p)\n", DeviceExt, FileObject, Buffer, Length, ReadOffset, IrpFlags, LengthRead); *LengthRead = 0; @@ -317,7 +317,7 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, ULONG AttributeOffset; ULONGLONG StreamSize; - DPRINT("NtfsWriteFile(%p, %p, %p, %u, %u, %x, %s, %p)\n", + DPRINT("NtfsWriteFile(%p, %p, %p, %lu, %lu, %x, %s, %p)\n", DeviceExt, FileObject, Buffer,

7 years

[reactos] 41/72: [NTFS] - Fix creation of files with long filenames.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=e4aab2678175b4e0533f8… commit e4aab2678175b4e0533f8c86e00ed370db501f1e Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun Jun 25 04:29:04 2017 +0000 [NTFS] - Fix creation of files with long filenames. svn path=/branches/GSoC_2016/NTFS/; revision=75193 --- drivers/filesystems/ntfs/attrib.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 120cf90185..7669008f99 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -220,9 +220,15 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, DPRINT1("FileNameAttribute->DirectoryFileReferenceNumber: 0x%016I64x\n", FileNameAttribute->DirectoryFileReferenceNumber); FileNameAttribute->NameLength = FilenameNoPath.Length / sizeof(WCHAR); - // TODO: Get proper nametype, add DOS links as needed - FileNameAttribute->NameType = NTFS_FILE_NAME_WIN32_AND_DOS; RtlCopyMemory(FileNameAttribute->Name, FilenameNoPath.Buffer, FilenameNoPath.Length); + + // For now, we're emulating the way Windows behaves when 8.3 name generation is disabled + // TODO: add DOS Filename as needed + if (RtlIsNameLegalDOS8Dot3(&FilenameNoPath, NULL, NULL)) + FileNameAttribute->NameType = NTFS_FILE_NAME_WIN32_AND_DOS; + else + FileNameAttribute->NameType = NTFS_FILE_NAME_POSIX; + FileRecord->LinkCount++; AttributeAddress->Length = ResidentHeaderLength +

7 years

[reactos] 40/72: [NTFS] - In the NtfsAddFilenameToDirectory() function, rename DirectoryContext parameter to the more descriptive, and accurate, IndexRootContext (to simplify the next commit).

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8bb62e20d333fb058ac5c… commit 8bb62e20d333fb058ac5cffd31600ad684cd6363 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun Jun 25 02:56:40 2017 +0000 [NTFS] - In the NtfsAddFilenameToDirectory() function, rename DirectoryContext parameter to the more descriptive, and accurate, IndexRootContext (to simplify the next commit). svn path=/branches/GSoC_2016/NTFS/; revision=75192 --- drivers/filesystems/ntfs/dirctl.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/drivers/filesystems/ntfs/dirctl.c b/drivers/filesystems/ntfs/dirctl.c index 7c59e88204..4d19052ac9 100644 --- a/drivers/filesystems/ntfs/dirctl.c +++ b/drivers/filesystems/ntfs/dirctl.c @@ -72,7 +72,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, { NTSTATUS Status = STATUS_SUCCESS; PFILE_RECORD_HEADER ParentFileRecord; - PNTFS_ATTR_CONTEXT DirectoryContext; + PNTFS_ATTR_CONTEXT IndexRootContext; PINDEX_ROOT_ATTRIBUTE I30IndexRoot; ULONG IndexRootOffset; ULONGLONG I30IndexRootLength; @@ -112,7 +112,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, AttributeIndexRoot, L"$I30", 4, - &DirectoryContext, + &IndexRootContext, &IndexRootOffset); if (!NT_SUCCESS(Status)) { @@ -122,23 +122,23 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, return Status; } - I30IndexRootLength = AttributeDataLength(&DirectoryContext->Record); + I30IndexRootLength = AttributeDataLength(&IndexRootContext->Record); // Allocate memory for the index root data I30IndexRoot = (PINDEX_ROOT_ATTRIBUTE)ExAllocatePoolWithTag(NonPagedPool, I30IndexRootLength, TAG_NTFS); if (!I30IndexRoot) { DPRINT1("ERROR: Couldn't allocate memory for index root attribute!\n"); - ReleaseAttributeContext(DirectoryContext); + ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); } // Read the Index Root - Status = ReadAttribute(DeviceExt, DirectoryContext, 0, (PCHAR)I30IndexRoot, I30IndexRootLength); + 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(DirectoryContext); + ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); return Status; @@ -149,7 +149,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, if (IndexNodeEntry->Data.Directory.IndexedFile != 0 || IndexNodeEntry->Flags != 2) { DPRINT1("FIXME: File-creation is only supported in empty directories right now! Be patient! :)\n"); - ReleaseAttributeContext(DirectoryContext); + ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); return STATUS_NOT_IMPLEMENTED; @@ -160,7 +160,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, if (!NewIndexRoot) { DPRINT1("ERROR: Unable to allocate memory for new index root attribute!\n"); - ReleaseAttributeContext(DirectoryContext); + ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); return STATUS_INSUFFICIENT_RESOURCES; @@ -225,14 +225,14 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, { DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n"); ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(DirectoryContext); + 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(DirectoryContext, + InternalSetResidentAttributeLength(IndexRootContext, ParentFileRecord, IndexRootOffset, AttributeLength); @@ -249,7 +249,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, // Update the parent directory with the new index root Status = WriteAttribute(DeviceExt, - DirectoryContext, + IndexRootContext, 0, (PUCHAR)NewIndexRoot, AttributeLength, @@ -258,7 +258,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, { DPRINT1("ERROR: Unable to write new index root attribute to parent directory!\n"); ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(DirectoryContext); + ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); return Status; @@ -278,7 +278,7 @@ NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, // Cleanup ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); - ReleaseAttributeContext(DirectoryContext); + ReleaseAttributeContext(IndexRootContext); ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); ExFreePoolWithTag(ParentFileRecord, TAG_NTFS);

7 years

[reactos] 39/72: [NTFS] - Fix a mistake with AddFileName() from my last commit. Also, move CaseSensitive parameter before output parameters in the parameter list of several functions.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=948e91907a3a545d9c002… commit 948e91907a3a545d9c0027e7e3bcd4e28507b110 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun Jun 25 02:38:15 2017 +0000 [NTFS] - Fix a mistake with AddFileName() from my last commit. Also, move CaseSensitive parameter before output parameters in the parameter list of several functions. svn path=/branches/GSoC_2016/NTFS/; revision=75191 --- drivers/filesystems/ntfs/attrib.c | 10 +++++----- drivers/filesystems/ntfs/create.c | 14 +++++++++++--- drivers/filesystems/ntfs/fcb.c | 2 +- drivers/filesystems/ntfs/mft.c | 18 ++++++++++++------ drivers/filesystems/ntfs/ntfs.h | 7 +++++-- 5 files changed, 34 insertions(+), 17 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 85f7f88047..120cf90185 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -112,13 +112,13 @@ AddData(PFILE_RECORD_HEADER FileRecord, * Pointer to the FILE_OBJECT which represents the new name. * This parameter is used to determine the filename and parent directory. * -* @param ParentMftIndex -* Pointer to a ULONGLONG which will receive the index of the parent directory. -* * @param CaseSensitive * Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE * if an application opened the file with the FILE_FLAG_POSIX_SEMANTICS flag. * +* @param ParentMftIndex +* Pointer to a ULONGLONG which will receive the index of the parent directory. +* * @return * STATUS_SUCCESS on success. STATUS_NOT_IMPLEMENTED if target address isn't at the end * of the given file record. @@ -136,8 +136,8 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, PNTFS_ATTR_RECORD AttributeAddress, PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, - PULONGLONG ParentMftIndex, - BOOLEAN CaseSensitive) + BOOLEAN CaseSensitive, + PULONGLONG ParentMftIndex) { ULONG ResidentHeaderLength = FIELD_OFFSET(NTFS_ATTR_RECORD, Resident.Reserved) + sizeof(UCHAR); PFILENAME_ATTRIBUTE FileNameAttribute; diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index ddafb14d67..f52cd7d187 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -570,7 +570,10 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, } // Create the file record on disk - Status = NtfsCreateFileRecord(DeviceExt, FileObject, BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)); + Status = NtfsCreateFileRecord(DeviceExt, + FileObject, + (Stack->Flags & SL_CASE_SENSITIVE), + BooleanFlagOn(IrpContext->Flags,IRPCONTEXT_CANWAIT)); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Couldn't create file record!\n"); @@ -656,6 +659,7 @@ NtfsCreate(PNTFS_IRP_CONTEXT IrpContext) NTSTATUS NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, + BOOLEAN CaseSensitive, BOOLEAN CanWait) { NTSTATUS Status = STATUS_SUCCESS; @@ -665,7 +669,11 @@ NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, ULONGLONG ParentMftIndex; ULONGLONG FileMftIndex; - DPRINT1("NtfsCreateFileRecord(%p, %p, %s)\n", DeviceExt, FileObject, CanWait ? "TRUE" : "FALSE"); + DPRINT1("NtfsCreateFileRecord(%p, %p, %s, %s)\n", + DeviceExt, + FileObject, + CaseSensitive ? "TRUE" : "FALSE", + CanWait ? "TRUE" : "FALSE"); // allocate memory for file record FileRecord = ExAllocatePoolWithTag(NonPagedPool, @@ -709,7 +717,7 @@ NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length); // Add the $FILE_NAME attribute - AddFileName(FileRecord, NextAttribute, DeviceExt, FileObject, &ParentMftIndex); + AddFileName(FileRecord, NextAttribute, DeviceExt, FileObject, CaseSensitive, &ParentMftIndex); // save a pointer to the filename attribute FilenameAttribute = (PFILENAME_ATTRIBUTE)((ULONG_PTR)NextAttribute + NextAttribute->Resident.ValueOffset); diff --git a/drivers/filesystems/ntfs/fcb.c b/drivers/filesystems/ntfs/fcb.c index 531749d4d2..851234c4fe 100644 --- a/drivers/filesystems/ntfs/fcb.c +++ b/drivers/filesystems/ntfs/fcb.c @@ -557,7 +557,7 @@ NtfsDirFindFile(PNTFS_VCB Vcb, DPRINT1("Will now look for file '%wZ' with stream '%S'\n", &File, Colon); } - Status = NtfsLookupFileAt(Vcb, &File, &FileRecord, &MFTIndex, CurrentDir, CaseSensitive); + Status = NtfsLookupFileAt(Vcb, &File, CaseSensitive, &FileRecord, &MFTIndex, CurrentDir); if (!NT_SUCCESS(Status)) { return Status; diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 2c0dab6586..e83c33e6de 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -2106,16 +2106,22 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, NTSTATUS NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, PUNICODE_STRING PathName, + BOOLEAN CaseSensitive, PFILE_RECORD_HEADER *FileRecord, PULONGLONG MFTIndex, - ULONGLONG CurrentMFTIndex, - BOOLEAN CaseSensitive) + ULONGLONG CurrentMFTIndex) { UNICODE_STRING Current, Remaining; NTSTATUS Status; ULONG FirstEntry = 0; - DPRINT("NtfsLookupFileAt(%p, %wZ, %p, %I64x)\n", Vcb, PathName, FileRecord, CurrentMFTIndex); + DPRINT("NtfsLookupFileAt(%p, %wZ, %s, %p, %p, %I64x)\n", + Vcb, + PathName, + CaseSensitive ? "TRUE" : "FALSE", + FileRecord, + MFTIndex, + CurrentMFTIndex); FsRtlDissectName(*PathName, &Current, &Remaining); @@ -2158,11 +2164,11 @@ NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, NTSTATUS NtfsLookupFile(PDEVICE_EXTENSION Vcb, PUNICODE_STRING PathName, + BOOLEAN CaseSensitive, PFILE_RECORD_HEADER *FileRecord, - PULONGLONG MFTIndex, - BOOLEAN CaseSensitive) + PULONGLONG MFTIndex) { - return NtfsLookupFileAt(Vcb, PathName, FileRecord, MFTIndex, NTFS_FILE_ROOT, CaseSensitive); + return NtfsLookupFileAt(Vcb, PathName, CaseSensitive, FileRecord, MFTIndex, NTFS_FILE_ROOT); } /** diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index f54a14d254..b2633c0dd8 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -536,6 +536,7 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, PNTFS_ATTR_RECORD AttributeAddress, PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, + BOOLEAN CaseSensitive, PULONGLONG ParentMftIndex); NTSTATUS @@ -668,6 +669,7 @@ NtfsCreate(PNTFS_IRP_CONTEXT IrpContext); NTSTATUS NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, + BOOLEAN CaseSensitive, BOOLEAN CanWait); /* devctl.c */ @@ -970,16 +972,17 @@ EnumerAttribute(PFILE_RECORD_HEADER file, NTSTATUS NtfsLookupFile(PDEVICE_EXTENSION Vcb, PUNICODE_STRING PathName, + BOOLEAN CaseSensitive, PFILE_RECORD_HEADER *FileRecord, PULONGLONG MFTIndex); NTSTATUS NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, PUNICODE_STRING PathName, + BOOLEAN CaseSensitive, PFILE_RECORD_HEADER *FileRecord, PULONGLONG MFTIndex, - ULONGLONG CurrentMFTIndex, - BOOLEAN CaseSensitive); + ULONGLONG CurrentMFTIndex); VOID NtfsDumpFileRecord(PDEVICE_EXTENSION Vcb,

7 years

[reactos] 38/72: [NTFS] - Fix POSIX rules. Fix accessing long filenames created in Windows when 8dot3 name creation is disabled. Whether or not a filename should be interpreted as case-sensitive is dependent on a flag passed to the driver when a file is created (opened); it's separate from the namespace associated with the file being accessed.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=032be0295481aeed18a5c… commit 032be0295481aeed18a5ced204f4b83d247b0232 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sat Jun 24 04:36:28 2017 +0000 [NTFS] - Fix POSIX rules. Fix accessing long filenames created in Windows when 8dot3 name creation is disabled. Whether or not a filename should be interpreted as case-sensitive is dependent on a flag passed to the driver when a file is created (opened); it's separate from the namespace associated with the file being accessed. svn path=/branches/GSoC_2016/NTFS/; revision=75178 --- drivers/filesystems/ntfs/attrib.c | 15 ++++- drivers/filesystems/ntfs/create.c | 12 +++- drivers/filesystems/ntfs/dirctl.c | 3 +- drivers/filesystems/ntfs/fcb.c | 20 +++++-- drivers/filesystems/ntfs/finfo.c | 20 ++++++- drivers/filesystems/ntfs/mft.c | 113 ++++++++++++++++++++++++++++++-------- drivers/filesystems/ntfs/ntfs.h | 22 +++++--- drivers/filesystems/ntfs/rw.c | 24 +++++++- 8 files changed, 185 insertions(+), 44 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 78be3ecf3c..85f7f88047 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -115,6 +115,10 @@ AddData(PFILE_RECORD_HEADER FileRecord, * @param ParentMftIndex * Pointer to a ULONGLONG which will receive the index of the parent directory. * +* @param CaseSensitive +* Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE +* if an application opened the file with the FILE_FLAG_POSIX_SEMANTICS flag. +* * @return * STATUS_SUCCESS on success. STATUS_NOT_IMPLEMENTED if target address isn't at the end * of the given file record. @@ -132,7 +136,8 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, PNTFS_ATTR_RECORD AttributeAddress, PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, - PULONGLONG ParentMftIndex) + PULONGLONG ParentMftIndex, + BOOLEAN CaseSensitive) { ULONG ResidentHeaderLength = FIELD_OFFSET(NTFS_ATTR_RECORD, Resident.Reserved) + sizeof(UCHAR); PFILENAME_ATTRIBUTE FileNameAttribute; @@ -178,7 +183,13 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, if(Remaining.Length != 0) RtlCopyUnicodeString(&FilenameNoPath, &Remaining); - Status = NtfsFindMftRecord(DeviceExt, CurrentMFTIndex, &Current, &FirstEntry, FALSE, &CurrentMFTIndex); + Status = NtfsFindMftRecord(DeviceExt, + CurrentMFTIndex, + &Current, + &FirstEntry, + FALSE, + &CurrentMFTIndex, + CaseSensitive); if (!NT_SUCCESS(Status)) break; diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 96f563e75d..ddafb14d67 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -246,6 +246,7 @@ NTSTATUS NtfsOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, PWSTR FileName, + BOOLEAN CaseSensitive, PNTFS_FCB * FoundFCB) { PNTFS_FCB ParentFcb; @@ -253,7 +254,12 @@ NtfsOpenFile(PDEVICE_EXTENSION DeviceExt, NTSTATUS Status; PWSTR AbsFileName = NULL; - DPRINT1("NtfsOpenFile(%p, %p, %S, %p)\n", DeviceExt, FileObject, FileName, FoundFCB); + DPRINT1("NtfsOpenFile(%p, %p, %S, %s, %p)\n", + DeviceExt, + FileObject, + FileName, + CaseSensitive ? "TRUE" : "FALSE", + FoundFCB); *FoundFCB = NULL; @@ -285,7 +291,8 @@ NtfsOpenFile(PDEVICE_EXTENSION DeviceExt, Status = NtfsGetFCBForFile(DeviceExt, &ParentFcb, &Fcb, - FileName); + FileName, + CaseSensitive); if (ParentFcb != NULL) { NtfsReleaseFCB(DeviceExt, @@ -412,6 +419,7 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, Status = NtfsOpenFile(DeviceExt, FileObject, ((RequestedOptions & FILE_OPEN_BY_FILE_ID) ? FullPath.Buffer : FileObject->FileName.Buffer), + (Stack->Flags & SL_CASE_SENSITIVE), &Fcb); if (RequestedOptions & FILE_OPEN_BY_FILE_ID) diff --git a/drivers/filesystems/ntfs/dirctl.c b/drivers/filesystems/ntfs/dirctl.c index 91f0bc5db7..7c59e88204 100644 --- a/drivers/filesystems/ntfs/dirctl.c +++ b/drivers/filesystems/ntfs/dirctl.c @@ -627,7 +627,8 @@ NtfsQueryDirectory(PNTFS_IRP_CONTEXT IrpContext) &Ccb->Entry, &FileRecord, &MFTRecord, - Fcb->MFTIndex); + Fcb->MFTIndex, + (Stack->Flags & SL_CASE_SENSITIVE)); if (NT_SUCCESS(Status)) { diff --git a/drivers/filesystems/ntfs/fcb.c b/drivers/filesystems/ntfs/fcb.c index 111660288a..531749d4d2 100644 --- a/drivers/filesystems/ntfs/fcb.c +++ b/drivers/filesystems/ntfs/fcb.c @@ -506,6 +506,7 @@ static NTSTATUS NtfsDirFindFile(PNTFS_VCB Vcb, PNTFS_FCB DirectoryFcb, PWSTR FileToFind, + BOOLEAN CaseSensitive, PNTFS_FCB *FoundFCB) { NTSTATUS Status; @@ -517,7 +518,12 @@ NtfsDirFindFile(PNTFS_VCB Vcb, PNTFS_ATTR_CONTEXT DataContext; USHORT Length = 0; - DPRINT1("NtfsDirFindFile(%p, %p, %S, %p)\n", Vcb, DirectoryFcb, FileToFind, FoundFCB); + DPRINT1("NtfsDirFindFile(%p, %p, %S, %s, %p)\n", + Vcb, + DirectoryFcb, + FileToFind, + CaseSensitive ? "TRUE" : "FALSE", + FoundFCB); *FoundFCB = NULL; RtlInitUnicodeString(&File, FileToFind); @@ -551,7 +557,7 @@ NtfsDirFindFile(PNTFS_VCB Vcb, DPRINT1("Will now look for file '%wZ' with stream '%S'\n", &File, Colon); } - Status = NtfsLookupFileAt(Vcb, &File, &FileRecord, &MFTIndex, CurrentDir); + Status = NtfsLookupFileAt(Vcb, &File, &FileRecord, &MFTIndex, CurrentDir, CaseSensitive); if (!NT_SUCCESS(Status)) { return Status; @@ -587,7 +593,8 @@ NTSTATUS NtfsGetFCBForFile(PNTFS_VCB Vcb, PNTFS_FCB *pParentFCB, PNTFS_FCB *pFCB, - const PWSTR pFileName) + const PWSTR pFileName, + BOOLEAN CaseSensitive) { NTSTATUS Status; WCHAR pathName [MAX_PATH]; @@ -596,11 +603,12 @@ NtfsGetFCBForFile(PNTFS_VCB Vcb, PNTFS_FCB FCB; PNTFS_FCB parentFCB; - DPRINT("NtfsGetFCBForFile(%p, %p, %p, '%S')\n", + DPRINT("NtfsGetFCBForFile(%p, %p, %p, '%S', %s)\n", Vcb, pParentFCB, pFCB, - pFileName); + pFileName, + CaseSensitive ? "TRUE" : "FALSE"); /* Dummy code */ // FCB = NtfsOpenRootFCB(Vcb); @@ -677,7 +685,7 @@ NtfsGetFCBForFile(PNTFS_VCB Vcb, NtfsGetNextPathElement(currentElement) - currentElement); DPRINT(" elementName:%S\n", elementName); - Status = NtfsDirFindFile(Vcb, parentFCB, elementName, &FCB); + Status = NtfsDirFindFile(Vcb, parentFCB, elementName, CaseSensitive, &FCB); if (Status == STATUS_OBJECT_NAME_NOT_FOUND) { *pParentFCB = parentFCB; diff --git a/drivers/filesystems/ntfs/finfo.c b/drivers/filesystems/ntfs/finfo.c index 76cc78f4d9..1cb7dbc0fe 100644 --- a/drivers/filesystems/ntfs/finfo.c +++ b/drivers/filesystems/ntfs/finfo.c @@ -415,6 +415,10 @@ NtfsQueryInformation(PNTFS_IRP_CONTEXT IrpContext) * @param IrpFlags * ULONG describing the flags of the original IRP request (Irp->Flags). * +* @param CaseSensitive +* Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE +* if an application opened the file with the FILE_FLAG_POSIX_SEMANTICS flag. +* * @param NewFileSize * Pointer to a LARGE_INTEGER which indicates the new end of file (file size). * @@ -436,6 +440,7 @@ NtfsSetEndOfFile(PNTFS_FCB Fcb, PFILE_OBJECT FileObject, PDEVICE_EXTENSION DeviceExt, ULONG IrpFlags, + BOOLEAN CaseSensitive, PLARGE_INTEGER NewFileSize) { LARGE_INTEGER CurrentFileSize; @@ -545,7 +550,13 @@ NtfsSetEndOfFile(PNTFS_FCB Fcb, AllocationSize = ROUND_UP(NewFileSize->QuadPart, Fcb->Vcb->NtfsInfo.BytesPerCluster); - Status = UpdateFileNameRecord(Fcb->Vcb, ParentMFTId, &filename, FALSE, NewFileSize->QuadPart, AllocationSize); + Status = UpdateFileNameRecord(Fcb->Vcb, + ParentMFTId, + &filename, + FALSE, + NewFileSize->QuadPart, + AllocationSize, + CaseSensitive); ReleaseAttributeContext(DataContext); ExFreePoolWithTag(FileRecord, TAG_NTFS); @@ -620,7 +631,12 @@ NtfsSetInformation(PNTFS_IRP_CONTEXT IrpContext) DPRINT1("FIXME: Using hacky method of setting FileAllocationInformation.\n"); case FileEndOfFileInformation: EndOfFileInfo = (PFILE_END_OF_FILE_INFORMATION)SystemBuffer; - Status = NtfsSetEndOfFile(Fcb, FileObject, DeviceExt, Irp->Flags, &EndOfFileInfo->EndOfFile); + Status = NtfsSetEndOfFile(Fcb, + FileObject, + DeviceExt, + Irp->Flags, + (Stack->Flags & SL_CASE_SENSITIVE), + &EndOfFileInfo->EndOfFile); break; // TODO: all other information classes diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 8df62ed542..2c0dab6586 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -1359,7 +1359,8 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, PUNICODE_STRING FileName, BOOLEAN DirSearch, ULONGLONG NewDataSize, - ULONGLONG NewAllocationSize) + ULONGLONG NewAllocationSize, + BOOLEAN CaseSensitive) { PFILE_RECORD_HEADER MftRecord; PNTFS_ATTR_CONTEXT IndexRootCtx; @@ -1369,7 +1370,14 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, NTSTATUS Status; ULONG CurrentEntry = 0; - DPRINT("UpdateFileNameRecord(%p, %I64d, %wZ, %u, %I64u, %I64u)\n", Vcb, ParentMFTIndex, FileName, DirSearch, NewDataSize, NewAllocationSize); + DPRINT("UpdateFileNameRecord(%p, %I64d, %wZ, %u, %I64u, %I64u, %s)\n", + Vcb, + ParentMFTIndex, + FileName, + DirSearch, + NewDataSize, + NewAllocationSize, + CaseSensitive ? "TRUE" : "FALSE"); MftRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, @@ -1421,7 +1429,8 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, &CurrentEntry, DirSearch, NewDataSize, - NewAllocationSize); + NewAllocationSize, + CaseSensitive); ReleaseAttributeContext(IndexRootCtx); ExFreePoolWithTag(IndexRecord, TAG_NTFS); @@ -1447,7 +1456,8 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, PULONG CurrentEntry, BOOLEAN DirSearch, ULONGLONG NewDataSize, - ULONGLONG NewAllocatedSize) + ULONGLONG NewAllocatedSize, + BOOLEAN CaseSensitive) { NTSTATUS Status; ULONG RecordOffset; @@ -1466,7 +1476,7 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) > 0x10 && *CurrentEntry >= *StartEntry && IndexEntry->FileName.NameType != NTFS_FILE_NAME_DOS && - CompareFileName(FileName, IndexEntry, DirSearch)) + CompareFileName(FileName, IndexEntry, DirSearch, CaseSensitive)) { *StartEntry = *CurrentEntry; IndexEntry->FileName.DataSize = NewDataSize; @@ -1517,7 +1527,19 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, LastEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)&IndexBuffer->Header + IndexBuffer->Header.TotalSizeOfEntries); ASSERT(LastEntry <= (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexBuffer + IndexBlockSize)); - Status = UpdateIndexEntryFileNameSize(NULL, NULL, NULL, 0, FirstEntry, LastEntry, FileName, StartEntry, CurrentEntry, DirSearch, NewDataSize, NewAllocatedSize); + Status = UpdateIndexEntryFileNameSize(NULL, + NULL, + NULL, + 0, + FirstEntry, + LastEntry, + FileName, + StartEntry, + CurrentEntry, + DirSearch, + NewDataSize, + NewAllocatedSize, + CaseSensitive); if (Status == STATUS_PENDING) { // write the index record back to disk @@ -1827,7 +1849,8 @@ ReadLCN(PDEVICE_EXTENSION Vcb, BOOLEAN CompareFileName(PUNICODE_STRING FileName, PINDEX_ENTRY_ATTRIBUTE IndexEntry, - BOOLEAN DirSearch) + BOOLEAN DirSearch, + BOOLEAN CaseSensitive) { BOOLEAN Ret, Alloc = FALSE; UNICODE_STRING EntryName; @@ -1839,7 +1862,7 @@ CompareFileName(PUNICODE_STRING FileName, if (DirSearch) { UNICODE_STRING IntFileName; - if (IndexEntry->FileName.NameType != NTFS_FILE_NAME_POSIX) + if (!CaseSensitive) { NT_VERIFY(NT_SUCCESS(RtlUpcaseUnicodeString(&IntFileName, FileName, TRUE))); Alloc = TRUE; @@ -1849,7 +1872,7 @@ CompareFileName(PUNICODE_STRING FileName, IntFileName = *FileName; } - Ret = FsRtlIsNameInExpression(&IntFileName, &EntryName, (IndexEntry->FileName.NameType != NTFS_FILE_NAME_POSIX), NULL); + Ret = FsRtlIsNameInExpression(&IntFileName, &EntryName, !CaseSensitive, NULL); if (Alloc) { @@ -1860,7 +1883,7 @@ CompareFileName(PUNICODE_STRING FileName, } else { - return (RtlCompareUnicodeString(FileName, &EntryName, (IndexEntry->FileName.NameType != NTFS_FILE_NAME_POSIX)) == 0); + return (RtlCompareUnicodeString(FileName, &EntryName, !CaseSensitive) == 0); } } @@ -1900,6 +1923,7 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, PULONG StartEntry, PULONG CurrentEntry, BOOLEAN DirSearch, + BOOLEAN CaseSensitive, ULONGLONG *OutMFTIndex) { NTSTATUS Status; @@ -1909,7 +1933,19 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, ULONGLONG IndexAllocationSize; PINDEX_BUFFER IndexBuffer; - DPRINT("BrowseIndexEntries(%p, %p, %p, %u, %p, %p, %wZ, %u, %u, %u, %p)\n", Vcb, MftRecord, IndexRecord, IndexBlockSize, FirstEntry, LastEntry, FileName, *StartEntry, *CurrentEntry, DirSearch, OutMFTIndex); + DPRINT("BrowseIndexEntries(%p, %p, %p, %u, %p, %p, %wZ, %u, %u, %s, %s, %p)\n", + Vcb, + MftRecord, + IndexRecord, + IndexBlockSize, + FirstEntry, + LastEntry, + FileName, + *StartEntry, + *CurrentEntry, + DirSearch ? "TRUE" : "FALSE", + CaseSensitive ? "TRUE" : "FALSE", + OutMFTIndex); IndexEntry = FirstEntry; while (IndexEntry < LastEntry && @@ -1918,7 +1954,7 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, if ((IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK) >= 0x10 && *CurrentEntry >= *StartEntry && IndexEntry->FileName.NameType != NTFS_FILE_NAME_DOS && - CompareFileName(FileName, IndexEntry, DirSearch)) + CompareFileName(FileName, IndexEntry, DirSearch, CaseSensitive)) { *StartEntry = *CurrentEntry; *OutMFTIndex = (IndexEntry->Data.Directory.IndexedFile & NTFS_MFT_MASK); @@ -1967,7 +2003,18 @@ BrowseIndexEntries(PDEVICE_EXTENSION Vcb, LastEntry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)&IndexBuffer->Header + IndexBuffer->Header.TotalSizeOfEntries); ASSERT(LastEntry <= (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexBuffer + IndexBlockSize)); - Status = BrowseIndexEntries(NULL, NULL, NULL, 0, FirstEntry, LastEntry, FileName, StartEntry, CurrentEntry, DirSearch, OutMFTIndex); + Status = BrowseIndexEntries(NULL, + NULL, + NULL, + 0, + FirstEntry, + LastEntry, + FileName, + StartEntry, + CurrentEntry, + DirSearch, + CaseSensitive, + OutMFTIndex); if (NT_SUCCESS(Status)) { break; @@ -1984,7 +2031,8 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, PUNICODE_STRING FileName, PULONG FirstEntry, BOOLEAN DirSearch, - ULONGLONG *OutMFTIndex) + ULONGLONG *OutMFTIndex, + BOOLEAN CaseSensitive) { PFILE_RECORD_HEADER MftRecord; PNTFS_ATTR_CONTEXT IndexRootCtx; @@ -2036,7 +2084,18 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, DPRINT("IndexRecordSize: %x IndexBlockSize: %x\n", Vcb->NtfsInfo.BytesPerIndexRecord, IndexRoot->SizeOfEntry); - Status = BrowseIndexEntries(Vcb, MftRecord, IndexRecord, IndexRoot->SizeOfEntry, IndexEntry, IndexEntryEnd, FileName, FirstEntry, &CurrentEntry, DirSearch, OutMFTIndex); + Status = BrowseIndexEntries(Vcb, + MftRecord, + IndexRecord, + IndexRoot->SizeOfEntry, + IndexEntry, + IndexEntryEnd, + FileName, + FirstEntry, + &CurrentEntry, + DirSearch, + CaseSensitive, + OutMFTIndex); ExFreePoolWithTag(IndexRecord, TAG_NTFS); ExFreePoolWithTag(MftRecord, TAG_NTFS); @@ -2049,7 +2108,8 @@ NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, PUNICODE_STRING PathName, PFILE_RECORD_HEADER *FileRecord, PULONGLONG MFTIndex, - ULONGLONG CurrentMFTIndex) + ULONGLONG CurrentMFTIndex, + BOOLEAN CaseSensitive) { UNICODE_STRING Current, Remaining; NTSTATUS Status; @@ -2063,7 +2123,7 @@ NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, { DPRINT("Current: %wZ\n", &Current); - Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, &Current, &FirstEntry, FALSE, &CurrentMFTIndex); + Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, &Current, &FirstEntry, FALSE, &CurrentMFTIndex, CaseSensitive); if (!NT_SUCCESS(Status)) { return Status; @@ -2099,9 +2159,10 @@ NTSTATUS NtfsLookupFile(PDEVICE_EXTENSION Vcb, PUNICODE_STRING PathName, PFILE_RECORD_HEADER *FileRecord, - PULONGLONG MFTIndex) + PULONGLONG MFTIndex, + BOOLEAN CaseSensitive) { - return NtfsLookupFileAt(Vcb, PathName, FileRecord, MFTIndex, NTFS_FILE_ROOT); + return NtfsLookupFileAt(Vcb, PathName, FileRecord, MFTIndex, NTFS_FILE_ROOT, CaseSensitive); } /** @@ -2150,13 +2211,21 @@ NtfsFindFileAt(PDEVICE_EXTENSION Vcb, PULONG FirstEntry, PFILE_RECORD_HEADER *FileRecord, PULONGLONG MFTIndex, - ULONGLONG CurrentMFTIndex) + ULONGLONG CurrentMFTIndex, + BOOLEAN CaseSensitive) { NTSTATUS Status; - DPRINT("NtfsFindFileAt(%p, %wZ, %u, %p, %p, %I64x)\n", Vcb, SearchPattern, *FirstEntry, FileRecord, MFTIndex, CurrentMFTIndex); + DPRINT("NtfsFindFileAt(%p, %wZ, %u, %p, %p, %I64x, %s)\n", + Vcb, + SearchPattern, + *FirstEntry, + FileRecord, + MFTIndex, + CurrentMFTIndex, + (CaseSensitive ? "TRUE" : "FALSE")); - Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, SearchPattern, FirstEntry, TRUE, &CurrentMFTIndex); + Status = NtfsFindMftRecord(Vcb, CurrentMFTIndex, SearchPattern, FirstEntry, TRUE, &CurrentMFTIndex, CaseSensitive); if (!NT_SUCCESS(Status)) { DPRINT("NtfsFindFileAt: NtfsFindMftRecord() failed with status 0x%08lx\n", Status); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 799f8e2a4f..f54a14d254 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -781,7 +781,8 @@ NTSTATUS NtfsGetFCBForFile(PNTFS_VCB Vcb, PNTFS_FCB *pParentFCB, PNTFS_FCB *pFCB, - const PWSTR pFileName); + const PWSTR pFileName, + BOOLEAN CaseSensitive); NTSTATUS NtfsReadFCBAttribute(PNTFS_VCB Vcb, @@ -811,6 +812,7 @@ NtfsSetEndOfFile(PNTFS_FCB Fcb, PFILE_OBJECT FileObject, PDEVICE_EXTENSION DeviceExt, ULONG IrpFlags, + BOOLEAN CaseSensitive, PLARGE_INTEGER NewFileSize); NTSTATUS @@ -892,7 +894,8 @@ AttributeAllocatedLength(PNTFS_ATTR_RECORD AttrRecord); BOOLEAN CompareFileName(PUNICODE_STRING FileName, PINDEX_ENTRY_ATTRIBUTE IndexEntry, - BOOLEAN DirSearch); + BOOLEAN DirSearch, + BOOLEAN CaseSensitive); NTSTATUS ReadFileRecord(PDEVICE_EXTENSION Vcb, @@ -911,7 +914,8 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, PULONG CurrentEntry, BOOLEAN DirSearch, ULONGLONG NewDataSize, - ULONGLONG NewAllocatedSize); + ULONGLONG NewAllocatedSize, + BOOLEAN CaseSensitive); NTSTATUS UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, @@ -919,7 +923,8 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, PUNICODE_STRING FileName, BOOLEAN DirSearch, ULONGLONG NewDataSize, - ULONGLONG NewAllocationSize); + ULONGLONG NewAllocationSize, + BOOLEAN CaseSensitive); NTSTATUS UpdateFileRecord(PDEVICE_EXTENSION Vcb, @@ -973,7 +978,8 @@ NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, PUNICODE_STRING PathName, PFILE_RECORD_HEADER *FileRecord, PULONGLONG MFTIndex, - ULONGLONG CurrentMFTIndex); + ULONGLONG CurrentMFTIndex, + BOOLEAN CaseSensitive); VOID NtfsDumpFileRecord(PDEVICE_EXTENSION Vcb, @@ -985,7 +991,8 @@ NtfsFindFileAt(PDEVICE_EXTENSION Vcb, PULONG FirstEntry, PFILE_RECORD_HEADER *FileRecord, PULONGLONG MFTIndex, - ULONGLONG CurrentMFTIndex); + ULONGLONG CurrentMFTIndex, + BOOLEAN CaseSensitive); NTSTATUS NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, @@ -993,7 +1000,8 @@ NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, PUNICODE_STRING FileName, PULONG FirstEntry, BOOLEAN DirSearch, - ULONGLONG *OutMFTIndex); + ULONGLONG *OutMFTIndex, + BOOLEAN CaseSensitive); /* misc.c */ diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 7f119d706b..1cfdd7fde2 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -283,6 +283,10 @@ NtfsRead(PNTFS_IRP_CONTEXT IrpContext) * @param IrpFlags * TODO: flags are presently ignored in code. * +* @param CaseSensitive +* Boolean indicating if the function should operate in case-sensitive mode. This will be TRUE +* if an application opened the file with the FILE_FLAG_POSIX_SEMANTICS flag. +* * @param LengthWritten * Pointer to a ULONG. This ULONG will be set to the number of bytes successfully written. * @@ -303,6 +307,7 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, ULONG Length, ULONG WriteOffset, ULONG IrpFlags, + BOOLEAN CaseSensitive, PULONG LengthWritten) { NTSTATUS Status = STATUS_NOT_IMPLEMENTED; @@ -312,7 +317,15 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, ULONG AttributeOffset; ULONGLONG StreamSize; - DPRINT("NtfsWriteFile(%p, %p, %p, %u, %u, %x, %p)\n", DeviceExt, FileObject, Buffer, Length, WriteOffset, IrpFlags, LengthWritten); + DPRINT("NtfsWriteFile(%p, %p, %p, %u, %u, %x, %s, %p)\n", + DeviceExt, + FileObject, + Buffer, + Length, + WriteOffset, + IrpFlags, + (CaseSensitive ? "TRUE" : "FALSE"), + LengthWritten); *LengthWritten = 0; @@ -444,7 +457,13 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, filename.Length = fileNameAttribute->NameLength * sizeof(WCHAR); filename.MaximumLength = filename.Length; - Status = UpdateFileNameRecord(Fcb->Vcb, ParentMFTId, &filename, FALSE, DataSize.QuadPart, AllocationSize); + Status = UpdateFileNameRecord(Fcb->Vcb, + ParentMFTId, + &filename, + FALSE, + DataSize.QuadPart, + AllocationSize, + CaseSensitive); } else @@ -667,6 +686,7 @@ NtfsWrite(PNTFS_IRP_CONTEXT IrpContext) Length, ByteOffset.LowPart, Irp->Flags, + (IrpContext->Stack->Flags & SL_CASE_SENSITIVE), &ReturnedWriteLength); IrpContext->Irp->IoStatus.Status = Status;

7 years

[reactos] 37/72: [NTFS] - Fix IncreaseMftSize(); check IrpContext to see if waiting for exclusive access to the MFT is allowed. As pointed out by Pierre.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=98ddf610bcd804bebd056… commit 98ddf610bcd804bebd056f1916b59e46dc5388eb Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Jun 23 17:30:13 2017 +0000 [NTFS] - Fix IncreaseMftSize(); check IrpContext to see if waiting for exclusive access to the MFT is allowed. As pointed out by Pierre. svn path=/branches/GSoC_2016/NTFS/; revision=75170 --- drivers/filesystems/ntfs/create.c | 24 ++++++++++++++++-------- drivers/filesystems/ntfs/mft.c | 27 +++++++++++++++++++-------- drivers/filesystems/ntfs/ntfs.h | 6 ++++-- 3 files changed, 39 insertions(+), 18 deletions(-) diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 07a9f5ac3e..96f563e75d 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -323,7 +323,7 @@ NtfsOpenFile(PDEVICE_EXTENSION DeviceExt, static NTSTATUS NtfsCreateFile(PDEVICE_OBJECT DeviceObject, - PIRP Irp) + PNTFS_IRP_CONTEXT IrpContext) { PDEVICE_EXTENSION DeviceExt; PIO_STACK_LOCATION Stack; @@ -334,8 +334,9 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, // PWSTR FileName; NTSTATUS Status; UNICODE_STRING FullPath; + PIRP Irp = IrpContext->Irp; - DPRINT1("NtfsCreateFile(%p, %p) called\n", DeviceObject, Irp); + DPRINT1("NtfsCreateFile(%p, %p) called\n", DeviceObject, IrpContext); DeviceExt = DeviceObject->DeviceExtension; ASSERT(DeviceExt); @@ -561,7 +562,7 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, } // Create the file record on disk - Status = NtfsCreateFileRecord(DeviceExt, FileObject); + Status = NtfsCreateFileRecord(DeviceExt, FileObject, BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Couldn't create file record!\n"); @@ -569,7 +570,7 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, } // Now we should be able to open the file - return NtfsCreateFile(DeviceObject, Irp); + return NtfsCreateFile(DeviceObject, IrpContext); } } @@ -615,7 +616,7 @@ NtfsCreate(PNTFS_IRP_CONTEXT IrpContext) ExAcquireResourceExclusiveLite(&DeviceExt->DirResource, TRUE); Status = NtfsCreateFile(DeviceObject, - IrpContext->Irp); + IrpContext); ExReleaseResourceLite(&DeviceExt->DirResource); return Status; @@ -634,13 +635,20 @@ NtfsCreate(PNTFS_IRP_CONTEXT IrpContext) * @param FileObject * Pointer to a FILE_OBJECT describing the file to be created * +* @param CanWait +* Boolean indicating if the function is allowed to wait for exclusive access to the master file table. +* This will only be relevant if the MFT doesn't have any free file records and needs to be enlarged. +* * @return * STATUS_SUCCESS on success. * STATUS_INSUFFICIENT_RESOURCES if unable to allocate memory for the file record. +* STATUS_CANT_WAIT if CanWait was FALSE and the function needed to resize the MFT but +* couldn't get immediate, exclusive access to it. */ NTSTATUS NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, - PFILE_OBJECT FileObject) + PFILE_OBJECT FileObject, + BOOLEAN CanWait) { NTSTATUS Status = STATUS_SUCCESS; PFILE_RECORD_HEADER FileRecord; @@ -649,7 +657,7 @@ NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, ULONGLONG ParentMftIndex; ULONGLONG FileMftIndex; - DPRINT1("NtfsCreateFileRecord(%p, %p)\n", DeviceExt, FileObject); + DPRINT1("NtfsCreateFileRecord(%p, %p, %s)\n", DeviceExt, FileObject, CanWait ? "TRUE" : "FALSE"); // allocate memory for file record FileRecord = ExAllocatePoolWithTag(NonPagedPool, @@ -708,7 +716,7 @@ NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, NtfsDumpFileRecord(DeviceExt, FileRecord); // Now that we've built the file record in memory, we need to store it in the MFT. - Status = AddNewMftEntry(FileRecord, DeviceExt, &FileMftIndex); + Status = AddNewMftEntry(FileRecord, DeviceExt, &FileMftIndex, CanWait); if (NT_SUCCESS(Status)) { // The highest 2 bytes should be the sequence number, unless the parent happens to be root diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 62b2979031..8df62ed542 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -195,10 +195,16 @@ AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord) * @param Vcb * Pointer to the VCB (DEVICE_EXTENSION) of the target volume. * +* +* @param CanWait +* Boolean indicating if the function is allowed to wait for exclusive access to the master file table. +* This will only be relevant if the MFT doesn't have any free file records and needs to be enlarged. +* * @return * STATUS_SUCCESS on success. * STATUS_INSUFFICIENT_RESOURCES if an allocation fails. * STATUS_INVALID_PARAMETER if there was an error reading the Mft's bitmap. +* STATUS_CANT_WAIT if CanWait was FALSE and the function could not get immediate, exclusive access to the MFT. * * @remarks * Increases the size of the Master File Table by 8 records. Bitmap entries for the new records are cleared, @@ -206,7 +212,7 @@ AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord) * This function will wait for exlusive access to the volume fcb. */ NTSTATUS -IncreaseMftSize(PDEVICE_EXTENSION Vcb) +IncreaseMftSize(PDEVICE_EXTENSION Vcb, BOOLEAN CanWait) { PNTFS_ATTR_CONTEXT BitmapContext; LARGE_INTEGER BitmapSize; @@ -221,10 +227,10 @@ IncreaseMftSize(PDEVICE_EXTENSION Vcb) ULONG LengthWritten; NTSTATUS Status; - DPRINT1("IncreaseMftSize(%p)\n", Vcb); + DPRINT1("IncreaseMftSize(%p, %s)\n", Vcb, CanWait ? "TRUE" : "FALSE"); // We need exclusive access to the mft while we change its size - if (!ExAcquireResourceExclusiveLite(&(Vcb->DirResource), TRUE)) + if (!ExAcquireResourceExclusiveLite(&(Vcb->DirResource), CanWait)) { return STATUS_CANT_WAIT; } @@ -1638,17 +1644,22 @@ FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, * @param DestinationIndex * Pointer to a ULONGLONG which will receive the MFT index where the file record was stored. * +* @param CanWait +* Boolean indicating if the function is allowed to wait for exclusive access to the master file table. +* This will only be relevant if the MFT doesn't have any free file records and needs to be enlarged. +* * @return * STATUS_SUCCESS on success. * STATUS_OBJECT_NAME_NOT_FOUND if we can't find the MFT's $Bitmap or if we weren't able * to read the attribute. * STATUS_INSUFFICIENT_RESOURCES if we can't allocate enough memory for a copy of $Bitmap. -* +* STATUS_CANT_WAIT if CanWait was FALSE and the function could not get immediate, exclusive access to the MFT. */ NTSTATUS AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, PDEVICE_EXTENSION DeviceExt, - PULONGLONG DestinationIndex) + PULONGLONG DestinationIndex, + BOOLEAN CanWait) { NTSTATUS Status = STATUS_SUCCESS; ULONGLONG MftIndex; @@ -1661,7 +1672,7 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, LARGE_INTEGER BitmapBits; UCHAR SystemReservedBits; - DPRINT1("AddNewMftEntry(%p, %p, %p)\n", FileRecord, DeviceExt, DestinationIndex); + DPRINT1("AddNewMftEntry(%p, %p, %p, %s)\n", FileRecord, DeviceExt, DestinationIndex, CanWait ? "TRUE" : "FALSE"); // First, we have to read the mft's $Bitmap attribute Status = FindAttribute(DeviceExt, DeviceExt->MasterFileTable, AttributeBitmap, L"", 0, &BitmapContext, NULL); @@ -1717,14 +1728,14 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, ReleaseAttributeContext(BitmapContext); // Couldn't find a free record in the MFT, add some blank records and try again - Status = IncreaseMftSize(DeviceExt); + Status = IncreaseMftSize(DeviceExt, CanWait); if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Couldn't find space in MFT for file or increase MFT size!\n"); return Status; } - return AddNewMftEntry(FileRecord, DeviceExt, DestinationIndex); + return AddNewMftEntry(FileRecord, DeviceExt, DestinationIndex, CanWait); } DPRINT1("Creating file record at MFT index: %I64u\n", MftIndex); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index b9336758ef..799f8e2a4f 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -667,7 +667,8 @@ NtfsCreate(PNTFS_IRP_CONTEXT IrpContext); NTSTATUS NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, - PFILE_OBJECT FileObject); + PFILE_OBJECT FileObject, + BOOLEAN CanWait); /* devctl.c */ @@ -825,7 +826,8 @@ NtfsFileSystemControl(PNTFS_IRP_CONTEXT IrpContext); NTSTATUS AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, PDEVICE_EXTENSION DeviceExt, - PULONGLONG DestinationIndex); + PULONGLONG DestinationIndex, + BOOLEAN CanWait); PNTFS_ATTR_CONTEXT PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord);

7 years

[reactos] 36/72: [NTFS] - Add support for expanding the master file table. Fix a bug with BrowseIndexEntries(). Improve diagnostic output. -AddNewMftEntry() - Increase size of MFT as needed. Fix math for bitmap length. Don't assign file records to MFT indices 0x10 - 0x17; In Windows, these records aren't used unless they have to be, even though they are marked as unused in the bitmap. +IncreaseMftSize() - Adds room for additional file records in the master file table. -BrowseIndexEntries() - all

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9ab86116a9cdddac4ced4… commit 9ab86116a9cdddac4ced4ea66dc6d228dc751aa9 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Jun 16 06:00:09 2017 +0000 [NTFS] - Add support for expanding the master file table. Fix a bug with BrowseIndexEntries(). Improve diagnostic output. -AddNewMftEntry() - Increase size of MFT as needed. Fix math for bitmap length. Don't assign file records to MFT indices 0x10 - 0x17; In Windows, these records aren't used unless they have to be, even though they are marked as unused in the bitmap. +IncreaseMftSize() - Adds room for additional file records in the master file table. -BrowseIndexEntries() - allow for the rare situation when a non-system file has an MFT index of 0x10. svn path=/branches/GSoC_2016/NTFS/; revision=75056 --- drivers/filesystems/ntfs/create.c | 2 + drivers/filesystems/ntfs/mft.c | 199 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 192 insertions(+), 9 deletions(-) diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index ef39b44373..07a9f5ac3e 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -649,6 +649,8 @@ NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, ULONGLONG ParentMftIndex; ULONGLONG FileMftIndex; + DPRINT1("NtfsCreateFileRecord(%p, %p)\n", DeviceExt, FileObject); + // allocate memory for file record FileRecord = ExAllocatePoolWithTag(NonPagedPool, DeviceExt->NtfsInfo.BytesPerFileRecord, diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 52a7caaa43..62b2979031 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -186,6 +186,161 @@ AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord) return AttrRecord->Resident.ValueLength; } +/** +* @name IncreaseMftSize +* @implemented +* +* Increases the size of the master file table on a volume, increasing the space available for file records. +* +* @param Vcb +* Pointer to the VCB (DEVICE_EXTENSION) of the target volume. +* +* @return +* STATUS_SUCCESS on success. +* STATUS_INSUFFICIENT_RESOURCES if an allocation fails. +* STATUS_INVALID_PARAMETER if there was an error reading the Mft's bitmap. +* +* @remarks +* Increases the size of the Master File Table by 8 records. Bitmap entries for the new records are cleared, +* and the bitmap is also enlarged if needed. Mimicking Windows' behavior when enlarging the mft is still TODO. +* This function will wait for exlusive access to the volume fcb. +*/ +NTSTATUS +IncreaseMftSize(PDEVICE_EXTENSION Vcb) +{ + PNTFS_ATTR_CONTEXT BitmapContext; + LARGE_INTEGER BitmapSize; + LARGE_INTEGER DataSize; + LONGLONG BitmapSizeDifference; + ULONG DataSizeDifference = Vcb->NtfsInfo.BytesPerFileRecord * 8; + ULONG BitmapOffset; + PUCHAR BitmapBuffer; + ULONGLONG BitmapBytes; + ULONGLONG NewBitmapSize; + ULONG BytesRead; + ULONG LengthWritten; + NTSTATUS Status; + + DPRINT1("IncreaseMftSize(%p)\n", Vcb); + + // We need exclusive access to the mft while we change its size + if (!ExAcquireResourceExclusiveLite(&(Vcb->DirResource), TRUE)) + { + return STATUS_CANT_WAIT; + } + + // Find the bitmap attribute of master file table + Status = FindAttribute(Vcb, Vcb->MasterFileTable, AttributeBitmap, L"", 0, &BitmapContext, &BitmapOffset); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't find $BITMAP attribute of Mft!\n"); + ExReleaseResourceLite(&(Vcb->DirResource)); + return Status; + } + + // Get size of Bitmap Attribute + BitmapSize.QuadPart = AttributeDataLength(&BitmapContext->Record); + + // Calculate the new mft size + DataSize.QuadPart = AttributeDataLength(&(Vcb->MFTContext->Record)) + DataSizeDifference; + + // Determine how many bytes will make up the bitmap + BitmapBytes = DataSize.QuadPart / Vcb->NtfsInfo.BytesPerFileRecord / 8; + + // Determine how much we need to adjust the bitmap size (it's possible we don't) + BitmapSizeDifference = BitmapBytes - BitmapSize.QuadPart; + NewBitmapSize = max(BitmapSize.QuadPart + BitmapSizeDifference, BitmapSize.QuadPart); + + // Allocate memory for the bitmap + BitmapBuffer = ExAllocatePoolWithTag(NonPagedPool, NewBitmapSize, TAG_NTFS); + if (!BitmapBuffer) + { + DPRINT1("ERROR: Unable to allocate memory for bitmap attribute!\n"); + ExReleaseResourceLite(&(Vcb->DirResource)); + ReleaseAttributeContext(BitmapContext); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Zero the bytes we'll be adding + RtlZeroMemory((PUCHAR)((ULONG_PTR)BitmapBuffer), NewBitmapSize); + + // Read the bitmap attribute + BytesRead = ReadAttribute(Vcb, + BitmapContext, + 0, + (PCHAR)BitmapBuffer, + BitmapSize.LowPart); + if (BytesRead != BitmapSize.LowPart) + { + DPRINT1("ERROR: Bytes read != Bitmap size!\n"); + ExReleaseResourceLite(&(Vcb->DirResource)); + ExFreePoolWithTag(BitmapBuffer, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + return STATUS_INVALID_PARAMETER; + } + + // Increase the mft size + Status = SetNonResidentAttributeDataLength(Vcb, Vcb->MFTContext, Vcb->MftDataOffset, Vcb->MasterFileTable, &DataSize); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to set size of $MFT data attribute!\n"); + ExReleaseResourceLite(&(Vcb->DirResource)); + ExFreePoolWithTag(BitmapBuffer, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + return Status; + } + + // If the bitmap grew + if (BitmapSizeDifference > 0) + { + // Set the new bitmap size + BitmapSize.QuadPart += BitmapSizeDifference; + if (BitmapContext->Record.IsNonResident) + Status = SetNonResidentAttributeDataLength(Vcb, BitmapContext, BitmapOffset, Vcb->MasterFileTable, &BitmapSize); + else + Status = SetResidentAttributeDataLength(Vcb, BitmapContext, BitmapOffset, Vcb->MasterFileTable, &BitmapSize); + + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to set size of bitmap attribute!\n"); + ExReleaseResourceLite(&(Vcb->DirResource)); + ExFreePoolWithTag(BitmapBuffer, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + return Status; + } + } + + //NtfsDumpFileAttributes(Vcb, FileRecord); + + // Update the file record with the new attribute sizes + Status = UpdateFileRecord(Vcb, Vcb->VolumeFcb->MFTIndex, Vcb->MasterFileTable); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to update $MFT file record!\n"); + ExReleaseResourceLite(&(Vcb->DirResource)); + ExFreePoolWithTag(BitmapBuffer, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + return Status; + } + + // Write out the new bitmap + Status = WriteAttribute(Vcb, BitmapContext, BitmapOffset, BitmapBuffer, BitmapSize.LowPart, &LengthWritten); + if (!NT_SUCCESS(Status)) + { + ExReleaseResourceLite(&(Vcb->DirResource)); + ExFreePoolWithTag(BitmapBuffer, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + DPRINT1("ERROR: Couldn't write to bitmap attribute of $MFT!\n"); + } + + // Cleanup + ExReleaseResourceLite(&(Vcb->DirResource)); + ExFreePoolWithTag(BitmapBuffer, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + + return STATUS_SUCCESS; +} + VOID InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, PFILE_RECORD_HEADER FileRecord, @@ -351,7 +506,7 @@ SetFileRecordEnd(PFILE_RECORD_HEADER FileRecord, * STATUS_INVALID_PARAMETER if we can't find the last cluster in the data run. * * @remarks -* Called by SetAttributeDataLength(). Use SetAttributeDataLength() unless you have a good +* Called by SetAttributeDataLength() and IncreaseMftSize(). Use SetAttributeDataLength() unless you have a good * reason to use this. Doesn't update the file record on disk. Doesn't inform the cache controller of changes with * any associated files. Synchronization is the callers responsibility. */ @@ -485,7 +640,7 @@ SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, * last attribute listed in the file record. * * @remarks -* Called by SetAttributeDataLength(). Use SetAttributeDataLength() unless you have a good +* Called by SetAttributeDataLength() and IncreaseMftSize(). Use SetAttributeDataLength() unless you have a good * reason to use this. Doesn't update the file record on disk. Doesn't inform the cache controller of changes with * any associated files. Synchronization is the callers responsibility. */ @@ -1488,7 +1643,6 @@ FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, * STATUS_OBJECT_NAME_NOT_FOUND if we can't find the MFT's $Bitmap or if we weren't able * to read the attribute. * STATUS_INSUFFICIENT_RESOURCES if we can't allocate enough memory for a copy of $Bitmap. -* STATUS_NOT_IMPLEMENTED if we need to increase the size of the MFT. * */ NTSTATUS @@ -1503,9 +1657,13 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, ULONGLONG AttrBytesRead; PVOID BitmapData; ULONG LengthWritten; + PNTFS_ATTR_CONTEXT BitmapContext; + LARGE_INTEGER BitmapBits; + UCHAR SystemReservedBits; + + DPRINT1("AddNewMftEntry(%p, %p, %p)\n", FileRecord, DeviceExt, DestinationIndex); // First, we have to read the mft's $Bitmap attribute - PNTFS_ATTR_CONTEXT BitmapContext; Status = FindAttribute(DeviceExt, DeviceExt->MasterFileTable, AttributeBitmap, L"", 0, &BitmapContext, NULL); if (!NT_SUCCESS(Status)) { @@ -1533,20 +1691,40 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, return STATUS_OBJECT_NAME_NOT_FOUND; } + // we need to backup the bits for records 0x10 - 0x17 and leave them unassigned if they aren't assigned + RtlCopyMemory(&SystemReservedBits, (PVOID)((ULONG_PTR)BitmapData + 2), 1); + RtlFillMemory((PVOID)((ULONG_PTR)BitmapData + 2), 1, (UCHAR)0xFF); + + // Calculate bit count + BitmapBits.QuadPart = AttributeDataLength(&(DeviceExt->MFTContext->Record)) / + DeviceExt->NtfsInfo.BytesPerFileRecord; + if (BitmapBits.HighPart != 0) + { + DPRINT1("\tFIXME: bitmap sizes beyond 32bits are not yet supported!\n"); + BitmapBits.LowPart = 0xFFFFFFFF; + } + // convert buffer into bitmap - RtlInitializeBitMap(&Bitmap, (PULONG)BitmapData, BitmapDataSize * 8); + RtlInitializeBitMap(&Bitmap, (PULONG)BitmapData, BitmapBits.LowPart); // set next available bit, preferrably after 23rd bit MftIndex = RtlFindClearBitsAndSet(&Bitmap, 1, 24); if ((LONG)MftIndex == -1) { - DPRINT1("ERROR: Couldn't find free space in MFT for file record!\n"); + DPRINT1("Couldn't find free space in MFT for file record, increasing MFT size.\n"); ExFreePoolWithTag(BitmapData, TAG_NTFS); ReleaseAttributeContext(BitmapContext); - // TODO: increase mft size - return STATUS_NOT_IMPLEMENTED; + // Couldn't find a free record in the MFT, add some blank records and try again + Status = IncreaseMftSize(DeviceExt); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't find space in MFT for file or increase MFT size!\n"); + return Status; + } + + return AddNewMftEntry(FileRecord, DeviceExt, DestinationIndex); } DPRINT1("Creating file record at MFT index: %I64u\n", MftIndex); @@ -1556,6 +1734,9 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, // [BitmapData should have been updated via RtlFindClearBitsAndSet()] + // Restore the system reserved bits + RtlCopyMemory((PVOID)((ULONG_PTR)BitmapData + 2), &SystemReservedBits, 1); + // write the bitmap back to the MFT's $Bitmap attribute Status = WriteAttribute(DeviceExt, BitmapContext, 0, BitmapData, BitmapDataSize, &LengthWritten); if (!NT_SUCCESS(Status)) @@ -1723,7 +1904,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) >= 0x10 && *CurrentEntry >= *StartEntry && IndexEntry->FileName.NameType != NTFS_FILE_NAME_DOS && CompareFileName(FileName, IndexEntry, DirSearch))

7 years

[reactos] 35/72: [NTFS] - Restructure some code in preparation for the next commit: -SetAttributeDataLength() has been split into two functions, SetNonResidentAttributeDataLength() and SetResidentAttributeDataLength(). This should improve code readibility and allows for resizing an attribute when there's no FileObject associated with it. -Added "MftDataOffset" member to DEVICE_EXTENSION, which stores the offset of the Mft's $DATA attribute. (I'm starting to think it's better to add a member for

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=1417f286e03dbb76ad9dd… commit 1417f286e03dbb76ad9ddd99929fbfef5b789a68 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Jun 16 05:43:52 2017 +0000 [NTFS] - Restructure some code in preparation for the next commit: -SetAttributeDataLength() has been split into two functions, SetNonResidentAttributeDataLength() and SetResidentAttributeDataLength(). This should improve code readibility and allows for resizing an attribute when there's no FileObject associated with it. -Added "MftDataOffset" member to DEVICE_EXTENSION, which stores the offset of the Mft's $DATA attribute. (I'm starting to think it's better to add a member for offset to NTFS_ATTR_CONTEXT directly, but I'll save that level of restructuring for a future commit.) svn path=/branches/GSoC_2016/NTFS/; revision=75055 --- drivers/filesystems/ntfs/fsctl.c | 8 +- drivers/filesystems/ntfs/mft.c | 557 ++++++++++++++++++++++++--------------- drivers/filesystems/ntfs/ntfs.h | 15 ++ 3 files changed, 360 insertions(+), 220 deletions(-) diff --git a/drivers/filesystems/ntfs/fsctl.c b/drivers/filesystems/ntfs/fsctl.c index a1f3048cd0..8acdd64e16 100644 --- a/drivers/filesystems/ntfs/fsctl.c +++ b/drivers/filesystems/ntfs/fsctl.c @@ -295,7 +295,13 @@ NtfsGetVolumeData(PDEVICE_OBJECT DeviceObject, return Status; } - Status = FindAttribute(DeviceExt, DeviceExt->MasterFileTable, AttributeData, L"", 0, &DeviceExt->MFTContext, NULL); + Status = FindAttribute(DeviceExt, + DeviceExt->MasterFileTable, + AttributeData, + L"", + 0, + &DeviceExt->MFTContext, + &DeviceExt->MftDataOffset); if (!NT_SUCCESS(Status)) { DPRINT1("Can't find data attribute for Master File Table.\n"); diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 5b9b291e4e..52a7caaa43 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -234,7 +234,6 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, PLARGE_INTEGER DataSize) { NTSTATUS Status = STATUS_SUCCESS; - ULONG BytesPerCluster = Fcb->Vcb->NtfsInfo.BytesPerCluster; // are we truncating the file? if (DataSize->QuadPart < AttributeDataLength(&AttrContext->Record)) @@ -248,229 +247,26 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, if (AttrContext->Record.IsNonResident) { - ULONGLONG AllocationSize = ROUND_UP(DataSize->QuadPart, BytesPerCluster); - PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); - ULONG ExistingClusters = AttrContext->Record.NonResident.AllocatedSize / BytesPerCluster; - - // do we need to increase the allocation size? - if (AttrContext->Record.NonResident.AllocatedSize < AllocationSize) - { - ULONG ClustersNeeded = (AllocationSize / BytesPerCluster) - ExistingClusters; - LARGE_INTEGER LastClusterInDataRun; - ULONG NextAssignedCluster; - ULONG AssignedClusters; - - if (ExistingClusters == 0) - { - LastClusterInDataRun.QuadPart = 0; - } - else - { - if (!FsRtlLookupLargeMcbEntry(&AttrContext->DataRunsMCB, - (LONGLONG)AttrContext->Record.NonResident.HighestVCN, - (PLONGLONG)&LastClusterInDataRun.QuadPart, - NULL, - NULL, - NULL, - NULL)) - { - 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); - return STATUS_INVALID_PARAMETER; - } - } - - DPRINT("LastClusterInDataRun: %I64u\n", LastClusterInDataRun.QuadPart); - DPRINT("Highest VCN of record: %I64u\n", AttrContext->Record.NonResident.HighestVCN); - - while (ClustersNeeded > 0) - { - Status = NtfsAllocateClusters(Fcb->Vcb, - LastClusterInDataRun.LowPart + 1, - ClustersNeeded, - &NextAssignedCluster, - &AssignedClusters); - - if (!NT_SUCCESS(Status)) - { - DPRINT1("Error: Unable to allocate requested clusters!\n"); - return Status; - } - - // now we need to add the clusters we allocated to the data run - Status = AddRun(Fcb->Vcb, AttrContext, AttrOffset, FileRecord, NextAssignedCluster, AssignedClusters); - if (!NT_SUCCESS(Status)) - { - DPRINT1("Error: Unable to add data run!\n"); - return Status; - } - - ClustersNeeded -= AssignedClusters; - LastClusterInDataRun.LowPart = NextAssignedCluster + AssignedClusters - 1; - } - } - else if (AttrContext->Record.NonResident.AllocatedSize > AllocationSize) - { - // shrink allocation size - ULONG ClustersToFree = ExistingClusters - (AllocationSize / BytesPerCluster); - Status = FreeClusters(Fcb->Vcb, AttrContext, AttrOffset, FileRecord, ClustersToFree); - } - - // TODO: is the file compressed, encrypted, or sparse? - - // NOTE: we need to have acquired the main resource exclusively, as well as(?) the PagingIoResource - - Fcb->RFCB.AllocationSize.QuadPart = AllocationSize; - AttrContext->Record.NonResident.AllocatedSize = AllocationSize; - AttrContext->Record.NonResident.DataSize = DataSize->QuadPart; - AttrContext->Record.NonResident.InitializedSize = DataSize->QuadPart; - - DestinationAttribute->NonResident.AllocatedSize = AllocationSize; - DestinationAttribute->NonResident.DataSize = DataSize->QuadPart; - DestinationAttribute->NonResident.InitializedSize = DataSize->QuadPart; - - DPRINT("Allocated Size: %I64u\n", DestinationAttribute->NonResident.AllocatedSize); + Status = SetNonResidentAttributeDataLength(Fcb->Vcb, + AttrContext, + AttrOffset, + FileRecord, + DataSize); } else { // resident attribute + Status = SetResidentAttributeDataLength(Fcb->Vcb, + AttrContext, + AttrOffset, + FileRecord, + DataSize); + } - // find the next attribute - ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; - PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((PCHAR)FileRecord + NextAttributeOffset); - - //NtfsDumpFileAttributes(Fcb->Vcb, FileRecord); - - // Do we need to increase the data length? - if (DataSize->QuadPart > AttrContext->Record.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; - if (MaxValueLength < DataSize->LowPart) - { - // If this is the last attribute, we could move the end marker to the very end of the file record - MaxValueLength += Fcb->Vcb->NtfsInfo.BytesPerFileRecord - NextAttributeOffset - (sizeof(ULONG) * 2); - - if (MaxValueLength < DataSize->LowPart || NextAttribute->Type != AttributeEnd) - { - // convert attribute to non-resident - PNTFS_ATTR_RECORD Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); - LARGE_INTEGER AttribDataSize; - PVOID AttribData; - ULONG EndAttributeOffset; - ULONG LengthWritten; - - DPRINT1("Converting attribute to non-resident.\n"); - - AttribDataSize.QuadPart = AttrContext->Record.Resident.ValueLength; - - // Is there existing data we need to back-up? - if (AttribDataSize.QuadPart > 0) - { - AttribData = ExAllocatePoolWithTag(NonPagedPool, AttribDataSize.QuadPart, TAG_NTFS); - if (AttribData == NULL) - { - DPRINT1("ERROR: Couldn't allocate memory for attribute data. Can't migrate to non-resident!\n"); - return STATUS_INSUFFICIENT_RESOURCES; - } - - // read data to temp buffer - Status = ReadAttribute(Fcb->Vcb, AttrContext, 0, AttribData, AttribDataSize.QuadPart); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Unable to read attribute before migrating!\n"); - ExFreePoolWithTag(AttribData, TAG_NTFS); - return Status; - } - } - - // Start by turning this attribute into a 0-length, non-resident attribute, then enlarge it. - - // 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)); - - // 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); - - // mark the attribute as non-resident - AttrContext->Record.IsNonResident = Destination->IsNonResident = 1; - - // 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 = ALIGN_UP_BY(EndAttributeOffset, 8); - - // Update the length - Destination->Length = EndAttributeOffset - AttrOffset; - AttrContext->Record.Length = Destination->Length; - - // Update the file record end - SetFileRecordEnd(FileRecord, - (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + EndAttributeOffset), - FILE_RECORD_END); - - // update file record on disk - Status = UpdateFileRecord(Fcb->Vcb, AttrContext->FileMFTIndex, FileRecord); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Couldn't update file record to continue migration!\n"); - if (AttribDataSize.QuadPart > 0) - ExFreePoolWithTag(AttribData, TAG_NTFS); - return Status; - } - - // Initialize the MCB, potentially catch an exception - _SEH2_TRY{ - FsRtlInitializeLargeMcb(&AttrContext->DataRunsMCB, NonPagedPool); - } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { - _SEH2_YIELD(return _SEH2_GetExceptionCode()); - } _SEH2_END; - - // Now we can treat the attribute as non-resident and enlarge it normally - Status = SetAttributeDataLength(FileObject, Fcb, AttrContext, AttrOffset, FileRecord, DataSize); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Unable to migrate resident attribute!\n"); - if (AttribDataSize.QuadPart > 0) - ExFreePoolWithTag(AttribData, TAG_NTFS); - return Status; - } - - // restore the back-up attribute, if we made one - if (AttribDataSize.QuadPart > 0) - { - Status = WriteAttribute(Fcb->Vcb, AttrContext, 0, AttribData, AttribDataSize.QuadPart, &LengthWritten); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Unable to write attribute data to non-resident clusters during migration!\n"); - // TODO: Reverse migration so no data is lost - ExFreePoolWithTag(AttribData, TAG_NTFS); - return Status; - } - - ExFreePoolWithTag(AttribData, TAG_NTFS); - } - } - } - } - else if (DataSize->LowPart < AttrContext->Record.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->Record.IsNonResident) - InternalSetResidentAttributeLength(AttrContext, FileRecord, AttrOffset, DataSize->LowPart); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Failed to set size of attribute!\n"); + return Status; } //NtfsDumpFileAttributes(Fcb->Vcb, FileRecord); @@ -480,6 +276,10 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, if (NT_SUCCESS(Status)) { + if(AttrContext->Record.IsNonResident) + Fcb->RFCB.AllocationSize.QuadPart = AttrContext->Record.NonResident.AllocatedSize; + else + Fcb->RFCB.AllocationSize = *DataSize; Fcb->RFCB.FileSize = *DataSize; Fcb->RFCB.ValidDataLength = *DataSize; CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&Fcb->RFCB.AllocationSize); @@ -523,6 +323,325 @@ SetFileRecordEnd(PFILE_RECORD_HEADER FileRecord, FileRecord->BytesInUse = (ULONG_PTR)AttrEnd - (ULONG_PTR)FileRecord + sizeof(ULONG) * 2; } +/** +* @name SetNonResidentAttributeDataLength +* @implemented +* +* Called by SetAttributeDataLength() to set the size of a non-resident attribute. Doesn't update the file record. +* +* @param Vcb +* Pointer to a DEVICE_EXTENSION describing the target disk. +* +* @param AttrContext +* PNTFS_ATTR_CONTEXT describing the location of the attribute whose size is being set. +* +* @param AttrOffset +* Offset, from the beginning of the record, of the attribute being sized. +* +* @param FileRecord +* Pointer to a file record containing the attribute to be resized. Must be a complete file record, +* not just the header. +* +* @param DataSize +* Pointer to a LARGE_INTEGER describing the new size of the attribute's data. +* +* @return +* STATUS_SUCCESS on success; +* STATUS_INSUFFICIENT_RESOURCES if an allocation fails. +* STATUS_INVALID_PARAMETER if we can't find the last cluster in the data run. +* +* @remarks +* Called by SetAttributeDataLength(). Use SetAttributeDataLength() unless you have a good +* reason to use this. Doesn't update the file record on disk. Doesn't inform the cache controller of changes with +* any associated files. Synchronization is the callers responsibility. +*/ +NTSTATUS +SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + PLARGE_INTEGER DataSize) +{ + NTSTATUS Status = STATUS_SUCCESS; + 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; + + if (!AttrContext->Record.IsNonResident) + { + DPRINT1("ERROR: SetNonResidentAttributeDataLength() called for resident attribute!\n"); + return STATUS_INVALID_PARAMETER; + } + + // do we need to increase the allocation size? + if (AttrContext->Record.NonResident.AllocatedSize < AllocationSize) + { + ULONG ClustersNeeded = (AllocationSize / BytesPerCluster) - ExistingClusters; + LARGE_INTEGER LastClusterInDataRun; + ULONG NextAssignedCluster; + ULONG AssignedClusters; + + if (ExistingClusters == 0) + { + LastClusterInDataRun.QuadPart = 0; + } + else + { + if (!FsRtlLookupLargeMcbEntry(&AttrContext->DataRunsMCB, + (LONGLONG)AttrContext->Record.NonResident.HighestVCN, + (PLONGLONG)&LastClusterInDataRun.QuadPart, + NULL, + NULL, + NULL, + NULL)) + { + 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); + return STATUS_INVALID_PARAMETER; + } + } + + DPRINT("LastClusterInDataRun: %I64u\n", LastClusterInDataRun.QuadPart); + DPRINT("Highest VCN of record: %I64u\n", AttrContext->Record.NonResident.HighestVCN); + + while (ClustersNeeded > 0) + { + Status = NtfsAllocateClusters(Vcb, + LastClusterInDataRun.LowPart + 1, + ClustersNeeded, + &NextAssignedCluster, + &AssignedClusters); + + if (!NT_SUCCESS(Status)) + { + DPRINT1("Error: Unable to allocate requested clusters!\n"); + return Status; + } + + // now we need to add the clusters we allocated to the data run + Status = AddRun(Vcb, AttrContext, AttrOffset, FileRecord, NextAssignedCluster, AssignedClusters); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Error: Unable to add data run!\n"); + return Status; + } + + ClustersNeeded -= AssignedClusters; + LastClusterInDataRun.LowPart = NextAssignedCluster + AssignedClusters - 1; + } + } + else if (AttrContext->Record.NonResident.AllocatedSize > AllocationSize) + { + // shrink allocation size + ULONG ClustersToFree = ExistingClusters - (AllocationSize / BytesPerCluster); + Status = FreeClusters(Vcb, AttrContext, AttrOffset, FileRecord, ClustersToFree); + } + + // 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; + + DestinationAttribute->NonResident.AllocatedSize = AllocationSize; + DestinationAttribute->NonResident.DataSize = DataSize->QuadPart; + DestinationAttribute->NonResident.InitializedSize = DataSize->QuadPart; + + DPRINT("Allocated Size: %I64u\n", DestinationAttribute->NonResident.AllocatedSize); + + return Status; +} + +/** +* @name SetResidentAttributeDataLength +* @implemented +* +* Called by SetAttributeDataLength() to set the size of a non-resident attribute. Doesn't update the file record. +* +* @param Vcb +* Pointer to a DEVICE_EXTENSION describing the target disk. +* +* @param AttrContext +* PNTFS_ATTR_CONTEXT describing the location of the attribute whose size is being set. +* +* @param AttrOffset +* Offset, from the beginning of the record, of the attribute being sized. +* +* @param FileRecord +* Pointer to a file record containing the attribute to be resized. Must be a complete file record, +* not just the header. +* +* @param DataSize +* Pointer to a LARGE_INTEGER describing the new size of the attribute's data. +* +* @return +* STATUS_SUCCESS on success; +* STATUS_INSUFFICIENT_RESOURCES if an allocation fails. +* STATUS_INVALID_PARAMETER if AttrContext describes a non-resident attribute. +* STATUS_NOT_IMPLEMENTED if requested to decrease the size of an attribute that isn't the +* last attribute listed in the file record. +* +* @remarks +* Called by SetAttributeDataLength(). Use SetAttributeDataLength() unless you have a good +* reason to use this. Doesn't update the file record on disk. Doesn't inform the cache controller of changes with +* any associated files. Synchronization is the callers responsibility. +*/ +NTSTATUS +SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + PLARGE_INTEGER DataSize) +{ + NTSTATUS Status; + + // find the next attribute + ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; + PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((PCHAR)FileRecord + NextAttributeOffset); + + if (AttrContext->Record.IsNonResident) + { + DPRINT1("ERROR: SetResidentAttributeDataLength() called for non-resident attribute!\n"); + return STATUS_INVALID_PARAMETER; + } + + //NtfsDumpFileAttributes(Vcb, FileRecord); + + // Do we need to increase the data length? + if (DataSize->QuadPart > AttrContext->Record.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; + if (MaxValueLength < DataSize->LowPart) + { + // If this is the last attribute, we could move the end marker to the very end of the file record + MaxValueLength += Vcb->NtfsInfo.BytesPerFileRecord - NextAttributeOffset - (sizeof(ULONG) * 2); + + if (MaxValueLength < DataSize->LowPart || NextAttribute->Type != AttributeEnd) + { + // convert attribute to non-resident + PNTFS_ATTR_RECORD Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); + LARGE_INTEGER AttribDataSize; + PVOID AttribData; + ULONG EndAttributeOffset; + ULONG LengthWritten; + + DPRINT1("Converting attribute to non-resident.\n"); + + AttribDataSize.QuadPart = AttrContext->Record.Resident.ValueLength; + + // Is there existing data we need to back-up? + if (AttribDataSize.QuadPart > 0) + { + AttribData = ExAllocatePoolWithTag(NonPagedPool, AttribDataSize.QuadPart, TAG_NTFS); + if (AttribData == NULL) + { + DPRINT1("ERROR: Couldn't allocate memory for attribute data. Can't migrate to non-resident!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // read data to temp buffer + Status = ReadAttribute(Vcb, AttrContext, 0, AttribData, AttribDataSize.QuadPart); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Unable to read attribute before migrating!\n"); + ExFreePoolWithTag(AttribData, TAG_NTFS); + return Status; + } + } + + // Start by turning this attribute into a 0-length, non-resident attribute, then enlarge it. + + // 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)); + + // 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); + + // mark the attribute as non-resident + AttrContext->Record.IsNonResident = Destination->IsNonResident = 1; + + // 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 = ALIGN_UP_BY(EndAttributeOffset, 8); + + // Update the length + Destination->Length = EndAttributeOffset - AttrOffset; + AttrContext->Record.Length = Destination->Length; + + // Update the file record end + SetFileRecordEnd(FileRecord, + (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + EndAttributeOffset), + FILE_RECORD_END); + + // update file record on disk + Status = UpdateFileRecord(Vcb, AttrContext->FileMFTIndex, FileRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't update file record to continue migration!\n"); + if (AttribDataSize.QuadPart > 0) + ExFreePoolWithTag(AttribData, TAG_NTFS); + return Status; + } + + // Initialize the MCB, potentially catch an exception + _SEH2_TRY{ + FsRtlInitializeLargeMcb(&AttrContext->DataRunsMCB, NonPagedPool); + } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { + _SEH2_YIELD(return _SEH2_GetExceptionCode()); + } _SEH2_END; + + // Now we can treat the attribute as non-resident and enlarge it normally + Status = SetNonResidentAttributeDataLength(Vcb, AttrContext, AttrOffset, FileRecord, DataSize); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Unable to migrate resident attribute!\n"); + if (AttribDataSize.QuadPart > 0) + ExFreePoolWithTag(AttribData, TAG_NTFS); + return Status; + } + + // restore the back-up attribute, if we made one + if (AttribDataSize.QuadPart > 0) + { + Status = WriteAttribute(Vcb, AttrContext, 0, AttribData, AttribDataSize.QuadPart, &LengthWritten); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Unable to write attribute data to non-resident clusters during migration!\n"); + // TODO: Reverse migration so no data is lost + ExFreePoolWithTag(AttribData, TAG_NTFS); + return Status; + } + + ExFreePoolWithTag(AttribData, TAG_NTFS); + } + } + } + } + else if (DataSize->LowPart < AttrContext->Record.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->Record.IsNonResident) + InternalSetResidentAttributeLength(AttrContext, FileRecord, AttrOffset, DataSize->LowPart); + + return STATUS_SUCCESS; +} + ULONG ReadAttribute(PDEVICE_EXTENSION Vcb, PNTFS_ATTR_CONTEXT Context, diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index a3265db9da..b9336758ef 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -116,6 +116,7 @@ typedef struct NTFS_INFO NtfsInfo; + ULONG MftDataOffset; ULONG Flags; ULONG OpenHandleCount; @@ -869,6 +870,20 @@ SetFileRecordEnd(PFILE_RECORD_HEADER FileRecord, PNTFS_ATTR_RECORD AttrEnd, ULONG EndMarker); +NTSTATUS +SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + PLARGE_INTEGER DataSize); + +NTSTATUS +SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb, + PNTFS_ATTR_CONTEXT AttrContext, + ULONG AttrOffset, + PFILE_RECORD_HEADER FileRecord, + PLARGE_INTEGER DataSize); + ULONGLONG AttributeAllocatedLength(PNTFS_ATTR_RECORD AttrRecord);

7 years

[reactos] 34/72: [NTFS] - Add some improvements to the previous commit, as suggested by Thomas.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9dce6f4db1ec015588ccf… commit 9dce6f4db1ec015588ccf7d5657693d5a0697390 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Jun 16 05:42:01 2017 +0000 [NTFS] - Add some improvements to the previous commit, as suggested by Thomas. svn path=/branches/GSoC_2016/NTFS/; revision=75054 --- drivers/filesystems/ntfs/attrib.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index eeed58104e..78be3ecf3c 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -167,9 +167,7 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, // we need to extract the filename from the path DPRINT1("Pathname: %wZ\n", &FileObject->FileName); - RtlZeroMemory(&FilenameNoPath, sizeof(UNICODE_STRING)); - FilenameNoPath.Buffer = Buffer; - FilenameNoPath.MaximumLength = MAX_PATH; + RtlInitEmptyUnicodeString(&FilenameNoPath, Buffer, MAX_PATH); FsRtlDissectName(FileObject->FileName, &Current, &Remaining); @@ -210,7 +208,7 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, DPRINT1("FileNameAttribute->DirectoryFileReferenceNumber: 0x%016I64x\n", FileNameAttribute->DirectoryFileReferenceNumber); - FileNameAttribute->NameLength = FilenameNoPath.Length / 2; + FileNameAttribute->NameLength = FilenameNoPath.Length / sizeof(WCHAR); // TODO: Get proper nametype, add DOS links as needed FileNameAttribute->NameType = NTFS_FILE_NAME_WIN32_AND_DOS; RtlCopyMemory(FileNameAttribute->Name, FilenameNoPath.Buffer, FilenameNoPath.Length);

7 years

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