[NTOSKRNL] Stub IoInitializeCrashDump()
[reactos.git] / ntoskrnl / mm / pagefile.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 1998, 1999, 2000, 2001 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 along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19 /*
20 * PROJECT: ReactOS kernel
21 * FILE: ntoskrnl/mm/pagefile.c
22 * PURPOSE: Paging file functions
23 * PROGRAMMER: David Welch (welch@mcmail.com)
24 * Pierre Schweitzer
25 * UPDATE HISTORY:
26 * Created 22/05/98
27 */
28
29 /* INCLUDES *****************************************************************/
30
31 #include <ntoskrnl.h>
32 #define NDEBUG
33 #include <debug.h>
34
35 #if defined (ALLOC_PRAGMA)
36 #pragma alloc_text(INIT, MmInitPagingFile)
37 #endif
38
39 /* GLOBALS *******************************************************************/
40
41 #define PAIRS_PER_RUN (1024)
42
43 /* List of paging files, both used and free */
44 PMMPAGING_FILE MmPagingFile[MAX_PAGING_FILES];
45
46 /* Lock for examining the list of paging files */
47 KGUARDED_MUTEX MmPageFileCreationLock;
48
49 /* Number of paging files */
50 ULONG MmNumberOfPagingFiles;
51
52 /* Number of pages that are available for swapping */
53 PFN_COUNT MiFreeSwapPages;
54
55 /* Number of pages that have been allocated for swapping */
56 PFN_COUNT MiUsedSwapPages;
57
58 BOOLEAN MmZeroPageFile;
59
60 /*
61 * Number of pages that have been reserved for swapping but not yet allocated
62 */
63 static PFN_COUNT MiReservedSwapPages;
64
65 /*
66 * Ratio between reserved and available swap pages, e.g. setting this to five
67 * forces one swap page to be available for every five swap pages that are
68 * reserved. Setting this to zero turns off commit checking altogether.
69 */
70 #define MM_PAGEFILE_COMMIT_RATIO (1)
71
72 /*
73 * Number of pages that can be used for potentially swapable memory without
74 * pagefile space being reserved. The intention is that this allows smss
75 * to start up and create page files while ordinarily having a commit
76 * ratio of one.
77 */
78 #define MM_PAGEFILE_COMMIT_GRACE (256)
79
80 /*
81 * Translate between a swap entry and a file and offset pair.
82 */
83 #define FILE_FROM_ENTRY(i) ((i) & 0x0f)
84 #define OFFSET_FROM_ENTRY(i) ((i) >> 11)
85 #define ENTRY_FROM_FILE_OFFSET(i, j) ((i) | ((j) << 11) | 0x400)
86
87 /* Make sure there can be only 16 paging files */
88 C_ASSERT(FILE_FROM_ENTRY(0xffffffff) < MAX_PAGING_FILES);
89
90 static BOOLEAN MmSwapSpaceMessage = FALSE;
91
92 static BOOLEAN MmSystemPageFileLocated = FALSE;
93
94 /* FUNCTIONS *****************************************************************/
95
96 VOID
97 NTAPI
98 MmBuildMdlFromPages(PMDL Mdl, PPFN_NUMBER Pages)
99 {
100 memcpy(Mdl + 1, Pages, sizeof(PFN_NUMBER) * (PAGE_ROUND_UP(Mdl->ByteOffset+Mdl->ByteCount)/PAGE_SIZE));
101
102 /* FIXME: this flag should be set by the caller perhaps? */
103 Mdl->MdlFlags |= MDL_IO_PAGE_READ;
104 }
105
106
107 BOOLEAN
108 NTAPI
109 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject)
110 {
111 ULONG i;
112
113 /* Loop through all the paging files */
114 for (i = 0; i < MmNumberOfPagingFiles; i++)
115 {
116 /* Check if this is one of them */
117 if (MmPagingFile[i]->FileObject == FileObject) return TRUE;
118 }
119
120 /* Nothing found */
121 return FALSE;
122 }
123
124 VOID
125 NTAPI
126 MmShowOutOfSpaceMessagePagingFile(VOID)
127 {
128 if (!MmSwapSpaceMessage)
129 {
130 DPRINT1("MM: Out of swap space.\n");
131 MmSwapSpaceMessage = TRUE;
132 }
133 }
134
135 NTSTATUS
136 NTAPI
137 MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
138 {
139 ULONG i;
140 ULONG_PTR offset;
141 LARGE_INTEGER file_offset;
142 IO_STATUS_BLOCK Iosb;
143 NTSTATUS Status;
144 KEVENT Event;
145 UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
146 PMDL Mdl = (PMDL)MdlBase;
147
148 DPRINT("MmWriteToSwapPage\n");
149
150 if (SwapEntry == 0)
151 {
152 KeBugCheck(MEMORY_MANAGEMENT);
153 return(STATUS_UNSUCCESSFUL);
154 }
155
156 i = FILE_FROM_ENTRY(SwapEntry);
157 offset = OFFSET_FROM_ENTRY(SwapEntry) - 1;
158
159 if (MmPagingFile[i]->FileObject == NULL ||
160 MmPagingFile[i]->FileObject->DeviceObject == NULL)
161 {
162 DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
163 KeBugCheck(MEMORY_MANAGEMENT);
164 }
165
166 MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
167 MmBuildMdlFromPages(Mdl, &Page);
168 Mdl->MdlFlags |= MDL_PAGES_LOCKED;
169
170 file_offset.QuadPart = offset * PAGE_SIZE;
171
172 KeInitializeEvent(&Event, NotificationEvent, FALSE);
173 Status = IoSynchronousPageWrite(MmPagingFile[i]->FileObject,
174 Mdl,
175 &file_offset,
176 &Event,
177 &Iosb);
178 if (Status == STATUS_PENDING)
179 {
180 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
181 Status = Iosb.Status;
182 }
183
184 if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
185 {
186 MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
187 }
188 return(Status);
189 }
190
191
192 NTSTATUS
193 NTAPI
194 MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
195 {
196 return MiReadPageFile(Page, FILE_FROM_ENTRY(SwapEntry), OFFSET_FROM_ENTRY(SwapEntry) - 1);
197 }
198
199 NTSTATUS
200 NTAPI
201 MiReadPageFile(
202 _In_ PFN_NUMBER Page,
203 _In_ ULONG PageFileIndex,
204 _In_ ULONG_PTR PageFileOffset)
205 {
206 LARGE_INTEGER file_offset;
207 IO_STATUS_BLOCK Iosb;
208 NTSTATUS Status;
209 KEVENT Event;
210 UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
211 PMDL Mdl = (PMDL)MdlBase;
212 PMMPAGING_FILE PagingFile;
213
214 DPRINT("MiReadSwapFile\n");
215
216 if (PageFileOffset == 0)
217 {
218 KeBugCheck(MEMORY_MANAGEMENT);
219 return(STATUS_UNSUCCESSFUL);
220 }
221
222 ASSERT(PageFileIndex < MAX_PAGING_FILES);
223
224 PagingFile = MmPagingFile[PageFileIndex];
225
226 if (PagingFile->FileObject == NULL || PagingFile->FileObject->DeviceObject == NULL)
227 {
228 DPRINT1("Bad paging file %u\n", PageFileIndex);
229 KeBugCheck(MEMORY_MANAGEMENT);
230 }
231
232 MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
233 MmBuildMdlFromPages(Mdl, &Page);
234 Mdl->MdlFlags |= MDL_PAGES_LOCKED;
235
236 file_offset.QuadPart = PageFileOffset * PAGE_SIZE;
237
238 KeInitializeEvent(&Event, NotificationEvent, FALSE);
239 Status = IoPageRead(PagingFile->FileObject,
240 Mdl,
241 &file_offset,
242 &Event,
243 &Iosb);
244 if (Status == STATUS_PENDING)
245 {
246 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
247 Status = Iosb.Status;
248 }
249 if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
250 {
251 MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
252 }
253 return(Status);
254 }
255
256 VOID
257 INIT_FUNCTION
258 NTAPI
259 MmInitPagingFile(VOID)
260 {
261 ULONG i;
262
263 KeInitializeGuardedMutex(&MmPageFileCreationLock);
264
265 MiFreeSwapPages = 0;
266 MiUsedSwapPages = 0;
267 MiReservedSwapPages = 0;
268
269 for (i = 0; i < MAX_PAGING_FILES; i++)
270 {
271 MmPagingFile[i] = NULL;
272 }
273 MmNumberOfPagingFiles = 0;
274 }
275
276 VOID
277 NTAPI
278 MmFreeSwapPage(SWAPENTRY Entry)
279 {
280 ULONG i;
281 ULONG_PTR off;
282 PMMPAGING_FILE PagingFile;
283
284 i = FILE_FROM_ENTRY(Entry);
285 off = OFFSET_FROM_ENTRY(Entry) - 1;
286
287 KeAcquireGuardedMutex(&MmPageFileCreationLock);
288
289 PagingFile = MmPagingFile[i];
290 if (PagingFile == NULL)
291 {
292 KeBugCheck(MEMORY_MANAGEMENT);
293 }
294
295 RtlClearBit(PagingFile->Bitmap, off >> 5);
296
297 PagingFile->FreeSpace++;
298 PagingFile->CurrentUsage--;
299
300 MiFreeSwapPages++;
301 MiUsedSwapPages--;
302
303 KeReleaseGuardedMutex(&MmPageFileCreationLock);
304 }
305
306 SWAPENTRY
307 NTAPI
308 MmAllocSwapPage(VOID)
309 {
310 ULONG i;
311 ULONG off;
312 SWAPENTRY entry;
313
314 KeAcquireGuardedMutex(&MmPageFileCreationLock);
315
316 if (MiFreeSwapPages == 0)
317 {
318 KeReleaseGuardedMutex(&MmPageFileCreationLock);
319 return(0);
320 }
321
322 for (i = 0; i < MAX_PAGING_FILES; i++)
323 {
324 if (MmPagingFile[i] != NULL &&
325 MmPagingFile[i]->FreeSpace >= 1)
326 {
327 off = RtlFindClearBitsAndSet(MmPagingFile[i]->Bitmap, 1, 0);
328 if (off == 0xFFFFFFFF)
329 {
330 KeBugCheck(MEMORY_MANAGEMENT);
331 KeReleaseGuardedMutex(&MmPageFileCreationLock);
332 return(STATUS_UNSUCCESSFUL);
333 }
334 MiUsedSwapPages++;
335 MiFreeSwapPages--;
336 KeReleaseGuardedMutex(&MmPageFileCreationLock);
337
338 entry = ENTRY_FROM_FILE_OFFSET(i, off + 1);
339 return(entry);
340 }
341 }
342
343 KeReleaseGuardedMutex(&MmPageFileCreationLock);
344 KeBugCheck(MEMORY_MANAGEMENT);
345 return(0);
346 }
347
348 NTSTATUS NTAPI
349 NtCreatePagingFile(IN PUNICODE_STRING FileName,
350 IN PLARGE_INTEGER MinimumSize,
351 IN PLARGE_INTEGER MaximumSize,
352 IN ULONG Reserved)
353 {
354 NTSTATUS Status;
355 OBJECT_ATTRIBUTES ObjectAttributes;
356 HANDLE FileHandle;
357 IO_STATUS_BLOCK IoStatus;
358 PFILE_OBJECT FileObject;
359 PMMPAGING_FILE PagingFile;
360 ULONG AllocMapSize;
361 ULONG Count;
362 KPROCESSOR_MODE PreviousMode;
363 UNICODE_STRING PageFileName;
364 LARGE_INTEGER SafeMinimumSize, SafeMaximumSize, AllocationSize;
365 FILE_FS_DEVICE_INFORMATION FsDeviceInfo;
366 SECURITY_DESCRIPTOR SecurityDescriptor;
367 PACL Dacl;
368 PWSTR Buffer;
369 DEVICE_TYPE DeviceType;
370
371 DPRINT("NtCreatePagingFile(FileName %wZ, MinimumSize %I64d)\n",
372 FileName, MinimumSize->QuadPart);
373
374 PAGED_CODE();
375
376 if (MmNumberOfPagingFiles >= MAX_PAGING_FILES)
377 {
378 return STATUS_TOO_MANY_PAGING_FILES;
379 }
380
381 PreviousMode = ExGetPreviousMode();
382
383 if (PreviousMode != KernelMode)
384 {
385 if (SeSinglePrivilegeCheck(SeCreatePagefilePrivilege, PreviousMode) != TRUE)
386 {
387 return STATUS_PRIVILEGE_NOT_HELD;
388 }
389
390 _SEH2_TRY
391 {
392 SafeMinimumSize = ProbeForReadLargeInteger(MinimumSize);
393 SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
394
395 PageFileName.Length = FileName->Length;
396 PageFileName.MaximumLength = FileName->MaximumLength;
397 PageFileName.Buffer = FileName->Buffer;
398 }
399 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
400 {
401 /* Return the exception code */
402 _SEH2_YIELD(return _SEH2_GetExceptionCode());
403 }
404 _SEH2_END;
405 }
406 else
407 {
408 SafeMinimumSize = *MinimumSize;
409 SafeMaximumSize = *MaximumSize;
410
411 PageFileName.Length = FileName->Length;
412 PageFileName.MaximumLength = FileName->MaximumLength;
413 PageFileName.Buffer = FileName->Buffer;
414 }
415
416 /* Pagefiles can't be larger than 4GB and ofcourse the minimum should be
417 smaller than the maximum */
418 if (0 != SafeMinimumSize.u.HighPart)
419 {
420 return STATUS_INVALID_PARAMETER_2;
421 }
422 if (0 != SafeMaximumSize.u.HighPart)
423 {
424 return STATUS_INVALID_PARAMETER_3;
425 }
426 if (SafeMaximumSize.u.LowPart < SafeMinimumSize.u.LowPart)
427 {
428 return STATUS_INVALID_PARAMETER_MIX;
429 }
430
431 /* Validate name length */
432 if (PageFileName.Length > 128 * sizeof(WCHAR))
433 {
434 return STATUS_OBJECT_NAME_INVALID;
435 }
436
437 /* We won't care about any potential UNICODE_NULL */
438 PageFileName.MaximumLength = PageFileName.Length;
439 /* Allocate a buffer to keep name copy */
440 Buffer = ExAllocatePoolWithTag(PagedPool, PageFileName.Length, TAG_MM);
441 if (Buffer == NULL)
442 {
443 return STATUS_INSUFFICIENT_RESOURCES;
444 }
445
446 /* Copy name */
447 if (PreviousMode != KernelMode)
448 {
449 _SEH2_TRY
450 {
451 if (PageFileName.Length != 0)
452 {
453 ProbeForRead(PageFileName.Buffer, PageFileName.Length, sizeof(WCHAR));
454 }
455
456 RtlCopyMemory(Buffer, PageFileName.Buffer, PageFileName.Length);
457 }
458 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
459 {
460 ExFreePoolWithTag(Buffer, TAG_MM);
461
462 /* Return the exception code */
463 _SEH2_YIELD(return _SEH2_GetExceptionCode());
464 }
465 _SEH2_END;
466 }
467 else
468 {
469 RtlCopyMemory(Buffer, PageFileName.Buffer, PageFileName.Length);
470 }
471
472 /* Erase caller's buffer with ours */
473 PageFileName.Buffer = Buffer;
474
475 /* Create the security descriptor for the page file */
476 Status = RtlCreateSecurityDescriptor(&SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
477 if (!NT_SUCCESS(Status))
478 {
479 ExFreePoolWithTag(Buffer, TAG_MM);
480 return Status;
481 }
482
483 /* Create the DACL: we will only allow two SIDs */
484 Count = sizeof(ACL) + (sizeof(ACE) + RtlLengthSid(SeLocalSystemSid)) +
485 (sizeof(ACE) + RtlLengthSid(SeAliasAdminsSid));
486 Dacl = ExAllocatePoolWithTag(PagedPool, Count, 'lcaD');
487 if (Dacl == NULL)
488 {
489 ExFreePoolWithTag(Buffer, TAG_MM);
490 return STATUS_INSUFFICIENT_RESOURCES;
491 }
492
493 /* Initialize the DACL */
494 Status = RtlCreateAcl(Dacl, Count, ACL_REVISION);
495 if (!NT_SUCCESS(Status))
496 {
497 ExFreePoolWithTag(Dacl, 'lcaD');
498 ExFreePoolWithTag(Buffer, TAG_MM);
499 return Status;
500 }
501
502 /* Grant full access to admins */
503 Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, FILE_ALL_ACCESS, SeAliasAdminsSid);
504 if (!NT_SUCCESS(Status))
505 {
506 ExFreePoolWithTag(Dacl, 'lcaD');
507 ExFreePoolWithTag(Buffer, TAG_MM);
508 return Status;
509 }
510
511 /* Grant full access to SYSTEM */
512 Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, FILE_ALL_ACCESS, SeLocalSystemSid);
513 if (!NT_SUCCESS(Status))
514 {
515 ExFreePoolWithTag(Dacl, 'lcaD');
516 ExFreePoolWithTag(Buffer, TAG_MM);
517 return Status;
518 }
519
520 /* Attach the DACL to the security descriptor */
521 Status = RtlSetDaclSecurityDescriptor(&SecurityDescriptor, TRUE, Dacl, FALSE);
522 if (!NT_SUCCESS(Status))
523 {
524 ExFreePoolWithTag(Dacl, 'lcaD');
525 ExFreePoolWithTag(Buffer, TAG_MM);
526 return Status;
527 }
528
529 InitializeObjectAttributes(&ObjectAttributes,
530 &PageFileName,
531 OBJ_KERNEL_HANDLE,
532 NULL,
533 &SecurityDescriptor);
534
535 /* Make sure we can at least store a complete page:
536 * If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
537 * a problem if the paging file is fragmented. Suppose the first cluster
538 * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
539 * paging file but of another file. We can't write a complete page (4096
540 * bytes) to the physical location of cluster 3042 then. */
541 AllocationSize.QuadPart = SafeMinimumSize.QuadPart + PAGE_SIZE;
542
543 /* First, attempt to replace the page file, if existing */
544 Status = IoCreateFile(&FileHandle,
545 SYNCHRONIZE | WRITE_DAC | FILE_READ_DATA | FILE_WRITE_DATA,
546 &ObjectAttributes,
547 &IoStatus,
548 &AllocationSize,
549 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
550 FILE_SHARE_WRITE,
551 FILE_SUPERSEDE,
552 FILE_DELETE_ON_CLOSE | FILE_NO_COMPRESSION | FILE_NO_INTERMEDIATE_BUFFERING,
553 NULL,
554 0,
555 CreateFileTypeNone,
556 NULL,
557 SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
558 /* If we failed, relax a bit constraints, someone may be already holding the
559 * the file, so share write, don't attempt to replace and don't delete on close
560 * (basically, don't do anything conflicting)
561 * This can happen if the caller attempts to extend a page file.
562 */
563 if (!NT_SUCCESS(Status))
564 {
565 ULONG i;
566
567 Status = IoCreateFile(&FileHandle,
568 SYNCHRONIZE | FILE_WRITE_DATA,
569 &ObjectAttributes,
570 &IoStatus,
571 &AllocationSize,
572 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
573 FILE_SHARE_WRITE | FILE_SHARE_READ,
574 FILE_OPEN,
575 FILE_NO_COMPRESSION | FILE_NO_INTERMEDIATE_BUFFERING,
576 NULL,
577 0,
578 CreateFileTypeNone,
579 NULL,
580 SL_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING);
581 if (!NT_SUCCESS(Status))
582 {
583 ExFreePoolWithTag(Dacl, 'lcaD');
584 ExFreePoolWithTag(Buffer, TAG_MM);
585 return Status;
586 }
587
588 /* We opened it! Check we are that "someone" ;-)
589 * First, get the opened file object.
590 */
591 Status = ObReferenceObjectByHandle(FileHandle,
592 FILE_READ_DATA | FILE_WRITE_DATA,
593 IoFileObjectType,
594 KernelMode,
595 (PVOID*)&FileObject,
596 NULL);
597 if (!NT_SUCCESS(Status))
598 {
599 ZwClose(FileHandle);
600 ExFreePoolWithTag(Dacl, 'lcaD');
601 ExFreePoolWithTag(Buffer, TAG_MM);
602 return Status;
603 }
604
605 /* Find if it matches a previous page file */
606 PagingFile = NULL;
607
608 /* FIXME: should be calling unsafe instead,
609 * we should already be in a guarded region
610 */
611 KeAcquireGuardedMutex(&MmPageFileCreationLock);
612 if (MmNumberOfPagingFiles > 0)
613 {
614 i = 0;
615
616 while (MmPagingFile[i]->FileObject->SectionObjectPointer != FileObject->SectionObjectPointer)
617 {
618 ++i;
619 if (i >= MmNumberOfPagingFiles)
620 {
621 break;
622 }
623 }
624
625 /* This is the matching page file */
626 PagingFile = MmPagingFile[i];
627 }
628
629 /* If we didn't find the page file, fail */
630 if (PagingFile == NULL)
631 {
632 KeReleaseGuardedMutex(&MmPageFileCreationLock);
633 ObDereferenceObject(FileObject);
634 ZwClose(FileHandle);
635 ExFreePoolWithTag(Dacl, 'lcaD');
636 ExFreePoolWithTag(Buffer, TAG_MM);
637 return STATUS_NOT_FOUND;
638 }
639
640 /* Don't allow page file shrinking */
641 if (PagingFile->MinimumSize > (SafeMinimumSize.QuadPart >> PAGE_SHIFT))
642 {
643 KeReleaseGuardedMutex(&MmPageFileCreationLock);
644 ObDereferenceObject(FileObject);
645 ZwClose(FileHandle);
646 ExFreePoolWithTag(Dacl, 'lcaD');
647 ExFreePoolWithTag(Buffer, TAG_MM);
648 return STATUS_INVALID_PARAMETER_2;
649 }
650
651 if ((SafeMaximumSize.QuadPart >> PAGE_SHIFT) < PagingFile->MaximumSize)
652 {
653 KeReleaseGuardedMutex(&MmPageFileCreationLock);
654 ObDereferenceObject(FileObject);
655 ZwClose(FileHandle);
656 ExFreePoolWithTag(Dacl, 'lcaD');
657 ExFreePoolWithTag(Buffer, TAG_MM);
658 return STATUS_INVALID_PARAMETER_3;
659 }
660
661 /* FIXME: implement parameters checking and page file extension */
662 UNIMPLEMENTED;
663
664 KeReleaseGuardedMutex(&MmPageFileCreationLock);
665 ObDereferenceObject(FileObject);
666 ZwClose(FileHandle);
667 ExFreePoolWithTag(Dacl, 'lcaD');
668 ExFreePoolWithTag(Buffer, TAG_MM);
669 return STATUS_NOT_IMPLEMENTED;
670 }
671
672 if (!NT_SUCCESS(Status))
673 {
674 DPRINT1("Failed creating page file: %lx\n", Status);
675 ExFreePoolWithTag(Dacl, 'lcaD');
676 ExFreePoolWithTag(Buffer, TAG_MM);
677 return Status;
678 }
679
680 /* Set the security descriptor */
681 if (NT_SUCCESS(IoStatus.Status))
682 {
683 Status = ZwSetSecurityObject(FileHandle, DACL_SECURITY_INFORMATION, &SecurityDescriptor);
684 if (!NT_SUCCESS(Status))
685 {
686 ExFreePoolWithTag(Dacl, 'lcaD');
687 ZwClose(FileHandle);
688 ExFreePoolWithTag(Buffer, TAG_MM);
689 return Status;
690 }
691 }
692
693 /* DACL is no longer needed, free it */
694 ExFreePoolWithTag(Dacl, 'lcaD');
695
696 /* FIXME: To enable once page file managment is moved to ARM3 */
697 #if 0
698 /* Check we won't overflow commit limit with the page file */
699 if (MmTotalCommitLimitMaximum + (SafeMaximumSize.QuadPart >> PAGE_SHIFT) <= MmTotalCommitLimitMaximum)
700 {
701 ZwClose(FileHandle);
702 ExFreePoolWithTag(Buffer, TAG_MM);
703 return STATUS_INVALID_PARAMETER_3;
704 }
705 #endif
706
707 /* Set its end of file to minimal size */
708 Status = ZwSetInformationFile(FileHandle,
709 &IoStatus,
710 &SafeMinimumSize,
711 sizeof(LARGE_INTEGER),
712 FileEndOfFileInformation);
713 if (!NT_SUCCESS(Status) || !NT_SUCCESS(IoStatus.Status))
714 {
715 ZwClose(FileHandle);
716 ExFreePoolWithTag(Buffer, TAG_MM);
717 return Status;
718 }
719
720 Status = ObReferenceObjectByHandle(FileHandle,
721 FILE_READ_DATA | FILE_WRITE_DATA,
722 IoFileObjectType,
723 KernelMode,
724 (PVOID*)&FileObject,
725 NULL);
726 if (!NT_SUCCESS(Status))
727 {
728 ZwClose(FileHandle);
729 ExFreePoolWithTag(Buffer, TAG_MM);
730 return Status;
731 }
732
733 /* Only allow page file on a few device types */
734 DeviceType = IoGetRelatedDeviceObject(FileObject)->DeviceType;
735 if (DeviceType != FILE_DEVICE_DISK_FILE_SYSTEM && DeviceType != FILE_DEVICE_NETWORK_FILE_SYSTEM &&
736 DeviceType != FILE_DEVICE_DFS_VOLUME && DeviceType != FILE_DEVICE_DFS_FILE_SYSTEM)
737 {
738 ObDereferenceObject(FileObject);
739 ZwClose(FileHandle);
740 ExFreePoolWithTag(Buffer, TAG_MM);
741 return Status;
742 }
743
744 /* Deny page file creation on a floppy disk */
745 FsDeviceInfo.Characteristics = 0;
746 IoQueryVolumeInformation(FileObject, FileFsDeviceInformation, sizeof(FsDeviceInfo), &FsDeviceInfo, &Count);
747 if (BooleanFlagOn(FsDeviceInfo.Characteristics, FILE_FLOPPY_DISKETTE))
748 {
749 ObDereferenceObject(FileObject);
750 ZwClose(FileHandle);
751 ExFreePoolWithTag(Buffer, TAG_MM);
752 return STATUS_FLOPPY_VOLUME;
753 }
754
755 PagingFile = ExAllocatePoolWithTag(NonPagedPool, sizeof(*PagingFile), TAG_MM);
756 if (PagingFile == NULL)
757 {
758 ObDereferenceObject(FileObject);
759 ZwClose(FileHandle);
760 ExFreePoolWithTag(Buffer, TAG_MM);
761 return STATUS_INSUFFICIENT_RESOURCES;
762 }
763
764 RtlZeroMemory(PagingFile, sizeof(*PagingFile));
765
766 PagingFile->FileHandle = FileHandle;
767 PagingFile->FileObject = FileObject;
768 PagingFile->MaximumSize = (SafeMaximumSize.QuadPart >> PAGE_SHIFT);
769 PagingFile->Size = (SafeMinimumSize.QuadPart >> PAGE_SHIFT);
770 PagingFile->MinimumSize = (SafeMinimumSize.QuadPart >> PAGE_SHIFT);
771 /* First page is never used: it's the header
772 * TODO: write it
773 */
774 PagingFile->FreeSpace = (ULONG)(SafeMinimumSize.QuadPart / PAGE_SIZE) - 1;
775 PagingFile->CurrentUsage = 0;
776 PagingFile->PageFileName = PageFileName;
777 ASSERT(PagingFile->Size == PagingFile->FreeSpace + PagingFile->CurrentUsage + 1);
778
779 AllocMapSize = sizeof(RTL_BITMAP) + (((PagingFile->MaximumSize + 31) / 32) * sizeof(ULONG));
780 PagingFile->Bitmap = ExAllocatePoolWithTag(NonPagedPool,
781 AllocMapSize,
782 TAG_MM);
783 if (PagingFile->Bitmap == NULL)
784 {
785 ExFreePoolWithTag(PagingFile, TAG_MM);
786 ObDereferenceObject(FileObject);
787 ZwClose(FileHandle);
788 ExFreePoolWithTag(Buffer, TAG_MM);
789 return STATUS_INSUFFICIENT_RESOURCES;
790 }
791
792 RtlInitializeBitMap(PagingFile->Bitmap,
793 (PULONG)(PagingFile->Bitmap + 1),
794 (ULONG)(PagingFile->MaximumSize));
795 RtlClearAllBits(PagingFile->Bitmap);
796
797 /* FIXME: should be calling unsafe instead,
798 * we should already be in a guarded region
799 */
800 KeAcquireGuardedMutex(&MmPageFileCreationLock);
801 ASSERT(MmPagingFile[MmNumberOfPagingFiles] == NULL);
802 MmPagingFile[MmNumberOfPagingFiles] = PagingFile;
803 MmNumberOfPagingFiles++;
804 MiFreeSwapPages = MiFreeSwapPages + PagingFile->FreeSpace;
805 KeReleaseGuardedMutex(&MmPageFileCreationLock);
806
807 MmSwapSpaceMessage = FALSE;
808
809 if (!MmSystemPageFileLocated && BooleanFlagOn(FileObject->DeviceObject->Flags, DO_SYSTEM_BOOT_PARTITION))
810 {
811 MmSystemPageFileLocated = IoInitializeCrashDump(FileHandle);
812 }
813
814 return STATUS_SUCCESS;
815 }
816
817 /* EOF */