ReactOS  0.4.15-dev-5463-g138eb58
pagefile.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Kernel
3  * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4  * PURPOSE: Paging file functions
5  * COPYRIGHT: Copyright 1998-2003 David Welch <welch@mcmail.com>
6  * Copyright 2010-2018 Pierre Schweitzer <pierre@reactos.org>
7  */
8 
9 /* INCLUDES *****************************************************************/
10 
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14 
15 /* GLOBALS *******************************************************************/
16 
17 /* Minimum pagefile size is 256 pages (1 MB) */
18 #define MINIMUM_PAGEFILE_SIZE (256ULL * PAGE_SIZE)
19 
20 /* Maximum pagefile sizes for different architectures */
21 #if defined(_M_IX86) && !defined(_X86PAE_)
22 /* Around 4 GB */
23  #define MAXIMUM_PAGEFILE_SIZE ((1ULL * 1024 * 1024 - 1) * PAGE_SIZE)
24  // PAGE_ROUND_DOWN(4ULL * GIGABYTE - 1)
25 /* PAE uses the same size as x64 */
26 #elif (defined(_M_IX86) && defined(_X86PAE_)) || defined (_M_AMD64) || defined(_M_ARM64)
27 /* Around 16 TB */
28  #if (NTDDI_VERSION >= NTDDI_WIN10)
29  #define MAXIMUM_PAGEFILE_SIZE ((4ULL * 1024 * 1024 * 1024 - 2) * PAGE_SIZE)
30  // PAGE_ROUND_DOWN(16ULL * TERABYTE - PAGE_SIZE - 1)
31  #else
32  #define MAXIMUM_PAGEFILE_SIZE ((4ULL * 1024 * 1024 * 1024 - 1) * PAGE_SIZE)
33  // PAGE_ROUND_DOWN(16ULL * TERABYTE - 1)
34  #endif
35 #elif defined (_M_IA64)
36 /* Around 32 TB */
37  #define MAXIMUM_PAGEFILE_SIZE ((8ULL * 1024 * 1024 * 1024 - 1) * PAGE_SIZE)
38  // PAGE_ROUND_DOWN(32ULL * TERABYTE - 1)
39 #elif defined(_M_ARM)
40 /* Around 2 GB */
41  #if (NTDDI_VERSION >= NTDDI_WIN10)
42  #define MAXIMUM_PAGEFILE_SIZE ((512ULL * 1024 - 2) * PAGE_SIZE)
43  // PAGE_ROUND_DOWN(2ULL * GIGABYTE - PAGE_SIZE - 1)
44  #elif (NTDDI_VERSION >= NTDDI_WINBLUE) // NTDDI_WIN81
45  #define MAXIMUM_PAGEFILE_SIZE ((512ULL * 1024 - 1) * PAGE_SIZE)
46  // PAGE_ROUND_DOWN(2ULL * GIGABYTE - 1)
47  #else
48 /* Around 4 GB */
49  #define MAXIMUM_PAGEFILE_SIZE ((1ULL * 1024 * 1024 - 1) * PAGE_SIZE)
50  // PAGE_ROUND_DOWN(4ULL * GIGABYTE - 1)
51  #endif
52 #else
53 #error Unknown architecture
54 #endif
55 
56 /* List of paging files, both used and free */
58 
59 /* Lock for examining the list of paging files */
61 
62 /* Number of paging files */
64 
65 /* Number of pages that are available for swapping */
67 
68 /* Number of pages that have been allocated for swapping */
70 
72 
73 /*
74  * Number of pages that have been reserved for swapping but not yet allocated
75  */
77 
78 /*
79  * Ratio between reserved and available swap pages, e.g. setting this to five
80  * forces one swap page to be available for every five swap pages that are
81  * reserved. Setting this to zero turns off commit checking altogether.
82  */
83 #define MM_PAGEFILE_COMMIT_RATIO (1)
84 
85 /*
86  * Number of pages that can be used for potentially swapable memory without
87  * pagefile space being reserved. The intention is that this allows smss
88  * to start up and create page files while ordinarily having a commit
89  * ratio of one.
90  */
91 #define MM_PAGEFILE_COMMIT_GRACE (256)
92 
93 /*
94  * Translate between a swap entry and a file and offset pair.
95  */
96 #define FILE_FROM_ENTRY(i) ((i) & 0x0f)
97 #define OFFSET_FROM_ENTRY(i) ((i) >> 11)
98 #define ENTRY_FROM_FILE_OFFSET(i, j) ((i) | ((j) << 11) | 0x400)
99 
100 /* Make sure there can be only 16 paging files */
102 
104 
106 
107 /* FUNCTIONS *****************************************************************/
108 
109 VOID
110 NTAPI
112 {
113  memcpy(Mdl + 1, Pages, sizeof(PFN_NUMBER) * (PAGE_ROUND_UP(Mdl->ByteOffset+Mdl->ByteCount)/PAGE_SIZE));
114 }
115 
116 
117 BOOLEAN
118 NTAPI
120 {
121  ULONG i;
122 
123  /* Loop through all the paging files */
124  for (i = 0; i < MmNumberOfPagingFiles; i++)
125  {
126  /* Check if this is one of them */
127  if (MmPagingFile[i]->FileObject == FileObject) return TRUE;
128  }
129 
130  /* Nothing found */
131  return FALSE;
132 }
133 
134 VOID
135 NTAPI
137 {
138  if (!MmSwapSpaceMessage)
139  {
140  DPRINT1("MM: Out of swap space.\n");
142  }
143 }
144 
145 NTSTATUS
146 NTAPI
148 {
149  ULONG i;
151  LARGE_INTEGER file_offset;
154  KEVENT Event;
155  UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
156  PMDL Mdl = (PMDL)MdlBase;
157 
158  DPRINT("MmWriteToSwapPage\n");
159 
160  if (SwapEntry == 0)
161  {
162  KeBugCheck(MEMORY_MANAGEMENT);
163  return(STATUS_UNSUCCESSFUL);
164  }
165 
166  i = FILE_FROM_ENTRY(SwapEntry);
167  offset = OFFSET_FROM_ENTRY(SwapEntry) - 1;
168 
169  if (MmPagingFile[i]->FileObject == NULL ||
170  MmPagingFile[i]->FileObject->DeviceObject == NULL)
171  {
172  DPRINT1("Bad paging file 0x%.8X\n", SwapEntry);
173  KeBugCheck(MEMORY_MANAGEMENT);
174  }
175 
178  Mdl->MdlFlags |= MDL_PAGES_LOCKED;
179 
180  file_offset.QuadPart = offset * PAGE_SIZE;
181 
184  Mdl,
185  &file_offset,
186  &Event,
187  &Iosb);
188  if (Status == STATUS_PENDING)
189  {
191  Status = Iosb.Status;
192  }
193 
194  if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
195  {
196  MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
197  }
198  return(Status);
199 }
200 
201 
202 NTSTATUS
203 NTAPI
205 {
206  return MiReadPageFile(Page, FILE_FROM_ENTRY(SwapEntry), OFFSET_FROM_ENTRY(SwapEntry));
207 }
208 
209 NTSTATUS
210 NTAPI
213  _In_ ULONG PageFileIndex,
214  _In_ ULONG_PTR PageFileOffset)
215 {
216  LARGE_INTEGER file_offset;
219  KEVENT Event;
220  UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
221  PMDL Mdl = (PMDL)MdlBase;
222  PMMPAGING_FILE PagingFile;
223 
224  DPRINT("MiReadSwapFile\n");
225 
226  if (PageFileOffset == 0)
227  {
228  KeBugCheck(MEMORY_MANAGEMENT);
229  return(STATUS_UNSUCCESSFUL);
230  }
231 
232  /* Normalize offset. */
233  PageFileOffset--;
234 
235  ASSERT(PageFileIndex < MAX_PAGING_FILES);
236 
237  PagingFile = MmPagingFile[PageFileIndex];
238 
239  if (PagingFile->FileObject == NULL || PagingFile->FileObject->DeviceObject == NULL)
240  {
241  DPRINT1("Bad paging file %u\n", PageFileIndex);
242  KeBugCheck(MEMORY_MANAGEMENT);
243  }
244 
247  Mdl->MdlFlags |= MDL_PAGES_LOCKED | MDL_IO_PAGE_READ;
248 
249  file_offset.QuadPart = PageFileOffset * PAGE_SIZE;
250 
252  Status = IoPageRead(PagingFile->FileObject,
253  Mdl,
254  &file_offset,
255  &Event,
256  &Iosb);
257  if (Status == STATUS_PENDING)
258  {
260  Status = Iosb.Status;
261  }
262  if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
263  {
264  MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
265  }
266  return(Status);
267 }
268 
269 CODE_SEG("INIT")
270 VOID
271 NTAPI
273 {
274  ULONG i;
275 
277 
278  MiFreeSwapPages = 0;
279  MiUsedSwapPages = 0;
281 
282  for (i = 0; i < MAX_PAGING_FILES; i++)
283  {
284  MmPagingFile[i] = NULL;
285  }
287 }
288 
289 VOID
290 NTAPI
292 {
293  ULONG i;
294  ULONG_PTR off;
295  PMMPAGING_FILE PagingFile;
296 
298  off = OFFSET_FROM_ENTRY(Entry) - 1;
299 
301 
302  PagingFile = MmPagingFile[i];
303  if (PagingFile == NULL)
304  {
305  KeBugCheck(MEMORY_MANAGEMENT);
306  }
307 
308  RtlClearBit(PagingFile->Bitmap, off >> 5);
309 
310  PagingFile->FreeSpace++;
311  PagingFile->CurrentUsage--;
312 
313  MiFreeSwapPages++;
314  MiUsedSwapPages--;
316 
318 }
319 
320 SWAPENTRY
321 NTAPI
323 {
324  ULONG i;
325  ULONG off;
327 
329 
330  if (MiFreeSwapPages == 0)
331  {
333  return(0);
334  }
335 
336  for (i = 0; i < MAX_PAGING_FILES; i++)
337  {
338  if (MmPagingFile[i] != NULL &&
339  MmPagingFile[i]->FreeSpace >= 1)
340  {
342  if (off == 0xFFFFFFFF)
343  {
344  KeBugCheck(MEMORY_MANAGEMENT);
346  return(STATUS_UNSUCCESSFUL);
347  }
348  MiUsedSwapPages++;
349  MiFreeSwapPages--;
351 
353 
354  entry = ENTRY_FROM_FILE_OFFSET(i, off + 1);
355  return(entry);
356  }
357  }
358 
360  KeBugCheck(MEMORY_MANAGEMENT);
361  return(0);
362 }
363 
364 NTSTATUS
365 NTAPI
368  _In_ PLARGE_INTEGER MinimumSize,
371 {
377  PMMPAGING_FILE PagingFile;
378  SIZE_T AllocMapSize;
379  ULONG Count;
381  UNICODE_STRING PageFileName;
382  LARGE_INTEGER SafeMinimumSize, SafeMaximumSize, AllocationSize;
383  FILE_FS_DEVICE_INFORMATION FsDeviceInfo;
385  PACL Dacl;
386  PWSTR Buffer;
388 
389  PAGED_CODE();
390 
391  DPRINT("NtCreatePagingFile(FileName: '%wZ', MinimumSize: %I64d, MaximumSize: %I64d)\n",
392  FileName, MinimumSize->QuadPart, MaximumSize->QuadPart);
393 
395  {
397  }
398 
400 
401  if (PreviousMode != KernelMode)
402  {
404  {
406  }
407 
408  _SEH2_TRY
409  {
410  SafeMinimumSize = ProbeForReadLargeInteger(MinimumSize);
411  SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
412  PageFileName = ProbeForReadUnicodeString(FileName);
413  }
415  {
416  /* Return the exception code */
418  }
419  _SEH2_END;
420  }
421  else
422  {
423  SafeMinimumSize = *MinimumSize;
424  SafeMaximumSize = *MaximumSize;
425  PageFileName = *FileName;
426  }
427 
428  /*
429  * Pagefiles cannot be larger than the platform-specific memory addressable
430  * limits, and of course the minimum should be smaller than the maximum.
431  */
432  if (SafeMinimumSize.QuadPart < MINIMUM_PAGEFILE_SIZE ||
433  SafeMinimumSize.QuadPart > MAXIMUM_PAGEFILE_SIZE)
434  {
436  }
437  if (SafeMaximumSize.QuadPart < SafeMinimumSize.QuadPart ||
438  SafeMaximumSize.QuadPart > MAXIMUM_PAGEFILE_SIZE)
439  {
441  }
442 
443  /* Validate the name length */
444  if ((PageFileName.Length == 0) ||
445  (PageFileName.Length > MAXIMUM_FILENAME_LENGTH))
446  {
448  }
449 
450  /* Allocate a buffer to keep the name copy. Note that it is kept only
451  * for information purposes, so it gets allocated in the paged pool,
452  * even if it will be stored in the PagingFile structure, that is
453  * allocated from non-paged pool (see below). */
454  PageFileName.MaximumLength = PageFileName.Length;
456  if (Buffer == NULL)
457  {
459  }
460 
461  /* Copy the name */
462  if (PreviousMode != KernelMode)
463  {
464  _SEH2_TRY
465  {
466  ProbeForRead(PageFileName.Buffer, PageFileName.Length, sizeof(WCHAR));
467  RtlCopyMemory(Buffer, PageFileName.Buffer, PageFileName.Length);
468  }
470  {
472 
473  /* Return the exception code */
475  }
476  _SEH2_END;
477  }
478  else
479  {
480  RtlCopyMemory(Buffer, PageFileName.Buffer, PageFileName.Length);
481  }
482 
483  /* Replace caller's buffer with ours */
484  PageFileName.Buffer = Buffer;
485 
486  /* Create the security descriptor for the page file */
488  if (!NT_SUCCESS(Status))
489  {
491  return Status;
492  }
493 
494  /* Create the DACL: we will only allow two SIDs */
495  Count = sizeof(ACL) + (sizeof(ACE) + RtlLengthSid(SeLocalSystemSid)) +
496  (sizeof(ACE) + RtlLengthSid(SeAliasAdminsSid));
498  if (Dacl == NULL)
499  {
502  }
503 
504  /* Initialize the DACL */
506  if (!NT_SUCCESS(Status))
507  goto EarlyQuit;
508 
509  /* Grant full access to admins */
511  if (!NT_SUCCESS(Status))
512  goto EarlyQuit;
513 
514  /* Grant full access to SYSTEM */
516  if (!NT_SUCCESS(Status))
517  goto EarlyQuit;
518 
519  /* Attach the DACL to the security descriptor */
521  if (!NT_SUCCESS(Status))
522  goto EarlyQuit;
523 
525  &PageFileName,
527  NULL,
529 
530  /* Make sure we can at least store a complete page:
531  * If we have 2048 BytesPerAllocationUnit (FAT16 < 128MB) there is
532  * a problem if the paging file is fragmented. Suppose the first cluster
533  * of the paging file is cluster 3042 but cluster 3043 is NOT part of the
534  * paging file but of another file. We can't write a complete page (4096
535  * bytes) to the physical location of cluster 3042 then. */
536  AllocationSize.QuadPart = SafeMinimumSize.QuadPart + PAGE_SIZE;
537 
538  /* First, attempt to replace the page file, if existing */
542  &IoStatus,
548  NULL,
549  0,
551  NULL,
553  /* If we failed, relax a bit constraints, someone may be already holding the
554  * the file, so share write, don't attempt to replace and don't delete on close
555  * (basically, don't do anything conflicting).
556  * This can happen if the caller attempts to extend a page file.
557  */
558  if (!NT_SUCCESS(Status))
559  {
560  ULONG i;
561 
565  &IoStatus,
569  FILE_OPEN,
571  NULL,
572  0,
574  NULL,
576  if (!NT_SUCCESS(Status))
577  goto EarlyQuit;
578 
579  /* We opened it! Check we are that "someone" ;-)
580  * First, get the opened file object.
581  */
585  KernelMode,
586  (PVOID*)&FileObject,
587  NULL);
588  if (!NT_SUCCESS(Status))
589  {
591  goto EarlyQuit;
592  }
593 
594  /* Find if it matches a previous page file */
595  PagingFile = NULL;
596 
598 
599  for (i = 0; i < MmNumberOfPagingFiles; ++i)
600  {
601  if (MmPagingFile[i]->FileObject->SectionObjectPointer == FileObject->SectionObjectPointer)
602  {
603  /* Same object pointer: this is the matching page file */
604  PagingFile = MmPagingFile[i];
605  break;
606  }
607  }
608 
609  /* If we didn't find the page file, fail */
610  if (PagingFile == NULL)
611  {
616  goto EarlyQuit;
617  }
618 
619  /* Don't allow page file shrinking */
620  if (PagingFile->MinimumSize > (SafeMinimumSize.QuadPart >> PAGE_SHIFT))
621  {
626  goto EarlyQuit;
627  }
628 
629  if ((SafeMaximumSize.QuadPart >> PAGE_SHIFT) < PagingFile->MaximumSize)
630  {
635  goto EarlyQuit;
636  }
637 
638  /* FIXME: implement parameters checking and page file extension */
640 
645  goto EarlyQuit;
646  }
647 
648  if (!NT_SUCCESS(Status))
649  {
650 EarlyQuit:
651  DPRINT1("Failed creating page file: %lx\n", Status);
654  return Status;
655  }
656 
657  /* Set the security descriptor */
658  if (NT_SUCCESS(IoStatus.Status))
659  {
661  if (!NT_SUCCESS(Status))
662  {
666  return Status;
667  }
668  }
669 
670  /* DACL is no longer needed, free it */
672 
673  /* FIXME: To enable once page file management is moved to ARM3 */
674 #if 0
675  /* Check we won't overflow commit limit with the page file */
677  {
681  }
682 #endif
683 
684  /* Set its end of file to minimal size */
685  Status = ZwSetInformationFile(FileHandle,
686  &IoStatus,
687  &SafeMinimumSize,
688  sizeof(LARGE_INTEGER),
690  if (!NT_SUCCESS(Status) || !NT_SUCCESS(IoStatus.Status))
691  {
694  return Status;
695  }
696 
700  KernelMode,
701  (PVOID*)&FileObject,
702  NULL);
703  if (!NT_SUCCESS(Status))
704  {
707  return Status;
708  }
709 
710  /* Only allow page file on a few device types */
716  {
720  return Status;
721  }
722 
723  /* Deny page file creation on a floppy disk */
724  FsDeviceInfo.Characteristics = 0;
726  sizeof(FsDeviceInfo), &FsDeviceInfo, &Count);
728  {
732  return STATUS_FLOPPY_VOLUME;
733  }
734 
735  /*
736  * Missing validation steps TODO:
737  * (see https://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/mm/modwrite/create.htm )
738  *
739  * - Verify that no file system driver or any filter driver has done file
740  * I/O while opening the file.
741  * Verify that nothing of the paging file is yet in memory. Specifically,
742  * the file object must either have no SectionObjectPointer or the latter
743  * must have neither a DataSectionObject nor an ImageSectionObject.
744  * Otherwise, we should fail, returning STATUS_INCOMPATIBLE_FILE_MAP.
745  *
746  * - Inform all the applicable drivers to prepare for the possibility of
747  * paging I/O. Much of the point to paging I/O is to resolve page faults.
748  * Especially important is that drivers that handle paging I/O do not
749  * cause more page faults. All the code and data that each driver might
750  * ever use for access to the paging file must be locked into physical
751  * memory. This can’t be left until paging I/O actually occurs.
752  * It must be done in advance.
753  */
754 
755  PagingFile = ExAllocatePoolZero(NonPagedPool, sizeof(*PagingFile), TAG_MM);
756  if (PagingFile == NULL)
757  {
762  }
763 
764  PagingFile->FileHandle = FileHandle;
765  PagingFile->FileObject = FileObject;
766  PagingFile->Size = (SafeMinimumSize.QuadPart >> PAGE_SHIFT);
767  PagingFile->MinimumSize = PagingFile->Size;
768  PagingFile->MaximumSize = (SafeMaximumSize.QuadPart >> PAGE_SHIFT);
769  /* First page is never used: it's the header
770  * TODO: write it
771  */
772  PagingFile->FreeSpace = PagingFile->Size - 1;
773  PagingFile->CurrentUsage = 0;
774  PagingFile->PageFileName = PageFileName;
775  ASSERT(PagingFile->Size == PagingFile->FreeSpace + PagingFile->CurrentUsage + 1);
776 
777  AllocMapSize = sizeof(RTL_BITMAP) + (((PagingFile->MaximumSize + 31) / 32) * sizeof(ULONG));
779  AllocMapSize,
780  TAG_MM);
781  if (PagingFile->Bitmap == NULL)
782  {
783  ExFreePoolWithTag(PagingFile, TAG_MM);
788  }
789 
790  RtlInitializeBitMap(PagingFile->Bitmap,
791  (PULONG)(PagingFile->Bitmap + 1),
792  (ULONG)(PagingFile->MaximumSize));
793  RtlClearAllBits(PagingFile->Bitmap);
794 
795  /* Insert the new paging file information into the list */
797  /* Ensure the corresponding slot is empty yet */
799  MmPagingFile[MmNumberOfPagingFiles] = PagingFile;
801  MiFreeSwapPages = MiFreeSwapPages + PagingFile->FreeSpace;
803 
805 
807  {
809  }
810 
811  return STATUS_SUCCESS;
812 }
813 
814 /* EOF */
#define MDL_IO_PAGE_READ
Definition: mmtypes.h:24
_SEH2_TRY
Definition: create.c:4226
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
static PFN_COUNT MiReservedSwapPages
Definition: pagefile.c:76
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
#define FILE_NO_COMPRESSION
Definition: from_kernel.h:43
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
struct _RTL_BITMAP RTL_BITMAP
#define MAXIMUM_PAGEFILE_SIZE
Definition: pagefile.c:76
#define MmInitializeMdl(_MemoryDescriptorList, _BaseVa, _Length)
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
USHORT MaximumLength
Definition: env_spec_w32.h:370
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
ULONG PFN_COUNT
Definition: mmtypes.h:102
#define TRUE
Definition: types.h:120
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
VOID NTAPI MmBuildMdlFromPages(PMDL Mdl, PPFN_NUMBER Pages)
Definition: pagefile.c:111
#define FILE_DEVICE_DFS_FILE_SYSTEM
Definition: winioctl.h:159
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define FILE_ATTRIBUTE_SYSTEM
Definition: nt_native.h:704
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
uint16_t * PWSTR
Definition: typedefs.h:56
SWAPENTRY NTAPI MmAllocSwapPage(VOID)
Definition: pagefile.c:322
NTSYSAPI void WINAPI RtlInitializeBitMap(PRTL_BITMAP, PULONG, ULONG)
LONG NTSTATUS
Definition: precomp.h:26
PFN_NUMBER Size
Definition: mm.h:501
SIZE_T MmTotalCommitLimitMaximum
Definition: mminit.c:360
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:3062
NTSTATUS NTAPI IoPageRead(IN PFILE_OBJECT FileObject, IN PMDL Mdl, IN PLARGE_INTEGER Offset, IN PKEVENT Event, IN PIO_STATUS_BLOCK StatusBlock)
Definition: iofunc.c:1201
PFILE_OBJECT FileObject
Definition: mm.h:506
NTSYSAPI NTSTATUS NTAPI RtlCreateSecurityDescriptor(_Out_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ ULONG Revision)
PDEVICE_OBJECT NTAPI IoGetRelatedDeviceObject(IN PFILE_OBJECT FileObject)
Definition: device.c:1539
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
_SEH2_END
Definition: create.c:4400
NTSYSAPI NTSTATUS WINAPI RtlAddAccessAllowedAce(PACL, DWORD, DWORD, PSID)
NTSYSAPI NTSTATUS WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR, BOOLEAN, PACL, BOOLEAN)
PVOID PMDL
Definition: usb.h:39
VOID NTAPI MmShowOutOfSpaceMessagePagingFile(VOID)
Definition: pagefile.c:136
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
NTSTATUS NTAPI MiReadPageFile(_In_ PFN_NUMBER Page, _In_ ULONG PageFileIndex, _In_ ULONG_PTR PageFileOffset)
Definition: pagefile.c:211
#define MDL_MAPPED_TO_SYSTEM_VA
Definition: mmtypes.h:18
#define MAXIMUM_FILENAME_LENGTH
Definition: env_spec_w32.h:41
#define FILE_SHARE_READ
Definition: compat.h:136
#define MINIMUM_PAGEFILE_SIZE
Definition: pagefile.c:18
BOOLEAN NTAPI IoInitializeCrashDump(IN HANDLE PageFileHandle)
Definition: iomgr.c:657
#define STATUS_TOO_MANY_PAGING_FILES
Definition: ntstatus.h:387
NTSYSAPI NTSTATUS NTAPI RtlCreateAcl(PACL Acl, ULONG AclSize, ULONG AclRevision)
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define SECURITY_DESCRIPTOR_REVISION
Definition: setypes.h:58
#define FILE_DEVICE_DFS_VOLUME
Definition: winioctl.h:160
ULONG * PPFN_NUMBER
Definition: ke.h:9
return STATUS_NOT_IMPLEMENTED
NTSTATUS NTAPI IoQueryVolumeInformation(IN PFILE_OBJECT FileObject, IN FS_INFORMATION_CLASS FsInformationClass, IN ULONG Length, OUT PVOID FsInformation, OUT PULONG ReturnedLength)
Definition: iofunc.c:1294
#define FILE_NO_INTERMEDIATE_BUFFERING
Definition: from_kernel.h:28
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
ULONG PFN_NUMBER
Definition: ke.h:9
#define STATUS_INVALID_PARAMETER_3
Definition: ntstatus.h:477
#define TAG_MM
Definition: tag.h:113
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
_In_ PVOID _Out_opt_ BOOLEAN _Out_opt_ PPFN_NUMBER Page
Definition: mm.h:1295
#define FALSE
Definition: types.h:117
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1427
#define IO_NO_PARAMETER_CHECKING
Definition: iotypes.h:541
#define FILE_READ_DATA
Definition: nt_native.h:628
VOID NTAPI MmUnmapLockedPages(IN PVOID BaseAddress, IN PMDL Mdl)
Definition: mdlsup.c:837
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
static BOOLEAN MmSwapSpaceMessage
Definition: pagefile.c:103
unsigned char BOOLEAN
#define DO_SYSTEM_BOOT_PARTITION
Definition: env_spec_w32.h:400
struct _ACL ACL
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:476
#define _In_
Definition: ms_sal.h:308
BOOLEAN MmZeroPageFile
Definition: pagefile.c:71
NTSYSAPI ULONG WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP, ULONG, ULONG)
VOID NTAPI MmInitPagingFile(VOID)
Definition: pagefile.c:272
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
Definition: bufpool.h:45
NTSYSAPI ULONG NTAPI RtlLengthSid(IN PSID Sid)
Definition: sid.c:150
DeviceType
Definition: mmdrv.h:41
PFN_NUMBER MaximumSize
Definition: mm.h:502
PFN_NUMBER MinimumSize
Definition: mm.h:503
#define FILE_WRITE_DATA
Definition: nt_native.h:631
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
UNICODE_STRING PageFileName
Definition: mm.h:507
#define FILE_DEVICE_DISK_FILE_SYSTEM
Definition: winioctl.h:114
Status
Definition: gdiplustypes.h:24
#define MAX_PAGING_FILES
Definition: pagefile.c:23
#define FILE_DELETE_ON_CLOSE
Definition: constants.h:494
#define STATUS_NOT_FOUND
Definition: shellext.h:72
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
int Count
Definition: noreturn.cpp:7
const LUID SeCreatePagefilePrivilege
Definition: priv.c:34
#define ASSERT(a)
Definition: mode.c:44
PFN_NUMBER FreeSpace
Definition: mm.h:504
#define FILE_FROM_ENTRY(i)
Definition: pagefile.c:96
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MDL_PAGES_LOCKED
Definition: mmtypes.h:19
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
GLintptr offset
Definition: glext.h:5920
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define ObDereferenceObject
Definition: obfuncs.h:203
NTSTATUS NTAPI NtCreatePagingFile(_In_ PUNICODE_STRING FileName, _In_ PLARGE_INTEGER MinimumSize, _In_ PLARGE_INTEGER MaximumSize, _In_ ULONG Reserved)
Definition: pagefile.c:366
VOID NTAPI RtlClearBit(_In_ PRTL_BITMAP BitMapHeader, _In_ BITMAP_INDEX BitNumber)
Definition: bitmap.c:294
BOOLEAN NTAPI MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject)
Definition: pagefile.c:119
#define WRITE_DAC
Definition: nt_native.h:59
#define ENTRY_FROM_FILE_OFFSET(i, j)
Definition: pagefile.c:98
#define ProbeForReadLargeInteger(Ptr)
Definition: probe.h:75
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
* PFILE_OBJECT
Definition: iotypes.h:1998
ULONG MmNumberOfPagingFiles
Definition: pagefile.c:63
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
KGUARDED_MUTEX MmPageFileCreationLock
Definition: pagefile.c:60
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL Dacl
Definition: rtlfuncs.h:1593
unsigned char UCHAR
Definition: xmlstorage.h:181
PSID SeAliasAdminsSid
Definition: sid.c:41
NTSTATUS NTAPI MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
Definition: pagefile.c:147
MDL
Definition: mmtypes.h:117
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
uint32_t entry
Definition: isohybrid.c:63
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define PAGE_SIZE
Definition: env_spec_w32.h:49
VOID UpdateTotalCommittedPages(LONG Delta)
Definition: mm.h:871
#define SYNCHRONIZE
Definition: nt_native.h:61
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
#define FILE_OPEN
Definition: from_kernel.h:54
HANDLE FileHandle
Definition: mm.h:509
PMMPAGING_FILE MmPagingFile[MAX_PAGING_FILES]
Definition: pagefile.c:57
IN PFCB IN PFILE_OBJECT FileObject IN ULONG AllocationSize
Definition: fatprocs.h:319
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define IO_OPEN_PAGING_FILE
Definition: iotypes.h:7351
PFN_NUMBER CurrentUsage
Definition: mm.h:505
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1230
struct _FileName FileName
Definition: fatprocs.h:893
PRTL_BITMAP Bitmap
Definition: mm.h:508
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ULONG_PTR SWAPENTRY
Definition: mm.h:56
#define DEVICE_TYPE
Definition: guid.c:10
#define STATUS_OBJECT_NAME_INVALID
Definition: udferr_usr.h:148
#define FILE_ATTRIBUTE_HIDDEN
Definition: nt_native.h:703
unsigned int * PULONG
Definition: retypes.h:1
NTSTATUS NTAPI IoSynchronousPageWrite(IN PFILE_OBJECT FileObject, IN PMDL Mdl, IN PLARGE_INTEGER Offset, IN PKEVENT Event, IN PIO_STATUS_BLOCK StatusBlock)
Definition: iofunc.c:1146
#define FILE_DEVICE_NETWORK_FILE_SYSTEM
Definition: winioctl.h:126
#define NULL
Definition: types.h:112
#define PAGE_ROUND_UP(x)
Definition: mmtypes.h:38
NTSYSAPI void WINAPI RtlClearAllBits(PRTL_BITMAP)
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_opt_ PLARGE_INTEGER MaximumSize
Definition: mmfuncs.h:360
#define ProbeForReadUnicodeString(Ptr)
Definition: probe.h:77
#define DPRINT1
Definition: precomp.h:8
NTSTATUS NTAPI IoCreateFile(OUT PHANDLE FileHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes, IN ULONG ShareAccess, IN ULONG Disposition, IN ULONG CreateOptions, IN PVOID EaBuffer OPTIONAL, IN ULONG EaLength, IN CREATE_FILE_TYPE CreateFileType, IN PVOID ExtraCreateParameters OPTIONAL, IN ULONG Options)
Definition: file.c:3009
BOOLEAN NTAPI SeSinglePrivilegeCheck(_In_ LUID PrivilegeValue, _In_ KPROCESSOR_MODE PreviousMode)
Checks if a single privilege is present in the context of the calling thread.
Definition: priv.c:744
#define ACL_REVISION
Definition: setypes.h:39
PSID SeLocalSystemSid
Definition: sid.c:38
NTSTATUS NTAPI MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_NUMBER Page)
Definition: pagefile.c:204
return Iosb
Definition: create.c:4402
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:155
unsigned int ULONG
Definition: retypes.h:1
#define FILE_SUPERSEDE
Definition: from_kernel.h:53
#define OFFSET_FROM_ENTRY(i)
Definition: pagefile.c:97
#define UNIMPLEMENTED
Definition: debug.h:115
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
#define STATUS_SUCCESS
Definition: shellext.h:65
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
PFN_COUNT MiUsedSwapPages
Definition: pagefile.c:69
#define DPRINT
Definition: sndvol32.h:71
#define FILE_FLOPPY_DISKETTE
Definition: nt_native.h:809
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
static CODE_SEG("PAGE")
Definition: isapnp.c:1482
Definition: rtltypes.h:992
#define TAG_DACL
Definition: tag.h:168
base of all file and directory entries
Definition: entries.h:82
C_ASSERT(FILE_FROM_ENTRY(0xffffffff)< MAX_PAGING_FILES)
#define DACL_SECURITY_INFORMATION
Definition: setypes.h:125
PFN_COUNT MiFreeSwapPages
Definition: pagefile.c:66
LONGLONG QuadPart
Definition: typedefs.h:114
#define STATUS_FLOPPY_VOLUME
Definition: ntstatus.h:592
#define PAGED_CODE()
VOID NTAPI MmFreeSwapPage(SWAPENTRY Entry)
Definition: pagefile.c:291
static BOOLEAN MmSystemPageFileLocated
Definition: pagefile.c:105