xref: /reactos/ntoskrnl/mm/pagefile.c (revision cc439606) 
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 */
818