[NTFS] - Add a few fixes and improvements, most from CR-123:
[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 BOOLEAN CaseSensitive,
250 PNTFS_FCB * FoundFCB)
251 {
252 PNTFS_FCB ParentFcb;
253 PNTFS_FCB Fcb;
254 NTSTATUS Status;
255 PWSTR AbsFileName = NULL;
256
257 DPRINT1("NtfsOpenFile(%p, %p, %S, %s, %p)\n",
258 DeviceExt,
259 FileObject,
260 FileName,
261 CaseSensitive ? "TRUE" : "FALSE",
262 FoundFCB);
263
264 *FoundFCB = NULL;
265
266 if (FileObject->RelatedFileObject)
267 {
268 DPRINT("Converting relative filename to absolute filename\n");
269
270 Status = NtfsMakeAbsoluteFilename(FileObject->RelatedFileObject,
271 FileName,
272 &AbsFileName);
273 if (AbsFileName) FileName = AbsFileName;
274 if (!NT_SUCCESS(Status))
275 {
276 return Status;
277 }
278 }
279
280 //FIXME: Get canonical path name (remove .'s, ..'s and extra separators)
281
282 DPRINT("PathName to open: %S\n", FileName);
283
284 /* try first to find an existing FCB in memory */
285 DPRINT("Checking for existing FCB in memory\n");
286 Fcb = NtfsGrabFCBFromTable(DeviceExt,
287 FileName);
288 if (Fcb == NULL)
289 {
290 DPRINT("No existing FCB found, making a new one if file exists.\n");
291 Status = NtfsGetFCBForFile(DeviceExt,
292 &ParentFcb,
293 &Fcb,
294 FileName,
295 CaseSensitive);
296 if (ParentFcb != NULL)
297 {
298 NtfsReleaseFCB(DeviceExt,
299 ParentFcb);
300 }
301
302 if (!NT_SUCCESS (Status))
303 {
304 DPRINT("Could not make a new FCB, status: %x\n", Status);
305
306 if (AbsFileName)
307 ExFreePoolWithTag(AbsFileName, TAG_NTFS);
308
309 return Status;
310 }
311 }
312
313 DPRINT("Attaching FCB to fileObject\n");
314 Status = NtfsAttachFCBToFileObject(DeviceExt,
315 Fcb,
316 FileObject);
317
318 if (AbsFileName)
319 ExFreePool(AbsFileName);
320
321 *FoundFCB = Fcb;
322
323 return Status;
324 }
325
326
327 /*
328 * FUNCTION: Opens a file
329 */
330 static
331 NTSTATUS
332 NtfsCreateFile(PDEVICE_OBJECT DeviceObject,
333 PNTFS_IRP_CONTEXT IrpContext)
334 {
335 PDEVICE_EXTENSION DeviceExt;
336 PIO_STACK_LOCATION Stack;
337 PFILE_OBJECT FileObject;
338 ULONG RequestedDisposition;
339 ULONG RequestedOptions;
340 PNTFS_FCB Fcb = NULL;
341 // PWSTR FileName;
342 NTSTATUS Status;
343 UNICODE_STRING FullPath;
344 PIRP Irp = IrpContext->Irp;
345
346 DPRINT1("NtfsCreateFile(%p, %p) called\n", DeviceObject, IrpContext);
347
348 DeviceExt = DeviceObject->DeviceExtension;
349 ASSERT(DeviceExt);
350 Stack = IoGetCurrentIrpStackLocation (Irp);
351 ASSERT(Stack);
352
353 RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
354 RequestedOptions = Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
355 // PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
356 if (RequestedOptions & FILE_DIRECTORY_FILE &&
357 RequestedDisposition == FILE_SUPERSEDE)
358 {
359 return STATUS_INVALID_PARAMETER;
360 }
361
362 /* Deny create if the volume is locked */
363 if (DeviceExt->Flags & VCB_VOLUME_LOCKED)
364 {
365 return STATUS_ACCESS_DENIED;
366 }
367
368 FileObject = Stack->FileObject;
369
370 if ((RequestedOptions & FILE_OPEN_BY_FILE_ID) == FILE_OPEN_BY_FILE_ID)
371 {
372 ULONGLONG MFTId;
373
374 if (FileObject->FileName.Length != sizeof(ULONGLONG))
375 return STATUS_INVALID_PARAMETER;
376
377 MFTId = (*(PULONGLONG)FileObject->FileName.Buffer) & NTFS_MFT_MASK;
378 if (MFTId < 0x10)
379 {
380 Status = NtfsOpenFileById(DeviceExt, FileObject, MFTId, &Fcb);
381 }
382 else
383 {
384 Status = NtfsMoonWalkID(DeviceExt, MFTId, &FullPath);
385 }
386
387 if (!NT_SUCCESS(Status))
388 {
389 return Status;
390 }
391
392 DPRINT1("Open by ID: %I64x -> %wZ\n", (*(PULONGLONG)FileObject->FileName.Buffer) & NTFS_MFT_MASK, &FullPath);
393 }
394
395 /* This a open operation for the volume itself */
396 if (FileObject->FileName.Length == 0 &&
397 (FileObject->RelatedFileObject == NULL || FileObject->RelatedFileObject->FsContext2 != NULL))
398 {
399 if (RequestedDisposition != FILE_OPEN &&
400 RequestedDisposition != FILE_OPEN_IF)
401 {
402 return STATUS_ACCESS_DENIED;
403 }
404
405 if (RequestedOptions & FILE_DIRECTORY_FILE)
406 {
407 return STATUS_NOT_A_DIRECTORY;
408 }
409
410 NtfsAttachFCBToFileObject(DeviceExt, DeviceExt->VolumeFcb, FileObject);
411 DeviceExt->VolumeFcb->RefCount++;
412
413 Irp->IoStatus.Information = FILE_OPENED;
414 return STATUS_SUCCESS;
415 }
416
417 if (Fcb == NULL)
418 {
419 Status = NtfsOpenFile(DeviceExt,
420 FileObject,
421 ((RequestedOptions & FILE_OPEN_BY_FILE_ID) ? FullPath.Buffer : FileObject->FileName.Buffer),
422 BooleanFlagOn(Stack->Flags, SL_CASE_SENSITIVE),
423 &Fcb);
424
425 if (RequestedOptions & FILE_OPEN_BY_FILE_ID)
426 {
427 ExFreePoolWithTag(FullPath.Buffer, TAG_NTFS);
428 }
429 }
430
431 if (NT_SUCCESS(Status))
432 {
433 if (RequestedDisposition == FILE_CREATE)
434 {
435 Irp->IoStatus.Information = FILE_EXISTS;
436 NtfsCloseFile(DeviceExt, FileObject);
437 return STATUS_OBJECT_NAME_COLLISION;
438 }
439
440 if (RequestedOptions & FILE_NON_DIRECTORY_FILE &&
441 NtfsFCBIsDirectory(Fcb))
442 {
443 NtfsCloseFile(DeviceExt, FileObject);
444 return STATUS_FILE_IS_A_DIRECTORY;
445 }
446
447 if (RequestedOptions & FILE_DIRECTORY_FILE &&
448 !NtfsFCBIsDirectory(Fcb))
449 {
450 NtfsCloseFile(DeviceExt, FileObject);
451 return STATUS_NOT_A_DIRECTORY;
452 }
453
454 /*
455 * If it is a reparse point & FILE_OPEN_REPARSE_POINT, then allow opening it
456 * as a normal file.
457 * Otherwise, attempt to read reparse data and hand them to the Io manager
458 * with status reparse to force a reparse.
459 */
460 if (NtfsFCBIsReparsePoint(Fcb) &&
461 ((RequestedOptions & FILE_OPEN_REPARSE_POINT) != FILE_OPEN_REPARSE_POINT))
462 {
463 PREPARSE_DATA_BUFFER ReparseData = NULL;
464
465 Status = NtfsReadFCBAttribute(DeviceExt, Fcb,
466 AttributeReparsePoint, L"", 0,
467 (PVOID *)&Irp->Tail.Overlay.AuxiliaryBuffer);
468 if (NT_SUCCESS(Status))
469 {
470 ReparseData = (PREPARSE_DATA_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
471 if (ReparseData->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
472 {
473 Status = STATUS_REPARSE;
474 }
475 else
476 {
477 Status = STATUS_NOT_IMPLEMENTED;
478 ExFreePoolWithTag(ReparseData, TAG_NTFS);
479 }
480 }
481
482 Irp->IoStatus.Information = ((Status == STATUS_REPARSE) ? ReparseData->ReparseTag : 0);
483
484 NtfsCloseFile(DeviceExt, FileObject);
485 return Status;
486 }
487
488 if (RequestedDisposition == FILE_OVERWRITE ||
489 RequestedDisposition == FILE_OVERWRITE_IF ||
490 RequestedDisposition == FILE_SUPERSEDE)
491 {
492 PFILE_RECORD_HEADER fileRecord = NULL;
493 PNTFS_ATTR_CONTEXT dataContext = NULL;
494 ULONG DataAttributeOffset;
495 LARGE_INTEGER Zero;
496 Zero.QuadPart = 0;
497
498 if (!NtfsGlobalData->EnableWriteSupport)
499 {
500 DPRINT1("NTFS write-support is EXPERIMENTAL and is disabled by default!\n");
501 NtfsCloseFile(DeviceExt, FileObject);
502 return STATUS_ACCESS_DENIED;
503 }
504
505 // TODO: check for appropriate access
506
507 ExAcquireResourceExclusiveLite(&(Fcb->MainResource), TRUE);
508
509 fileRecord = ExAllocatePoolWithTag(NonPagedPool,
510 Fcb->Vcb->NtfsInfo.BytesPerFileRecord,
511 TAG_NTFS);
512 if (fileRecord)
513 {
514
515 Status = ReadFileRecord(Fcb->Vcb,
516 Fcb->MFTIndex,
517 fileRecord);
518 if (!NT_SUCCESS(Status))
519 goto DoneOverwriting;
520
521 // find the data attribute and set it's length to 0 (TODO: Handle Alternate Data Streams)
522 Status = FindAttribute(Fcb->Vcb, fileRecord, AttributeData, L"", 0, &dataContext, &DataAttributeOffset);
523 if (!NT_SUCCESS(Status))
524 goto DoneOverwriting;
525
526 Status = SetAttributeDataLength(FileObject, Fcb, dataContext, DataAttributeOffset, fileRecord, &Zero);
527 }
528 else
529 {
530 Status = STATUS_NO_MEMORY;
531 }
532
533 DoneOverwriting:
534 if (fileRecord)
535 ExFreePoolWithTag(fileRecord, TAG_NTFS);
536 if (dataContext)
537 ReleaseAttributeContext(dataContext);
538
539 ExReleaseResourceLite(&(Fcb->MainResource));
540
541 if (!NT_SUCCESS(Status))
542 {
543 NtfsCloseFile(DeviceExt, FileObject);
544 return Status;
545 }
546
547 if (RequestedDisposition == FILE_SUPERSEDE)
548 {
549 Irp->IoStatus.Information = FILE_SUPERSEDED;
550 }
551 else
552 {
553 Irp->IoStatus.Information = FILE_OVERWRITTEN;
554 }
555 }
556 }
557 else
558 {
559 /* HUGLY HACK: Can't create new files yet... */
560 if (RequestedDisposition == FILE_CREATE ||
561 RequestedDisposition == FILE_OPEN_IF ||
562 RequestedDisposition == FILE_OVERWRITE_IF ||
563 RequestedDisposition == FILE_SUPERSEDE)
564 {
565 if (!NtfsGlobalData->EnableWriteSupport)
566 {
567 DPRINT1("NTFS write-support is EXPERIMENTAL and is disabled by default!\n");
568 NtfsCloseFile(DeviceExt, FileObject);
569 return STATUS_ACCESS_DENIED;
570 }
571
572 // Create the file record on disk
573 Status = NtfsCreateFileRecord(DeviceExt,
574 FileObject,
575 BooleanFlagOn(Stack->Flags, SL_CASE_SENSITIVE),
576 BooleanFlagOn(IrpContext->Flags,IRPCONTEXT_CANWAIT));
577 if (!NT_SUCCESS(Status))
578 {
579 DPRINT1("ERROR: Couldn't create file record!\n");
580 return Status;
581 }
582
583 // Now we should be able to open the file
584 return NtfsCreateFile(DeviceObject, IrpContext);
585 }
586 }
587
588 if (NT_SUCCESS(Status))
589 {
590 Fcb->OpenHandleCount++;
591 DeviceExt->OpenHandleCount++;
592 }
593
594 /*
595 * If the directory containing the file to open doesn't exist then
596 * fail immediately
597 */
598 Irp->IoStatus.Information = (NT_SUCCESS(Status)) ? FILE_OPENED : 0;
599
600 return Status;
601 }
602
603
604 NTSTATUS
605 NtfsCreate(PNTFS_IRP_CONTEXT IrpContext)
606 {
607 PDEVICE_EXTENSION DeviceExt;
608 NTSTATUS Status;
609 PDEVICE_OBJECT DeviceObject;
610
611 DeviceObject = IrpContext->DeviceObject;
612 if (DeviceObject == NtfsGlobalData->DeviceObject)
613 {
614 /* DeviceObject represents FileSystem instead of logical volume */
615 DPRINT("Opening file system\n");
616 IrpContext->Irp->IoStatus.Information = FILE_OPENED;
617 return STATUS_SUCCESS;
618 }
619
620 DeviceExt = DeviceObject->DeviceExtension;
621
622 if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
623 {
624 return NtfsMarkIrpContextForQueue(IrpContext);
625 }
626
627 ExAcquireResourceExclusiveLite(&DeviceExt->DirResource,
628 TRUE);
629 Status = NtfsCreateFile(DeviceObject,
630 IrpContext);
631 ExReleaseResourceLite(&DeviceExt->DirResource);
632
633 return Status;
634 }
635
636 /**
637 * @name NtfsCreateFileRecord()
638 * @implemented
639 *
640 * Creates a file record and saves it to the MFT. Adds the filename attribute of the
641 * created file to the parent directory's index.
642 *
643 * @param DeviceExt
644 * Points to the target disk's DEVICE_EXTENSION
645 *
646 * @param FileObject
647 * Pointer to a FILE_OBJECT describing the file to be created
648 *
649 * @param CanWait
650 * Boolean indicating if the function is allowed to wait for exclusive access to the master file table.
651 * This will only be relevant if the MFT doesn't have any free file records and needs to be enlarged.
652 *
653 * @return
654 * STATUS_SUCCESS on success.
655 * STATUS_INSUFFICIENT_RESOURCES if unable to allocate memory for the file record.
656 * STATUS_CANT_WAIT if CanWait was FALSE and the function needed to resize the MFT but
657 * couldn't get immediate, exclusive access to it.
658 */
659 NTSTATUS
660 NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt,
661 PFILE_OBJECT FileObject,
662 BOOLEAN CaseSensitive,
663 BOOLEAN CanWait)
664 {
665 NTSTATUS Status = STATUS_SUCCESS;
666 PFILE_RECORD_HEADER FileRecord;
667 PNTFS_ATTR_RECORD NextAttribute;
668 PFILENAME_ATTRIBUTE FilenameAttribute;
669 ULONGLONG ParentMftIndex;
670 ULONGLONG FileMftIndex;
671
672 DPRINT1("NtfsCreateFileRecord(%p, %p, %s, %s)\n",
673 DeviceExt,
674 FileObject,
675 CaseSensitive ? "TRUE" : "FALSE",
676 CanWait ? "TRUE" : "FALSE");
677
678 // allocate memory for file record
679 FileRecord = ExAllocatePoolWithTag(NonPagedPool,
680 DeviceExt->NtfsInfo.BytesPerFileRecord,
681 TAG_NTFS);
682 if (!FileRecord)
683 {
684 DPRINT1("ERROR: Unable to allocate memory for file record!\n");
685 return STATUS_INSUFFICIENT_RESOURCES;
686 }
687
688 RtlZeroMemory(FileRecord, DeviceExt->NtfsInfo.BytesPerFileRecord);
689
690 FileRecord->Ntfs.Type = NRH_FILE_TYPE;
691
692 // calculate USA offset and count
693 FileRecord->Ntfs.UsaOffset = FIELD_OFFSET(FILE_RECORD_HEADER, MFTRecordNumber) + sizeof(ULONG);
694
695 // size of USA (in ULONG's) will be 1 (for USA number) + 1 for every sector the file record uses
696 FileRecord->BytesAllocated = DeviceExt->NtfsInfo.BytesPerFileRecord;
697 FileRecord->Ntfs.UsaCount = (FileRecord->BytesAllocated / DeviceExt->NtfsInfo.BytesPerSector) + 1;
698
699 // setup other file record fields
700 FileRecord->SequenceNumber = 1;
701 FileRecord->AttributeOffset = FileRecord->Ntfs.UsaOffset + (2 * FileRecord->Ntfs.UsaCount);
702 FileRecord->AttributeOffset = ALIGN_UP_BY(FileRecord->AttributeOffset, ATTR_RECORD_ALIGNMENT);
703 FileRecord->Flags = FRH_IN_USE;
704 FileRecord->BytesInUse = FileRecord->AttributeOffset + sizeof(ULONG) * 2;
705
706 // find where the first attribute will be added
707 NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)FileRecord + FileRecord->AttributeOffset);
708
709 // mark the (temporary) end of the file-record
710 NextAttribute->Type = AttributeEnd;
711 NextAttribute->Length = FILE_RECORD_END;
712
713 // add first attribute, $STANDARD_INFORMATION
714 AddStandardInformation(FileRecord, NextAttribute);
715
716 // advance NextAttribute pointer to the next attribute
717 NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length);
718
719 // Add the $FILE_NAME attribute
720 AddFileName(FileRecord, NextAttribute, DeviceExt, FileObject, CaseSensitive, &ParentMftIndex);
721
722 // save a pointer to the filename attribute
723 FilenameAttribute = (PFILENAME_ATTRIBUTE)((ULONG_PTR)NextAttribute + NextAttribute->Resident.ValueOffset);
724
725 // advance NextAttribute pointer to the next attribute
726 NextAttribute = (PNTFS_ATTR_RECORD)((ULONG_PTR)NextAttribute + (ULONG_PTR)NextAttribute->Length);
727
728 // add the $DATA attribute
729 AddData(FileRecord, NextAttribute);
730
731 // dump file record in memory (for debugging)
732 NtfsDumpFileRecord(DeviceExt, FileRecord);
733
734 // Now that we've built the file record in memory, we need to store it in the MFT.
735 Status = AddNewMftEntry(FileRecord, DeviceExt, &FileMftIndex, CanWait);
736 if (NT_SUCCESS(Status))
737 {
738 // The highest 2 bytes should be the sequence number, unless the parent happens to be root
739 if (FileMftIndex == NTFS_FILE_ROOT)
740 FileMftIndex = FileMftIndex + ((ULONGLONG)NTFS_FILE_ROOT << 48);
741 else
742 FileMftIndex = FileMftIndex + ((ULONGLONG)FileRecord->SequenceNumber << 48);
743
744 DPRINT1("New File Reference: 0x%016I64x\n", FileMftIndex);
745
746 // Add the filename attribute to the filename-index of the parent directory
747 Status = NtfsAddFilenameToDirectory(DeviceExt,
748 ParentMftIndex,
749 FileMftIndex,
750 FilenameAttribute,
751 CaseSensitive);
752 }
753
754 ExFreePoolWithTag(FileRecord, TAG_NTFS);
755
756 return Status;
757 }
758
759 /* EOF */