Ros-diffs December 2017

ros-diffs@reactos.org

26 participants
355 discussions

[reactos] 33/72: [NTFS] - Add the most basic support for file creation. Expand diagnostic output, especially in NtfsDumpIndexRootAttribute(). Replace an ExFreePool() with ExFreePoolWithTag(). AddFileName() - Add a parameter to receive the Mft index of the parent directory. Fix so the name of the file will be stored in the attribute, not the name of the directory. NtfsCreateFile() - Open a file that was successfully created, instead of assuming failure. NtfsCreateFileRecord() - Add the filename a

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=e0048b1362c812705d326… commit e0048b1362c812705d326bf902b3712a258b4611 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri Jun 9 03:14:30 2017 +0000 [NTFS] - Add the most basic support for file creation. Expand diagnostic output, especially in NtfsDumpIndexRootAttribute(). Replace an ExFreePool() with ExFreePoolWithTag(). AddFileName() - Add a parameter to receive the Mft index of the parent directory. Fix so the name of the file will be stored in the attribute, not the name of the directory. NtfsCreateFile() - Open a file that was successfully created, instead of assuming failure. NtfsCreateFileRecord() - Add the filename attribute of the created file to the parent directory's index. +NtfsAddFilenameToDirectory() - Adds a $FILE_NAME attribute to a given directory index. Presently, a file can be created in an empty directory only. AddNewMftEntry() - Add a parameter to receive the mft index where the new entry was stored. svn path=/branches/GSoC_2016/NTFS/; revision=74970 --- drivers/filesystems/ntfs/attrib.c | 94 ++++++++++++-- drivers/filesystems/ntfs/create.c | 44 +++++-- drivers/filesystems/ntfs/dirctl.c | 250 ++++++++++++++++++++++++++++++++++++++ drivers/filesystems/ntfs/mft.c | 8 +- drivers/filesystems/ntfs/ntfs.h | 18 ++- 5 files changed, 388 insertions(+), 26 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index bb678e3ef8..eeed58104e 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -112,6 +112,9 @@ 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. +* * @return * STATUS_SUCCESS on success. STATUS_NOT_IMPLEMENTED if target address isn't at the end * of the given file record. @@ -128,16 +131,18 @@ NTSTATUS AddFileName(PFILE_RECORD_HEADER FileRecord, PNTFS_ATTR_RECORD AttributeAddress, PDEVICE_EXTENSION DeviceExt, - PFILE_OBJECT FileObject) + PFILE_OBJECT FileObject, + PULONGLONG ParentMftIndex) { ULONG ResidentHeaderLength = FIELD_OFFSET(NTFS_ATTR_RECORD, Resident.Reserved) + sizeof(UCHAR); PFILENAME_ATTRIBUTE FileNameAttribute; LARGE_INTEGER SystemTime; ULONG FileRecordEnd = AttributeAddress->Length; ULONGLONG CurrentMFTIndex = NTFS_FILE_ROOT; - UNICODE_STRING Current, Remaining; + UNICODE_STRING Current, Remaining, FilenameNoPath; NTSTATUS Status = STATUS_SUCCESS; ULONG FirstEntry = 0; + WCHAR Buffer[MAX_PATH]; if (AttributeAddress->Type != AttributeEnd) { @@ -162,20 +167,29 @@ 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; + FsRtlDissectName(FileObject->FileName, &Current, &Remaining); while (Current.Length != 0) { DPRINT1("Current: %wZ\n", &Current); + if(Remaining.Length != 0) + RtlCopyUnicodeString(&FilenameNoPath, &Remaining); + Status = NtfsFindMftRecord(DeviceExt, CurrentMFTIndex, &Current, &FirstEntry, FALSE, &CurrentMFTIndex); if (!NT_SUCCESS(Status)) - { break; - } - if (Remaining.Length == 0) + if (Remaining.Length == 0 ) + { + if(Current.Length != 0) + RtlCopyUnicodeString(&FilenameNoPath, &Current); break; + } FsRtlDissectName(Current, &Current, &Remaining); } @@ -184,6 +198,9 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, // set reference to parent directory FileNameAttribute->DirectoryFileReferenceNumber = CurrentMFTIndex; + *ParentMftIndex = CurrentMFTIndex; + + DPRINT1("SequenceNumber: 0x%02x\n", FileRecord->SequenceNumber); // The highest 2 bytes should be the sequence number, unless the parent happens to be root if (CurrentMFTIndex == NTFS_FILE_ROOT) @@ -191,19 +208,19 @@ AddFileName(PFILE_RECORD_HEADER FileRecord, else FileNameAttribute->DirectoryFileReferenceNumber |= (ULONGLONG)FileRecord->SequenceNumber << 48; - DPRINT1("FileNameAttribute->DirectoryFileReferenceNumber: 0x%I64x\n", FileNameAttribute->DirectoryFileReferenceNumber); + DPRINT1("FileNameAttribute->DirectoryFileReferenceNumber: 0x%016I64x\n", FileNameAttribute->DirectoryFileReferenceNumber); - FileNameAttribute->NameLength = Current.Length / 2; + FileNameAttribute->NameLength = FilenameNoPath.Length / 2; // TODO: Get proper nametype, add DOS links as needed FileNameAttribute->NameType = NTFS_FILE_NAME_WIN32_AND_DOS; - RtlCopyMemory(FileNameAttribute->Name, Current.Buffer, Current.Length); + RtlCopyMemory(FileNameAttribute->Name, FilenameNoPath.Buffer, FilenameNoPath.Length); FileRecord->LinkCount++; AttributeAddress->Length = ResidentHeaderLength + - FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + Current.Length; + FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + FilenameNoPath.Length; AttributeAddress->Length = ALIGN_UP_BY(AttributeAddress->Length, 8); - AttributeAddress->Resident.ValueLength = FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + Current.Length; + AttributeAddress->Resident.ValueLength = FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + FilenameNoPath.Length; AttributeAddress->Resident.ValueOffset = ResidentHeaderLength; AttributeAddress->Resident.Flags = 1; // indexed @@ -1054,6 +1071,7 @@ NtfsDumpFileNameAttribute(PNTFS_ATTR_RECORD Attribute) DbgPrint(" (%x) '%.*S' ", FileNameAttr->NameType, FileNameAttr->NameLength, FileNameAttr->Name); DbgPrint(" '%x' \n", FileNameAttr->FileAttributes); DbgPrint(" AllocatedSize: %I64u\nDataSize: %I64u\n", FileNameAttr->AllocatedSize, FileNameAttr->DataSize); + DbgPrint(" File reference: 0x%016I64x\n", FileNameAttr->DirectoryFileReferenceNumber); } @@ -1110,23 +1128,73 @@ VOID NtfsDumpIndexRootAttribute(PNTFS_ATTR_RECORD Attribute) { PINDEX_ROOT_ATTRIBUTE IndexRootAttr; + ULONG currentOffset; + ULONG currentNode; IndexRootAttr = (PINDEX_ROOT_ATTRIBUTE)((ULONG_PTR)Attribute + Attribute->Resident.ValueOffset); if (IndexRootAttr->AttributeType == AttributeFileName) ASSERT(IndexRootAttr->CollationRule == COLLATION_FILE_NAME); - DbgPrint(" $INDEX_ROOT (%uB, %u) ", IndexRootAttr->SizeOfEntry, IndexRootAttr->ClustersPerIndexRecord); + DbgPrint(" $INDEX_ROOT (%u bytes per index record, %u clusters) ", IndexRootAttr->SizeOfEntry, IndexRootAttr->ClustersPerIndexRecord); if (IndexRootAttr->Header.Flags == INDEX_ROOT_SMALL) { - DbgPrint(" (small) "); + DbgPrint(" (small)\n"); } else { ASSERT(IndexRootAttr->Header.Flags == INDEX_ROOT_LARGE); - DbgPrint(" (large) "); + DbgPrint(" (large)\n"); } + + DbgPrint(" Offset to first index: 0x%lx\n Total size of index entries: 0x%lx\n Allocated size of node: 0x%lx\n", + IndexRootAttr->Header.FirstEntryOffset, + IndexRootAttr->Header.TotalSizeOfEntries, + IndexRootAttr->Header.AllocatedSize); + currentOffset = IndexRootAttr->Header.FirstEntryOffset; + currentNode = 0; + // print details of every node in the index + while (currentOffset < IndexRootAttr->Header.TotalSizeOfEntries) + { + PINDEX_ENTRY_ATTRIBUTE currentIndexExtry = (PINDEX_ENTRY_ATTRIBUTE)((ULONG_PTR)IndexRootAttr + 0x10 + currentOffset); + DbgPrint(" Index Node Entry %u", currentNode++); + if (currentIndexExtry->Flags & NTFS_INDEX_ENTRY_NODE) + DbgPrint(" (Branch)"); + else + DbgPrint(" (Leaf)"); + if((currentIndexExtry->Flags & NTFS_INDEX_ENTRY_END)) + { + DbgPrint(" (Dummy Key)"); + } + DbgPrint("\n File Reference: 0x%016I64x\n", currentIndexExtry->Data.Directory.IndexedFile); + DbgPrint(" Index Entry Length: 0x%x\n", currentIndexExtry->Length); + DbgPrint(" Index Key Length: 0x%x\n", currentIndexExtry->KeyLength); + + // if this isn't the final (dummy) node, print info about the key (Filename attribute) + if (!(currentIndexExtry->Flags & NTFS_INDEX_ENTRY_END)) + { + UNICODE_STRING Name; + DbgPrint(" Parent File Reference: 0x%016I64x\n", currentIndexExtry->FileName.DirectoryFileReferenceNumber); + DbgPrint(" $FILENAME indexed: "); + Name.Length = currentIndexExtry->FileName.NameLength * sizeof(WCHAR); + Name.MaximumLength = Name.Length; + Name.Buffer = currentIndexExtry->FileName.Name; + DbgPrint("'%wZ'\n", &Name); + } + + // if this node has a sub-node beneath it + if (currentIndexExtry->Flags & NTFS_INDEX_ENTRY_NODE) + { + // Print the VCN of the sub-node + PULONGLONG SubNodeVCN = (PULONGLONG)((ULONG_PTR)currentIndexExtry + currentIndexExtry->Length - 8); + DbgPrint(" VCN of sub-node: 0x%llx\n", *SubNodeVCN); + } + + currentOffset += currentIndexExtry->Length; + ASSERT(currentIndexExtry->Length); + } + } diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 6513827c62..ef39b44373 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -523,7 +523,7 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, DoneOverwriting: if (fileRecord) - ExFreePool(fileRecord); + ExFreePoolWithTag(fileRecord, TAG_NTFS); if (dataContext) ReleaseAttributeContext(dataContext); @@ -562,13 +562,14 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, // Create the file record on disk Status = NtfsCreateFileRecord(DeviceExt, FileObject); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't create file record!\n"); + return Status; + } - // Update the parent directory index - // Still TODO - - // Call NtfsOpenFile() - - return STATUS_CANNOT_MAKE; + // Now we should be able to open the file + return NtfsCreateFile(DeviceObject, Irp); } } @@ -624,7 +625,8 @@ NtfsCreate(PNTFS_IRP_CONTEXT IrpContext) * @name NtfsCreateFileRecord() * @implemented * -* Creates a file record and saves it to the MFT. +* Creates a file record and saves it to the MFT. Adds the filename attribute of the +* created file to the parent directory's index. * * @param DeviceExt * Points to the target disk's DEVICE_EXTENSION @@ -643,6 +645,9 @@ NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, NTSTATUS Status = STATUS_SUCCESS; PFILE_RECORD_HEADER FileRecord; PNTFS_ATTR_RECORD NextAttribute; + PFILENAME_ATTRIBUTE FilenameAttribute; + ULONGLONG ParentMftIndex; + ULONGLONG FileMftIndex; // allocate memory for file record FileRecord = ExAllocatePoolWithTag(NonPagedPool, @@ -686,7 +691,10 @@ 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); + AddFileName(FileRecord, NextAttribute, DeviceExt, FileObject, &ParentMftIndex); + + // save a pointer to the filename attribute + FilenameAttribute = (PFILENAME_ATTRIBUTE)((ULONG_PTR)NextAttribute + NextAttribute->Resident.ValueOffset); // advance NextAttribute pointer to the next attribute NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length); @@ -698,7 +706,23 @@ 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); + Status = AddNewMftEntry(FileRecord, DeviceExt, &FileMftIndex); + if (NT_SUCCESS(Status)) + { + // The highest 2 bytes should be the sequence number, unless the parent happens to be root + if (FileMftIndex == NTFS_FILE_ROOT) + FileMftIndex = FileMftIndex + ((ULONGLONG)NTFS_FILE_ROOT << 48); + else + FileMftIndex = FileMftIndex + ((ULONGLONG)FileRecord->SequenceNumber << 48); + + DPRINT1("New File Reference: 0x%016I64x\n", FileMftIndex); + + // Add the filename attribute to the filename-index of the parent directory + Status = NtfsAddFilenameToDirectory(DeviceExt, + ParentMftIndex, + FileMftIndex, + FilenameAttribute); + } ExFreePoolWithTag(FileRecord, TAG_NTFS); diff --git a/drivers/filesystems/ntfs/dirctl.c b/drivers/filesystems/ntfs/dirctl.c index aaa6dfcb87..91f0bc5db7 100644 --- a/drivers/filesystems/ntfs/dirctl.c +++ b/drivers/filesystems/ntfs/dirctl.c @@ -34,6 +34,256 @@ /* FUNCTIONS ****************************************************************/ +/** +* @name NtfsAddFilenameToDirectory +* @implemented +* +* Adds a $FILE_NAME attribute to a given directory index. +* +* @param DeviceExt +* Points to the target disk's DEVICE_EXTENSION. +* +* @param DirectoryMftIndex +* Mft index of the parent directory which will receive the file. +* +* @param FileReferenceNumber +* File reference of the file to be added to the directory. This is a combination of the +* Mft index and sequence number. +* +* @param FilenameAttribute +* Pointer to the FILENAME_ATTRIBUTE of the file being added to the directory. +* +* @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. +* One FILENAME_ATTRIBUTE is added to the directory's index for each link to that file. So, each +* file which contains one FILENAME_ATTRIBUTE for a long name and another for the 8.3 name, will +* get both attributes added to its parent directory. +*/ +NTSTATUS +NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, + ULONGLONG DirectoryMftIndex, + ULONGLONG FileReferenceNumber, + PFILENAME_ATTRIBUTE FilenameAttribute) +{ + NTSTATUS Status = STATUS_SUCCESS; + PFILE_RECORD_HEADER ParentFileRecord; + PNTFS_ATTR_CONTEXT DirectoryContext; + 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; + + // Allocate memory for the parent directory + ParentFileRecord = ExAllocatePoolWithTag(NonPagedPool, + DeviceExt->NtfsInfo.BytesPerFileRecord, + TAG_NTFS); + if (!ParentFileRecord) + { + DPRINT1("ERROR: Couldn't allocate memory for file record!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // Open the parent directory + Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); + if (!NT_SUCCESS(Status)) + { + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + DPRINT1("ERROR: Couldn't read parent directory with index %I64u\n", + DirectoryMftIndex); + return Status; + } + + DPRINT1("Dumping old parent file record:\n"); + NtfsDumpFileRecord(DeviceExt, ParentFileRecord); + + // Find the index root attribute for the directory + Status = FindAttribute(DeviceExt, + ParentFileRecord, + AttributeIndexRoot, + L"$I30", + 4, + &DirectoryContext, + &IndexRootOffset); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't find $I30 $INDEX_ROOT attribute for parent directory with MFT #: %I64u!\n", + DirectoryMftIndex); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + I30IndexRootLength = AttributeDataLength(&DirectoryContext->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); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + } + + // Read the Index Root + Status = ReadAttribute(DeviceExt, DirectoryContext, 0, (PCHAR)I30IndexRoot, I30IndexRootLength); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couln't read index root attribute for Mft index #%I64u\n", DirectoryMftIndex); + ReleaseAttributeContext(DirectoryContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + 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) + { + DPRINT1("FIXME: File-creation is only supported in empty directories right now! Be patient! :)\n"); + ReleaseAttributeContext(DirectoryContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return STATUS_NOT_IMPLEMENTED; + } + + // 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) + { + DPRINT1("ERROR: Unable to allocate memory for new index root attribute!\n"); + ReleaseAttributeContext(DirectoryContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // 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) + + // Write back the new index root attribute to the parent directory file record + + // First, we need to make sure the attribute is large enough. + // 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); + + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); + if (NextAttribute->Type != AttributeEnd) + { + DPRINT1("FIXME: For now, only resizing index root at the end of a file record is supported!\n"); + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(DirectoryContext); + 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, + ParentFileRecord, + IndexRootOffset, + AttributeLength); + + 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); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + return Status; + } + + // Update the parent directory with the new index root + Status = WriteAttribute(DeviceExt, + DirectoryContext, + 0, + (PUCHAR)NewIndexRoot, + AttributeLength, + &LengthWritten); + if (!NT_SUCCESS(Status) ) + { + DPRINT1("ERROR: Unable to write new index root attribute to parent directory!\n"); + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(DirectoryContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + return Status; + } + + // re-read the parent file record, so we can dump it + Status = ReadFileRecord(DeviceExt, DirectoryMftIndex, ParentFileRecord); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Couldn't read parent directory after messing with it!\n"); + } + else + { + DPRINT1("Dumping new parent file record:\n"); + NtfsDumpFileRecord(DeviceExt, ParentFileRecord); + } + + // Cleanup + ExFreePoolWithTag(NewIndexRoot, TAG_NTFS); + ReleaseAttributeContext(DirectoryContext); + ExFreePoolWithTag(I30IndexRoot, TAG_NTFS); + ExFreePoolWithTag(ParentFileRecord, TAG_NTFS); + + return Status; +} ULONGLONG NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt, diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 19ae0d15c1..5b9b291e4e 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -1361,6 +1361,9 @@ FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, * @param DeviceExt * Pointer to the DEVICE_EXTENSION of the target drive. * +* @param DestinationIndex +* Pointer to a ULONGLONG which will receive the MFT index where the file record was stored. +* * @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 @@ -1371,7 +1374,8 @@ FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, */ NTSTATUS AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, - PDEVICE_EXTENSION DeviceExt) + PDEVICE_EXTENSION DeviceExt, + PULONGLONG DestinationIndex) { NTSTATUS Status = STATUS_SUCCESS; ULONGLONG MftIndex; @@ -1454,6 +1458,8 @@ AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, return Status; } + *DestinationIndex = MftIndex; + ExFreePoolWithTag(BitmapData, TAG_NTFS); ReleaseAttributeContext(BitmapContext); diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 2177f1db0e..a3265db9da 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -534,7 +534,8 @@ NTSTATUS AddFileName(PFILE_RECORD_HEADER FileRecord, PNTFS_ATTR_RECORD AttributeAddress, PDEVICE_EXTENSION DeviceExt, - PFILE_OBJECT FileObject); + PFILE_OBJECT FileObject, + PULONGLONG ParentMftIndex); NTSTATUS AddStandardInformation(PFILE_RECORD_HEADER FileRecord, @@ -675,6 +676,12 @@ NtfsDeviceControl(PNTFS_IRP_CONTEXT IrpContext); /* dirctl.c */ +NTSTATUS +NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt, + ULONGLONG DirectoryMftIndex, + ULONGLONG FileMftIndex, + PFILENAME_ATTRIBUTE FilenameAttribute); + ULONGLONG NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt, PFILE_RECORD_HEADER FileRecord, @@ -816,7 +823,8 @@ NtfsFileSystemControl(PNTFS_IRP_CONTEXT IrpContext); /* mft.c */ NTSTATUS AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, - PDEVICE_EXTENSION DeviceExt); + PDEVICE_EXTENSION DeviceExt, + PULONGLONG DestinationIndex); PNTFS_ATTR_CONTEXT PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord); @@ -842,6 +850,12 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, ULONGLONG AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord); +VOID +InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, + PFILE_RECORD_HEADER FileRecord, + ULONG AttrOffset, + ULONG DataSize); + NTSTATUS SetAttributeDataLength(PFILE_OBJECT FileObject, PNTFS_FCB Fcb,

6 years, 9 months

[reactos] 32/72: [NTFS] - Decrease debug spam

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=4ca91513004b2f6989415… commit 4ca91513004b2f698941566b50fb1b81796b614f Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun May 28 20:51:31 2017 +0000 [NTFS] - Decrease debug spam svn path=/branches/GSoC_2016/NTFS/; revision=74694 --- drivers/filesystems/ntfs/mft.c | 1 - drivers/filesystems/ntfs/rw.c | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 4dba9c66cd..19ae0d15c1 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -32,7 +32,6 @@ #include "ntfs.h" #define NDEBUG -#undef NDEBUG #include <debug.h> /* FUNCTIONS ****************************************************************/ diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 5afb87e9e6..7f119d706b 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -165,7 +165,7 @@ NtfsReadFile(PDEVICE_EXTENSION DeviceExt, AllocatedBuffer = TRUE; } - DPRINT1("Effective read: %lu at %lu for stream '%S'\n", RealLength, RealReadOffset, Fcb->Stream); + DPRINT("Effective read: %lu at %lu for stream '%S'\n", RealLength, RealReadOffset, Fcb->Stream); RealLengthRead = ReadAttribute(DeviceExt, DataContext, RealReadOffset, (PCHAR)ReadBuffer, RealLength); if (RealLengthRead == 0) { @@ -184,7 +184,7 @@ NtfsReadFile(PDEVICE_EXTENSION DeviceExt, *LengthRead = ToRead; - DPRINT1("%lu got read\n", *LengthRead); + DPRINT("%lu got read\n", *LengthRead); if (AllocatedBuffer) {

6 years, 9 months

[reactos] 31/72: [NTFS] - Disable write support by default. Enable it via the registry. [BOOTDATA] - Add a commented-out section to hivesys.inf which can add the required key to enable NTFS write support.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=037d88201d4312d6a4c19… commit 037d88201d4312d6a4c1936124f76ed48af83f6d Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sat May 27 19:32:43 2017 +0000 [NTFS] - Disable write support by default. Enable it via the registry. [BOOTDATA] - Add a commented-out section to hivesys.inf which can add the required key to enable NTFS write support. svn path=/branches/GSoC_2016/NTFS/; revision=74685 --- boot/bootdata/hivesys.inf | 2 ++ drivers/filesystems/ntfs/create.c | 16 ++++++++++++++- drivers/filesystems/ntfs/dispatch.c | 20 +++++++++++++++++-- drivers/filesystems/ntfs/ntfs.c | 40 ++++++++++++++++++++++++++++++++++++- drivers/filesystems/ntfs/ntfs.h | 1 + 5 files changed, 75 insertions(+), 4 deletions(-) diff --git a/boot/bootdata/hivesys.inf b/boot/bootdata/hivesys.inf index b0ece8594a..2fdb5e3097 100644 --- a/boot/bootdata/hivesys.inf +++ b/boot/bootdata/hivesys.inf @@ -1605,6 +1605,8 @@ HKLM,"SYSTEM\CurrentControlSet\Services\Ntfs","Group",0x00000000,"File System" HKLM,"SYSTEM\CurrentControlSet\Services\Ntfs","ImagePath",0x00020000,"system32\drivers\ntfs.sys" HKLM,"SYSTEM\CurrentControlSet\Services\Ntfs","Start",0x00010001,0x00000003 HKLM,"SYSTEM\CurrentControlSet\Services\Ntfs","Type",0x00010001,0x00000002 +; un-comment the line below to enable EXPERIMENTAL write-support on NTFS volumes: +;HKLM,"SYSTEM\CurrentControlSet\Services\Ntfs","MyDataDoesNotMatterSoEnableExperimentalWriteSupportForEveryNTFSVolume",0x00010001,0x00000001 ; Null device driver HKLM,"SYSTEM\CurrentControlSet\Services\Null","ErrorControl",0x00010001,0x00000000 diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 30312d6104..6513827c62 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -486,6 +486,13 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, LARGE_INTEGER Zero; Zero.QuadPart = 0; + if (!NtfsGlobalData->EnableWriteSupport) + { + DPRINT1("NTFS write-support is EXPERIMENTAL and is disabled by default!\n"); + NtfsCloseFile(DeviceExt, FileObject); + return STATUS_ACCESS_DENIED; + } + // TODO: check for appropriate access ExAcquireResourceExclusiveLite(&(Fcb->MainResource), TRUE); @@ -545,7 +552,14 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, RequestedDisposition == FILE_OPEN_IF || RequestedDisposition == FILE_OVERWRITE_IF || RequestedDisposition == FILE_SUPERSEDE) - { + { + if (!NtfsGlobalData->EnableWriteSupport) + { + DPRINT1("NTFS write-support is EXPERIMENTAL and is disabled by default!\n"); + NtfsCloseFile(DeviceExt, FileObject); + return STATUS_ACCESS_DENIED; + } + // Create the file record on disk Status = NtfsCreateFileRecord(DeviceExt, FileObject); diff --git a/drivers/filesystems/ntfs/dispatch.c b/drivers/filesystems/ntfs/dispatch.c index bb67de73aa..53d79303ed 100644 --- a/drivers/filesystems/ntfs/dispatch.c +++ b/drivers/filesystems/ntfs/dispatch.c @@ -82,7 +82,15 @@ NtfsDispatch(PNTFS_IRP_CONTEXT IrpContext) break; case IRP_MJ_SET_INFORMATION: - Status = NtfsSetInformation(IrpContext); + if (!NtfsGlobalData->EnableWriteSupport) + { + DPRINT1("NTFS write-support is EXPERIMENTAL and is disabled by default!\n"); + Status = STATUS_ACCESS_DENIED; + } + else + { + Status = NtfsSetInformation(IrpContext); + } break; case IRP_MJ_DIRECTORY_CONTROL: @@ -98,7 +106,15 @@ NtfsDispatch(PNTFS_IRP_CONTEXT IrpContext) break; case IRP_MJ_WRITE: - Status = NtfsWrite(IrpContext); + if (!NtfsGlobalData->EnableWriteSupport) + { + DPRINT1("NTFS write-support is EXPERIMENTAL and is disabled by default!\n"); + Status = STATUS_ACCESS_DENIED; + } + else + { + Status = NtfsWrite(IrpContext); + } break; case IRP_MJ_CLOSE: diff --git a/drivers/filesystems/ntfs/ntfs.c b/drivers/filesystems/ntfs/ntfs.c index de36a65328..c9bbc490bd 100644 --- a/drivers/filesystems/ntfs/ntfs.c +++ b/drivers/filesystems/ntfs/ntfs.c @@ -58,6 +58,8 @@ DriverEntry(PDRIVER_OBJECT DriverObject, UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(DEVICE_NAME); NTSTATUS Status; PDEVICE_OBJECT DeviceObject; + OBJECT_ATTRIBUTES Attributes; + HANDLE DriverKey = NULL; TRACE_(NTFS, "DriverEntry(%p, '%wZ')\n", DriverObject, RegistryPath); @@ -84,6 +86,42 @@ DriverEntry(PDRIVER_OBJECT DriverObject, ExInitializeResourceLite(&NtfsGlobalData->Resource); + NtfsGlobalData->EnableWriteSupport = FALSE; + + // Read registry to determine if write support should be enabled + InitializeObjectAttributes(&Attributes, + RegistryPath, + OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, + NULL, + NULL); + + Status = ZwOpenKey(&DriverKey, KEY_READ, &Attributes); + if (NT_SUCCESS(Status)) + { + UNICODE_STRING ValueName; + UCHAR Buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)]; + PKEY_VALUE_PARTIAL_INFORMATION Value = (PKEY_VALUE_PARTIAL_INFORMATION)Buffer; + ULONG ValueLength = sizeof(Buffer); + ULONG ResultLength; + + RtlInitUnicodeString(&ValueName, L"MyDataDoesNotMatterSoEnableExperimentalWriteSupportForEveryNTFSVolume"); + + Status = ZwQueryValueKey(DriverKey, + &ValueName, + KeyValuePartialInformation, + Value, + ValueLength, + &ResultLength); + + if (NT_SUCCESS(Status) && Value->Data[0] == TRUE) + { + DPRINT1("\tEnabling write support on ALL NTFS volumes!\n"); + NtfsGlobalData->EnableWriteSupport = TRUE; + } + + ZwClose(DriverKey); + } + /* Keep trace of Driver Object */ NtfsGlobalData->DriverObject = DriverObject; @@ -118,7 +156,7 @@ DriverEntry(PDRIVER_OBJECT DriverObject, IoRegisterFileSystem(NtfsGlobalData->DeviceObject); ObReferenceObject(NtfsGlobalData->DeviceObject); - return Status; + return STATUS_SUCCESS; } diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 68259177ee..2177f1db0e 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -151,6 +151,7 @@ typedef struct FAST_IO_DISPATCH FastIoDispatch; NPAGED_LOOKASIDE_LIST IrpContextLookasideList; NPAGED_LOOKASIDE_LIST FcbLookasideList; + BOOLEAN EnableWriteSupport; } NTFS_GLOBAL_DATA, *PNTFS_GLOBAL_DATA;

6 years, 9 months

[reactos] 30/72: [NTFS] - Add support for changing a file's size via SetEndOfFile(): -Handle IRP_MJ_SET_INFORMATION IRP requests. +NtfsSetEndOfFile() - Sets the end of file (file size) for a given file. +NtfsSetInformation() - Sets the specified file information. At this point, only FileEndOfFileInformation is fully implemented. FileAllocationInformation is handled the same way and not truly implemented, but this works well enough for SetEndOfFile(). Overwriting a file in NTFS should now work in

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=7f762aac01103bffbbdd2… commit 7f762aac01103bffbbdd23807cef9731fdcf9936 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sat May 27 03:20:31 2017 +0000 [NTFS] - Add support for changing a file's size via SetEndOfFile(): -Handle IRP_MJ_SET_INFORMATION IRP requests. +NtfsSetEndOfFile() - Sets the end of file (file size) for a given file. +NtfsSetInformation() - Sets the specified file information. At this point, only FileEndOfFileInformation is fully implemented. FileAllocationInformation is handled the same way and not truly implemented, but this works well enough for SetEndOfFile(). Overwriting a file in NTFS should now work in the majority of use cases. svn path=/branches/GSoC_2016/NTFS/; revision=74675 --- drivers/filesystems/ntfs/dispatch.c | 4 + drivers/filesystems/ntfs/finfo.c | 244 ++++++++++++++++++++++++++++++++++++ drivers/filesystems/ntfs/ntfs.c | 1 + drivers/filesystems/ntfs/ntfs.h | 9 ++ 4 files changed, 258 insertions(+) diff --git a/drivers/filesystems/ntfs/dispatch.c b/drivers/filesystems/ntfs/dispatch.c index 09140f2f32..bb67de73aa 100644 --- a/drivers/filesystems/ntfs/dispatch.c +++ b/drivers/filesystems/ntfs/dispatch.c @@ -81,6 +81,10 @@ NtfsDispatch(PNTFS_IRP_CONTEXT IrpContext) Status = NtfsQueryInformation(IrpContext); break; + case IRP_MJ_SET_INFORMATION: + Status = NtfsSetInformation(IrpContext); + break; + case IRP_MJ_DIRECTORY_CONTROL: Status = NtfsDirectoryControl(IrpContext); break; diff --git a/drivers/filesystems/ntfs/finfo.c b/drivers/filesystems/ntfs/finfo.c index 50604f847d..76cc78f4d9 100644 --- a/drivers/filesystems/ntfs/finfo.c +++ b/drivers/filesystems/ntfs/finfo.c @@ -396,4 +396,248 @@ NtfsQueryInformation(PNTFS_IRP_CONTEXT IrpContext) return Status; } +/** +* @name NtfsSetEndOfFile +* @implemented +* +* Sets the end of file (file size) for a given file. +* +* @param Fcb +* Pointer to an NTFS_FCB which describes the target file. Fcb->MainResource should have been +* acquired with ExAcquireResourceSharedLite(). +* +* @param FileObject +* Pointer to a FILE_OBJECT describing the target file. +* +* @param DeviceExt +* Points to the target disk's DEVICE_EXTENSION +* +* @param IrpFlags +* ULONG describing the flags of the original IRP request (Irp->Flags). +* +* @param NewFileSize +* Pointer to a LARGE_INTEGER which indicates the new end of file (file size). +* +* @return +* STATUS_SUCCESS if successful, +* STATUS_USER_MAPPED_FILE if trying to truncate a file but MmCanFileBeTruncated() returned false, +* STATUS_OBJECT_NAME_NOT_FOUND if there was no $DATA attribute associated with the target file, +* STATUS_INVALID_PARAMETER if there was no $FILENAME attribute associated with the target file, +* STATUS_INSUFFICIENT_RESOURCES if an allocation failed, +* STATUS_ACCESS_DENIED if target file is a volume or if paging is involved. +* +* @remarks As this function sets the size of a file at the file-level +* (and not at the attribute level) it's not recommended to use this +* function alongside functions that operate on the data attribute directly. +* +*/ +NTSTATUS +NtfsSetEndOfFile(PNTFS_FCB Fcb, + PFILE_OBJECT FileObject, + PDEVICE_EXTENSION DeviceExt, + ULONG IrpFlags, + PLARGE_INTEGER NewFileSize) +{ + LARGE_INTEGER CurrentFileSize; + PFILE_RECORD_HEADER FileRecord; + PNTFS_ATTR_CONTEXT DataContext; + ULONG AttributeOffset; + NTSTATUS Status = STATUS_SUCCESS; + ULONGLONG AllocationSize; + PFILENAME_ATTRIBUTE fileNameAttribute; + ULONGLONG ParentMFTId; + UNICODE_STRING filename; + + + // Allocate non-paged memory for the file record + FileRecord = ExAllocatePoolWithTag(NonPagedPool, DeviceExt->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + if (FileRecord == NULL) + { + DPRINT1("Couldn't allocate memory for file record!"); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // read the file record + DPRINT("Reading file record...\n"); + Status = ReadFileRecord(DeviceExt, Fcb->MFTIndex, FileRecord); + if (!NT_SUCCESS(Status)) + { + // We couldn't get the file's record. Free the memory and return the error + DPRINT1("Can't find record for %wS!\n", Fcb->ObjectName); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + return Status; + } + + DPRINT("Found record for %wS\n", Fcb->ObjectName); + + CurrentFileSize.QuadPart = NtfsGetFileSize(DeviceExt, FileRecord, L"", 0, (PULONGLONG)&CurrentFileSize); + + // Are we trying to decrease the file size? + if (NewFileSize->QuadPart < CurrentFileSize.QuadPart) + { + // Is the file mapped? + if (!MmCanFileBeTruncated(FileObject->SectionObjectPointer, + NewFileSize)) + { + DPRINT1("Couldn't decrease file size!\n"); + return STATUS_USER_MAPPED_FILE; + } + } + + // Find the attribute with the data stream for our file + DPRINT("Finding Data Attribute...\n"); + Status = FindAttribute(DeviceExt, + FileRecord, + AttributeData, + Fcb->Stream, + wcslen(Fcb->Stream), + &DataContext, + &AttributeOffset); + + // Did we fail to find the attribute? + if (!NT_SUCCESS(Status)) + { + DPRINT1("No '%S' data stream associated with file!\n", Fcb->Stream); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + return Status; + } + + // Get the size of the data attribute + CurrentFileSize.QuadPart = AttributeDataLength(&DataContext->Record); + + // Are we enlarging the attribute? + if (NewFileSize->QuadPart > CurrentFileSize.QuadPart) + { + // is increasing the stream size not allowed? + if ((Fcb->Flags & FCB_IS_VOLUME) || + (IrpFlags & IRP_PAGING_IO)) + { + // TODO - just fail for now + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + return STATUS_ACCESS_DENIED; + } + } + + // set the attribute data length + Status = SetAttributeDataLength(FileObject, Fcb, DataContext, AttributeOffset, FileRecord, NewFileSize); + if (!NT_SUCCESS(Status)) + { + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + return Status; + } + + // now we need to update this file's size in every directory index entry that references it + // TODO: expand to work with every filename / hardlink stored in the file record. + fileNameAttribute = GetBestFileNameFromRecord(Fcb->Vcb, FileRecord); + if (fileNameAttribute == NULL) + { + DPRINT1("Unable to find FileName attribute associated with file!\n"); + return STATUS_INVALID_PARAMETER; + } + + ParentMFTId = fileNameAttribute->DirectoryFileReferenceNumber & NTFS_MFT_MASK; + + filename.Buffer = fileNameAttribute->Name; + filename.Length = fileNameAttribute->NameLength * sizeof(WCHAR); + filename.MaximumLength = filename.Length; + + AllocationSize = ROUND_UP(NewFileSize->QuadPart, Fcb->Vcb->NtfsInfo.BytesPerCluster); + + Status = UpdateFileNameRecord(Fcb->Vcb, ParentMFTId, &filename, FALSE, NewFileSize->QuadPart, AllocationSize); + + ReleaseAttributeContext(DataContext); + ExFreePoolWithTag(FileRecord, TAG_NTFS); + + return Status; +} + +/** +* @name NtfsSetInformation +* @implemented +* +* Sets the specified file information. +* +* @param IrpContext +* Points to an NTFS_IRP_CONTEXT which describes the set operation +* +* @return +* STATUS_SUCCESS if successful, +* STATUS_NOT_IMPLEMENTED if trying to set an unimplemented information class, +* STATUS_USER_MAPPED_FILE if trying to truncate a file but MmCanFileBeTruncated() returned false, +* STATUS_OBJECT_NAME_NOT_FOUND if there was no $DATA attribute associated with the target file, +* STATUS_INVALID_PARAMETER if there was no $FILENAME attribute associated with the target file, +* STATUS_INSUFFICIENT_RESOURCES if an allocation failed, +* STATUS_ACCESS_DENIED if target file is a volume or if paging is involved. +* +* @remarks Called by NtfsDispatch() in response to an IRP_MJ_SET_INFORMATION request. +* Only the FileEndOfFileInformation InformationClass is fully implemented. FileAllocationInformation +* is a hack and not a true implementation, but it's enough to make SetEndOfFile() work. +* All other information classes are TODO. +* +*/ +NTSTATUS +NtfsSetInformation(PNTFS_IRP_CONTEXT IrpContext) +{ + FILE_INFORMATION_CLASS FileInformationClass; + PIO_STACK_LOCATION Stack; + PDEVICE_EXTENSION DeviceExt; + PFILE_OBJECT FileObject; + PNTFS_FCB Fcb; + PVOID SystemBuffer; + ULONG BufferLength; + PIRP Irp; + PDEVICE_OBJECT DeviceObject; + NTSTATUS Status = STATUS_NOT_IMPLEMENTED; + + DPRINT1("NtfsSetInformation(%p)\n", IrpContext); + + Irp = IrpContext->Irp; + Stack = IrpContext->Stack; + DeviceObject = IrpContext->DeviceObject; + DeviceExt = DeviceObject->DeviceExtension; + FileInformationClass = Stack->Parameters.QueryFile.FileInformationClass; + FileObject = IrpContext->FileObject; + Fcb = FileObject->FsContext; + + SystemBuffer = Irp->AssociatedIrp.SystemBuffer; + BufferLength = Stack->Parameters.QueryFile.Length; + + if (!ExAcquireResourceSharedLite(&Fcb->MainResource, + BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT))) + { + return NtfsMarkIrpContextForQueue(IrpContext); + } + + switch (FileInformationClass) + { + PFILE_END_OF_FILE_INFORMATION EndOfFileInfo; + + /* TODO: Allocation size is not actually the same as file end for NTFS, + however, few applications are likely to make the distinction. */ + case FileAllocationInformation: + 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); + break; + + // TODO: all other information classes + + default: + DPRINT1("FIXME: Unimplemented information class %u\n", FileInformationClass); + Status = STATUS_NOT_IMPLEMENTED; + } + + ExReleaseResourceLite(&Fcb->MainResource); + + if (NT_SUCCESS(Status)) + Irp->IoStatus.Information = + Stack->Parameters.QueryFile.Length - BufferLength; + else + Irp->IoStatus.Information = 0; + + return Status; +} /* EOF */ diff --git a/drivers/filesystems/ntfs/ntfs.c b/drivers/filesystems/ntfs/ntfs.c index 94ba4f8f6a..de36a65328 100644 --- a/drivers/filesystems/ntfs/ntfs.c +++ b/drivers/filesystems/ntfs/ntfs.c @@ -139,6 +139,7 @@ NtfsInitializeFunctionPointers(PDRIVER_OBJECT DriverObject) DriverObject->MajorFunction[IRP_MJ_READ] = NtfsFsdDispatch; DriverObject->MajorFunction[IRP_MJ_WRITE] = NtfsFsdDispatch; DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = NtfsFsdDispatch; + DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = NtfsFsdDispatch; DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = NtfsFsdDispatch; DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = NtfsFsdDispatch; DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = NtfsFsdDispatch; diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 462980d45d..68259177ee 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -796,6 +796,15 @@ NtfsMakeFCBFromDirEntry(PNTFS_VCB Vcb, NTSTATUS NtfsQueryInformation(PNTFS_IRP_CONTEXT IrpContext); +NTSTATUS +NtfsSetEndOfFile(PNTFS_FCB Fcb, + PFILE_OBJECT FileObject, + PDEVICE_EXTENSION DeviceExt, + ULONG IrpFlags, + PLARGE_INTEGER NewFileSize); + +NTSTATUS +NtfsSetInformation(PNTFS_IRP_CONTEXT IrpContext); /* fsctl.c */

6 years, 9 months

[reactos] 29/72: [NTFS] - Fix a bug with last commit, as spotted by Pierre.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=58402b67300e24e8822f7… commit 58402b67300e24e8822f7a1dd1f3997014ed25cf Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sat May 13 09:17:06 2017 +0000 [NTFS] - Fix a bug with last commit, as spotted by Pierre. svn path=/branches/GSoC_2016/NTFS/; revision=74525 --- drivers/filesystems/ntfs/mft.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 1e23675a0c..4dba9c66cd 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -437,7 +437,7 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, if (!NT_SUCCESS(Status)) { DPRINT1("ERROR: Unable to migrate resident attribute!\n"); - if(AttribData != NULL) + if (AttribDataSize.QuadPart > 0) ExFreePoolWithTag(AttribData, TAG_NTFS); return Status; }

6 years, 9 months

[reactos] 28/72: [NTFS] - Expand support for resizing resident attributes and fix NtfsAllocateClusters(). -Modify SetAttributeDataLength() to allow a resident attribute to migrate to non-resident if the attribute grows too large to remain resident. -Fix values returned by NtfsAllocateClusters() in case of error; return error codes, not 0.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c25b9747a168c659c76e1… commit c25b9747a168c659c76e1b41a53655dad53f8007 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sat May 13 08:56:54 2017 +0000 [NTFS] - Expand support for resizing resident attributes and fix NtfsAllocateClusters(). -Modify SetAttributeDataLength() to allow a resident attribute to migrate to non-resident if the attribute grows too large to remain resident. -Fix values returned by NtfsAllocateClusters() in case of error; return error codes, not 0. svn path=/branches/GSoC_2016/NTFS/; revision=74524 --- drivers/filesystems/ntfs/mft.c | 106 +++++++++++++++++++++++++++++++++++-- drivers/filesystems/ntfs/volinfo.c | 8 +-- 2 files changed, 107 insertions(+), 7 deletions(-) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index e78be29184..1e23675a0c 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -356,8 +356,106 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, if (MaxValueLength < DataSize->LowPart || NextAttribute->Type != AttributeEnd) { - DPRINT1("FIXME: Need to convert attribute to non-resident!\n"); - return STATUS_NOT_IMPLEMENTED; + // 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(AttribData != NULL) + 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); + } } } } @@ -371,7 +469,9 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, } } - InternalSetResidentAttributeLength(AttrContext, FileRecord, AttrOffset, DataSize->LowPart); + // set the new length of the resident attribute (if we didn't migrate it) + if(!AttrContext->Record.IsNonResident) + InternalSetResidentAttributeLength(AttrContext, FileRecord, AttrOffset, DataSize->LowPart); } //NtfsDumpFileAttributes(Fcb->Vcb, FileRecord); diff --git a/drivers/filesystems/ntfs/volinfo.c b/drivers/filesystems/ntfs/volinfo.c index 338ea84750..1a577d45e2 100644 --- a/drivers/filesystems/ntfs/volinfo.c +++ b/drivers/filesystems/ntfs/volinfo.c @@ -127,21 +127,21 @@ NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt, TAG_NTFS); if (BitmapRecord == NULL) { - return 0; + return STATUS_INSUFFICIENT_RESOURCES; } Status = ReadFileRecord(DeviceExt, NTFS_FILE_BITMAP, BitmapRecord); if (!NT_SUCCESS(Status)) { ExFreePoolWithTag(BitmapRecord, TAG_NTFS); - return 0; + return Status; } Status = FindAttribute(DeviceExt, BitmapRecord, AttributeData, L"", 0, &DataContext, NULL); if (!NT_SUCCESS(Status)) { ExFreePoolWithTag(BitmapRecord, TAG_NTFS); - return 0; + return Status; } BitmapDataSize = AttributeDataLength(&DataContext->Record); @@ -152,7 +152,7 @@ NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt, { ReleaseAttributeContext(DataContext); ExFreePoolWithTag(BitmapRecord, TAG_NTFS); - return 0; + return STATUS_INSUFFICIENT_RESOURCES; } DPRINT1("Total clusters: %I64x\n", DeviceExt->NtfsInfo.ClusterCount);

6 years, 9 months

[reactos] 27/72: [NTFS] - Commit early results of a small restructuring effort: -Add a new member to the NTFS_ATTR_CONTEXT struct, a LARGE_MCB. This allows an attribute context to describe the cluster mapping of a non-resident file while allowing that mapping to change dynamically, without the context itself needing to be resized. This fixes problems which sometimes arose from resizing files. -Remove hacky code from NtfsWriteFile() for dealing with "stale" contexts. This fixes that issue. -Updat

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=52b9f46776d9850c49976… commit 52b9f46776d9850c49976c949513fdd34a6d935f Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Fri May 12 22:16:20 2017 +0000 [NTFS] - Commit early results of a small restructuring effort: -Add a new member to the NTFS_ATTR_CONTEXT struct, a LARGE_MCB. This allows an attribute context to describe the cluster mapping of a non-resident file while allowing that mapping to change dynamically, without the context itself needing to be resized. This fixes problems which sometimes arose from resizing files. -Remove hacky code from NtfsWriteFile() for dealing with "stale" contexts. This fixes that issue. -Update SetDataAttributeLength(), PrepareAttributeContext(), ReleaseAttributeContext(), FreeClusters(), and AddRun() for the new member. -Update ReadAttribute() and WriteAttribute() to work with the changed structure. A very-soon-to-come commit will overhaul these functions so they'll operate directly on the LARGE_MCB, instead of converting to and from a packed list of data runs. (Sparse files are broken until then.) -Rename "RunBufferOffset" to "RunBufferSize" in several places where appropriate. -Fix, improve, and add some comments. svn path=/branches/GSoC_2016/NTFS/; revision=74523 --- drivers/filesystems/ntfs/attrib.c | 127 +++++++++++++------------------------- drivers/filesystems/ntfs/mft.c | 85 ++++++++++++++++++++++--- drivers/filesystems/ntfs/ntfs.h | 1 + drivers/filesystems/ntfs/rw.c | 16 ----- 4 files changed, 121 insertions(+), 108 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index 2a70e8c3c8..bb678e3ef8 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -261,39 +261,23 @@ AddRun(PNTFS_VCB Vcb, ULONG RunLength) { NTSTATUS Status; - PUCHAR DataRun = (PUCHAR)&AttrContext->Record + AttrContext->Record.NonResident.MappingPairsOffset; int DataRunMaxLength; PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); - LARGE_MCB DataRunsMCB; ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; - ULONGLONG NextVBN = AttrContext->Record.NonResident.LowestVCN; + ULONGLONG NextVBN = 0; - // Allocate some memory for the RunBuffer PUCHAR RunBuffer; - ULONG RunBufferOffset = 0; + ULONG RunBufferSize; if (!AttrContext->Record.IsNonResident) return STATUS_INVALID_PARAMETER; - RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); - if (!RunBuffer) - { - DPRINT1("ERROR: Couldn't allocate memory for data runs!\n"); - return STATUS_INSUFFICIENT_RESOURCES; - } - - // Convert the data runs to a map control block - Status = ConvertDataRunsToLargeMCB(DataRun, &DataRunsMCB, &NextVBN); - if (!NT_SUCCESS(Status)) - { - DPRINT1("Unable to convert data runs to MCB (probably ran out of memory)!\n"); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); - return Status; - } + if (AttrContext->Record.NonResident.AllocatedSize != 0) + NextVBN = AttrContext->Record.NonResident.HighestVCN + 1; // Add newly-assigned clusters to mcb _SEH2_TRY{ - if (!FsRtlAddLargeMcbEntry(&DataRunsMCB, + if (!FsRtlAddLargeMcbEntry(&AttrContext->DataRunsMCB, NextVBN, NextAssignedCluster, RunLength)) @@ -301,70 +285,65 @@ AddRun(PNTFS_VCB Vcb, ExRaiseStatus(STATUS_UNSUCCESSFUL); } } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { - FsRtlUninitializeLargeMcb(&DataRunsMCB); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); _SEH2_YIELD(_SEH2_GetExceptionCode()); } _SEH2_END; + RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + if (!RunBuffer) + { + DPRINT1("ERROR: Couldn't allocate memory for data runs!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } // Convert the map control block back to encoded data runs - ConvertLargeMCBToDataRuns(&DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferOffset); + ConvertLargeMCBToDataRuns(&AttrContext->DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferSize); // Get the amount of free space between the start of the of the first data run and the attribute end DataRunMaxLength = AttrContext->Record.Length - AttrContext->Record.NonResident.MappingPairsOffset; // Do we need to extend the attribute (or convert to attribute list)? - if (DataRunMaxLength < RunBufferOffset) + if (DataRunMaxLength < RunBufferSize) { PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); DataRunMaxLength += Vcb->NtfsInfo.BytesPerFileRecord - NextAttributeOffset - (sizeof(ULONG) * 2); // Can we move the end of the attribute? - if (NextAttribute->Type != AttributeEnd || DataRunMaxLength < RunBufferOffset - 1) + if (NextAttribute->Type != AttributeEnd || DataRunMaxLength < RunBufferSize - 1) { DPRINT1("FIXME: Need to create attribute list! Max Data Run Length available: %d\n", DataRunMaxLength); if (NextAttribute->Type != AttributeEnd) DPRINT1("There's another attribute after this one with type %0xlx\n", NextAttribute->Type); ExFreePoolWithTag(RunBuffer, TAG_NTFS); - FsRtlUninitializeLargeMcb(&DataRunsMCB); return STATUS_NOT_IMPLEMENTED; } // calculate position of end markers - NextAttributeOffset = AttrOffset + AttrContext->Record.NonResident.MappingPairsOffset + RunBufferOffset; + NextAttributeOffset = AttrOffset + AttrContext->Record.NonResident.MappingPairsOffset + RunBufferSize; NextAttributeOffset = ALIGN_UP_BY(NextAttributeOffset, 8); - // Write the end markers - NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); - NextAttribute->Type = AttributeEnd; - NextAttribute->Length = FILE_RECORD_END; - // Update the length DestinationAttribute->Length = NextAttributeOffset - AttrOffset; AttrContext->Record.Length = DestinationAttribute->Length; - // We need to increase the FileRecord size - FileRecord->BytesInUse = NextAttributeOffset + (sizeof(ULONG) * 2); + // End the file record + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); + SetFileRecordEnd(FileRecord, NextAttribute, FILE_RECORD_END); } - // NOTE: from this point on the original attribute record will contain invalid data in it's runbuffer - // TODO: Elegant fix? Could we free the old Record and allocate a new one without issue? - // Update HighestVCN DestinationAttribute->NonResident.HighestVCN = - AttrContext->Record.NonResident.HighestVCN = max(NextVBN - 1 + RunLength, + AttrContext->Record.NonResident.HighestVCN = max(NextVBN - 1 + RunLength, AttrContext->Record.NonResident.HighestVCN); // Write data runs to destination attribute RtlCopyMemory((PVOID)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), RunBuffer, - RunBufferOffset); + RunBufferSize); // Update the file record Status = UpdateFileRecord(Vcb, AttrContext->FileMFTIndex, FileRecord); ExFreePoolWithTag(RunBuffer, TAG_NTFS); - FsRtlUninitializeLargeMcb(&DataRunsMCB); NtfsDumpDataRuns((PUCHAR)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), 0); @@ -567,7 +546,7 @@ ConvertLargeMCBToDataRuns(PLARGE_MCB DataRunsMCB, DataRunLengthSize = GetPackedByteCount(Count, TRUE); DPRINT("%d bytes needed.\n", DataRunLengthSize); - // ensure the next data run + end marker would be > Max buffer size + // ensure the next data run + end marker would be <= Max buffer size if (RunBufferOffset + 2 + DataRunLengthSize + DataRunOffsetSize > MaxBufferSize) { Status = STATUS_BUFFER_TOO_SMALL; @@ -698,17 +677,12 @@ FreeClusters(PNTFS_VCB Vcb, NTSTATUS Status = STATUS_SUCCESS; ULONG ClustersLeftToFree = ClustersToFree; - // convert data runs to mcb - PUCHAR DataRun = (PUCHAR)&AttrContext->Record + AttrContext->Record.NonResident.MappingPairsOffset; PNTFS_ATTR_RECORD DestinationAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + AttrOffset); - LARGE_MCB DataRunsMCB; ULONG NextAttributeOffset = AttrOffset + AttrContext->Record.Length; PNTFS_ATTR_RECORD NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + NextAttributeOffset); - ULONGLONG NextVBN = AttrContext->Record.NonResident.LowestVCN; - // Allocate some memory for the RunBuffer PUCHAR RunBuffer; - ULONG RunBufferOffset = 0; + ULONG RunBufferSize = 0; PFILE_RECORD_HEADER BitmapRecord; PNTFS_ATTR_CONTEXT DataContext; @@ -722,30 +696,13 @@ FreeClusters(PNTFS_VCB Vcb, return STATUS_INVALID_PARAMETER; } - RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); - if (!RunBuffer) - { - DPRINT1("ERROR: Couldn't allocate memory for data runs!\n"); - return STATUS_INSUFFICIENT_RESOURCES; - } - - // Convert the data runs to a map control block - Status = ConvertDataRunsToLargeMCB(DataRun, &DataRunsMCB, &NextVBN); - if (!NT_SUCCESS(Status)) - { - DPRINT1("Unable to convert data runs to MCB (probably ran out of memory)!\n"); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); - return Status; - } - + // Read the $Bitmap file BitmapRecord = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); if (BitmapRecord == NULL) { DPRINT1("Error: Unable to allocate memory for bitmap file record!\n"); - FsRtlUninitializeLargeMcb(&DataRunsMCB); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); return STATUS_NO_MEMORY; } @@ -753,9 +710,7 @@ FreeClusters(PNTFS_VCB Vcb, if (!NT_SUCCESS(Status)) { DPRINT1("Error: Unable to read file record for bitmap!\n"); - FsRtlUninitializeLargeMcb(&DataRunsMCB); ExFreePoolWithTag(BitmapRecord, TAG_NTFS); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); return 0; } @@ -763,9 +718,7 @@ FreeClusters(PNTFS_VCB Vcb, if (!NT_SUCCESS(Status)) { DPRINT1("Error: Unable to find data attribute for bitmap file!\n"); - FsRtlUninitializeLargeMcb(&DataRunsMCB); ExFreePoolWithTag(BitmapRecord, TAG_NTFS); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); return 0; } @@ -777,9 +730,7 @@ FreeClusters(PNTFS_VCB Vcb, { DPRINT1("Error: Unable to allocate memory for bitmap file data!\n"); ReleaseAttributeContext(DataContext); - FsRtlUninitializeLargeMcb(&DataRunsMCB); ExFreePoolWithTag(BitmapRecord, TAG_NTFS); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); return 0; } @@ -792,7 +743,7 @@ FreeClusters(PNTFS_VCB Vcb, { LONGLONG LargeVbn, LargeLbn; - if (!FsRtlLookupLastLargeMcbEntry(&DataRunsMCB, &LargeVbn, &LargeLbn)) + if (!FsRtlLookupLastLargeMcbEntry(&AttrContext->DataRunsMCB, &LargeVbn, &LargeLbn)) { Status = STATUS_INVALID_PARAMETER; DPRINT1("DRIVER ERROR: FreeClusters called to free %lu clusters, which is %lu more clusters than are assigned to attribute!", @@ -806,7 +757,9 @@ FreeClusters(PNTFS_VCB Vcb, // deallocate this cluster RtlClearBits(&Bitmap, LargeLbn, 1); } - FsRtlTruncateLargeMcb(&DataRunsMCB, AttrContext->Record.NonResident.HighestVCN); + FsRtlTruncateLargeMcb(&AttrContext->DataRunsMCB, AttrContext->Record.NonResident.HighestVCN); + + // decrement HighestVCN, but don't let it go below 0 AttrContext->Record.NonResident.HighestVCN = min(AttrContext->Record.NonResident.HighestVCN, AttrContext->Record.NonResident.HighestVCN - 1); ClustersLeftToFree--; } @@ -816,19 +769,27 @@ FreeClusters(PNTFS_VCB Vcb, if (!NT_SUCCESS(Status)) { ReleaseAttributeContext(DataContext); - FsRtlUninitializeLargeMcb(&DataRunsMCB); ExFreePoolWithTag(BitmapData, TAG_NTFS); ExFreePoolWithTag(BitmapRecord, TAG_NTFS); - ExFreePoolWithTag(RunBuffer, TAG_NTFS); return Status; } ReleaseAttributeContext(DataContext); ExFreePoolWithTag(BitmapData, TAG_NTFS); ExFreePoolWithTag(BitmapRecord, TAG_NTFS); + + // Save updated data runs to file record + + // Allocate some memory for a new RunBuffer + RunBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + if (!RunBuffer) + { + DPRINT1("ERROR: Couldn't allocate memory for data runs!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } // Convert the map control block back to encoded data runs - ConvertLargeMCBToDataRuns(&DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferOffset); + ConvertLargeMCBToDataRuns(&AttrContext->DataRunsMCB, RunBuffer, Vcb->NtfsInfo.BytesPerCluster, &RunBufferSize); // Update HighestVCN DestinationAttribute->NonResident.HighestVCN = AttrContext->Record.NonResident.HighestVCN; @@ -836,27 +797,23 @@ FreeClusters(PNTFS_VCB Vcb, // Write data runs to destination attribute RtlCopyMemory((PVOID)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), RunBuffer, - RunBufferOffset); + RunBufferSize); + // Is DestinationAttribute the last attribute in the file record? if (NextAttribute->Type == AttributeEnd) { // update attribute length - AttrContext->Record.Length = ALIGN_UP_BY(AttrContext->Record.NonResident.MappingPairsOffset + RunBufferOffset, 8); + AttrContext->Record.Length = ALIGN_UP_BY(AttrContext->Record.NonResident.MappingPairsOffset + RunBufferSize, 8); DestinationAttribute->Length = AttrContext->Record.Length; // write end markers NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)DestinationAttribute + DestinationAttribute->Length); - NextAttribute->Type = AttributeEnd; - NextAttribute->Length = FILE_RECORD_END; - - // update file record length - FileRecord->BytesInUse = AttrOffset + DestinationAttribute->Length + (sizeof(ULONG) * 2); + SetFileRecordEnd(FileRecord, NextAttribute, FILE_RECORD_END); } // Update the file record Status = UpdateFileRecord(Vcb, AttrContext->FileMFTIndex, FileRecord); - FsRtlUninitializeLargeMcb(&DataRunsMCB); ExFreePoolWithTag(RunBuffer, TAG_NTFS); NtfsDumpDataRuns((PUCHAR)((ULONG_PTR)DestinationAttribute + DestinationAttribute->NonResident.MappingPairsOffset), 0); diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 8b588d760b..e78be29184 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -50,8 +50,10 @@ PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord) { LONGLONG DataRunOffset; ULONGLONG DataRunLength; + ULONGLONG NextVBN = 0; + PUCHAR DataRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset; - Context->CacheRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset; + Context->CacheRun = DataRun; Context->CacheRunOffset = 0; Context->CacheRun = DecodeRun(Context->CacheRun, &DataRunOffset, &DataRunLength); Context->CacheRunLength = DataRunLength; @@ -68,6 +70,14 @@ PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord) Context->CacheRunLastLCN = 0; } Context->CacheRunCurrentOffset = 0; + + // Convert the data runs to a map control block + if (!NT_SUCCESS(ConvertDataRunsToLargeMCB(DataRun, &Context->DataRunsMCB, &NextVBN))) + { + DPRINT1("Unable to convert data runs to MCB!\n"); + ExFreePoolWithTag(Context, TAG_NTFS); + return NULL; + } } return Context; @@ -77,6 +87,11 @@ PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord) VOID ReleaseAttributeContext(PNTFS_ATTR_CONTEXT Context) { + if (Context->Record.IsNonResident) + { + FsRtlUninitializeLargeMcb(&Context->DataRunsMCB); + } + ExFreePoolWithTag(Context, TAG_NTFS); } @@ -246,10 +261,30 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, ULONG NextAssignedCluster; ULONG AssignedClusters; - NTSTATUS Status = GetLastClusterInDataRun(Fcb->Vcb, &AttrContext->Record, (PULONGLONG)&LastClusterInDataRun.QuadPart); + 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"); - DPRINT1("GetLastClusterInDataRun returned: %I64u\n", LastClusterInDataRun.QuadPart); - DPRINT1("Highest VCN of record: %I64u\n", AttrContext->Record.NonResident.HighestVCN); + // 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) { @@ -405,6 +440,9 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, ULONG ReadLength; ULONG AlreadyRead; NTSTATUS Status; + + //TEMPTEMP + PUCHAR TempBuffer; if (!Context->Record.IsNonResident) { @@ -438,10 +476,21 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, } else { + //TEMPTEMP + ULONG UsedBufferSize; + TempBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + LastLCN = 0; - DataRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset; CurrentOffset = 0; + // This will be rewritten in the next iteration to just use the DataRuns MCB directly + ConvertLargeMCBToDataRuns(&Context->DataRunsMCB, + TempBuffer, + Vcb->NtfsInfo.BytesPerFileRecord, + &UsedBufferSize); + + DataRun = TempBuffer; + while (1) { DataRun = DecodeRun(DataRun, &DataRunOffset, &DataRunLength); @@ -558,6 +607,10 @@ ReadAttribute(PDEVICE_EXTENSION Vcb, } /* if Disk */ + // TEMPTEMP + if (Context->Record.IsNonResident) + ExFreePoolWithTag(TempBuffer, TAG_NTFS); + Context->CacheRun = DataRun; Context->CacheRunOffset = Offset + AlreadyRead; Context->CacheRunStartLCN = DataRunStartLCN; @@ -622,6 +675,10 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, NTSTATUS Status; PUCHAR SourceBuffer = Buffer; LONGLONG StartingOffset; + + //TEMPTEMP + PUCHAR TempBuffer; + DPRINT("WriteAttribute(%p, %p, %I64u, %p, %lu, %p)\n", Vcb, Context, Offset, Buffer, Length, RealLengthWritten); @@ -707,9 +764,19 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, } else*/ { + ULONG UsedBufferSize; LastLCN = 0; - DataRun = (PUCHAR)&Context->Record + Context->Record.NonResident.MappingPairsOffset; - CurrentOffset = 0; + CurrentOffset = 0; + + // This will be rewritten in the next iteration to just use the DataRuns MCB directly + TempBuffer = ExAllocatePoolWithTag(NonPagedPool, Vcb->NtfsInfo.BytesPerFileRecord, TAG_NTFS); + + ConvertLargeMCBToDataRuns(&Context->DataRunsMCB, + TempBuffer, + Vcb->NtfsInfo.BytesPerFileRecord, + &UsedBufferSize); + + DataRun = TempBuffer; while (1) { @@ -864,6 +931,10 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, } } // end while (Length > 0) [more data to write] + // TEMPTEMP + if(Context->Record.IsNonResident) + ExFreePoolWithTag(TempBuffer, TAG_NTFS); + Context->CacheRun = DataRun; Context->CacheRunOffset = Offset + *RealLengthWritten; Context->CacheRunStartLCN = DataRunStartLCN; diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 5a36bcc9fe..462980d45d 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -437,6 +437,7 @@ typedef struct _NTFS_ATTR_CONTEXT ULONGLONG CacheRunLength; LONGLONG CacheRunLastLCN; ULONGLONG CacheRunCurrentOffset; + LARGE_MCB DataRunsMCB; ULONGLONG FileMFTIndex; NTFS_ATTR_RECORD Record; } NTFS_ATTR_CONTEXT, *PNTFS_ATTR_CONTEXT; diff --git a/drivers/filesystems/ntfs/rw.c b/drivers/filesystems/ntfs/rw.c index 4db1c38815..5afb87e9e6 100644 --- a/drivers/filesystems/ntfs/rw.c +++ b/drivers/filesystems/ntfs/rw.c @@ -432,22 +432,6 @@ NTSTATUS NtfsWriteFile(PDEVICE_EXTENSION DeviceExt, return Status; } - // at this point the record in DataContext may be stale, so we need to refresh it - ReleaseAttributeContext(DataContext); - - Status = FindAttribute(DeviceExt, - FileRecord, - AttributeData, - Fcb->Stream, - wcslen(Fcb->Stream), - &DataContext, - &AttributeOffset); - if (!NT_SUCCESS(Status)) - { - DPRINT1("DRIVER ERROR: Couldn't find $DATA attribute after setting size!\n"); - return Status; - } - // now we need to update this file's size in every directory index entry that references it // TODO: put this code in its own function and adapt it to work with every filename / hardlink // stored in the file record.

6 years, 9 months

[reactos] 26/72: [NTFS] Add support for creating new MFT entries: +AddStandardInformation(), +AddData(), +AddFileName() - Add attributes to a file record +NtfsCreateFileRecord() - Creates a new file record and saves it to the MFT. +AddNewMftEntry() - Adds a file record to the MFT. NtfsCreateFile() - Modified to create a file record on a file-creation request (file creation is still unsupported; the created file needs to be added to the parent's directory index). +SetFileRecordEnd() - Establishes

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0409b3161e8789a4c9aa6… commit 0409b3161e8789a4c9aa606616626e1237427766 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Sun Apr 16 00:17:07 2017 +0000 [NTFS] Add support for creating new MFT entries: +AddStandardInformation(), +AddData(), +AddFileName() - Add attributes to a file record +NtfsCreateFileRecord() - Creates a new file record and saves it to the MFT. +AddNewMftEntry() - Adds a file record to the MFT. NtfsCreateFile() - Modified to create a file record on a file-creation request (file creation is still unsupported; the created file needs to be added to the parent's directory index). +SetFileRecordEnd() - Establishes a new file record size UpdateFileRecord() - Improved documentation InternalSetResidentAttributeLength() - Updated to use SetFileRecordEnd(). svn path=/branches/GSoC_2016/NTFS/; revision=74321 --- drivers/filesystems/ntfs/attrib.c | 242 ++++++++++++++++++++++++++++++++++++++ drivers/filesystems/ntfs/create.c | 96 ++++++++++++++- drivers/filesystems/ntfs/mft.c | 189 ++++++++++++++++++++++++++--- drivers/filesystems/ntfs/ntfs.h | 38 +++++- 4 files changed, 545 insertions(+), 20 deletions(-) diff --git a/drivers/filesystems/ntfs/attrib.c b/drivers/filesystems/ntfs/attrib.c index b65a6b8b50..2a70e8c3c8 100644 --- a/drivers/filesystems/ntfs/attrib.c +++ b/drivers/filesystems/ntfs/attrib.c @@ -35,6 +35,185 @@ /* FUNCTIONS ****************************************************************/ +/** +* @name AddData +* @implemented +* +* Adds a $DATA attribute to a given FileRecord. +* +* @param FileRecord +* Pointer to a complete file record to add the attribute to. Caller is responsible for +* ensuring FileRecord is large enough to contain $DATA. +* +* @param AttributeAddress +* Pointer to the region of memory that will receive the $DATA attribute. +* This address must reside within FileRecord. Must be aligned to an 8-byte boundary (relative to FileRecord). +* +* @return +* STATUS_SUCCESS on success. STATUS_NOT_IMPLEMENTED if target address isn't at the end +* of the given file record. +* +* @remarks +* Only adding the attribute to the end of the file record is supported; AttributeAddress must +* be of type AttributeEnd. +* As it's implemented, this function is only intended to assist in creating new file records. It +* could be made more general-purpose by considering file records with an $ATTRIBUTE_LIST. +* It's the caller's responsibility to ensure the given file record has enough memory allocated +* for the attribute. +*/ +NTSTATUS +AddData(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttributeAddress) +{ + ULONG ResidentHeaderLength = FIELD_OFFSET(NTFS_ATTR_RECORD, Resident.Reserved) + sizeof(UCHAR); + ULONG FileRecordEnd = AttributeAddress->Length; + + if (AttributeAddress->Type != AttributeEnd) + { + DPRINT1("FIXME: Can only add $DATA attribute to the end of a file record.\n"); + return STATUS_NOT_IMPLEMENTED; + } + + AttributeAddress->Type = AttributeData; + AttributeAddress->Length = ResidentHeaderLength; + AttributeAddress->Length = ALIGN_UP_BY(AttributeAddress->Length, 8); + AttributeAddress->Resident.ValueLength = 0; + AttributeAddress->Resident.ValueOffset = ResidentHeaderLength; + + // for unnamed $DATA attributes, NameOffset equals header length + AttributeAddress->NameOffset = ResidentHeaderLength; + AttributeAddress->Instance = FileRecord->NextAttributeNumber++; + + // move the attribute-end and file-record-end markers to the end of the file record + AttributeAddress = (PNTFS_ATTR_RECORD)((ULONG_PTR)AttributeAddress + AttributeAddress->Length); + SetFileRecordEnd(FileRecord, AttributeAddress, FileRecordEnd); + + return STATUS_SUCCESS; +} + +/** +* @name AddFileName +* @implemented +* +* Adds a $FILE_NAME attribute to a given FileRecord. +* +* @param FileRecord +* Pointer to a complete file record to add the attribute to. Caller is responsible for +* ensuring FileRecord is large enough to contain $FILE_NAME. +* +* @param AttributeAddress +* Pointer to the region of memory that will receive the $FILE_NAME attribute. +* This address must reside within FileRecord. Must be aligned to an 8-byte boundary (relative to FileRecord). +* +* @param DeviceExt +* Points to the target disk's DEVICE_EXTENSION. +* +* @param FileObject +* Pointer to the FILE_OBJECT which represents the new name. +* This parameter is used to determine the filename and parent directory. +* +* @return +* STATUS_SUCCESS on success. STATUS_NOT_IMPLEMENTED if target address isn't at the end +* of the given file record. +* +* @remarks +* Only adding the attribute to the end of the file record is supported; AttributeAddress must +* be of type AttributeEnd. +* As it's implemented, this function is only intended to assist in creating new file records. It +* could be made more general-purpose by considering file records with an $ATTRIBUTE_LIST. +* It's the caller's responsibility to ensure the given file record has enough memory allocated +* for the attribute. +*/ +NTSTATUS +AddFileName(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttributeAddress, + PDEVICE_EXTENSION DeviceExt, + PFILE_OBJECT FileObject) +{ + ULONG ResidentHeaderLength = FIELD_OFFSET(NTFS_ATTR_RECORD, Resident.Reserved) + sizeof(UCHAR); + PFILENAME_ATTRIBUTE FileNameAttribute; + LARGE_INTEGER SystemTime; + ULONG FileRecordEnd = AttributeAddress->Length; + ULONGLONG CurrentMFTIndex = NTFS_FILE_ROOT; + UNICODE_STRING Current, Remaining; + NTSTATUS Status = STATUS_SUCCESS; + ULONG FirstEntry = 0; + + if (AttributeAddress->Type != AttributeEnd) + { + DPRINT1("FIXME: Can only add $FILE_NAME attribute to the end of a file record.\n"); + return STATUS_NOT_IMPLEMENTED; + } + + AttributeAddress->Type = AttributeFileName; + AttributeAddress->Instance = FileRecord->NextAttributeNumber++; + + FileNameAttribute = (PFILENAME_ATTRIBUTE)((LONG_PTR)AttributeAddress + ResidentHeaderLength); + + // set timestamps + KeQuerySystemTime(&SystemTime); + FileNameAttribute->CreationTime = SystemTime.QuadPart; + FileNameAttribute->ChangeTime = SystemTime.QuadPart; + FileNameAttribute->LastWriteTime = SystemTime.QuadPart; + FileNameAttribute->LastAccessTime = SystemTime.QuadPart; + + FileNameAttribute->FileAttributes = NTFS_FILE_TYPE_ARCHIVE; + + // we need to extract the filename from the path + DPRINT1("Pathname: %wZ\n", &FileObject->FileName); + + FsRtlDissectName(FileObject->FileName, &Current, &Remaining); + + while (Current.Length != 0) + { + DPRINT1("Current: %wZ\n", &Current); + + Status = NtfsFindMftRecord(DeviceExt, CurrentMFTIndex, &Current, &FirstEntry, FALSE, &CurrentMFTIndex); + if (!NT_SUCCESS(Status)) + { + break; + } + + if (Remaining.Length == 0) + break; + + FsRtlDissectName(Current, &Current, &Remaining); + } + + DPRINT1("MFT Index of parent: %I64u\n", CurrentMFTIndex); + + // set reference to parent directory + FileNameAttribute->DirectoryFileReferenceNumber = CurrentMFTIndex; + + // The highest 2 bytes should be the sequence number, unless the parent happens to be root + if (CurrentMFTIndex == NTFS_FILE_ROOT) + FileNameAttribute->DirectoryFileReferenceNumber |= (ULONGLONG)NTFS_FILE_ROOT << 48; + else + FileNameAttribute->DirectoryFileReferenceNumber |= (ULONGLONG)FileRecord->SequenceNumber << 48; + + DPRINT1("FileNameAttribute->DirectoryFileReferenceNumber: 0x%I64x\n", FileNameAttribute->DirectoryFileReferenceNumber); + + FileNameAttribute->NameLength = Current.Length / 2; + // TODO: Get proper nametype, add DOS links as needed + FileNameAttribute->NameType = NTFS_FILE_NAME_WIN32_AND_DOS; + RtlCopyMemory(FileNameAttribute->Name, Current.Buffer, Current.Length); + FileRecord->LinkCount++; + + AttributeAddress->Length = ResidentHeaderLength + + FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + Current.Length; + AttributeAddress->Length = ALIGN_UP_BY(AttributeAddress->Length, 8); + + AttributeAddress->Resident.ValueLength = FIELD_OFFSET(FILENAME_ATTRIBUTE, Name) + Current.Length; + AttributeAddress->Resident.ValueOffset = ResidentHeaderLength; + AttributeAddress->Resident.Flags = 1; // indexed + + // move the attribute-end and file-record-end markers to the end of the file record + AttributeAddress = (PNTFS_ATTR_RECORD)((ULONG_PTR)AttributeAddress + AttributeAddress->Length); + SetFileRecordEnd(FileRecord, AttributeAddress, FileRecordEnd); + + return Status; +} + /** * @name AddRun * @implemented @@ -192,6 +371,69 @@ AddRun(PNTFS_VCB Vcb, return Status; } +/** +* @name AddStandardInformation +* @implemented +* +* Adds a $STANDARD_INFORMATION attribute to a given FileRecord. +* +* @param FileRecord +* Pointer to a complete file record to add the attribute to. Caller is responsible for +* ensuring FileRecord is large enough to contain $STANDARD_INFORMATION. +* +* @param AttributeAddress +* Pointer to the region of memory that will receive the $STANDARD_INFORMATION attribute. +* This address must reside within FileRecord. Must be aligned to an 8-byte boundary (relative to FileRecord). +* +* @return +* STATUS_SUCCESS on success. STATUS_NOT_IMPLEMENTED if target address isn't at the end +* of the given file record. +* +* @remarks +* Only adding the attribute to the end of the file record is supported; AttributeAddress must +* be of type AttributeEnd. +* As it's implemented, this function is only intended to assist in creating new file records. It +* could be made more general-purpose by considering file records with an $ATTRIBUTE_LIST. +* It's the caller's responsibility to ensure the given file record has enough memory allocated +* for the attribute. +*/ +NTSTATUS +AddStandardInformation(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttributeAddress) +{ + ULONG ResidentHeaderLength = FIELD_OFFSET(NTFS_ATTR_RECORD, Resident.Reserved) + sizeof(UCHAR); + PSTANDARD_INFORMATION StandardInfo = (PSTANDARD_INFORMATION)((LONG_PTR)AttributeAddress + ResidentHeaderLength); + LARGE_INTEGER SystemTime; + ULONG FileRecordEnd = AttributeAddress->Length; + + if (AttributeAddress->Type != AttributeEnd) + { + DPRINT1("FIXME: Can only add $STANDARD_INFORMATION attribute to the end of a file record.\n"); + return STATUS_NOT_IMPLEMENTED; + } + + AttributeAddress->Type = AttributeStandardInformation; + AttributeAddress->Length = sizeof(STANDARD_INFORMATION) + ResidentHeaderLength; + AttributeAddress->Length = ALIGN_UP_BY(AttributeAddress->Length, 8); + AttributeAddress->Resident.ValueLength = sizeof(STANDARD_INFORMATION); + AttributeAddress->Resident.ValueOffset = ResidentHeaderLength; + AttributeAddress->Instance = FileRecord->NextAttributeNumber++; + + // set dates and times + KeQuerySystemTime(&SystemTime); + StandardInfo->CreationTime = SystemTime.QuadPart; + StandardInfo->ChangeTime = SystemTime.QuadPart; + StandardInfo->LastWriteTime = SystemTime.QuadPart; + StandardInfo->LastAccessTime = SystemTime.QuadPart; + StandardInfo->FileAttribute = NTFS_FILE_TYPE_ARCHIVE; + + // move the attribute-end and file-record-end markers to the end of the file record + AttributeAddress = (PNTFS_ATTR_RECORD)((ULONG_PTR)AttributeAddress + AttributeAddress->Length); + SetFileRecordEnd(FileRecord, AttributeAddress, FileRecordEnd); + + return STATUS_SUCCESS; +} + /** * @name ConvertDataRunsToLargeMCB * @implemented diff --git a/drivers/filesystems/ntfs/create.c b/drivers/filesystems/ntfs/create.c index 344c16464f..30312d6104 100644 --- a/drivers/filesystems/ntfs/create.c +++ b/drivers/filesystems/ntfs/create.c @@ -545,8 +545,15 @@ NtfsCreateFile(PDEVICE_OBJECT DeviceObject, RequestedDisposition == FILE_OPEN_IF || RequestedDisposition == FILE_OVERWRITE_IF || RequestedDisposition == FILE_SUPERSEDE) - { - DPRINT1("Denying file creation request on NTFS volume\n"); + { + // Create the file record on disk + Status = NtfsCreateFileRecord(DeviceExt, FileObject); + + // Update the parent directory index + // Still TODO + + // Call NtfsOpenFile() + return STATUS_CANNOT_MAKE; } } @@ -599,4 +606,89 @@ NtfsCreate(PNTFS_IRP_CONTEXT IrpContext) return Status; } +/** +* @name NtfsCreateFileRecord() +* @implemented +* +* Creates a file record and saves it to the MFT. +* +* @param DeviceExt +* Points to the target disk's DEVICE_EXTENSION +* +* @param FileObject +* Pointer to a FILE_OBJECT describing the file to be created +* +* @return +* STATUS_SUCCESS on success. +* STATUS_INSUFFICIENT_RESOURCES if unable to allocate memory for the file record. +*/ +NTSTATUS +NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, + PFILE_OBJECT FileObject) +{ + NTSTATUS Status = STATUS_SUCCESS; + PFILE_RECORD_HEADER FileRecord; + PNTFS_ATTR_RECORD NextAttribute; + + // allocate memory for file record + FileRecord = ExAllocatePoolWithTag(NonPagedPool, + DeviceExt->NtfsInfo.BytesPerFileRecord, + TAG_NTFS); + if (!FileRecord) + { + DPRINT1("ERROR: Unable to allocate memory for file record!\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + + RtlZeroMemory(FileRecord, DeviceExt->NtfsInfo.BytesPerFileRecord); + + FileRecord->Ntfs.Type = NRH_FILE_TYPE; + + // calculate USA offset and count + FileRecord->Ntfs.UsaOffset = FIELD_OFFSET(FILE_RECORD_HEADER, MFTRecordNumber) + sizeof(ULONG); + + // size of USA (in ULONG's) will be 1 (for USA number) + 1 for every sector the file record uses + FileRecord->BytesAllocated = DeviceExt->NtfsInfo.BytesPerFileRecord; + FileRecord->Ntfs.UsaCount = (FileRecord->BytesAllocated / DeviceExt->NtfsInfo.BytesPerSector) + 1; + + // setup other file record fields + FileRecord->SequenceNumber = 1; + FileRecord->AttributeOffset = FileRecord->Ntfs.UsaOffset + (2 * FileRecord->Ntfs.UsaCount); + FileRecord->AttributeOffset = ALIGN_UP_BY(FileRecord->AttributeOffset, 8); + FileRecord->Flags = FRH_IN_USE; + FileRecord->BytesInUse = FileRecord->AttributeOffset + sizeof(ULONG) * 2; + + // find where the first attribute will be added + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + FileRecord->AttributeOffset); + + // mark the (temporary) end of the file-record + NextAttribute->Type = AttributeEnd; + NextAttribute->Length = FILE_RECORD_END; + + // add first attribute, $STANDARD_INFORMATION + AddStandardInformation(FileRecord, NextAttribute); + + // advance NextAttribute pointer to the next attribute + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length); + + // Add the $FILE_NAME attribute + AddFileName(FileRecord, NextAttribute, DeviceExt, FileObject); + + // advance NextAttribute pointer to the next attribute + NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length); + + // add the $DATA attribute + AddData(FileRecord, NextAttribute); + + // dump file record in memory (for debugging) + 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); + + ExFreePoolWithTag(FileRecord, TAG_NTFS); + + return Status; +} + /* EOF */ diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 30ef5f0e3e..8b588d760b 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -172,7 +172,7 @@ AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord) return AttrRecord->Resident.ValueLength; } -void +VOID InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, PFILE_RECORD_HEADER FileRecord, ULONG AttrOffset, @@ -201,14 +201,9 @@ InternalSetResidentAttributeLength(PNTFS_ATTR_CONTEXT AttrContext, Destination->Length += Padding; } - // advance Destination to the final "attribute" and write the end type + // advance Destination to the final "attribute" and set the file record end Destination = (PNTFS_ATTR_RECORD)((ULONG_PTR)Destination + Destination->Length); - Destination->Type = AttributeEnd; - - // write the final marker (which shares the same offset and type as the Length field) - Destination->Length = FILE_RECORD_END; - - FileRecord->BytesInUse = NextAttributeOffset + (sizeof(ULONG) * 2); + SetFileRecordEnd(FileRecord, Destination, FILE_RECORD_END); } /** @@ -359,6 +354,41 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, return STATUS_SUCCESS; } +/** +* @name SetFileRecordEnd +* @implemented +* +* This small function sets a new endpoint for the file record. It set's the final +* AttrEnd->Type to AttributeEnd and recalculates the bytes used by the file record. +* +* @param FileRecord +* Pointer to the file record whose endpoint (length) will be set. +* +* @param AttrEnd +* Pointer to section of memory that will receive the AttributeEnd marker. This must point +* to memory allocated for the FileRecord. Must be aligned to an 8-byte boundary (relative to FileRecord). +* +* @param EndMarker +* This value will be written after AttributeEnd but isn't critical at all. When Windows resizes +* a file record, it preserves the final ULONG that previously ended the record, even though this +* value is (to my knowledge) never used. We emulate this behavior. +* +*/ +VOID +SetFileRecordEnd(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttrEnd, + ULONG EndMarker) +{ + // mark the end of attributes + AttrEnd->Type = AttributeEnd; + + // Restore the "file-record-end marker." The value is never checked but this behavior is consistent with Win2k3. + AttrEnd->Length = EndMarker; + + // recalculate bytes in use + FileRecord->BytesInUse = (ULONG_PTR)AttrEnd - (ULONG_PTR)FileRecord + sizeof(ULONG) * 2; +} + ULONG ReadAttribute(PDEVICE_EXTENSION Vcb, PNTFS_ATTR_CONTEXT Context, @@ -711,7 +741,9 @@ WriteAttribute(PDEVICE_EXTENSION Vcb, { // We reached the last assigned cluster // TODO: assign new clusters to the end of the file. - // (Presently, this code will never be reached, the write should have already failed by now) + // (Presently, this code will rarely be reached, the write will usually have already failed by now) + // [We can reach here by creating a new file record when the MFT isn't large enough] + DPRINT1("FIXME: Master File Table needs to be enlarged.\n"); return STATUS_END_OF_FILE; } @@ -1070,25 +1102,39 @@ UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb, } /** -* UpdateFileRecord +* @name UpdateFileRecord * @implemented +* * Writes a file record to the master file table, at a given index. +* +* @param Vcb +* Pointer to the DEVICE_EXTENSION of the target drive being written to. +* +* @param MftIndex +* Target index in the master file table to store the file record. +* +* @param FileRecord +* Pointer to the complete file record which will be written to the master file table. +* +* @return +* STATUS_SUCCESSFUL on success. An error passed from WriteAttribute() otherwise. +* */ NTSTATUS UpdateFileRecord(PDEVICE_EXTENSION Vcb, - ULONGLONG index, - PFILE_RECORD_HEADER file) + ULONGLONG MftIndex, + PFILE_RECORD_HEADER FileRecord) { ULONG BytesWritten; NTSTATUS Status = STATUS_SUCCESS; - DPRINT("UpdateFileRecord(%p, %I64x, %p)\n", Vcb, index, file); + DPRINT("UpdateFileRecord(%p, 0x%I64x, %p)\n", Vcb, MftIndex, FileRecord); // Add the fixup array to prepare the data for writing to disk - AddFixupArray(Vcb, &file->Ntfs); + AddFixupArray(Vcb, &FileRecord->Ntfs); // write the file record to the master file table - Status = WriteAttribute(Vcb, Vcb->MFTContext, index * Vcb->NtfsInfo.BytesPerFileRecord, (const PUCHAR)file, Vcb->NtfsInfo.BytesPerFileRecord, &BytesWritten); + Status = WriteAttribute(Vcb, Vcb->MFTContext, MftIndex * Vcb->NtfsInfo.BytesPerFileRecord, (const PUCHAR)FileRecord, Vcb->NtfsInfo.BytesPerFileRecord, &BytesWritten); if (!NT_SUCCESS(Status)) { @@ -1096,7 +1142,7 @@ UpdateFileRecord(PDEVICE_EXTENSION Vcb, } // remove the fixup array (so the file record pointer can still be used) - FixupUpdateSequenceArray(Vcb, &file->Ntfs); + FixupUpdateSequenceArray(Vcb, &FileRecord->Ntfs); return Status; } @@ -1133,6 +1179,117 @@ FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb, return STATUS_SUCCESS; } +/** +* @name AddNewMftEntry +* @implemented +* +* Adds a file record to the master file table of a given device. +* +* @param FileRecord +* Pointer to a complete file record which will be saved to disk. +* +* @param DeviceExt +* Pointer to the DEVICE_EXTENSION of the target drive. +* +* @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_NOT_IMPLEMENTED if we need to increase the size of the MFT. +* +*/ +NTSTATUS +AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, + PDEVICE_EXTENSION DeviceExt) +{ + NTSTATUS Status = STATUS_SUCCESS; + ULONGLONG MftIndex; + RTL_BITMAP Bitmap; + ULONGLONG BitmapDataSize; + ULONGLONG AttrBytesRead; + PVOID BitmapData; + ULONG LengthWritten; + + // 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)) + { + DPRINT1("ERROR: Couldn't find $Bitmap attribute of master file table!\n"); + return Status; + } + + // allocate a buffer for the $Bitmap attribute + BitmapDataSize = AttributeDataLength(&BitmapContext->Record); + BitmapData = ExAllocatePoolWithTag(NonPagedPool, BitmapDataSize, TAG_NTFS); + if (!BitmapData) + { + ReleaseAttributeContext(BitmapContext); + return STATUS_INSUFFICIENT_RESOURCES; + } + + // read $Bitmap attribute + AttrBytesRead = ReadAttribute(DeviceExt, BitmapContext, 0, BitmapData, BitmapDataSize); + + if (AttrBytesRead == 0) + { + DPRINT1("ERROR: Unable to read $Bitmap attribute of master file table!\n"); + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + return STATUS_OBJECT_NAME_NOT_FOUND; + } + + // convert buffer into bitmap + RtlInitializeBitMap(&Bitmap, (PULONG)BitmapData, BitmapDataSize * 8); + + // 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"); + + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + + // TODO: increase mft size + return STATUS_NOT_IMPLEMENTED; + } + + DPRINT1("Creating file record at MFT index: %I64u\n", MftIndex); + + // update file record with index + FileRecord->MFTRecordNumber = MftIndex; + + // [BitmapData should have been updated via RtlFindClearBitsAndSet()] + + // write the bitmap back to the MFT's $Bitmap attribute + Status = WriteAttribute(DeviceExt, BitmapContext, 0, BitmapData, BitmapDataSize, &LengthWritten); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR encountered when writing $Bitmap attribute!\n"); + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + return Status; + } + + // update the file record (write it to disk) + Status = UpdateFileRecord(DeviceExt, MftIndex, FileRecord); + + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Unable to write file record!\n"); + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + return Status; + } + + ExFreePoolWithTag(BitmapData, TAG_NTFS); + ReleaseAttributeContext(BitmapContext); + + return Status; +} + NTSTATUS AddFixupArray(PDEVICE_EXTENSION Vcb, PNTFS_RECORD_HEADER Record) diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index ce8a7df2de..5a36bcc9fe 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -516,6 +516,10 @@ NtfsMarkIrpContextForQueue(PNTFS_IRP_CONTEXT IrpContext) //VOID //NtfsDumpAttribute(PATTRIBUTE Attribute); +NTSTATUS +AddData(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttributeAddress); + NTSTATUS AddRun(PNTFS_VCB Vcb, PNTFS_ATTR_CONTEXT AttrContext, @@ -524,6 +528,16 @@ AddRun(PNTFS_VCB Vcb, ULONGLONG NextAssignedCluster, ULONG RunLength); +NTSTATUS +AddFileName(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttributeAddress, + PDEVICE_EXTENSION DeviceExt, + PFILE_OBJECT FileObject); + +NTSTATUS +AddStandardInformation(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttributeAddress); + NTSTATUS ConvertDataRunsToLargeMCB(PUCHAR DataRun, PLARGE_MCB DataRunsMCB, @@ -647,6 +661,9 @@ NtfsClose(PNTFS_IRP_CONTEXT IrpContext); NTSTATUS NtfsCreate(PNTFS_IRP_CONTEXT IrpContext); +NTSTATUS +NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt, + PFILE_OBJECT FileObject); /* devctl.c */ @@ -786,6 +803,10 @@ NtfsFileSystemControl(PNTFS_IRP_CONTEXT IrpContext); /* mft.c */ +NTSTATUS +AddNewMftEntry(PFILE_RECORD_HEADER FileRecord, + PDEVICE_EXTENSION DeviceExt); + PNTFS_ATTR_CONTEXT PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord); @@ -818,6 +839,11 @@ SetAttributeDataLength(PFILE_OBJECT FileObject, PFILE_RECORD_HEADER FileRecord, PLARGE_INTEGER DataSize); +VOID +SetFileRecordEnd(PFILE_RECORD_HEADER FileRecord, + PNTFS_ATTR_RECORD AttrEnd, + ULONG EndMarker); + ULONGLONG AttributeAllocatedLength(PNTFS_ATTR_RECORD AttrRecord); @@ -855,8 +881,8 @@ UpdateFileNameRecord(PDEVICE_EXTENSION Vcb, NTSTATUS UpdateFileRecord(PDEVICE_EXTENSION Vcb, - ULONGLONG index, - PFILE_RECORD_HEADER file); + ULONGLONG MftIndex, + PFILE_RECORD_HEADER FileRecord); NTSTATUS FindAttribute(PDEVICE_EXTENSION Vcb, @@ -919,6 +945,14 @@ NtfsFindFileAt(PDEVICE_EXTENSION Vcb, PULONGLONG MFTIndex, ULONGLONG CurrentMFTIndex); +NTSTATUS +NtfsFindMftRecord(PDEVICE_EXTENSION Vcb, + ULONGLONG MFTIndex, + PUNICODE_STRING FileName, + PULONG FirstEntry, + BOOLEAN DirSearch, + ULONGLONG *OutMFTIndex); + /* misc.c */ BOOLEAN

6 years, 9 months

[reactos] 25/72: [NTFS] +NtfsDumpFileRecord() - Provides diagnostic information about a file record.

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=7643831d569d693c73858… commit 7643831d569d693c73858bfdd0f9d63cc6d1b6af Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Mon Aug 22 11:08:22 2016 +0000 [NTFS] +NtfsDumpFileRecord() - Provides diagnostic information about a file record. svn path=/branches/GSoC_2016/NTFS/; revision=72424 --- drivers/filesystems/ntfs/mft.c | 40 ++++++++++++++++++++++++++++++++++++++++ drivers/filesystems/ntfs/ntfs.h | 4 ++++ 2 files changed, 44 insertions(+) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index 4b0ded49f3..30ef5f0e3e 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -1460,6 +1460,46 @@ NtfsLookupFile(PDEVICE_EXTENSION Vcb, return NtfsLookupFileAt(Vcb, PathName, FileRecord, MFTIndex, NTFS_FILE_ROOT); } +/** +* @name NtfsDumpFileRecord +* @implemented +* +* Provides diagnostic information about a file record. Prints a hex dump +* of the entire record (based on the size reported by FileRecord->ByesInUse), +* then prints a dump of each attribute. +* +* @param Vcb +* Pointer to a DEVICE_EXTENSION describing the volume. +* +* @param FileRecord +* Pointer to the file record to be analyzed. +* +* @remarks +* FileRecord must be a complete file record at least FileRecord->BytesAllocated +* in size, and not just the header. +* +*/ +VOID +NtfsDumpFileRecord(PDEVICE_EXTENSION Vcb, + PFILE_RECORD_HEADER FileRecord) +{ + ULONG i, j; + + // dump binary data, 8 bytes at a time + for (i = 0; i < FileRecord->BytesInUse; i += 8) + { + // display current offset, in hex + DbgPrint("\t%03x\t", i); + + // display hex value of each of the next 8 bytes + for (j = 0; j < 8; j++) + DbgPrint("%02x ", *(PUCHAR)((ULONG_PTR)FileRecord + i + j)); + DbgPrint("\n"); + } + + NtfsDumpFileAttributes(Vcb, FileRecord); +} + NTSTATUS NtfsFindFileAt(PDEVICE_EXTENSION Vcb, PUNICODE_STRING SearchPattern, diff --git a/drivers/filesystems/ntfs/ntfs.h b/drivers/filesystems/ntfs/ntfs.h index 29a6c2af00..ce8a7df2de 100644 --- a/drivers/filesystems/ntfs/ntfs.h +++ b/drivers/filesystems/ntfs/ntfs.h @@ -907,6 +907,10 @@ NtfsLookupFileAt(PDEVICE_EXTENSION Vcb, PULONGLONG MFTIndex, ULONGLONG CurrentMFTIndex); +VOID +NtfsDumpFileRecord(PDEVICE_EXTENSION Vcb, + PFILE_RECORD_HEADER FileRecord); + NTSTATUS NtfsFindFileAt(PDEVICE_EXTENSION Vcb, PUNICODE_STRING SearchPattern,

6 years, 9 months

[reactos] 24/72: [NTFS] *UpdateFileRecord() - Fix a DPRINT

by Trevor Thompson

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6ab3072098ec3a2829247… commit 6ab3072098ec3a28292471ac6ec6a7310dff04a5 Author: Trevor Thompson <tmt256(a)email.vccs.edu> AuthorDate: Mon Aug 22 08:27:35 2016 +0000 [NTFS] *UpdateFileRecord() - Fix a DPRINT svn path=/branches/GSoC_2016/NTFS/; revision=72423 --- drivers/filesystems/ntfs/mft.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/filesystems/ntfs/mft.c b/drivers/filesystems/ntfs/mft.c index f3ac3182dc..4b0ded49f3 100644 --- a/drivers/filesystems/ntfs/mft.c +++ b/drivers/filesystems/ntfs/mft.c @@ -1092,7 +1092,7 @@ UpdateFileRecord(PDEVICE_EXTENSION Vcb, if (!NT_SUCCESS(Status)) { - DPRINT1("UpdateFileRecord failed: %I64u written, %lu expected\n", BytesWritten, Vcb->NtfsInfo.BytesPerFileRecord); + DPRINT1("UpdateFileRecord failed: %lu written, %lu expected\n", BytesWritten, Vcb->NtfsInfo.BytesPerFileRecord); } // remove the fixup array (so the file record pointer can still be used)

6 years, 9 months

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