ReactOS  0.4.14-dev-77-gd9e7c48
init.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Kernel
3  * LICENSE: BSD - See COPYING.ARM in the top level directory
4  * FILE: ntoskrnl/mm/ARM3/i386/init.c
5  * PURPOSE: ARM Memory Manager Initialization for x86
6  * PROGRAMMERS: ReactOS Portable Systems Group
7  */
8 
9 /* INCLUDES *******************************************************************/
10 
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14 
15 #define MODULE_INVOLVED_IN_ARM3
16 #include <mm/ARM3/miarm.h>
17 
18 /* GLOBALS ********************************************************************/
19 
20 /* Template PTE and PDE for a kernel page */
21  /* FIXME: These should be PTE_GLOBAL */
22 MMPTE ValidKernelPde = {{PTE_VALID|PTE_READWRITE|PTE_DIRTY|PTE_ACCESSED}};
23 MMPTE ValidKernelPte = {{PTE_VALID|PTE_READWRITE|PTE_DIRTY|PTE_ACCESSED}};
24 
25 /* The same, but for local pages */
26 MMPTE ValidKernelPdeLocal = {{PTE_VALID|PTE_READWRITE|PTE_DIRTY|PTE_ACCESSED}};
27 MMPTE ValidKernelPteLocal = {{PTE_VALID|PTE_READWRITE|PTE_DIRTY|PTE_ACCESSED}};
28 
29 /* Template PDE for a demand-zero page */
32 
33 /* Template PTE for prototype page */
35  PTE_PROTOTYPE | (MI_PTE_LOOKUP_NEEDED << PAGE_SHIFT)}};
36 
37 /* Template PTE for decommited page */
39 
40 /* PRIVATE FUNCTIONS **********************************************************/
41 
42 INIT_FUNCTION
43 VOID
44 NTAPI
46 {
47  //
48  // Set the size of session view, pool, and image
49  //
54 
55  //
56  // Set the size of system view
57  //
59 
60  //
61  // This is where it all ends
62  //
64 
65  //
66  // This is where we will load Win32k.sys and the video driver
67  //
70 
71  //
72  // So the view starts right below the session working set (itself below
73  // the image area)
74  //
79 
80  //
81  // Session pool follows
82  //
86 
87  //
88  // And it all begins here
89  //
91 
92  //
93  // Sanity check that our math is correct
94  //
96 
97  //
98  // Session space ends wherever image session space ends
99  //
101 
102  //
103  // System view space ends at session space, so now that we know where
104  // this is, we can compute the base address of system view space itself.
105  //
108 
109  /* Compute the PTE addresses for all the addresses we carved out */
115 
116  /* Initialize session space */
118  MmSessionSize -
121 }
122 
123 INIT_FUNCTION
124 VOID
125 NTAPI
127 {
128  IN PFN_NUMBER PoolPages;
129 
130  /* Check if this is a machine with less than 256MB of RAM, and no overide */
133  {
134  /* Force the non paged pool to be 2MB so we can reduce RAM usage */
136  }
137 
138  /* Hyperspace ends here */
140 
141  /* Check if the user gave a ridicuously large nonpaged pool RAM size */
142  if ((MmSizeOfNonPagedPoolInBytes >> PAGE_SHIFT) > (FreePages * 7 / 8))
143  {
144  /* More than 7/8ths of RAM was dedicated to nonpaged pool, ignore! */
146  }
147 
148  /* Check if no registry setting was set, or if the setting was too low */
150  {
151  /* Start with the minimum (256 KB) and add 32 KB for each MB above 4 */
153  MmSizeOfNonPagedPoolInBytes += (FreePages - 1024) / 256 * MmMinAdditionNonPagedPoolPerMb;
154  }
155 
156  /* Check if the registy setting or our dynamic calculation was too high */
158  {
159  /* Set it to the maximum */
161  }
162 
163  /* Check if a percentage cap was set through the registry */
165 
166  /* Page-align the nonpaged pool size */
168 
169  /* Now, check if there was a registry size for the maximum size */
171  {
172  /* Start with the default (1MB) */
174 
175  /* Add space for PFN database */
177  PAGE_ALIGN((MmHighestPhysicalPage + 1) * sizeof(MMPFN));
178 
179  /* Check if the machine has more than 512MB of free RAM */
180  if (FreePages >= 0x1F000)
181  {
182  /* Add 200KB for each MB above 4 */
183  MmMaximumNonPagedPoolInBytes += (FreePages - 1024) / 256 *
186  {
187  /* Make it at least 128MB since this machine has a lot of RAM */
189  }
190  }
191  else
192  {
193  /* Add 400KB for each MB above 4 */
194  MmMaximumNonPagedPoolInBytes += (FreePages - 1024) / 256 *
196  }
197  }
198 
199  /* Make sure there's at least 16 pages + the PFN available for expansion */
200  PoolPages = MmSizeOfNonPagedPoolInBytes + (PAGE_SIZE * 16) +
201  ((ULONG)PAGE_ALIGN(MmHighestPhysicalPage + 1) * sizeof(MMPFN));
202  if (MmMaximumNonPagedPoolInBytes < PoolPages)
203  {
204  /* The maximum should be at least high enough to cover all the above */
205  MmMaximumNonPagedPoolInBytes = PoolPages;
206  }
207 
208  /* Systems with 2GB of kernel address space get double the size */
209  PoolPages = MI_MAX_NONPAGED_POOL_SIZE * 2;
210 
211  /* On the other hand, make sure that PFN + nonpaged pool doesn't get too big */
212  if (MmMaximumNonPagedPoolInBytes > PoolPages)
213  {
214  /* Trim it down to the maximum architectural limit (256MB) */
215  MmMaximumNonPagedPoolInBytes = PoolPages;
216  }
217 
218  /* Check if this is a system with > 128MB of non paged pool */
220  {
221  /* Check if the initial size is less than the extra 128MB boost */
224  {
225  /* FIXME: Should check if the initial pool can be expanded */
226 
227  /* Assume no expansion possible, check ift he maximum is too large */
230  {
231  /* Set it to the initial value plus the boost */
234  }
235  }
236  }
237 }
238 
239 INIT_FUNCTION
240 NTSTATUS
241 NTAPI
243 {
244  PFN_NUMBER PageFrameIndex;
245  PMMPTE StartPde, EndPde, PointerPte, LastPte;
247  PVOID NonPagedPoolExpansionVa;
248  SIZE_T NonPagedSystemSize;
249  KIRQL OldIrql;
250  PMMPFN Pfn1;
251  ULONG Flags;
252 
253 #if defined(_GLOBAL_PAGES_ARE_AWESOME_)
254 
255  /* Check for global bit */
257  {
258  /* Set it on the template PTE and PDE */
261  }
262 
263 #endif
264 
265  /* Now templates are ready */
268 
269  //
270  // Set CR3 for the system process
271  //
272  PointerPte = MiAddressToPde(PDE_BASE);
273  PageFrameIndex = PFN_FROM_PTE(PointerPte) << PAGE_SHIFT;
274  PsGetCurrentProcess()->Pcb.DirectoryTableBase[0] = PageFrameIndex;
275 
276  //
277  // Blow away user-mode
278  //
279  StartPde = MiAddressToPde(0);
280  EndPde = MiAddressToPde(KSEG0_BASE);
281  RtlZeroMemory(StartPde, (EndPde - StartPde) * sizeof(MMPTE));
282 
283  /* Compute non paged pool limits and size */
285 
286  //
287  // Now calculate the nonpaged pool expansion VA region
288  //
293  NonPagedPoolExpansionVa = MmNonPagedPoolStart;
294  DPRINT("NP Pool has been tuned to: %lu bytes and %lu bytes\n",
296 
297  //
298  // Now calculate the nonpaged system VA region, which includes the
299  // nonpaged pool expansion (above) and the system PTEs. Note that it is
300  // then aligned to a PDE boundary (4MB).
301  //
302  NonPagedSystemSize = (MmNumberOfSystemPtes + 1) * PAGE_SIZE;
304  NonPagedSystemSize);
306  ~(PDE_MAPPED_VA - 1));
307 
308  //
309  // Don't let it go below the minimum
310  //
311  if (MmNonPagedSystemStart < (PVOID)0xEB000000)
312  {
313  //
314  // This is a hard-coded limit in the Windows NT address space
315  //
316  MmNonPagedSystemStart = (PVOID)0xEB000000;
317 
318  //
319  // Reduce the amount of system PTEs to reach this point
320  //
323  PAGE_SHIFT;
326  }
327 
328  //
329  // Check if we are in a situation where the size of the paged pool
330  // is so large that it overflows into nonpaged pool
331  //
334  {
335  //
336  // We need some recalculations here
337  //
338  DPRINT1("Paged pool is too big!\n");
339  }
340 
341  //
342  // Normally, the PFN database should start after the loader images.
343  // This is already the case in ReactOS, but for now we want to co-exist
344  // with the old memory manager, so we'll create a "Shadow PFN Database"
345  // instead, and arbitrarly start it at 0xB0000000.
346  //
347  MmPfnDatabase = (PVOID)0xB0000000;
348  ASSERT(((ULONG_PTR)MmPfnDatabase & (PDE_MAPPED_VA - 1)) == 0);
349 
350  //
351  // Non paged pool comes after the PFN database
352  //
355 
356  //
357  // Now we actually need to get these many physical pages. Nonpaged pool
358  // is actually also physically contiguous (but not the expansion)
359  //
360  PageFrameIndex = MxGetNextPage(MxPfnAllocation +
362  ASSERT(PageFrameIndex != 0);
363  DPRINT("PFN DB PA PFN begins at: %lx\n", PageFrameIndex);
364  DPRINT("NP PA PFN begins at: %lx\n", PageFrameIndex + MxPfnAllocation);
365 
366  /* Convert nonpaged pool size from bytes to pages */
368 
369  //
370  // Now we need some pages to create the page tables for the NP system VA
371  // which includes system PTEs and expansion NP
372  //
375  while (StartPde <= EndPde)
376  {
377  //
378  // Get a page
379  //
381  MI_WRITE_VALID_PTE(StartPde, TempPde);
382 
383  //
384  // Zero out the page table
385  //
386  PointerPte = MiPteToAddress(StartPde);
387  RtlZeroMemory(PointerPte, PAGE_SIZE);
388 
389  //
390  // Next
391  //
392  StartPde++;
393  }
394 
395  //
396  // Now we need pages for the page tables which will map initial NP
397  //
398  StartPde = MiAddressToPde(MmPfnDatabase);
401  while (StartPde <= EndPde)
402  {
403  //
404  // Get a page
405  //
407  MI_WRITE_VALID_PTE(StartPde, TempPde);
408 
409  //
410  // Zero out the page table
411  //
412  PointerPte = MiPteToAddress(StartPde);
413  RtlZeroMemory(PointerPte, PAGE_SIZE);
414 
415  //
416  // Next
417  //
418  StartPde++;
419  }
420 
421  //
422  // Now remember where the expansion starts
423  //
424  MmNonPagedPoolExpansionStart = NonPagedPoolExpansionVa;
425 
426  //
427  // Last step is to actually map the nonpaged pool
428  //
429  PointerPte = MiAddressToPte(MmNonPagedPoolStart);
432  while (PointerPte <= LastPte)
433  {
434  //
435  // Use one of our contigous pages
436  //
437  TempPte.u.Hard.PageFrameNumber = PageFrameIndex++;
438  MI_WRITE_VALID_PTE(PointerPte++, TempPte);
439  }
440 
441  //
442  // Sanity check: make sure we have properly defined the system PTE space
443  //
446 
447  /* Now go ahead and initialize the nonpaged pool */
450 
451  /* Map the PFN database pages */
452  MiMapPfnDatabase(LoaderBlock);
453 
454  /* Initialize the color tables */
456 
457  /* Build the PFN Database */
458  MiInitializePfnDatabase(LoaderBlock);
460 
461  //
462  // Reset the descriptor back so we can create the correct memory blocks
463  //
465 
466  //
467  // Initialize the nonpaged pool
468  //
470 
471  //
472  // We PDE-aligned the nonpaged system start VA, so haul some extra PTEs!
473  //
476  PointerPte;
478  DPRINT("Final System PTE count: %lu (%lu bytes)\n",
480 
481  //
482  // Create the system PTE space
483  //
485 
486  /* Get the PDE For hyperspace */
487  StartPde = MiAddressToPde(HYPER_SPACE);
488 
489  /* Lock PFN database */
491 
492  /* Allocate a page for hyperspace and create it */
494  MI_SET_PROCESS2("Kernel");
495  PageFrameIndex = MiRemoveAnyPage(0);
497  TempPde.u.Hard.PageFrameNumber = PageFrameIndex;
498  MI_WRITE_VALID_PTE(StartPde, TempPde);
499 
500  /* Flush the TLB */
502 
503  /* Release the lock */
505 
506  //
507  // Zero out the page table now
508  //
509  PointerPte = MiAddressToPte(HYPER_SPACE);
510  RtlZeroMemory(PointerPte, PAGE_SIZE);
511 
512  //
513  // Setup the mapping PTEs
514  //
518 
519  /* Set the working set address */
521 
522  //
523  // Reserve system PTEs for zeroing PTEs and clear them
524  //
528 
529  //
530  // Set the counter to maximum to boot with
531  //
533 
534  /* Lock PFN database */
536 
537  /* Reset the ref/share count so that MmInitializeProcessAddressSpace works */
539  Pfn1->u2.ShareCount = 0;
540  Pfn1->u3.e2.ReferenceCount = 0;
541 
542  /* Get a page for the working set list */
544  MI_SET_PROCESS2("Kernel WS List");
545  PageFrameIndex = MiRemoveAnyPage(0);
547  TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
548 
549  /* Map the working set list */
550  PointerPte = MiAddressToPte(MmWorkingSetList);
551  MI_WRITE_VALID_PTE(PointerPte, TempPte);
552 
553  /* Zero it out, and save the frame index */
554  RtlZeroMemory(MiPteToAddress(PointerPte), PAGE_SIZE);
555  PsGetCurrentProcess()->WorkingSetPage = PageFrameIndex;
556 
557  /* Check for Pentium LOCK errata */
559  {
560  /* Mark the 1st IDT page as Write-Through to prevent a lockup
561  on a F00F instruction.
562  See http://www.rcollins.org/Errata/Dec97/F00FBug.html */
563  PointerPte = MiAddressToPte(KeGetPcr()->IDT);
564  PointerPte->u.Hard.WriteThrough = 1;
565  }
566 
567  /* Release the lock */
569 
570  /* Initialize the bogus address space */
571  Flags = 0;
573 
574  /* Make sure the color lists are valid */
576  StartPde = MiAddressToPde(MmFreePagesByColor[0]);
577  ASSERT(StartPde->u.Hard.Valid == 1);
578  PointerPte = MiAddressToPte(MmFreePagesByColor[0]);
579  ASSERT(PointerPte->u.Hard.Valid == 1);
581  ASSERT(LastPte->u.Hard.Valid == 1);
582 
583  /* Loop the color list PTEs */
584  while (PointerPte <= LastPte)
585  {
586  /* Get the PFN entry */
587  Pfn1 = MiGetPfnEntry(PFN_FROM_PTE(PointerPte));
588  if (!Pfn1->u3.e2.ReferenceCount)
589  {
590  /* Fill it out */
591  Pfn1->u4.PteFrame = PFN_FROM_PTE(StartPde);
592  Pfn1->PteAddress = PointerPte;
593  Pfn1->u2.ShareCount++;
594  Pfn1->u3.e2.ReferenceCount = 1;
596  Pfn1->u3.e1.CacheAttribute = MiCached;
597  }
598 
599  /* Keep going */
600  PointerPte++;
601  }
602 
603  /* All done */
604  return STATUS_SUCCESS;
605 }
606 
607 /* EOF */
PFN_NUMBER MiNumberOfFreePages
Definition: mminit.c:384
INIT_FUNCTION VOID NTAPI InitializePool(IN POOL_TYPE PoolType, IN ULONG Threshold)
Definition: expool.c:1017
struct _MMPFN::@1730::@1736 e2
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define IN
Definition: typedefs.h:38
MMPTE PrototypePte
Definition: init.c:42
#define MI_MAX_NONPAGED_POOL_SIZE
Definition: mm.h:57
#define TRUE
Definition: types.h:120
BOOLEAN KiI386PentiumLockErrataPresent
Definition: cpu.c:40
NTSTATUS NTAPI INIT_FUNCTION MiInitMachineDependent(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:672
#define MI_SESSION_SIZE
Definition: mm.h:63
PVOID MiSessionPoolStart
Definition: init.c:32
INIT_FUNCTION VOID NTAPI MiInitializeNonPagedPool(VOID)
Definition: pool.c:276
#define MiAddressToPde(x)
Definition: mmx86.c:20
ULONG MmSessionSize
Definition: init.c:34
SIZE_T MmMinimumNonPagedPoolSize
Definition: mminit.c:39
INIT_FUNCTION VOID NTAPI MiComputeNonPagedPoolVa(IN ULONG FreePages)
Definition: init.c:126
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
ULONG MmMaximumNonPagedPoolPercent
Definition: init.c:20
#define MM_DECOMMIT
Definition: miarm.h:68
ULONG MmNumberOfSystemPtes
Definition: init.c:42
union _MMPFN::@1729 u2
PVOID MiSessionImageStart
Definition: init.c:29
ULONG MmMaxAdditionNonPagedPoolPerMb
Definition: mminit.c:42
LONG NTSTATUS
Definition: precomp.h:26
PMMPTE MiSessionLastPte
Definition: mminit.c:146
PVOID MmNonPagedPoolExpansionStart
Definition: init.c:25
#define MI_PTE_LOOKUP_NEEDED
Definition: miarm.h:255
HARDWARE_PDE_ARMV6 TempPde
Definition: winldr.c:78
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:901
PMM_SESSION_SPACE MmSessionSpace
Definition: session.c:21
INIT_FUNCTION VOID NTAPI MiMapPfnDatabase(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:672
PMMPTE MmLastReservedMappingPte
Definition: hypermap.c:20
#define MM_PTE_SOFTWARE_PROTECTION_BITS
Definition: mm.h:72
ULONG KeFeatureBits
Definition: krnlinit.c:22
PVOID MiSessionSpaceWs
Definition: mminit.c:130
PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor
Definition: init.c:46
ULONG MmSessionImageSize
Definition: init.c:37
PFN_NUMBER MmAvailablePages
Definition: freelist.c:26
ULONG64 Global
Definition: mmtypes.h:166
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:908
#define KeGetPcr()
Definition: ke.h:25
USHORT PageLocation
Definition: mm.h:297
PMMPFN MmPfnDatabase
Definition: freelist.c:24
INIT_FUNCTION PFN_NUMBER NTAPI MxGetNextPage(IN PFN_NUMBER PageCount)
Definition: mminit.c:483
SIZE_T MmSizeOfPagedPoolInBytes
Definition: miarm.h:600
PVOID MmNonPagedPoolEnd
Definition: mminit.c:99
uint32_t ULONG_PTR
Definition: typedefs.h:63
UCHAR KIRQL
Definition: env_spec_w32.h:591
MMPFNENTRY e1
Definition: mm.h:329
PVOID MmSessionBase
Definition: init.c:33
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define MI_SESSION_WORKING_SET_SIZE
Definition: mm.h:62
USHORT CacheAttribute
Definition: mm.h:299
#define MiAddressToPte(x)
Definition: mmx86.c:19
ULONG PFN_NUMBER
Definition: ke.h:8
PVOID MmNonPagedSystemStart
Definition: init.c:23
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:951
ULONG MmSystemViewSize
Definition: init.c:39
ULONG_PTR ShareCount
Definition: mm.h:322
INIT_FUNCTION VOID NTAPI MiInitializePfnDatabase(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:1074
union _MMPTE::@2236 u
#define KSEG0_BASE
Definition: ketypes.h:273
#define PDE_BASE
Definition: winldr.c:21
PMMPTE MmFirstReservedMappingPte
Definition: hypermap.c:20
ULONG MmSessionViewSize
Definition: init.c:35
#define MI_SET_PROCESS2(x)
Definition: mm.h:254
PVOID MiSystemViewStart
Definition: init.c:38
ULONG64 WriteThrough
Definition: mmtypes.h:161
VOID NTAPI INIT_FUNCTION MiInitializeSessionSpaceLayout(VOID)
Definition: init.c:65
#define PsGetCurrentProcess
Definition: psfuncs.h:17
#define MI_HYPERSPACE_PTES
Definition: mm.h:78
smooth NULL
Definition: ftsmooth.c:416
PVOID FORCEINLINE MiPteToAddress(PMMPTE PointerPte)
Definition: mm.h:198
void DPRINT(...)
Definition: polytest.cpp:61
#define MI_SET_USAGE(x)
Definition: mm.h:253
void * PVOID
Definition: retypes.h:9
PMMCOLOR_TABLES MmFreePagesByColor[FreePageList+1]
Definition: mminit.c:286
Definition: utils.h:177
ULONG PageFrameNumber
Definition: mmtypes.h:74
#define PDE_MAPPED_VA
Definition: miarm.h:22
#define MI_WORKING_SET_LIST
Definition: mm.h:48
#define MI_MAPPING_RANGE_END
Definition: mm.h:45
MMPTE ValidKernelPteLocal
Definition: init.c:35
ULONG64 Valid
Definition: mmtypes.h:150
NTSTATUS NTAPI MmInitializeProcessAddressSpace(IN PEPROCESS Process, IN PEPROCESS Clone OPTIONAL, IN PVOID Section OPTIONAL, IN OUT PULONG Flags, IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL)
PVOID MiSessionSpaceEnd
Definition: init.c:27
#define MI_SESSION_IMAGE_SIZE
Definition: mm.h:61
#define PAGE_ALIGN(Va)
PVOID MiSessionImageEnd
Definition: init.c:28
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
MMPTE ValidKernelPte
Definition: init.c:31
ULONG MmHighestPhysicalPage
Definition: init.c:48
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define MI_MIN_PAGES_FOR_NONPAGED_POOL_TUNING
Definition: mm.h:51
INIT_FUNCTION VOID NTAPI MiInitializeNonPagedPoolThresholds(VOID)
Definition: pool.c:184
#define MI_MAPPING_RANGE_START
Definition: mm.h:44
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define MM_READWRITE
Definition: inbv.c:10
PFN_NUMBER MmMaximumNonPagedPoolInPages
Definition: mminit.c:30
PMMPTE MiSessionImagePteStart
Definition: mminit.c:143
Definition: mm.h:305
ULONG MmMinAdditionNonPagedPoolPerMb
Definition: mminit.c:40
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define PTE_BASE
Definition: mmx86.c:14
#define _1MB
Definition: miarm.h:15
ULONG MmSecondaryColors
Definition: mminit.c:256
INIT_FUNCTION VOID NTAPI MiInitializeSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE PoolType)
Definition: syspte.c:399
struct _MMPFN MMPFN
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:940
PMMWSL MmWorkingSetList
Definition: procsup.c:21
MMPTE ValidKernelPdeLocal
Definition: init.c:34
MMPTE ValidKernelPde
Definition: init.c:30
PVOID MmPagedPoolStart
Definition: miarm.h:589
PVOID MmNonPagedPoolStart
Definition: init.c:24
ULONG MmSessionPoolSize
Definition: init.c:36
PFN_NUMBER NTAPI MiRemoveAnyPage(IN ULONG Color)
Definition: pfnlist.c:475
ULONG_PTR SIZE_T
Definition: typedefs.h:78
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
SIZE_T MmDefaultMaximumNonPagedPool
Definition: mminit.c:41
INIT_FUNCTION VOID NTAPI MmInitializeBalancer(ULONG NrAvailablePages, ULONG NrSystemPages)
Definition: balance.c:53
PVOID MiSessionViewStart
Definition: init.c:30
ULONG_PTR PteFrame
Definition: mm.h:350
ULONG MmMaximumNonPagedPoolInBytes
Definition: init.c:22
PMMPTE PteAddress
Definition: mm.h:318
ULONG MmNumberOfPhysicalPages
Definition: init.c:48
MMPDE DemandZeroPde
Definition: init.c:38
#define MI_MAX_INIT_NONPAGED_POOL_SIZE
Definition: mm.h:56
#define DPRINT1
Definition: precomp.h:8
ULONG MxPfnAllocation
Definition: init.c:43
struct _MM_SESSION_SPACE * PMM_SESSION_SPACE
union _MMPFN::@1733 u4
#define MI_SYSTEM_VIEW_SIZE
Definition: mm.h:58
union _MMPFN::@1730 u3
#define HYPER_SPACE
Definition: mm.h:14
PVOID MiSessionPoolEnd
Definition: init.c:31
PVOID MmHyperSpaceEnd
Definition: init.c:56
PMMWSL MmSystemCacheWorkingSetList
Definition: mminit.c:174
unsigned int ULONG
Definition: retypes.h:1
#define UNIMPLEMENTED
Definition: debug.h:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define ULONG_PTR
Definition: config.h:101
ULONG64 PageFrameNumber
Definition: mmtypes.h:171
PMMPTE MiFirstReservedZeroingPte
Definition: hypermap.c:21
MMPTE DemandZeroPte
Definition: init.c:39
#define MI_SESSION_VIEW_SIZE
Definition: mm.h:59
#define MI_SESSION_POOL_SIZE
Definition: mm.h:60
MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor
Definition: init.c:47
ULONG MmSizeOfNonPagedPoolInBytes
Definition: init.c:21
#define KF_GLOBAL_PAGE
Definition: ketypes.h:147
PMMPTE MiSessionBasePte
Definition: mminit.c:145
MMPTE MmDecommittedPte
Definition: init.c:46
#define MI_ZERO_PTES
Definition: mm.h:79
INIT_FUNCTION VOID NTAPI MiInitializeColorTables(VOID)
Definition: mminit.c:562
return STATUS_SUCCESS
Definition: btrfs.c:2966
#define PFN_FROM_PTE(v)
Definition: mm.h:89
#define MM_ALLOCATION_GRANULARITY
Definition: mmtypes.h:36
VOID NTAPI KeFlushCurrentTb(VOID)
Definition: cpu.c:322
ULONG PageFrameNumber
Definition: mmtypes.h:109
PMMPTE MiSessionImagePteEnd
Definition: mminit.c:144