[NTFS] Add support for creating new MFT entries:
[reactos.git] / drivers / filesystems / ntfs / create.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2002, 2014 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
18 *
19 * COPYRIGHT: See COPYING in the top level directory
20 * PROJECT: ReactOS kernel
21 * FILE: drivers/filesystem/ntfs/create.c
22 * PURPOSE: NTFS filesystem driver
23 * PROGRAMMERS: Eric Kohl
24 * Pierre Schweitzer (pierre@reactos.org)
25 */
26
27 /* INCLUDES *****************************************************************/
28
29 #include "ntfs.h"
30
31 #define NDEBUG
32 #include <debug.h>
33
34 static PCWSTR MftIdToName[] = {
35 L"$MFT",
36 L"$MFTMirr",
37 L"$LogFile",
38 L"$Volume",
39 L"AttrDef",
40 L".",
41 L"$Bitmap",
42 L"$Boot",
43 L"$BadClus",
44 L"$Quota",
45 L"$UpCase",
46 L"$Extended",
47 };
48
49 /* FUNCTIONS ****************************************************************/
50
51 static
52 NTSTATUS
53 NtfsMakeAbsoluteFilename(PFILE_OBJECT pFileObject,
54 PWSTR pRelativeFileName,
55 PWSTR *pAbsoluteFilename)
56 {
57 PWSTR rcName;
58 PNTFS_FCB Fcb;
59
60 DPRINT("try related for %S\n", pRelativeFileName);
61 Fcb = pFileObject->FsContext;
62 ASSERT(Fcb);
63
64 if (Fcb->Flags & FCB_IS_VOLUME)
65 {
66 /* This is likely to be an opening by ID, return ourselves */
67 if (pRelativeFileName[0] == L'\\')
68 {
69 *pAbsoluteFilename = NULL;
70 return STATUS_SUCCESS;
71 }
72
73 return STATUS_INVALID_PARAMETER;
74 }
75
76 /* verify related object is a directory and target name
77 don't start with \. */
78 if (NtfsFCBIsDirectory(Fcb) == FALSE ||
79 pRelativeFileName[0] == L'\\')
80 {
81 return STATUS_INVALID_PARAMETER;
82 }
83
84 /* construct absolute path name */
85 ASSERT(wcslen (Fcb->PathName) + 1 + wcslen (pRelativeFileName) + 1 <= MAX_PATH);
86 rcName = ExAllocatePoolWithTag(NonPagedPool, MAX_PATH * sizeof(WCHAR), TAG_NTFS);
87 if (!rcName)
88 {
89 return STATUS_INSUFFICIENT_RESOURCES;
90 }
91
92 wcscpy(rcName, Fcb->PathName);
93 if (!NtfsFCBIsRoot(Fcb))
94 wcscat (rcName, L"\\");
95 wcscat (rcName, pRelativeFileName);
96 *pAbsoluteFilename = rcName;
97
98 return STATUS_SUCCESS;
99 }
100
101
102 static
103 NTSTATUS
104 NtfsMoonWalkID(PDEVICE_EXTENSION DeviceExt,
105 ULONGLONG Id,
106 PUNICODE_STRING OutPath)
107 {
108 NTSTATUS Status;
109 PFILE_RECORD_HEADER MftRecord;
110 PFILENAME_ATTRIBUTE FileName;
111 WCHAR FullPath[MAX_PATH];
112 ULONG WritePosition = MAX_PATH - 1;
113
114 DPRINT1("NtfsMoonWalkID(%p, %I64x, %p)\n", DeviceExt, Id, OutPath);
115
116 RtlZeroMemory(FullPath, sizeof(FullPath));
117 MftRecord = ExAllocatePoolWithTag(NonPagedPool,
118 DeviceExt->NtfsInfo.BytesPerFileRecord,
119 TAG_NTFS);
120 if (MftRecord == NULL)
121 {
122 return STATUS_INSUFFICIENT_RESOURCES;
123 }
124
125 while (TRUE)
126 {
127 Status = ReadFileRecord(DeviceExt, Id, MftRecord);
128 if (!NT_SUCCESS(Status))
129 break;
130
131 ASSERT(MftRecord->Ntfs.Type == NRH_FILE_TYPE);
132 if (!(MftRecord->Flags & FRH_IN_USE))
133 {
134 Status = STATUS_OBJECT_PATH_NOT_FOUND;
135 break;
136 }
137
138 FileName = GetBestFileNameFromRecord(DeviceExt, MftRecord);
139 if (FileName == NULL)
140 {
141 DPRINT1("$FILE_NAME attribute not found for %I64x\n", Id);
142 Status = STATUS_OBJECT_PATH_NOT_FOUND;
143 break;
144 }
145
146 WritePosition -= FileName->NameLength;
147 ASSERT(WritePosition < MAX_PATH);
148 RtlCopyMemory(FullPath + WritePosition, FileName->Name, FileName->NameLength * sizeof(WCHAR));
149 WritePosition -= 1;
150 ASSERT(WritePosition < MAX_PATH);
151 FullPath[WritePosition] = L'\\';
152
153 Id = FileName->DirectoryFileReferenceNumber & NTFS_MFT_MASK;
154 if (Id == NTFS_FILE_ROOT)
155 break;
156 }
157
158 ExFreePoolWithTag(MftRecord, TAG_NTFS);
159
160 if (!NT_SUCCESS(Status))
161 return Status;
162
163 OutPath->Length = (MAX_PATH - WritePosition - 1) * sizeof(WCHAR);
164 OutPath->MaximumLength = (MAX_PATH - WritePosition) * sizeof(WCHAR);
165 OutPath->Buffer = ExAllocatePoolWithTag(NonPagedPool, OutPath->MaximumLength, TAG_NTFS);
166 if (OutPath->Buffer == NULL)
167 {
168 return STATUS_INSUFFICIENT_RESOURCES;
169 }
170 RtlCopyMemory(OutPath->Buffer, FullPath + WritePosition, OutPath->MaximumLength);
171
172 return Status;
173 }
174
175 static
176 NTSTATUS
177 NtfsOpenFileById(PDEVICE_EXTENSION DeviceExt,
178 PFILE_OBJECT FileObject,
179 ULONGLONG MftId,
180 PNTFS_FCB * FoundFCB)
181 {
182 NTSTATUS Status;
183 PNTFS_FCB FCB;
184 PFILE_RECORD_HEADER MftRecord;
185
186 DPRINT1("NtfsOpenFileById(%p, %p, %I64x, %p)\n", DeviceExt, FileObject, MftId, FoundFCB);
187
188 ASSERT(MftId < 0x10);
189 if (MftId > 0xb) /* No entries are used yet beyond this */
190 {
191 return STATUS_OBJECT_NAME_NOT_FOUND;
192 }
193
194 MftRecord = ExAllocatePoolWithTag(NonPagedPool,
195 DeviceExt->NtfsInfo.BytesPerFileRecord,
196 TAG_NTFS);
197 if (MftRecord == NULL)
198 {
199 return STATUS_INSUFFICIENT_RESOURCES;
200 }
201
202 Status = ReadFileRecord(DeviceExt, MftId, MftRecord);
203 if (!NT_SUCCESS(Status))
204 {
205 ExFreePoolWithTag(MftRecord, TAG_NTFS);
206 return Status;
207 }
208
209 if (!(MftRecord->Flags & FRH_IN_USE))
210 {
211 ExFreePoolWithTag(MftRecord, TAG_NTFS);
212 return STATUS_OBJECT_PATH_NOT_FOUND;
213 }
214
215 FCB = NtfsGrabFCBFromTable(DeviceExt, MftIdToName[MftId]);
216 if (FCB == NULL)
217 {
218 UNICODE_STRING Name;
219
220 RtlInitUnicodeString(&Name, MftIdToName[MftId]);
221 Status = NtfsMakeFCBFromDirEntry(DeviceExt, NULL, &Name, NULL, MftRecord, MftId, &FCB);
222 if (!NT_SUCCESS(Status))
223 {
224 ExFreePoolWithTag(MftRecord, TAG_NTFS);
225 return Status;
226 }
227 }
228
229 ASSERT(FCB != NULL);
230
231 ExFreePoolWithTag(MftRecord, TAG_NTFS);
232
233 Status = NtfsAttachFCBToFileObject(DeviceExt,
234 FCB,
235 FileObject);
236 *FoundFCB = FCB;
237
238 return Status;
239 }
240
241 /*
242 * FUNCTION: Opens a file
243 */
244 static
245 NTSTATUS
246 NtfsOpenFile(PDEVICE_EXTENSION DeviceExt,
247 PFILE_OBJECT FileObject,
248 PWSTR FileName,
249 PNTFS_FCB * FoundFCB)
250 {
251 PNTFS_FCB ParentFcb;
252 PNTFS_FCB Fcb;
253 NTSTATUS Status;
254 PWSTR AbsFileName = NULL;
255
256 DPRINT1("NtfsOpenFile(%p, %p, %S, %p)\n", DeviceExt, FileObject, FileName, FoundFCB);
257
258 *FoundFCB = NULL;
259
260 if (FileObject->RelatedFileObject)
261 {
262 DPRINT("Converting relative filename to absolute filename\n");
263
264 Status = NtfsMakeAbsoluteFilename(FileObject->RelatedFileObject,
265 FileName,
266 &AbsFileName);
267 if (AbsFileName) FileName = AbsFileName;
268 if (!NT_SUCCESS(Status))
269 {
270 return Status;
271 }
272 }
273
274 //FIXME: Get canonical path name (remove .'s, ..'s and extra separators)
275
276 DPRINT("PathName to open: %S\n", FileName);
277
278 /* try first to find an existing FCB in memory */
279 DPRINT("Checking for existing FCB in memory\n");
280 Fcb = NtfsGrabFCBFromTable(DeviceExt,
281 FileName);
282 if (Fcb == NULL)
283 {
284 DPRINT("No existing FCB found, making a new one if file exists.\n");
285 Status = NtfsGetFCBForFile(DeviceExt,
286 &ParentFcb,
287 &Fcb,
288 FileName);
289 if (ParentFcb != NULL)
290 {
291 NtfsReleaseFCB(DeviceExt,
292 ParentFcb);
293 }
294
295 if (!NT_SUCCESS (Status))
296 {
297 DPRINT("Could not make a new FCB, status: %x\n", Status);
298
299 if (AbsFileName)
300 ExFreePool(AbsFileName);
301
302 return Status;
303 }
304 }
305
306 DPRINT("Attaching FCB to fileObject\n");
307 Status = NtfsAttachFCBToFileObject(DeviceExt,
308 Fcb,
309 FileObject);
310
311 if (AbsFileName)
312 ExFreePool(AbsFileName);
313
314 *FoundFCB = Fcb;
315
316 return Status;
317 }
318
319
320 /*
321 * FUNCTION: Opens a file
322 */
323 static
324 NTSTATUS
325 NtfsCreateFile(PDEVICE_OBJECT DeviceObject,
326 PIRP Irp)
327 {
328 PDEVICE_EXTENSION DeviceExt;
329 PIO_STACK_LOCATION Stack;
330 PFILE_OBJECT FileObject;
331 ULONG RequestedDisposition;
332 ULONG RequestedOptions;
333 PNTFS_FCB Fcb = NULL;
334 // PWSTR FileName;
335 NTSTATUS Status;
336 UNICODE_STRING FullPath;
337
338 DPRINT1("NtfsCreateFile(%p, %p) called\n", DeviceObject, Irp);
339
340 DeviceExt = DeviceObject->DeviceExtension;
341 ASSERT(DeviceExt);
342 Stack = IoGetCurrentIrpStackLocation (Irp);
343 ASSERT(Stack);
344
345 RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
346 RequestedOptions = Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
347 // PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
348 if (RequestedOptions & FILE_DIRECTORY_FILE &&
349 RequestedDisposition == FILE_SUPERSEDE)
350 {
351 return STATUS_INVALID_PARAMETER;
352 }
353
354 /* Deny create if the volume is locked */
355 if (DeviceExt->Flags & VCB_VOLUME_LOCKED)
356 {
357 return STATUS_ACCESS_DENIED;
358 }
359
360 FileObject = Stack->FileObject;
361
362 if ((RequestedOptions & FILE_OPEN_BY_FILE_ID) == FILE_OPEN_BY_FILE_ID)
363 {
364 ULONGLONG MFTId;
365
366 if (FileObject->FileName.Length != sizeof(ULONGLONG))
367 return STATUS_INVALID_PARAMETER;
368
369 MFTId = (*(PULONGLONG)FileObject->FileName.Buffer) & NTFS_MFT_MASK;
370 if (MFTId < 0x10)
371 {
372 Status = NtfsOpenFileById(DeviceExt, FileObject, MFTId, &Fcb);
373 }
374 else
375 {
376 Status = NtfsMoonWalkID(DeviceExt, MFTId, &FullPath);
377 }
378
379 if (!NT_SUCCESS(Status))
380 {
381 return Status;
382 }
383
384 DPRINT1("Open by ID: %I64x -> %wZ\n", (*(PULONGLONG)FileObject->FileName.Buffer) & NTFS_MFT_MASK, &FullPath);
385 }
386
387 /* This a open operation for the volume itself */
388 if (FileObject->FileName.Length == 0 &&
389 (FileObject->RelatedFileObject == NULL || FileObject->RelatedFileObject->FsContext2 != NULL))
390 {
391 if (RequestedDisposition != FILE_OPEN &&
392 RequestedDisposition != FILE_OPEN_IF)
393 {
394 return STATUS_ACCESS_DENIED;
395 }
396
397 if (RequestedOptions & FILE_DIRECTORY_FILE)
398 {
399 return STATUS_NOT_A_DIRECTORY;
400 }
401
402 NtfsAttachFCBToFileObject(DeviceExt, DeviceExt->VolumeFcb, FileObject);
403 DeviceExt->VolumeFcb->RefCount++;
404
405 Irp->IoStatus.Information = FILE_OPENED;
406 return STATUS_SUCCESS;
407 }
408
409 if (Fcb == NULL)
410 {
411 Status = NtfsOpenFile(DeviceExt,
412 FileObject,
413 ((RequestedOptions & FILE_OPEN_BY_FILE_ID) ? FullPath.Buffer : FileObject->FileName.Buffer),
414 &Fcb);
415
416 if (RequestedOptions & FILE_OPEN_BY_FILE_ID)
417 {
418 ExFreePoolWithTag(FullPath.Buffer, TAG_NTFS);
419 }
420 }
421
422 if (NT_SUCCESS(Status))
423 {
424 if (RequestedDisposition == FILE_CREATE)
425 {
426 Irp->IoStatus.Information = FILE_EXISTS;
427 NtfsCloseFile(DeviceExt, FileObject);
428 return STATUS_OBJECT_NAME_COLLISION;
429 }
430
431 if (RequestedOptions & FILE_NON_DIRECTORY_FILE &&
432 NtfsFCBIsDirectory(Fcb))
433 {
434 NtfsCloseFile(DeviceExt, FileObject);
435 return STATUS_FILE_IS_A_DIRECTORY;
436 }
437
438 if (RequestedOptions & FILE_DIRECTORY_FILE &&
439 !NtfsFCBIsDirectory(Fcb))
440 {
441 NtfsCloseFile(DeviceExt, FileObject);
442 return STATUS_NOT_A_DIRECTORY;
443 }
444
445 /*
446 * If it is a reparse point & FILE_OPEN_REPARSE_POINT, then allow opening it
447 * as a normal file.
448 * Otherwise, attempt to read reparse data and hand them to the Io manager
449 * with status reparse to force a reparse.
450 */
451 if (NtfsFCBIsReparsePoint(Fcb) &&
452 ((RequestedOptions & FILE_OPEN_REPARSE_POINT) != FILE_OPEN_REPARSE_POINT))
453 {
454 PREPARSE_DATA_BUFFER ReparseData = NULL;
455
456 Status = NtfsReadFCBAttribute(DeviceExt, Fcb,
457 AttributeReparsePoint, L"", 0,
458 (PVOID *)&Irp->Tail.Overlay.AuxiliaryBuffer);
459 if (NT_SUCCESS(Status))
460 {
461 ReparseData = (PREPARSE_DATA_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
462 if (ReparseData->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
463 {
464 Status = STATUS_REPARSE;
465 }
466 else
467 {
468 Status = STATUS_NOT_IMPLEMENTED;
469 ExFreePoolWithTag(ReparseData, TAG_NTFS);
470 }
471 }
472
473 Irp->IoStatus.Information = ((Status == STATUS_REPARSE) ? ReparseData->ReparseTag : 0);
474
475 NtfsCloseFile(DeviceExt, FileObject);
476 return Status;
477 }
478
479 if (RequestedDisposition == FILE_OVERWRITE ||
480 RequestedDisposition == FILE_OVERWRITE_IF ||
481 RequestedDisposition == FILE_SUPERSEDE)
482 {
483 PFILE_RECORD_HEADER fileRecord = NULL;
484 PNTFS_ATTR_CONTEXT dataContext = NULL;
485 ULONG DataAttributeOffset;
486 LARGE_INTEGER Zero;
487 Zero.QuadPart = 0;
488
489 // TODO: check for appropriate access
490
491 ExAcquireResourceExclusiveLite(&(Fcb->MainResource), TRUE);
492
493 fileRecord = ExAllocatePoolWithTag(NonPagedPool,
494 Fcb->Vcb->NtfsInfo.BytesPerFileRecord,
495 TAG_NTFS);
496 if (fileRecord)
497 {
498
499 Status = ReadFileRecord(Fcb->Vcb,
500 Fcb->MFTIndex,
501 fileRecord);
502 if (!NT_SUCCESS(Status))
503 goto DoneOverwriting;
504
505 // find the data attribute and set it's length to 0 (TODO: Handle Alternate Data Streams)
506 Status = FindAttribute(Fcb->Vcb, fileRecord, AttributeData, L"", 0, &dataContext, &DataAttributeOffset);
507 if (!NT_SUCCESS(Status))
508 goto DoneOverwriting;
509
510 Status = SetAttributeDataLength(FileObject, Fcb, dataContext, DataAttributeOffset, fileRecord, &Zero);
511 }
512 else
513 {
514 Status = STATUS_NO_MEMORY;
515 }
516
517 DoneOverwriting:
518 if (fileRecord)
519 ExFreePool(fileRecord);
520 if (dataContext)
521 ReleaseAttributeContext(dataContext);
522
523 ExReleaseResourceLite(&(Fcb->MainResource));
524
525 if (!NT_SUCCESS(Status))
526 {
527 NtfsCloseFile(DeviceExt, FileObject);
528 return Status;
529 }
530
531 if (RequestedDisposition == FILE_SUPERSEDE)
532 {
533 Irp->IoStatus.Information = FILE_SUPERSEDED;
534 }
535 else
536 {
537 Irp->IoStatus.Information = FILE_OVERWRITTEN;
538 }
539 }
540 }
541 else
542 {
543 /* HUGLY HACK: Can't create new files yet... */
544 if (RequestedDisposition == FILE_CREATE ||
545 RequestedDisposition == FILE_OPEN_IF ||
546 RequestedDisposition == FILE_OVERWRITE_IF ||
547 RequestedDisposition == FILE_SUPERSEDE)
548 {
549 // Create the file record on disk
550 Status = NtfsCreateFileRecord(DeviceExt, FileObject);
551
552 // Update the parent directory index
553 // Still TODO
554
555 // Call NtfsOpenFile()
556
557 return STATUS_CANNOT_MAKE;
558 }
559 }
560
561 if (NT_SUCCESS(Status))
562 {
563 Fcb->OpenHandleCount++;
564 DeviceExt->OpenHandleCount++;
565 }
566
567 /*
568 * If the directory containing the file to open doesn't exist then
569 * fail immediately
570 */
571 Irp->IoStatus.Information = (NT_SUCCESS(Status)) ? FILE_OPENED : 0;
572
573 return Status;
574 }
575
576
577 NTSTATUS
578 NtfsCreate(PNTFS_IRP_CONTEXT IrpContext)
579 {
580 PDEVICE_EXTENSION DeviceExt;
581 NTSTATUS Status;
582 PDEVICE_OBJECT DeviceObject;
583
584 DeviceObject = IrpContext->DeviceObject;
585 if (DeviceObject == NtfsGlobalData->DeviceObject)
586 {
587 /* DeviceObject represents FileSystem instead of logical volume */
588 DPRINT("Opening file system\n");
589 IrpContext->Irp->IoStatus.Information = FILE_OPENED;
590 return STATUS_SUCCESS;
591 }
592
593 DeviceExt = DeviceObject->DeviceExtension;
594
595 if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
596 {
597 return NtfsMarkIrpContextForQueue(IrpContext);
598 }
599
600 ExAcquireResourceExclusiveLite(&DeviceExt->DirResource,
601 TRUE);
602 Status = NtfsCreateFile(DeviceObject,
603 IrpContext->Irp);
604 ExReleaseResourceLite(&DeviceExt->DirResource);
605
606 return Status;
607 }
608
609 /**
610 * @name NtfsCreateFileRecord()
611 * @implemented
612 *
613 * Creates a file record and saves it to the MFT.
614 *
615 * @param DeviceExt
616 * Points to the target disk's DEVICE_EXTENSION
617 *
618 * @param FileObject
619 * Pointer to a FILE_OBJECT describing the file to be created
620 *
621 * @return
622 * STATUS_SUCCESS on success.
623 * STATUS_INSUFFICIENT_RESOURCES if unable to allocate memory for the file record.
624 */
625 NTSTATUS
626 NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt,
627 PFILE_OBJECT FileObject)
628 {
629 NTSTATUS Status = STATUS_SUCCESS;
630 PFILE_RECORD_HEADER FileRecord;
631 PNTFS_ATTR_RECORD NextAttribute;
632
633 // allocate memory for file record
634 FileRecord = ExAllocatePoolWithTag(NonPagedPool,
635 DeviceExt->NtfsInfo.BytesPerFileRecord,
636 TAG_NTFS);
637 if (!FileRecord)
638 {
639 DPRINT1("ERROR: Unable to allocate memory for file record!\n");
640 return STATUS_INSUFFICIENT_RESOURCES;
641 }
642
643 RtlZeroMemory(FileRecord, DeviceExt->NtfsInfo.BytesPerFileRecord);
644
645 FileRecord->Ntfs.Type = NRH_FILE_TYPE;
646
647 // calculate USA offset and count
648 FileRecord->Ntfs.UsaOffset = FIELD_OFFSET(FILE_RECORD_HEADER, MFTRecordNumber) + sizeof(ULONG);
649
650 // size of USA (in ULONG's) will be 1 (for USA number) + 1 for every sector the file record uses
651 FileRecord->BytesAllocated = DeviceExt->NtfsInfo.BytesPerFileRecord;
652 FileRecord->Ntfs.UsaCount = (FileRecord->BytesAllocated / DeviceExt->NtfsInfo.BytesPerSector) + 1;
653
654 // setup other file record fields
655 FileRecord->SequenceNumber = 1;
656 FileRecord->AttributeOffset = FileRecord->Ntfs.UsaOffset + (2 * FileRecord->Ntfs.UsaCount);
657 FileRecord->AttributeOffset = ALIGN_UP_BY(FileRecord->AttributeOffset, 8);
658 FileRecord->Flags = FRH_IN_USE;
659 FileRecord->BytesInUse = FileRecord->AttributeOffset + sizeof(ULONG) * 2;
660
661 // find where the first attribute will be added
662 NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + FileRecord->AttributeOffset);
663
664 // mark the (temporary) end of the file-record
665 NextAttribute->Type = AttributeEnd;
666 NextAttribute->Length = FILE_RECORD_END;
667
668 // add first attribute, $STANDARD_INFORMATION
669 AddStandardInformation(FileRecord, NextAttribute);
670
671 // advance NextAttribute pointer to the next attribute
672 NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length);
673
674 // Add the $FILE_NAME attribute
675 AddFileName(FileRecord, NextAttribute, DeviceExt, FileObject);
676
677 // advance NextAttribute pointer to the next attribute
678 NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length);
679
680 // add the $DATA attribute
681 AddData(FileRecord, NextAttribute);
682
683 // dump file record in memory (for debugging)
684 NtfsDumpFileRecord(DeviceExt, FileRecord);
685
686 // Now that we've built the file record in memory, we need to store it in the MFT.
687 Status = AddNewMftEntry(FileRecord, DeviceExt);
688
689 ExFreePoolWithTag(FileRecord, TAG_NTFS);
690
691 return Status;
692 }
693
694 /* EOF */