3 * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
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.
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.
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.
20 * PROJECT: ReactOS kernel
21 * FILE: ntoskrnl/mm/pagefile.c
22 * PURPOSE: Paging file functions
23 * PROGRAMMER: David Welch (welch@mcmail.com)
29 /* INCLUDES *****************************************************************/
35 #if defined (ALLOC_PRAGMA)
36 #pragma alloc_text(INIT, MmInitPagingFile)
39 /* GLOBALS *******************************************************************/
41 #define PAIRS_PER_RUN (1024)
43 /* List of paging files, both used and free */
44 PMMPAGING_FILE MmPagingFile
[MAX_PAGING_FILES
];
46 /* Lock for examining the list of paging files */
47 KGUARDED_MUTEX MmPageFileCreationLock
;
49 /* Number of paging files */
50 ULONG MmNumberOfPagingFiles
;
52 /* Number of pages that are available for swapping */
53 PFN_COUNT MiFreeSwapPages
;
55 /* Number of pages that have been allocated for swapping */
56 PFN_COUNT MiUsedSwapPages
;
58 BOOLEAN MmZeroPageFile
;
61 * Number of pages that have been reserved for swapping but not yet allocated
63 static PFN_COUNT MiReservedSwapPages
;
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.
70 #define MM_PAGEFILE_COMMIT_RATIO (1)
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
78 #define MM_PAGEFILE_COMMIT_GRACE (256)
81 * Translate between a swap entry and a file and offset pair.
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)
87 /* Make sure there can be only 16 paging files */
88 C_ASSERT(FILE_FROM_ENTRY(0xffffffff) < MAX_PAGING_FILES
);
90 static BOOLEAN MmSwapSpaceMessage
= FALSE
;
92 /* FUNCTIONS *****************************************************************/
96 MmBuildMdlFromPages(PMDL Mdl
, PPFN_NUMBER Pages
)
98 memcpy(Mdl
+ 1, Pages
, sizeof(PFN_NUMBER
) * (PAGE_ROUND_UP(Mdl
->ByteOffset
+Mdl
->ByteCount
)/PAGE_SIZE
));
100 /* FIXME: this flag should be set by the caller perhaps? */
101 Mdl
->MdlFlags
|= MDL_IO_PAGE_READ
;
107 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject
)
111 /* Loop through all the paging files */
112 for (i
= 0; i
< MmNumberOfPagingFiles
; i
++)
114 /* Check if this is one of them */
115 if (MmPagingFile
[i
]->FileObject
== FileObject
) return TRUE
;
124 MmShowOutOfSpaceMessagePagingFile(VOID
)
126 if (!MmSwapSpaceMessage
)
128 DPRINT1("MM: Out of swap space.\n");
129 MmSwapSpaceMessage
= TRUE
;
135 MmWriteToSwapPage(SWAPENTRY SwapEntry
, PFN_NUMBER Page
)
139 LARGE_INTEGER file_offset
;
140 IO_STATUS_BLOCK Iosb
;
143 UCHAR MdlBase
[sizeof(MDL
) + sizeof(ULONG
)];
144 PMDL Mdl
= (PMDL
)MdlBase
;
146 DPRINT("MmWriteToSwapPage\n");
150 KeBugCheck(MEMORY_MANAGEMENT
);
151 return(STATUS_UNSUCCESSFUL
);
154 i
= FILE_FROM_ENTRY(SwapEntry
);
155 offset
= OFFSET_FROM_ENTRY(SwapEntry
) - 1;
157 if (MmPagingFile
[i
]->FileObject
== NULL
||
158 MmPagingFile
[i
]->FileObject
->DeviceObject
== NULL
)
160 DPRINT1("Bad paging file 0x%.8X\n", SwapEntry
);
161 KeBugCheck(MEMORY_MANAGEMENT
);
164 MmInitializeMdl(Mdl
, NULL
, PAGE_SIZE
);
165 MmBuildMdlFromPages(Mdl
, &Page
);
166 Mdl
->MdlFlags
|= MDL_PAGES_LOCKED
;
168 file_offset
.QuadPart
= offset
* PAGE_SIZE
;
170 KeInitializeEvent(&Event
, NotificationEvent
, FALSE
);
171 Status
= IoSynchronousPageWrite(MmPagingFile
[i
]->FileObject
,
176 if (Status
== STATUS_PENDING
)
178 KeWaitForSingleObject(&Event
, Executive
, KernelMode
, FALSE
, NULL
);
179 Status
= Iosb
.Status
;
182 if (Mdl
->MdlFlags
& MDL_MAPPED_TO_SYSTEM_VA
)
184 MmUnmapLockedPages (Mdl
->MappedSystemVa
, Mdl
);
192 MmReadFromSwapPage(SWAPENTRY SwapEntry
, PFN_NUMBER Page
)
194 return MiReadPageFile(Page
, FILE_FROM_ENTRY(SwapEntry
), OFFSET_FROM_ENTRY(SwapEntry
) - 1);
200 _In_ PFN_NUMBER Page
,
201 _In_ ULONG PageFileIndex
,
202 _In_ ULONG_PTR PageFileOffset
)
204 LARGE_INTEGER file_offset
;
205 IO_STATUS_BLOCK Iosb
;
208 UCHAR MdlBase
[sizeof(MDL
) + sizeof(ULONG
)];
209 PMDL Mdl
= (PMDL
)MdlBase
;
210 PMMPAGING_FILE PagingFile
;
212 DPRINT("MiReadSwapFile\n");
214 if (PageFileOffset
== 0)
216 KeBugCheck(MEMORY_MANAGEMENT
);
217 return(STATUS_UNSUCCESSFUL
);
220 ASSERT(PageFileIndex
< MAX_PAGING_FILES
);
222 PagingFile
= MmPagingFile
[PageFileIndex
];
224 if (PagingFile
->FileObject
== NULL
|| PagingFile
->FileObject
->DeviceObject
== NULL
)
226 DPRINT1("Bad paging file %u\n", PageFileIndex
);
227 KeBugCheck(MEMORY_MANAGEMENT
);
230 MmInitializeMdl(Mdl
, NULL
, PAGE_SIZE
);
231 MmBuildMdlFromPages(Mdl
, &Page
);
232 Mdl
->MdlFlags
|= MDL_PAGES_LOCKED
;
234 file_offset
.QuadPart
= PageFileOffset
* PAGE_SIZE
;
236 KeInitializeEvent(&Event
, NotificationEvent
, FALSE
);
237 Status
= IoPageRead(PagingFile
->FileObject
,
242 if (Status
== STATUS_PENDING
)
244 KeWaitForSingleObject(&Event
, Executive
, KernelMode
, FALSE
, NULL
);
245 Status
= Iosb
.Status
;
247 if (Mdl
->MdlFlags
& MDL_MAPPED_TO_SYSTEM_VA
)
249 MmUnmapLockedPages (Mdl
->MappedSystemVa
, Mdl
);
257 MmInitPagingFile(VOID
)
261 KeInitializeGuardedMutex(&MmPageFileCreationLock
);
265 MiReservedSwapPages
= 0;
267 for (i
= 0; i
< MAX_PAGING_FILES
; i
++)
269 MmPagingFile
[i
] = NULL
;
271 MmNumberOfPagingFiles
= 0;
276 MmFreeSwapPage(SWAPENTRY Entry
)
280 PMMPAGING_FILE PagingFile
;
282 i
= FILE_FROM_ENTRY(Entry
);
283 off
= OFFSET_FROM_ENTRY(Entry
) - 1;
285 KeAcquireGuardedMutex(&MmPageFileCreationLock
);
287 PagingFile
= MmPagingFile
[i
];
288 if (PagingFile
== NULL
)
290 KeBugCheck(MEMORY_MANAGEMENT
);
293 RtlClearBit(PagingFile
->Bitmap
, off
>> 5);
295 PagingFile
->FreeSpace
++;
296 PagingFile
->CurrentUsage
--;
301 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
306 MmAllocSwapPage(VOID
)
312 KeAcquireGuardedMutex(&MmPageFileCreationLock
);
314 if (MiFreeSwapPages
== 0)
316 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
320 for (i
= 0; i
< MAX_PAGING_FILES
; i
++)
322 if (MmPagingFile
[i
] != NULL
&&
323 MmPagingFile
[i
]->FreeSpace
>= 1)
325 off
= RtlFindClearBitsAndSet(MmPagingFile
[i
]->Bitmap
, 1, 0);
326 if (off
== 0xFFFFFFFF)
328 KeBugCheck(MEMORY_MANAGEMENT
);
329 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
330 return(STATUS_UNSUCCESSFUL
);
334 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
336 entry
= ENTRY_FROM_FILE_OFFSET(i
, off
+ 1);
341 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
342 KeBugCheck(MEMORY_MANAGEMENT
);
347 NtCreatePagingFile(IN PUNICODE_STRING FileName
,
348 IN PLARGE_INTEGER MinimumSize
,
349 IN PLARGE_INTEGER MaximumSize
,
353 OBJECT_ATTRIBUTES ObjectAttributes
;
355 IO_STATUS_BLOCK IoStatus
;
356 PFILE_OBJECT FileObject
;
357 PMMPAGING_FILE PagingFile
;
360 KPROCESSOR_MODE PreviousMode
;
361 UNICODE_STRING PageFileName
;
362 LARGE_INTEGER SafeMinimumSize
, SafeMaximumSize
, AllocationSize
;
363 FILE_FS_DEVICE_INFORMATION FsDeviceInfo
;
364 SECURITY_DESCRIPTOR SecurityDescriptor
;
368 DPRINT("NtCreatePagingFile(FileName %wZ, MinimumSize %I64d)\n",
369 FileName
, MinimumSize
->QuadPart
);
373 if (MmNumberOfPagingFiles
>= MAX_PAGING_FILES
)
375 return STATUS_TOO_MANY_PAGING_FILES
;
378 PreviousMode
= ExGetPreviousMode();
380 if (PreviousMode
!= KernelMode
)
382 if (SeSinglePrivilegeCheck(SeCreatePagefilePrivilege
, PreviousMode
) != TRUE
)
384 return STATUS_PRIVILEGE_NOT_HELD
;
389 SafeMinimumSize
= ProbeForReadLargeInteger(MinimumSize
);
390 SafeMaximumSize
= ProbeForReadLargeInteger(MaximumSize
);
392 PageFileName
.Length
= FileName
->Length
;
393 PageFileName
.MaximumLength
= FileName
->MaximumLength
;
394 PageFileName
.Buffer
= FileName
->Buffer
;
396 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
398 /* Return the exception code */
399 _SEH2_YIELD(return _SEH2_GetExceptionCode());
405 SafeMinimumSize
= *MinimumSize
;
406 SafeMaximumSize
= *MaximumSize
;
408 PageFileName
.Length
= FileName
->Length
;
409 PageFileName
.MaximumLength
= FileName
->MaximumLength
;
410 PageFileName
.Buffer
= FileName
->Buffer
;
413 /* Pagefiles can't be larger than 4GB and ofcourse the minimum should be
414 smaller than the maximum */
415 if (0 != SafeMinimumSize
.u
.HighPart
)
417 return STATUS_INVALID_PARAMETER_2
;
419 if (0 != SafeMaximumSize
.u
.HighPart
)
421 return STATUS_INVALID_PARAMETER_3
;
423 if (SafeMaximumSize
.u
.LowPart
< SafeMinimumSize
.u
.LowPart
)
425 return STATUS_INVALID_PARAMETER_MIX
;
428 /* Validate name length */
429 if (PageFileName
.Length
> 128 * sizeof(WCHAR
))
431 return STATUS_OBJECT_NAME_INVALID
;
434 /* We won't care about any potential UNICODE_NULL */
435 PageFileName
.MaximumLength
= PageFileName
.Length
;
436 /* Allocate a buffer to keep name copy */
437 Buffer
= ExAllocatePoolWithTag(PagedPool
, PageFileName
.Length
, TAG_MM
);
440 return STATUS_INSUFFICIENT_RESOURCES
;
444 if (PreviousMode
!= KernelMode
)
448 if (PageFileName
.Length
!= 0)
450 ProbeForRead(PageFileName
.Buffer
, PageFileName
.Length
, sizeof(WCHAR
));
453 RtlCopyMemory(Buffer
, PageFileName
.Buffer
, PageFileName
.Length
);
455 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
457 ExFreePoolWithTag(Buffer
, TAG_MM
);
459 /* Return the exception code */
460 _SEH2_YIELD(return _SEH2_GetExceptionCode());
466 RtlCopyMemory(Buffer
, PageFileName
.Buffer
, PageFileName
.Length
);
469 /* Erase caller's buffer with ours */
470 PageFileName
.Buffer
= Buffer
;
472 /* Create the security descriptor for the page file */
473 Status
= RtlCreateSecurityDescriptor(&SecurityDescriptor
, SECURITY_DESCRIPTOR_REVISION
);
474 if (!NT_SUCCESS(Status
))
476 ExFreePoolWithTag(Buffer
, TAG_MM
);
480 /* Create the DACL: we will only allow two SIDs */
481 Count
= sizeof(ACL
) + (sizeof(ACE
) + RtlLengthSid(SeLocalSystemSid
)) +
482 (sizeof(ACE
) + RtlLengthSid(SeAliasAdminsSid
));
483 Dacl
= ExAllocatePoolWithTag(PagedPool
, Count
, 'lcaD');
486 ExFreePoolWithTag(Buffer
, TAG_MM
);
487 return STATUS_INSUFFICIENT_RESOURCES
;
490 /* Initialize the DACL */
491 Status
= RtlCreateAcl(Dacl
, Count
, ACL_REVISION
);
492 if (!NT_SUCCESS(Status
))
494 ExFreePoolWithTag(Dacl
, 'lcaD');
495 ExFreePoolWithTag(Buffer
, TAG_MM
);
499 /* Grant full access to admins */
500 Status
= RtlAddAccessAllowedAce(Dacl
, ACL_REVISION
, FILE_ALL_ACCESS
, SeAliasAdminsSid
);
501 if (!NT_SUCCESS(Status
))
503 ExFreePoolWithTag(Dacl
, 'lcaD');
504 ExFreePoolWithTag(Buffer
, TAG_MM
);
508 /* Grant full access to SYSTEM */
509 Status
= RtlAddAccessAllowedAce(Dacl
, ACL_REVISION
, FILE_ALL_ACCESS
, SeLocalSystemSid
);
510 if (!NT_SUCCESS(Status
))
512 ExFreePoolWithTag(Dacl
, 'lcaD');
513 ExFreePoolWithTag(Buffer
, TAG_MM
);
517 /* Attach the DACL to the security descriptor */
518 Status
= RtlSetDaclSecurityDescriptor(&SecurityDescriptor
, TRUE
, Dacl
, FALSE
);
519 if (!NT_SUCCESS(Status
))
521 ExFreePoolWithTag(Dacl
, 'lcaD');
522 ExFreePoolWithTag(Buffer
, TAG_MM
);
526 InitializeObjectAttributes(&ObjectAttributes
,
530 &SecurityDescriptor
);
532 /* Make sure we can at least store a complete page:
533 * If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
534 * a problem if the paging file is fragmented. Suppose the first cluster
535 * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
536 * paging file but of another file. We can't write a complete page (4096
537 * bytes) to the physical location of cluster 3042 then. */
538 AllocationSize
.QuadPart
= SafeMinimumSize
.QuadPart
+ PAGE_SIZE
;
540 /* First, attempt to replace the page file, if existing */
541 Status
= IoCreateFile(&FileHandle
,
542 SYNCHRONIZE
| WRITE_DAC
| FILE_READ_DATA
| FILE_WRITE_DATA
,
546 FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
,
549 FILE_DELETE_ON_CLOSE
| FILE_NO_COMPRESSION
| FILE_NO_INTERMEDIATE_BUFFERING
,
554 SL_OPEN_PAGING_FILE
| IO_NO_PARAMETER_CHECKING
);
555 /* If we failed, relax a bit constraints, someone may be already holding the
556 * the file, so share write, don't attempt to replace and don't delete on close
557 * (basically, don't do anything conflicting)
558 * This can happen if the caller attempts to extend a page file.
560 if (!NT_SUCCESS(Status
))
564 Status
= IoCreateFile(&FileHandle
,
565 SYNCHRONIZE
| FILE_WRITE_DATA
,
569 FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
,
570 FILE_SHARE_WRITE
| FILE_SHARE_READ
,
572 FILE_NO_COMPRESSION
| FILE_NO_INTERMEDIATE_BUFFERING
,
577 SL_OPEN_PAGING_FILE
| IO_NO_PARAMETER_CHECKING
);
578 if (!NT_SUCCESS(Status
))
580 ExFreePoolWithTag(Dacl
, 'lcaD');
581 ExFreePoolWithTag(Buffer
, TAG_MM
);
585 /* We opened it! Check we are that "someone" ;-)
586 * First, get the opened file object.
588 Status
= ObReferenceObjectByHandle(FileHandle
,
589 FILE_READ_DATA
| FILE_WRITE_DATA
,
594 if (!NT_SUCCESS(Status
))
597 ExFreePoolWithTag(Dacl
, 'lcaD');
598 ExFreePoolWithTag(Buffer
, TAG_MM
);
602 /* Find if it matches a previous page file */
605 /* FIXME: should be calling unsafe instead,
606 * we should already be in a guarded region
608 KeAcquireGuardedMutex(&MmPageFileCreationLock
);
609 if (MmNumberOfPagingFiles
> 0)
613 while (MmPagingFile
[i
]->FileObject
->SectionObjectPointer
!= FileObject
->SectionObjectPointer
)
616 if (i
>= MmNumberOfPagingFiles
)
622 /* This is the matching page file */
623 PagingFile
= MmPagingFile
[i
];
626 /* If we didn't find the page file, fail */
627 if (PagingFile
== NULL
)
629 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
630 ObDereferenceObject(FileObject
);
632 ExFreePoolWithTag(Dacl
, 'lcaD');
633 ExFreePoolWithTag(Buffer
, TAG_MM
);
634 return STATUS_NOT_FOUND
;
637 /* Don't allow page file shrinking */
638 if (PagingFile
->MinimumSize
> (SafeMinimumSize
.QuadPart
>> PAGE_SHIFT
))
640 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
641 ObDereferenceObject(FileObject
);
643 ExFreePoolWithTag(Dacl
, 'lcaD');
644 ExFreePoolWithTag(Buffer
, TAG_MM
);
645 return STATUS_INVALID_PARAMETER_2
;
648 if ((SafeMaximumSize
.QuadPart
>> PAGE_SHIFT
) < PagingFile
->MaximumSize
)
650 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
651 ObDereferenceObject(FileObject
);
653 ExFreePoolWithTag(Dacl
, 'lcaD');
654 ExFreePoolWithTag(Buffer
, TAG_MM
);
655 return STATUS_INVALID_PARAMETER_3
;
658 /* FIXME: implement parameters checking and page file extension */
661 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
662 ObDereferenceObject(FileObject
);
664 ExFreePoolWithTag(Dacl
, 'lcaD');
665 ExFreePoolWithTag(Buffer
, TAG_MM
);
666 return STATUS_NOT_IMPLEMENTED
;
669 if (!NT_SUCCESS(Status
))
671 DPRINT1("Failed creating page file: %lx\n", Status
);
672 ExFreePoolWithTag(Dacl
, 'lcaD');
673 ExFreePoolWithTag(Buffer
, TAG_MM
);
677 /* Set the security descriptor */
678 if (NT_SUCCESS(IoStatus
.Status
))
680 Status
= ZwSetSecurityObject(FileHandle
, DACL_SECURITY_INFORMATION
, &SecurityDescriptor
);
681 if (!NT_SUCCESS(Status
))
683 ExFreePoolWithTag(Dacl
, 'lcaD');
685 ExFreePoolWithTag(Buffer
, TAG_MM
);
690 /* DACL is no longer needed, free it */
691 ExFreePoolWithTag(Dacl
, 'lcaD');
693 /* FIXME: To enable once page file managment is moved to ARM3 */
695 /* Check we won't overflow commit limit with the page file */
696 if (MmTotalCommitLimitMaximum
+ (SafeMaximumSize
.QuadPart
>> PAGE_SHIFT
) <= MmTotalCommitLimitMaximum
)
699 ExFreePoolWithTag(Buffer
, TAG_MM
);
700 return STATUS_INVALID_PARAMETER_3
;
704 /* Set its end of file to minimal size */
705 Status
= ZwSetInformationFile(FileHandle
,
708 sizeof(LARGE_INTEGER
),
709 FileEndOfFileInformation
);
710 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(IoStatus
.Status
))
713 ExFreePoolWithTag(Buffer
, TAG_MM
);
717 Status
= ObReferenceObjectByHandle(FileHandle
,
723 if (!NT_SUCCESS(Status
))
726 ExFreePoolWithTag(Buffer
, TAG_MM
);
730 /* Deny page file creation on a floppy disk */
731 FsDeviceInfo
.Characteristics
= 0;
732 IoQueryVolumeInformation(FileObject
, FileFsDeviceInformation
, sizeof(FsDeviceInfo
), &FsDeviceInfo
, &Count
);
733 if (BooleanFlagOn(FsDeviceInfo
.Characteristics
, FILE_FLOPPY_DISKETTE
))
735 ObDereferenceObject(FileObject
);
737 ExFreePoolWithTag(Buffer
, TAG_MM
);
738 return STATUS_FLOPPY_VOLUME
;
741 PagingFile
= ExAllocatePoolWithTag(NonPagedPool
, sizeof(*PagingFile
), TAG_MM
);
742 if (PagingFile
== NULL
)
744 ObDereferenceObject(FileObject
);
746 ExFreePoolWithTag(Buffer
, TAG_MM
);
747 return STATUS_INSUFFICIENT_RESOURCES
;
750 RtlZeroMemory(PagingFile
, sizeof(*PagingFile
));
752 PagingFile
->FileHandle
= FileHandle
;
753 PagingFile
->FileObject
= FileObject
;
754 PagingFile
->MaximumSize
= (SafeMaximumSize
.QuadPart
>> PAGE_SHIFT
);
755 PagingFile
->Size
= (SafeMinimumSize
.QuadPart
>> PAGE_SHIFT
);
756 PagingFile
->MinimumSize
= (SafeMinimumSize
.QuadPart
>> PAGE_SHIFT
);
757 /* First page is never used: it's the header
760 PagingFile
->FreeSpace
= (ULONG
)(SafeMinimumSize
.QuadPart
/ PAGE_SIZE
) - 1;
761 PagingFile
->CurrentUsage
= 0;
762 PagingFile
->PageFileName
= PageFileName
;
763 ASSERT(PagingFile
->Size
== PagingFile
->FreeSpace
+ PagingFile
->CurrentUsage
+ 1);
765 AllocMapSize
= sizeof(RTL_BITMAP
) + (((PagingFile
->MaximumSize
+ 31) / 32) * sizeof(ULONG
));
766 PagingFile
->Bitmap
= ExAllocatePoolWithTag(NonPagedPool
,
769 if (PagingFile
->Bitmap
== NULL
)
771 ExFreePoolWithTag(PagingFile
, TAG_MM
);
772 ObDereferenceObject(FileObject
);
774 ExFreePoolWithTag(Buffer
, TAG_MM
);
775 return STATUS_INSUFFICIENT_RESOURCES
;
778 RtlInitializeBitMap(PagingFile
->Bitmap
,
779 (PULONG
)(PagingFile
->Bitmap
+ 1),
780 (ULONG
)(PagingFile
->MaximumSize
));
781 RtlClearAllBits(PagingFile
->Bitmap
);
783 /* FIXME: should be calling unsafe instead,
784 * we should already be in a guarded region
786 KeAcquireGuardedMutex(&MmPageFileCreationLock
);
787 ASSERT(MmPagingFile
[MmNumberOfPagingFiles
] == NULL
);
788 MmPagingFile
[MmNumberOfPagingFiles
] = PagingFile
;
789 MmNumberOfPagingFiles
++;
790 MiFreeSwapPages
= MiFreeSwapPages
+ PagingFile
->FreeSpace
;
791 KeReleaseGuardedMutex(&MmPageFileCreationLock
);
793 MmSwapSpaceMessage
= FALSE
;
795 return STATUS_SUCCESS
;