ReactOS  0.4.14-dev-114-gc8cbd56
procsup.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/procsup.c
5  * PURPOSE: ARM Memory Manager Process Related Management
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 
24 
25 /* PRIVATE FUNCTIONS **********************************************************/
26 
28 NTAPI
30  IN ULONG Size,
32 {
33  PMMVAD_LONG Vad;
35  ULONG_PTR HighestAddress, RandomBase;
36  ULONG AlignedSize;
37  LARGE_INTEGER CurrentTime;
38 
39  /* Allocate a VAD */
40  Vad = ExAllocatePoolWithTag(NonPagedPool, sizeof(MMVAD_LONG), 'ldaV');
41  if (!Vad) return STATUS_NO_MEMORY;
42 
43  /* Setup the primary flags with the size, and make it commited, private, RW */
44  Vad->u.LongFlags = 0;
46  Vad->u.VadFlags.MemCommit = TRUE;
49  Vad->u.VadFlags.NoChange = TRUE;
50  Vad->u1.Parent = NULL;
51 
52  /* Setup the secondary flags to make it a secured, writable, long VAD */
53  Vad->u2.LongFlags2 = 0;
54  Vad->u2.VadFlags2.OneSecured = TRUE;
55  Vad->u2.VadFlags2.LongVad = TRUE;
56  Vad->u2.VadFlags2.ReadOnly = FALSE;
57 
58  Vad->ControlArea = NULL; // For Memory-Area hack
59  Vad->FirstPrototypePte = NULL;
60 
61  /* Check if this is a PEB creation */
62  ASSERT(sizeof(TEB) != sizeof(PEB));
63  if (Size == sizeof(PEB))
64  {
65  /* Create a random value to select one page in a 64k region */
66  KeQueryTickCount(&CurrentTime);
67  CurrentTime.LowPart &= (_64K / PAGE_SIZE) - 1;
68 
69  /* Calculate a random base address */
70  RandomBase = (ULONG_PTR)MM_HIGHEST_VAD_ADDRESS + 1;
71  RandomBase -= CurrentTime.LowPart << PAGE_SHIFT;
72 
73  /* Make sure the base address is not too high */
74  AlignedSize = ROUND_TO_PAGES(Size);
75  if ((RandomBase + AlignedSize) > (ULONG_PTR)MM_HIGHEST_VAD_ADDRESS + 1)
76  {
77  RandomBase = (ULONG_PTR)MM_HIGHEST_VAD_ADDRESS + 1 - AlignedSize;
78  }
79 
80  /* Calculate the highest allowed address */
81  HighestAddress = RandomBase + AlignedSize - 1;
82  }
83  else
84  {
85  HighestAddress = (ULONG_PTR)MM_HIGHEST_VAD_ADDRESS;
86  }
87 
88  *BaseAddress = 0;
91  Size,
92  HighestAddress,
93  PAGE_SIZE,
94  MEM_TOP_DOWN);
95  if (!NT_SUCCESS(Status))
96  {
97  ExFreePoolWithTag(Vad, 'ldaV');
98  return STATUS_NO_MEMORY;
99  }
100 
101  /* Success */
102  return STATUS_SUCCESS;
103 }
104 
105 VOID
106 NTAPI
108  IN PTEB Teb)
109 {
110  ULONG_PTR TebEnd;
112  PMMVAD Vad;
113  PMM_AVL_TABLE VadTree = &Process->VadRoot;
114  DPRINT("Deleting TEB: %p in %16s\n", Teb, Process->ImageFileName);
115 
116  /* TEB is one page */
117  TebEnd = (ULONG_PTR)Teb + ROUND_TO_PAGES(sizeof(TEB)) - 1;
118 
119  /* Attach to the process */
120  KeAttachProcess(&Process->Pcb);
121 
122  /* Lock the process address space */
123  KeAcquireGuardedMutex(&Process->AddressCreationLock);
124 
125  /* Find the VAD, make sure it's a TEB VAD */
126  Vad = MiLocateAddress(Teb);
127  DPRINT("Removing node for VAD: %lx %lx\n", Vad->StartingVpn, Vad->EndingVpn);
128  ASSERT(Vad != NULL);
129  if (Vad->StartingVpn != ((ULONG_PTR)Teb >> PAGE_SHIFT))
130  {
131  /* Bug in the AVL code? */
132  DPRINT1("Corrupted VAD!\n");
133  }
134  else
135  {
136  /* Sanity checks for a valid TEB VAD */
137  ASSERT((Vad->StartingVpn == ((ULONG_PTR)Teb >> PAGE_SHIFT) &&
138  (Vad->EndingVpn == (TebEnd >> PAGE_SHIFT))));
139  ASSERT(Vad->u.VadFlags.NoChange == TRUE);
140  ASSERT(Vad->u2.VadFlags2.OneSecured == TRUE);
142 
143  /* Lock the working set */
145 
146  /* Remove this VAD from the tree */
147  ASSERT(VadTree->NumberGenericTableElements >= 1);
148  MiRemoveNode((PMMADDRESS_NODE)Vad, VadTree);
149 
150  /* Delete the pages */
151  MiDeleteVirtualAddresses((ULONG_PTR)Teb, TebEnd, NULL);
152 
153  /* Release the working set */
155 
156  /* Remove the VAD */
157  ExFreePool(Vad);
158  }
159 
160  /* Release the address space lock */
161  KeReleaseGuardedMutex(&Process->AddressCreationLock);
162 
163  /* Detach */
164  KeDetachProcess();
165 }
166 
167 VOID
168 NTAPI
170  IN BOOLEAN GuiStack)
171 {
172  PMMPTE PointerPte;
173  PFN_NUMBER PageFrameNumber, PageTableFrameNumber;
174  PFN_COUNT StackPages;
175  PMMPFN Pfn1, Pfn2;
176  ULONG i;
177  KIRQL OldIrql;
178  PSLIST_ENTRY SListEntry;
179 
180  //
181  // This should be the guard page, so decrement by one
182  //
183  PointerPte = MiAddressToPte(StackBase);
184  PointerPte--;
185 
186  //
187  // If this is a small stack, just push the stack onto the dead stack S-LIST
188  //
189  if (!GuiStack)
190  {
192  {
193  SListEntry = ((PSLIST_ENTRY)StackBase) - 1;
195  return;
196  }
197  }
198 
199  //
200  // Calculate pages used
201  //
202  StackPages = BYTES_TO_PAGES(GuiStack ?
204 
205  /* Acquire the PFN lock */
207 
208  //
209  // Loop them
210  //
211  for (i = 0; i < StackPages; i++)
212  {
213  //
214  // Check if this is a valid PTE
215  //
216  if (PointerPte->u.Hard.Valid == 1)
217  {
218  /* Get the PTE's page */
219  PageFrameNumber = PFN_FROM_PTE(PointerPte);
220  Pfn1 = MiGetPfnEntry(PageFrameNumber);
221 
222  /* Now get the page of the page table mapping it */
223  PageTableFrameNumber = Pfn1->u4.PteFrame;
224  Pfn2 = MiGetPfnEntry(PageTableFrameNumber);
225 
226  /* Remove a shared reference, since the page is going away */
227  MiDecrementShareCount(Pfn2, PageTableFrameNumber);
228 
229  /* Set the special pending delete marker */
230  MI_SET_PFN_DELETED(Pfn1);
231 
232  /* And now delete the actual stack page */
233  MiDecrementShareCount(Pfn1, PageFrameNumber);
234  }
235 
236  //
237  // Next one
238  //
239  PointerPte--;
240  }
241 
242  //
243  // We should be at the guard page now
244  //
245  ASSERT(PointerPte->u.Hard.Valid == 0);
246 
247  /* Release the PFN lock */
249 
250  //
251  // Release the PTEs
252  //
253  MiReleaseSystemPtes(PointerPte, StackPages + 1, SystemPteSpace);
254 }
255 
256 PVOID
257 NTAPI
259  IN UCHAR Node)
260 {
261  PFN_COUNT StackPtes, StackPages;
262  PMMPTE PointerPte, StackPte;
264  MMPTE TempPte, InvalidPte;
265  KIRQL OldIrql;
266  PFN_NUMBER PageFrameIndex;
267  ULONG i;
268  PSLIST_ENTRY SListEntry;
269 
270  //
271  // Calculate pages needed
272  //
273  if (GuiStack)
274  {
275  //
276  // We'll allocate 64KB stack, but only commit 12K
277  //
278  StackPtes = BYTES_TO_PAGES(MmLargeStackSize);
280  }
281  else
282  {
283  //
284  // If the dead stack S-LIST has a stack on it, use it instead of allocating
285  // new system PTEs for this stack
286  //
288  {
290  if (SListEntry != NULL)
291  {
292  BaseAddress = (SListEntry + 1);
293  return BaseAddress;
294  }
295  }
296 
297  //
298  // We'll allocate 12K and that's it
299  //
300  StackPtes = BYTES_TO_PAGES(KERNEL_STACK_SIZE);
301  StackPages = StackPtes;
302  }
303 
304  //
305  // Reserve stack pages, plus a guard page
306  //
307  StackPte = MiReserveSystemPtes(StackPtes + 1, SystemPteSpace);
308  if (!StackPte) return NULL;
309 
310  //
311  // Get the stack address
312  //
313  BaseAddress = MiPteToAddress(StackPte + StackPtes + 1);
314 
315  //
316  // Select the right PTE address where we actually start committing pages
317  //
318  PointerPte = StackPte;
319  if (GuiStack) PointerPte += BYTES_TO_PAGES(MmLargeStackSize -
321 
322 
323  /* Setup the temporary invalid PTE */
324  MI_MAKE_SOFTWARE_PTE(&InvalidPte, MM_NOACCESS);
325 
326  /* Setup the template stack PTE */
327  MI_MAKE_HARDWARE_PTE_KERNEL(&TempPte, PointerPte + 1, MM_READWRITE, 0);
328 
329  //
330  // Acquire the PFN DB lock
331  //
333 
334  //
335  // Loop each stack page
336  //
337  for (i = 0; i < StackPages; i++)
338  {
339  //
340  // Next PTE
341  //
342  PointerPte++;
343 
344  /* Get a page and write the current invalid PTE */
346  MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
347  PageFrameIndex = MiRemoveAnyPage(MI_GET_NEXT_COLOR());
348  MI_WRITE_INVALID_PTE(PointerPte, InvalidPte);
349 
350  /* Initialize the PFN entry for this page */
351  MiInitializePfn(PageFrameIndex, PointerPte, 1);
352 
353  /* Write the valid PTE */
354  TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
355  MI_WRITE_VALID_PTE(PointerPte, TempPte);
356  }
357 
358  //
359  // Release the PFN lock
360  //
362 
363  //
364  // Return the stack address
365  //
366  return BaseAddress;
367 }
368 
369 NTSTATUS
370 NTAPI
372  IN ULONG GrowSize)
373 {
375  PMMPTE LimitPte, NewLimitPte, LastPte;
376  KIRQL OldIrql;
377  MMPTE TempPte, InvalidPte;
378  PFN_NUMBER PageFrameIndex;
379 
380  //
381  // Make sure the stack did not overflow
382  //
383  ASSERT(((ULONG_PTR)Thread->StackBase - (ULONG_PTR)Thread->StackLimit) <=
385 
386  //
387  // Get the current stack limit
388  //
389  LimitPte = MiAddressToPte(Thread->StackLimit);
390  ASSERT(LimitPte->u.Hard.Valid == 1);
391 
392  //
393  // Get the new one and make sure this isn't a retarded request
394  //
395  NewLimitPte = MiAddressToPte((PVOID)((ULONG_PTR)StackPointer - GrowSize));
396  if (NewLimitPte == LimitPte) return STATUS_SUCCESS;
397 
398  //
399  // Now make sure you're not going past the reserved space
400  //
401  LastPte = MiAddressToPte((PVOID)((ULONG_PTR)Thread->StackBase -
403  if (NewLimitPte < LastPte)
404  {
405  //
406  // Sorry!
407  //
408  return STATUS_STACK_OVERFLOW;
409  }
410 
411  //
412  // Calculate the number of new pages
413  //
414  LimitPte--;
415 
416  /* Setup the temporary invalid PTE */
417  MI_MAKE_SOFTWARE_PTE(&InvalidPte, MM_NOACCESS);
418 
419  //
420  // Acquire the PFN DB lock
421  //
423 
424  //
425  // Loop each stack page
426  //
427  while (LimitPte >= NewLimitPte)
428  {
429  /* Get a page and write the current invalid PTE */
431  MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
432  PageFrameIndex = MiRemoveAnyPage(MI_GET_NEXT_COLOR());
433  MI_WRITE_INVALID_PTE(LimitPte, InvalidPte);
434 
435  /* Initialize the PFN entry for this page */
436  MiInitializePfn(PageFrameIndex, LimitPte, 1);
437 
438  /* Setup the template stack PTE */
439  MI_MAKE_HARDWARE_PTE_KERNEL(&TempPte, LimitPte, MM_READWRITE, PageFrameIndex);
440 
441  /* Write the valid PTE */
442  MI_WRITE_VALID_PTE(LimitPte--, TempPte);
443  }
444 
445  //
446  // Release the PFN lock
447  //
449 
450  //
451  // Set the new limit
452  //
453  Thread->StackLimit = (ULONG_PTR)MiPteToAddress(NewLimitPte);
454  return STATUS_SUCCESS;
455 }
456 
457 NTSTATUS
458 NTAPI
460 {
461  //
462  // Call the extended version
463  //
464  return MmGrowKernelStackEx(StackPointer, KERNEL_LARGE_STACK_COMMIT);
465 }
466 
467 NTSTATUS
468 NTAPI
470  IN UCHAR MemoryPriority)
471 {
472  UCHAR OldPriority;
473 
474  //
475  // Check if we have less then 16MB of Physical Memory
476  //
477  if ((MmSystemSize == MmSmallSystem) &&
478  (MmNumberOfPhysicalPages < ((15 * 1024 * 1024) / PAGE_SIZE)))
479  {
480  //
481  // Always use background priority
482  //
483  MemoryPriority = MEMORY_PRIORITY_BACKGROUND;
484  }
485 
486  //
487  // Save the old priority and update it
488  //
489  OldPriority = (UCHAR)Process->Vm.Flags.MemoryPriority;
490  Process->Vm.Flags.MemoryPriority = MemoryPriority;
491 
492  //
493  // Return the old priority
494  //
495  return OldPriority;
496 }
497 
498 NTSTATUS
499 NTAPI
501  IN PINITIAL_PEB InitialPeb,
502  OUT PPEB *BasePeb)
503 {
504  PPEB Peb = NULL;
506  SIZE_T ViewSize = 0;
507  PVOID TableBase = NULL;
508  PIMAGE_NT_HEADERS NtHeaders;
509  PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigData;
511  USHORT Characteristics;
513  SectionOffset.QuadPart = (ULONGLONG)0;
514  *BasePeb = NULL;
515 
516  //
517  // Attach to Process
518  //
519  KeAttachProcess(&Process->Pcb);
520 
521  //
522  // Map NLS Tables
523  //
526  &TableBase,
527  0,
528  0,
529  &SectionOffset,
530  &ViewSize,
531  ViewShare,
532  MEM_TOP_DOWN,
533  PAGE_READONLY);
534  DPRINT("NLS Tables at: %p\n", TableBase);
535  if (!NT_SUCCESS(Status))
536  {
537  /* Cleanup and exit */
538  KeDetachProcess();
539  return Status;
540  }
541 
542  //
543  // Allocate the PEB
544  //
546  DPRINT("PEB at: %p\n", Peb);
547  if (!NT_SUCCESS(Status))
548  {
549  /* Cleanup and exit */
550  KeDetachProcess();
551  return Status;
552  }
553 
554  //
555  // Use SEH in case we can't load the PEB
556  //
557  _SEH2_TRY
558  {
559  //
560  // Initialize the PEB
561  //
562  RtlZeroMemory(Peb, sizeof(PEB));
563 
564  //
565  // Set up data
566  //
567  Peb->ImageBaseAddress = Process->SectionBaseAddress;
568  Peb->InheritedAddressSpace = InitialPeb->InheritedAddressSpace;
569  Peb->Mutant = InitialPeb->Mutant;
570  Peb->ImageUsesLargePages = InitialPeb->ImageUsesLargePages;
571 
572  //
573  // NLS
574  //
578 
579  //
580  // Default Version Data (could get changed below)
581  //
584  Peb->OSBuildNumber = (USHORT)(NtBuildNumber & 0x3FFF);
586  Peb->OSCSDVersion = (USHORT)CmNtCSDVersion;
587 
588  //
589  // Heap and Debug Data
590  //
592  Peb->BeingDebugged = (BOOLEAN)(Process->DebugPort != NULL);
600  Peb->MaximumNumberOfHeaps = (PAGE_SIZE - sizeof(PEB)) / sizeof(PVOID);
601  Peb->ProcessHeaps = (PVOID*)(Peb + 1);
602 
603  //
604  // Session ID
605  //
606  if (Process->Session) Peb->SessionId = MmGetSessionId(Process);
607  }
609  {
610  //
611  // Fail
612  //
613  KeDetachProcess();
615  }
616  _SEH2_END;
617 
618  //
619  // Use SEH in case we can't load the image
620  //
621  _SEH2_TRY
622  {
623  //
624  // Get NT Headers
625  //
626  NtHeaders = RtlImageNtHeader(Peb->ImageBaseAddress);
627  Characteristics = NtHeaders->FileHeader.Characteristics;
628  }
630  {
631  //
632  // Fail
633  //
634  KeDetachProcess();
636  }
637  _SEH2_END;
638 
639  //
640  // Parse the headers
641  //
642  if (NtHeaders)
643  {
644  //
645  // Use SEH in case we can't load the headers
646  //
647  _SEH2_TRY
648  {
649  //
650  // Get the Image Config Data too
651  //
653  TRUE,
655  (PULONG)&ViewSize);
656  if (ImageConfigData)
657  {
658  //
659  // Probe it
660  //
661  ProbeForRead(ImageConfigData,
663  sizeof(ULONG));
664  }
665 
666  //
667  // Write subsystem data
668  //
672 
673  //
674  // Check for version data
675  //
676  if (NtHeaders->OptionalHeader.Win32VersionValue)
677  {
678  //
679  // Extract values and write them
680  //
681  Peb->OSMajorVersion = NtHeaders->OptionalHeader.Win32VersionValue & 0xFF;
682  Peb->OSMinorVersion = (NtHeaders->OptionalHeader.Win32VersionValue >> 8) & 0xFF;
683  Peb->OSBuildNumber = (NtHeaders->OptionalHeader.Win32VersionValue >> 16) & 0x3FFF;
684  Peb->OSPlatformId = (NtHeaders->OptionalHeader.Win32VersionValue >> 30) ^ 2;
685 
686  /* Process CSD version override */
687  if ((ImageConfigData) && (ImageConfigData->CSDVersion))
688  {
689  /* Take the value from the image configuration directory */
690  Peb->OSCSDVersion = ImageConfigData->CSDVersion;
691  }
692  }
693 
694  /* Process optional process affinity mask override */
695  if ((ImageConfigData) && (ImageConfigData->ProcessAffinityMask))
696  {
697  /* Take the value from the image configuration directory */
698  ProcessAffinityMask = ImageConfigData->ProcessAffinityMask;
699  }
700 
701  //
702  // Check if this is a UP image
703  if (Characteristics & IMAGE_FILE_UP_SYSTEM_ONLY)
704  {
705  //
706  // Force it to use CPU 0
707  //
708  /* FIXME: this should use the MmRotatingUniprocessorNumber */
710  }
711  else
712  {
713  //
714  // Whatever was configured
715  //
717  }
718  }
720  {
721  //
722  // Fail
723  //
724  KeDetachProcess();
726  }
727  _SEH2_END;
728  }
729 
730  //
731  // Detach from the Process
732  //
733  KeDetachProcess();
734  *BasePeb = Peb;
735  return STATUS_SUCCESS;
736 }
737 
738 NTSTATUS
739 NTAPI
742  IN PINITIAL_TEB InitialTeb,
743  OUT PTEB *BaseTeb)
744 {
745  PTEB Teb;
747  *BaseTeb = NULL;
748 
749  //
750  // Attach to Target
751  //
752  KeAttachProcess(&Process->Pcb);
753 
754  //
755  // Allocate the TEB
756  //
757  Status = MiCreatePebOrTeb(Process, sizeof(TEB), (PULONG_PTR)&Teb);
758  if (!NT_SUCCESS(Status))
759  {
760  /* Cleanup and exit */
761  KeDetachProcess();
762  return Status;
763  }
764 
765  //
766  // Use SEH in case we can't load the TEB
767  //
768  _SEH2_TRY
769  {
770  //
771  // Initialize the PEB
772  //
773  RtlZeroMemory(Teb, sizeof(TEB));
774 
775  //
776  // Set TIB Data
777  //
778 #ifdef _M_AMD64
779  Teb->NtTib.ExceptionList = NULL;
780 #else
781  Teb->NtTib.ExceptionList = EXCEPTION_CHAIN_END;
782 #endif
783  Teb->NtTib.Self = (PNT_TIB)Teb;
784 
785  //
786  // Identify this as an OS/2 V3.0 ("Cruiser") TIB
787  //
788  Teb->NtTib.Version = 30 << 8;
789 
790  //
791  // Set TEB Data
792  //
793  Teb->ClientId = *ClientId;
794  Teb->RealClientId = *ClientId;
795  Teb->ProcessEnvironmentBlock = Process->Peb;
796  Teb->CurrentLocale = PsDefaultThreadLocaleId;
797 
798  //
799  // Check if we have a grandparent TEB
800  //
801  if ((InitialTeb->PreviousStackBase == NULL) &&
802  (InitialTeb->PreviousStackLimit == NULL))
803  {
804  //
805  // Use initial TEB values
806  //
807  Teb->NtTib.StackBase = InitialTeb->StackBase;
808  Teb->NtTib.StackLimit = InitialTeb->StackLimit;
809  Teb->DeallocationStack = InitialTeb->AllocatedStackBase;
810  }
811  else
812  {
813  //
814  // Use grandparent TEB values
815  //
816  Teb->NtTib.StackBase = InitialTeb->PreviousStackBase;
817  Teb->NtTib.StackLimit = InitialTeb->PreviousStackLimit;
818  }
819 
820  //
821  // Initialize the static unicode string
822  //
823  Teb->StaticUnicodeString.MaximumLength = sizeof(Teb->StaticUnicodeBuffer);
824  Teb->StaticUnicodeString.Buffer = Teb->StaticUnicodeBuffer;
825  }
827  {
828  //
829  // Get error code
830  //
832  }
833  _SEH2_END;
834 
835  //
836  // Return
837  //
838  KeDetachProcess();
839  *BaseTeb = Teb;
840  return Status;
841 }
842 
843 VOID
844 NTAPI
846 {
847  PMMPFN Pfn1;
848  PMMPTE sysPte;
849  MMPTE tempPte;
850 
851  /* Setup some bogus list data */
852  MmWorkingSetList->LastEntry = CurrentProcess->Vm.MinimumWorkingSetSize;
856  MmWorkingSetList->Wsle = (PVOID)(ULONG_PTR)0xDEADBABEDEADBABEULL;
858  MmWorkingSetList->HashTableStart = (PVOID)(ULONG_PTR)0xBADAB00BBADAB00BULL;
864 
865  /* The rule is that the owner process is always in the FLINK of the PDE's PFN entry */
866  Pfn1 = MiGetPfnEntry(CurrentProcess->Pcb.DirectoryTableBase[0] >> PAGE_SHIFT);
867  ASSERT(Pfn1->u4.PteFrame == MiGetPfnEntryIndex(Pfn1));
868  Pfn1->u1.Event = (PKEVENT)CurrentProcess;
869 
870  /* Map the process working set in kernel space */
871  sysPte = MiReserveSystemPtes(1, SystemPteSpace);
872  MI_MAKE_HARDWARE_PTE_KERNEL(&tempPte, sysPte, MM_READWRITE, CurrentProcess->WorkingSetPage);
873  MI_WRITE_VALID_PTE(sysPte, tempPte);
874  CurrentProcess->Vm.VmWorkingSetList = MiPteToAddress(sysPte);
875 }
876 
877 NTSTATUS
878 NTAPI
880  IN PEPROCESS ProcessClone OPTIONAL,
881  IN PVOID Section OPTIONAL,
882  IN OUT PULONG Flags,
884 {
886  SIZE_T ViewSize = 0;
887  PVOID ImageBase = 0;
889  PMMPTE PointerPte;
890  KIRQL OldIrql;
891  PMMPDE PointerPde;
892  PFN_NUMBER PageFrameNumber;
894  PWCHAR Source;
896  USHORT Length = 0;
897  MMPTE TempPte;
898 
899  /* We should have a PDE */
900  ASSERT(Process->Pcb.DirectoryTableBase[0] != 0);
901  ASSERT(Process->PdeUpdateNeeded == FALSE);
902 
903  /* Attach to the process */
904  KeAttachProcess(&Process->Pcb);
905 
906  /* The address space should now been in phase 1 or 0 */
907  ASSERT(Process->AddressSpaceInitialized <= 1);
908  Process->AddressSpaceInitialized = 2;
909 
910  /* Initialize the Addresss Space lock */
911  KeInitializeGuardedMutex(&Process->AddressCreationLock);
912  Process->Vm.WorkingSetExpansionLinks.Flink = NULL;
913 
914  /* Initialize AVL tree */
915  ASSERT(Process->VadRoot.NumberGenericTableElements == 0);
916  Process->VadRoot.BalancedRoot.u1.Parent = &Process->VadRoot.BalancedRoot;
917 
918  /* Lock PFN database */
920 
921  /* Setup the PFN for the PDE base of this process */
922 #ifdef _M_AMD64
923  PointerPte = MiAddressToPte(PXE_BASE);
924 #else
925  PointerPte = MiAddressToPte(PDE_BASE);
926 #endif
927  PageFrameNumber = PFN_FROM_PTE(PointerPte);
928  ASSERT(Process->Pcb.DirectoryTableBase[0] == PageFrameNumber * PAGE_SIZE);
929  MiInitializePfn(PageFrameNumber, PointerPte, TRUE);
930 
931  /* Do the same for hyperspace */
932 #ifdef _M_AMD64
933  PointerPde = MiAddressToPxe((PVOID)HYPER_SPACE);
934 #else
935  PointerPde = MiAddressToPde(HYPER_SPACE);
936 #endif
937  PageFrameNumber = PFN_FROM_PTE(PointerPde);
938  //ASSERT(Process->Pcb.DirectoryTableBase[0] == PageFrameNumber * PAGE_SIZE); // we're not lucky
939  MiInitializePfn(PageFrameNumber, (PMMPTE)PointerPde, TRUE);
940 
941  /* Setup the PFN for the PTE for the working set */
942  PointerPte = MiAddressToPte(MI_WORKING_SET_LIST);
943  MI_MAKE_HARDWARE_PTE(&TempPte, PointerPte, MM_READWRITE, 0);
944  ASSERT(PointerPte->u.Long != 0);
945  PageFrameNumber = PFN_FROM_PTE(PointerPte);
946  MI_WRITE_INVALID_PTE(PointerPte, DemandZeroPte);
947  MiInitializePfn(PageFrameNumber, PointerPte, TRUE);
948  TempPte.u.Hard.PageFrameNumber = PageFrameNumber;
949  MI_WRITE_VALID_PTE(PointerPte, TempPte);
950 
951  /* Now initialize the working set list */
953 
954  /* Sanity check */
955  ASSERT(Process->PhysicalVadRoot == NULL);
956 
957  /* Release PFN lock */
959 
960  /* Check if there's a Section Object */
961  if (SectionObject)
962  {
963  /* Determine the image file name and save it to EPROCESS */
964  FileName = SectionObject->FileObject->FileName;
965  Source = (PWCHAR)((PCHAR)FileName.Buffer + FileName.Length);
966  if (FileName.Buffer)
967  {
968  /* Loop the file name*/
969  while (Source > FileName.Buffer)
970  {
971  /* Make sure this isn't a backslash */
973  {
974  /* If so, stop it here */
975  Source++;
976  break;
977  }
978  else
979  {
980  /* Otherwise, keep going */
981  Length++;
982  }
983  }
984  }
985 
986  /* Copy the to the process and truncate it to 15 characters if necessary */
987  Destination = Process->ImageFileName;
988  Length = min(Length, sizeof(Process->ImageFileName) - 1);
989  while (Length--) *Destination++ = (UCHAR)*Source++;
991 
992  /* Check if caller wants an audit name */
993  if (AuditName)
994  {
995  /* Setup the audit name */
997  FALSE,
998  AuditName);
999  if (!NT_SUCCESS(Status))
1000  {
1001  /* Fail */
1002  KeDetachProcess();
1003  return Status;
1004  }
1005  }
1006 
1007  /* Map the section */
1008  Status = MmMapViewOfSection(Section,
1009  Process,
1010  (PVOID*)&ImageBase,
1011  0,
1012  0,
1013  NULL,
1014  &ViewSize,
1015  0,
1016  MEM_COMMIT,
1017  PAGE_READWRITE);
1018 
1019  /* Save the pointer */
1020  Process->SectionBaseAddress = ImageBase;
1021  }
1022 
1023  /* Be nice and detach */
1024  KeDetachProcess();
1025 
1026  /* Return status to caller */
1027  return Status;
1028 }
1029 
1030 INIT_FUNCTION
1031 NTSTATUS
1032 NTAPI
1034  IN PULONG_PTR DirectoryTableBase)
1035 {
1036  /* Share the directory base with the idle process */
1037  DirectoryTableBase[0] = PsGetCurrentProcess()->Pcb.DirectoryTableBase[0];
1038  DirectoryTableBase[1] = PsGetCurrentProcess()->Pcb.DirectoryTableBase[1];
1039 
1040  /* Initialize the Addresss Space */
1041  KeInitializeGuardedMutex(&Process->AddressCreationLock);
1042  KeInitializeSpinLock(&Process->HyperSpaceLock);
1043  Process->Vm.WorkingSetExpansionLinks.Flink = NULL;
1044  ASSERT(Process->VadRoot.NumberGenericTableElements == 0);
1045  Process->VadRoot.BalancedRoot.u1.Parent = &Process->VadRoot.BalancedRoot;
1046 
1047  /* Use idle process Working set */
1048  Process->Vm.VmWorkingSetList = PsGetCurrentProcess()->Vm.VmWorkingSetList;
1049 
1050  /* Done */
1051  Process->HasAddressSpace = TRUE;//??
1052  return STATUS_SUCCESS;
1053 }
1054 
1055 INIT_FUNCTION
1056 NTSTATUS
1057 NTAPI
1059 {
1060  /* Lock the VAD, ARM3-owned ranges away */
1061  return STATUS_SUCCESS;
1062 }
1063 
1064 #ifdef _M_IX86
1065 /* FIXME: Evaluate ways to make this portable yet arch-specific */
1066 BOOLEAN
1067 NTAPI
1070  OUT PULONG_PTR DirectoryTableBase)
1071 {
1072  KIRQL OldIrql;
1073  PFN_NUMBER PdeIndex, HyperIndex, WsListIndex;
1074  PMMPTE PointerPte;
1075  MMPTE TempPte, PdePte;
1076  ULONG PdeOffset;
1077  PMMPTE SystemTable, HyperTable;
1078  ULONG Color;
1079  PMMPFN Pfn1;
1080 
1081  /* Choose a process color */
1082  Process->NextPageColor = (USHORT)RtlRandom(&MmProcessColorSeed);
1083 
1084  /* Setup the hyperspace lock */
1085  KeInitializeSpinLock(&Process->HyperSpaceLock);
1086 
1087  /* Lock PFN database */
1089 
1090  /* Get a zero page for the PDE, if possible */
1093  PdeIndex = MiRemoveZeroPageSafe(Color);
1094  if (!PdeIndex)
1095  {
1096  /* No zero pages, grab a free one */
1097  PdeIndex = MiRemoveAnyPage(Color);
1098 
1099  /* Zero it outside the PFN lock */
1101  MiZeroPhysicalPage(PdeIndex);
1103  }
1104 
1105  /* Get a zero page for hyperspace, if possible */
1108  HyperIndex = MiRemoveZeroPageSafe(Color);
1109  if (!HyperIndex)
1110  {
1111  /* No zero pages, grab a free one */
1112  HyperIndex = MiRemoveAnyPage(Color);
1113 
1114  /* Zero it outside the PFN lock */
1116  MiZeroPhysicalPage(HyperIndex);
1118  }
1119 
1120  /* Get a zero page for the woring set list, if possible */
1123  WsListIndex = MiRemoveZeroPageSafe(Color);
1124  if (!WsListIndex)
1125  {
1126  /* No zero pages, grab a free one */
1127  WsListIndex = MiRemoveAnyPage(Color);
1128 
1129  /* Zero it outside the PFN lock */
1131  MiZeroPhysicalPage(WsListIndex);
1132  }
1133  else
1134  {
1135  /* Release the PFN lock */
1137  }
1138 
1139  /* Switch to phase 1 initialization */
1140  ASSERT(Process->AddressSpaceInitialized == 0);
1141  Process->AddressSpaceInitialized = 1;
1142 
1143  /* Set the base directory pointers */
1144  Process->WorkingSetPage = WsListIndex;
1145  DirectoryTableBase[0] = PdeIndex << PAGE_SHIFT;
1146  DirectoryTableBase[1] = HyperIndex << PAGE_SHIFT;
1147 
1148  /* Make sure we don't already have a page directory setup */
1149  ASSERT(Process->Pcb.DirectoryTableBase[0] == 0);
1150 
1151  /* Get a PTE to map hyperspace */
1152  PointerPte = MiReserveSystemPtes(1, SystemPteSpace);
1153  ASSERT(PointerPte != NULL);
1154 
1155  /* Build it */
1157  PointerPte,
1158  MM_READWRITE,
1159  HyperIndex);
1160 
1161  /* Set it dirty and map it */
1162  MI_MAKE_DIRTY_PAGE(&PdePte);
1163  MI_WRITE_VALID_PTE(PointerPte, PdePte);
1164 
1165  /* Now get hyperspace's page table */
1166  HyperTable = MiPteToAddress(PointerPte);
1167 
1168  /* Now write the PTE/PDE entry for the working set list index itself */
1170  TempPte.u.Hard.PageFrameNumber = WsListIndex;
1172  HyperTable[PdeOffset] = TempPte;
1173 
1174  /* Let go of the system PTE */
1175  MiReleaseSystemPtes(PointerPte, 1, SystemPteSpace);
1176 
1177  /* Save the PTE address of the page directory itself */
1178  Pfn1 = MiGetPfnEntry(PdeIndex);
1179  Pfn1->PteAddress = (PMMPTE)PDE_BASE;
1180 
1181  /* Insert us into the Mm process list */
1183  InsertTailList(&MmProcessList, &Process->MmProcessLinks);
1185 
1186  /* Get a PTE to map the page directory */
1187  PointerPte = MiReserveSystemPtes(1, SystemPteSpace);
1188  ASSERT(PointerPte != NULL);
1189 
1190  /* Build it */
1192  PointerPte,
1193  MM_READWRITE,
1194  PdeIndex);
1195 
1196  /* Set it dirty and map it */
1197  MI_MAKE_DIRTY_PAGE(&PdePte);
1198  MI_WRITE_VALID_PTE(PointerPte, PdePte);
1199 
1200  /* Now get the page directory (which we'll double map, so call it a page table */
1201  SystemTable = MiPteToAddress(PointerPte);
1202 
1203  /* Copy all the kernel mappings */
1204  PdeOffset = MiGetPdeOffset(MmSystemRangeStart);
1205  RtlCopyMemory(&SystemTable[PdeOffset],
1207  PAGE_SIZE - PdeOffset * sizeof(MMPTE));
1208 
1209  /* Now write the PTE/PDE entry for hyperspace itself */
1211  TempPte.u.Hard.PageFrameNumber = HyperIndex;
1212  PdeOffset = MiGetPdeOffset(HYPER_SPACE);
1213  SystemTable[PdeOffset] = TempPte;
1214 
1215  /* Sanity check */
1216  PdeOffset++;
1217  ASSERT(MiGetPdeOffset(MmHyperSpaceEnd) >= PdeOffset);
1218 
1219  /* Now do the x86 trick of making the PDE a page table itself */
1220  PdeOffset = MiGetPdeOffset(PTE_BASE);
1221  TempPte.u.Hard.PageFrameNumber = PdeIndex;
1222  SystemTable[PdeOffset] = TempPte;
1223 
1224  /* Let go of the system PTE */
1225  MiReleaseSystemPtes(PointerPte, 1, SystemPteSpace);
1226 
1227  /* Add the process to the session */
1229  return TRUE;
1230 }
1231 #endif
1232 
1233 VOID
1234 NTAPI
1236 {
1237  PMMVAD Vad;
1238  PMM_AVL_TABLE VadTree;
1240 
1241  /* Only support this */
1242  ASSERT(Process->AddressSpaceInitialized == 2);
1243 
1244  /* Remove from the session */
1246 
1247  /* Lock the process address space from changes */
1250 
1251  /* VM is deleted now */
1252  Process->VmDeleted = TRUE;
1254 
1255  /* Enumerate the VADs */
1256  VadTree = &Process->VadRoot;
1257  while (VadTree->NumberGenericTableElements)
1258  {
1259  /* Grab the current VAD */
1260  Vad = (PMMVAD)VadTree->BalancedRoot.RightChild;
1261 
1262  /* Check for old-style memory areas */
1263  if (Vad->u.VadFlags.Spare == 1)
1264  {
1265  /* Let RosMm handle this */
1267  continue;
1268  }
1269 
1270  /* Lock the working set */
1272 
1273  /* Remove this VAD from the tree */
1274  ASSERT(VadTree->NumberGenericTableElements >= 1);
1275  MiRemoveNode((PMMADDRESS_NODE)Vad, VadTree);
1276 
1277  /* Only regular VADs supported for now */
1278  ASSERT(Vad->u.VadFlags.VadType == VadNone);
1279 
1280  /* Check if this is a section VAD */
1281  if (!(Vad->u.VadFlags.PrivateMemory) && (Vad->ControlArea))
1282  {
1283  /* Remove the view */
1285  }
1286  else
1287  {
1288  /* Delete the addresses */
1290  (Vad->EndingVpn << PAGE_SHIFT) | (PAGE_SIZE - 1),
1291  Vad);
1292 
1293  /* Release the working set */
1295  }
1296 
1297  /* Skip ARM3 fake VADs, they'll be freed by MmDeleteProcessAddresSpace */
1298  if (Vad->u.VadFlags.Spare == 1)
1299  {
1300  /* Set a flag so MmDeleteMemoryArea knows to free, but not to remove */
1301  Vad->u.VadFlags.Spare = 2;
1302  continue;
1303  }
1304 
1305  /* Free the VAD memory */
1306  ExFreePool(Vad);
1307  }
1308 
1309  /* Lock the working set */
1311  ASSERT(Process->CloneRoot == NULL);
1312  ASSERT(Process->PhysicalVadRoot == NULL);
1313 
1314  /* Delete the shared user data section */
1316 
1317  /* Release the working set */
1319 
1320  /* Release the address space */
1322 }
1323 
1324 VOID
1325 NTAPI
1327 {
1328  PMMPFN Pfn1, Pfn2;
1329  KIRQL OldIrql;
1330  PFN_NUMBER PageFrameIndex;
1331 
1332  //ASSERT(Process->CommitCharge == 0);
1333 
1334  /* Acquire the PFN lock */
1336 
1337  /* Check for fully initialized process */
1338  if (Process->AddressSpaceInitialized == 2)
1339  {
1340  /* Map the working set page and its page table */
1341  Pfn1 = MiGetPfnEntry(Process->WorkingSetPage);
1342  Pfn2 = MiGetPfnEntry(Pfn1->u4.PteFrame);
1343 
1344  /* Nuke it */
1345  MI_SET_PFN_DELETED(Pfn1);
1346  MiDecrementShareCount(Pfn2, Pfn1->u4.PteFrame);
1347  MiDecrementShareCount(Pfn1, Process->WorkingSetPage);
1348  ASSERT((Pfn1->u3.e2.ReferenceCount == 0) || (Pfn1->u3.e1.WriteInProgress));
1349  MiReleaseSystemPtes(MiAddressToPte(Process->Vm.VmWorkingSetList), 1, SystemPteSpace);
1350 
1351  /* Now map hyperspace and its page table */
1352  PageFrameIndex = Process->Pcb.DirectoryTableBase[1] >> PAGE_SHIFT;
1353  Pfn1 = MiGetPfnEntry(PageFrameIndex);
1354  Pfn2 = MiGetPfnEntry(Pfn1->u4.PteFrame);
1355 
1356  /* Nuke it */
1357  MI_SET_PFN_DELETED(Pfn1);
1358  MiDecrementShareCount(Pfn2, Pfn1->u4.PteFrame);
1359  MiDecrementShareCount(Pfn1, PageFrameIndex);
1360  ASSERT((Pfn1->u3.e2.ReferenceCount == 0) || (Pfn1->u3.e1.WriteInProgress));
1361 
1362  /* Finally, nuke the PDE itself */
1363  PageFrameIndex = Process->Pcb.DirectoryTableBase[0] >> PAGE_SHIFT;
1364  Pfn1 = MiGetPfnEntry(PageFrameIndex);
1365  MI_SET_PFN_DELETED(Pfn1);
1366  MiDecrementShareCount(Pfn1, PageFrameIndex);
1367  MiDecrementShareCount(Pfn1, PageFrameIndex);
1368 
1369  /* Page table is now dead. Bye bye... */
1370  ASSERT((Pfn1->u3.e2.ReferenceCount == 0) || (Pfn1->u3.e1.WriteInProgress));
1371  }
1372  else
1373  {
1374  /* A partly-initialized process should never exit through here */
1375  ASSERT(FALSE);
1376  }
1377 
1378  /* Release the PFN lock */
1380 
1381  /* Drop a reference on the session */
1383 
1384  /* Clear out the PDE pages */
1385  Process->Pcb.DirectoryTableBase[0] = 0;
1386  Process->Pcb.DirectoryTableBase[1] = 0;
1387 }
1388 
1389 
1390 /* SYSTEM CALLS ***************************************************************/
1391 
1392 NTSTATUS
1393 NTAPI
1395  IN OUT PULONG_PTR NumberOfPages,
1396  IN OUT PULONG_PTR UserPfnArray)
1397 {
1398  UNIMPLEMENTED;
1399  return STATUS_NOT_IMPLEMENTED;
1400 }
1401 
1402 NTSTATUS
1403 NTAPI
1405  IN ULONG_PTR NumberOfPages,
1406  IN OUT PULONG_PTR UserPfnArray)
1407 {
1408  UNIMPLEMENTED;
1409  return STATUS_NOT_IMPLEMENTED;
1410 }
1411 
1412 NTSTATUS
1413 NTAPI
1415  IN ULONG_PTR NumberOfPages,
1416  IN OUT PULONG_PTR UserPfnArray)
1417 {
1418  UNIMPLEMENTED;
1419  return STATUS_NOT_IMPLEMENTED;
1420 }
1421 
1422 NTSTATUS
1423 NTAPI
1425  IN OUT PULONG_PTR NumberOfPages,
1426  IN OUT PULONG_PTR UserPfnArray)
1427 {
1428  UNIMPLEMENTED;
1429  return STATUS_NOT_IMPLEMENTED;
1430 }
1431 
1432 /* EOF */
_Must_inspect_result_ _Outptr_ PVOID * SectionObject
Definition: fsrtlfuncs.h:860
#define MI_MAKE_SOFTWARE_PTE(p, x)
Definition: miarm.h:193
union _MMVAD::@2500 u
signed char * PCHAR
Definition: retypes.h:7
NTSYSAPI ULONG NTAPI RtlRandom(_Inout_ PULONG Seed)
union _MMVAD_LONG::@2502 u1
ULONG ImageSubsystemMajorVersion
Definition: ntddk_ex.h:305
VOID NTAPI MiInitializePfn(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN BOOLEAN Modified)
Definition: pfnlist.c:969
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define IN
Definition: typedefs.h:38
PVOID NTAPI MmCreateKernelStack(IN BOOLEAN GuiStack, IN UCHAR Node)
Definition: procsup.c:258
#define VER_PLATFORM_WIN32_NT
Definition: rtltypes.h:236
VOID NTAPI MmCleanProcessAddressSpace(IN PEPROCESS Process)
Definition: procsup.c:1235
ULONG HeapSegmentReserve
Definition: ntddk_ex.h:275
SIZE_T MmHeapDeCommitTotalFreeThreshold
Definition: mminit.c:368
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
struct _KEVENT * PKEVENT
VOID NTAPI MiSessionRemoveProcess(VOID)
Definition: session.c:396
union _MMPFN::@1732 u1
PPEB Peb
Definition: dllmain.c:27
ULONG ReadOnly
Definition: mmtypes.h:710
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1214
PVOID HashTableStart
Definition: mmtypes.h:865
#define MiAddressToPde(x)
Definition: mmx86.c:20
FORCEINLINE KIRQL MiAcquireExpansionLock(VOID)
Definition: miarm.h:1385
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
ULONG ImageProcessAffinityMask
Definition: ntddk_ex.h:307
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
ULONG OSPlatformId
Definition: ntddk_ex.h:303
PMMVAD Parent
Definition: mmtypes.h:754
VOID NTAPI MiReleaseProcessReferenceToSessionDataPage(IN PMM_SESSION_SPACE SessionGlobal)
Definition: session.c:210
ULONG PFN_COUNT
Definition: mmtypes.h:102
ULONG OneSecured
Definition: mmtypes.h:708
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
ULONG FirstDynamic
Definition: mmtypes.h:856
FORCEINLINE VOID MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1431
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:763
ULONG_PTR CommitCharge
Definition: mmtypes.h:691
LONG NTSTATUS
Definition: precomp.h:26
INIT_FUNCTION NTSTATUS NTAPI MmInitializeHandBuiltProcess2(IN PEPROCESS Process)
Definition: procsup.c:1058
union _MMPTE::@2240 u
PVOID HighestPermittedHashAddress
Definition: mmtypes.h:866
ULONG_PTR NumberGenericTableElements
Definition: mmtypes.h:668
#define MI_GET_NEXT_COLOR()
Definition: miarm.h:246
NTSTATUS NTAPI NtMapUserPhysicalPagesScatter(IN PVOID *VirtualAddresses, IN ULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1414
#define MM_NOACCESS
Definition: miarm.h:69
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:901
BYTE BeingDebugged
Definition: btrfs_drv.h:1813
NTSTATUS NTAPI NtFreeUserPhysicalPages(IN HANDLE ProcessHandle, IN OUT PULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1424
PCONTROL_AREA ControlArea
Definition: mmtypes.h:765
ULONG_PTR Protection
Definition: mmtypes.h:696
ULONG LongVad
Definition: mmtypes.h:711
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
uint16_t * PWCHAR
Definition: typedefs.h:54
#define InsertTailList(ListHead, Entry)
#define KERNEL_LARGE_STACK_COMMIT
LCID PsDefaultThreadLocaleId
Definition: locale.c:25
ULONG_PTR LongFlags
Definition: mmtypes.h:762
SIZE_T MmMinimumStackCommitInBytes
Definition: mminit.c:370
#define MEM_COMMIT
Definition: nt_native.h:1313
VOID NTAPI MiRosCleanupMemoryArea(PEPROCESS Process, PMMVAD Vad)
Definition: marea.c:522
ULONG_PTR NoChange
Definition: mmtypes.h:693
#define MiGetPdeOffset(x)
Definition: mm.h:185
ULONG MmLargeStackSize
Definition: mminit.c:262
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:734
ULONG NtMajorVersion
Definition: init.c:42
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:908
SLIST_HEADER MmDeadStackSListHead
Definition: procsup.c:23
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
PSLIST_ENTRY WINAPI InterlockedPopEntrySList(PSLIST_HEADER ListHead)
Definition: interlocked.c:55
struct Color Color
NTSTATUS NTAPI MmCreatePeb(IN PEPROCESS Process, IN PINITIAL_PEB InitialPeb, OUT PPEB *BasePeb)
Definition: procsup.c:500
MMADDRESS_NODE BalancedRoot
Definition: mmtypes.h:662
_SEH2_TRY
Definition: create.c:4250
uint32_t ULONG_PTR
Definition: typedefs.h:63
ULONG HeapDeCommitFreeBlockThreshold
Definition: ntddk_ex.h:278
PVOID ImageBaseAddress
Definition: ntddk_ex.h:245
ULONG NtGlobalFlag
Definition: ntddk_ex.h:270
UCHAR KIRQL
Definition: env_spec_w32.h:591
MMPFNENTRY e1
Definition: mm.h:329
#define MI_MAKE_DIRTY_PAGE(x)
Definition: mm.h:95
ULONG_PTR EndingVpn
Definition: mmtypes.h:730
NTSTATUS NTAPI MmCreateTeb(IN PEPROCESS Process, IN PCLIENT_ID ClientId, IN PINITIAL_TEB InitialTeb, OUT PTEB *BaseTeb)
Definition: procsup.c:740
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
HANDLE Mutant
Definition: ntddk_ex.h:243
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
#define MiAddressToPte(x)
Definition: mmx86.c:19
NTSTATUS NTAPI MmGrowKernelStack(IN PVOID StackPointer)
Definition: procsup.c:459
ULONG PFN_NUMBER
Definition: ke.h:8
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
union _MMVAD_LONG::@2503 u
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:951
#define ANSI_NULL
LARGE_INTEGER MmCriticalSectionTimeout
Definition: mminit.c:388
#define PDE_BASE
Definition: winldr.c:21
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
ULONG MmProcessColorSeed
Definition: procsup.c:20
PKEVENT Event
Definition: mm.h:311
#define MI_SET_PROCESS2(x)
Definition: mm.h:254
ULONG MmMaximumDeadKernelStacks
Definition: procsup.c:22
VOID NTAPI MmDeleteKernelStack(IN PVOID StackBase, IN BOOLEAN GuiStack)
Definition: procsup.c:169
#define USER_SHARED_DATA
Definition: pstypes.h:51
#define PsGetCurrentProcess
Definition: psfuncs.h:17
ULONG LongFlags2
Definition: mmtypes.h:770
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
FORCEINLINE PFN_NUMBER MiRemoveZeroPageSafe(IN ULONG Color)
Definition: miarm.h:2315
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
PVOID FORCEINLINE MiPteToAddress(PMMPTE PointerPte)
Definition: mm.h:198
PMMVAD NTAPI MiLocateAddress(IN PVOID VirtualAddress)
Definition: vadnode.c:48
void DPRINT(...)
Definition: polytest.cpp:61
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1133
ULONG NextSlot
Definition: mmtypes.h:858
#define MI_SET_USAGE(x)
Definition: mm.h:253
NTSTATUS NTAPI MmMapViewOfSection(IN PVOID SectionObject, IN PEPROCESS Process, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:4502
void * PVOID
Definition: retypes.h:9
VOID NTAPI MiReleaseSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:275
ULONG_PTR StartingVpn
Definition: mmtypes.h:729
ULONG_PTR StartingVpn
Definition: mmtypes.h:653
VOID NTAPI MiInitializeWorkingSetList(IN PEPROCESS CurrentProcess)
Definition: procsup.c:845
NTSTATUS NTAPI NtAllocateUserPhysicalPages(IN HANDLE ProcessHandle, IN OUT PULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1394
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
VOID NTAPI KeQueryTickCount(IN PLARGE_INTEGER TickCount)
Definition: clock.c:165
#define ULL(a, b)
Definition: format_msg.c:27
MMVAD_FLAGS2 VadFlags2
Definition: mmtypes.h:742
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER SectionOffset
Definition: mmfuncs.h:404
ULONG_PTR MemCommit
Definition: mmtypes.h:695
USHORT WriteInProgress
Definition: mm.h:294
union _MMVAD::@2501 u2
#define PCHAR
Definition: match.c:90
ULONG MultipleSecured
Definition: mmtypes.h:709
ULONG_PTR EndingVpn
Definition: mmtypes.h:654
#define STATUS_INVALID_IMAGE_PROTECT
Definition: ntstatus.h:526
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1144
struct _MMPFN::@1734::@1740 e2
ULONG HeapSegmentCommit
Definition: ntddk_ex.h:276
union _MMPFN::@1734 u3
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
ULONG CurrentProcess
Definition: shell.c:125
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1176
ULONG_PTR PrivateMemory
Definition: mmtypes.h:698
NTSTATUS NTAPI MiInsertVadEx(_Inout_ PMMVAD Vad, _In_ ULONG_PTR *BaseAddress, _In_ SIZE_T ViewSize, _In_ ULONG_PTR HighestAddress, _In_ ULONG_PTR Alignment, _In_ ULONG AllocationType)
Definition: vadnode.c:204
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
NTSTATUS NTAPI SeInitializeProcessAuditName(IN PFILE_OBJECT FileObject, IN BOOLEAN DoAudit, OUT POBJECT_NAME_INFORMATION *AuditInfo)
Definition: audit.c:47
if(!(yy_init))
Definition: macro.lex.yy.c:714
PVOID * ProcessHeaps
Definition: ntddk_ex.h:288
ULONG MaximumNumberOfHeaps
Definition: ntddk_ex.h:287
#define MI_WORKING_SET_LIST
Definition: mm.h:48
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
SIZE_T MmHeapDeCommitFreeBlockThreshold
Definition: mminit.c:369
ULONG LastInitializedWsle
Definition: mmtypes.h:860
uint64_t ULONGLONG
Definition: typedefs.h:65
#define MI_GET_NEXT_PROCESS_COLOR(x)
Definition: miarm.h:247
MMPTE ValidKernelPteLocal
Definition: init.c:35
ULONG64 Valid
Definition: mmtypes.h:150
struct _MMPTE * PMMPTE
NTSTATUS NTAPI MiCreatePebOrTeb(IN PEPROCESS Process, IN ULONG Size, OUT PULONG_PTR BaseAddress)
Definition: procsup.c:29
struct _NT_TIB * PNT_TIB
PVOID ExpNlsSectionPointer
Definition: init.c:86
#define MEMORY_PRIORITY_BACKGROUND
Definition: pstypes.h:124
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
ULONG NtMinorVersion
Definition: init.c:43
MMVAD_FLAGS2 VadFlags2
Definition: mmtypes.h:771
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2891
LARGE_INTEGER CriticalSectionTimeout
Definition: ntddk_ex.h:274
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
#define PSLIST_ENTRY
Definition: rtltypes.h:130
FORCEINLINE USHORT ExQueryDepthSList(_In_ PSLIST_HEADER SListHead)
Definition: exfuncs.h:153
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define KERNEL_STACK_SIZE
SIZE_T MinimumStackCommit
Definition: winternl.h:358
ULONG NtBuildNumber
Definition: init.c:47
struct _MMADDRESS_NODE * RightChild
Definition: mmtypes.h:652
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define BYTES_TO_PAGES(Size)
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:618
unsigned char UCHAR
Definition: xmlstorage.h:181
SIZE_T MmHeapSegmentReserve
Definition: mminit.c:366
ULONG OSBuildNumber
Definition: ntddk_ex.h:302
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
ULONG SessionId
Definition: btrfs_drv.h:1823
PMMWSLE Wsle
Definition: mmtypes.h:859
PMMWSLE_HASH HashTable
Definition: mmtypes.h:862
#define RtlImageDirectoryEntryToData
Definition: compat.h:460
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define IMAGE_FILE_UP_SYSTEM_ONLY
Definition: pedump.c:170
#define MM_READWRITE
Definition: inbv.c:10
ULONG ExpUnicodeCaseTableDataOffset
Definition: init.c:83
Definition: mm.h:305
ULONG LowPart
Definition: typedefs.h:104
PMMPTE FORCEINLINE MiAddressToPxe(PVOID Address)
Definition: mm.h:161
NTSTATUS NTAPI MmSetMemoryPriorityProcess(IN PEPROCESS Process, IN UCHAR MemoryPriority)
Definition: procsup.c:469
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define PTE_BASE
Definition: mmx86.c:14
NTKERNELAPI PSLIST_ENTRY FASTCALL InterlockedPushEntrySList(IN PSLIST_HEADER ListHead, IN PSLIST_ENTRY ListEntry)
Definition: interlocked.c:82
PVOID UnicodeCaseTableData
Definition: ntddk_ex.h:266
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
MM_SYSTEMSIZE MmSystemSize
Definition: mminit.c:326
#define _64K
Definition: miarm.h:19
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:940
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:360
BOOLEAN NTAPI MmCreateProcessAddressSpace(IN ULONG MinWs, IN PEPROCESS Dest, IN PULONG_PTR DirectoryTableBase)
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
Status
Definition: gdiplustypes.h:24
ULONG_PTR Long
Definition: mmtypes.h:215
VOID NTAPI MiDeleteVirtualAddresses(IN ULONG_PTR Va, IN ULONG_PTR EndingAddress, IN PMMVAD Vad)
Definition: virtual.c:540
PFN_NUMBER NTAPI MiRemoveAnyPage(IN ULONG Color)
Definition: pfnlist.c:475
ULONG ExpOemCodePageDataOffset
Definition: init.c:82
ULONG_PTR SIZE_T
Definition: typedefs.h:78
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
Definition: compat.h:484
#define PXE_BASE
#define MI_SET_PFN_DELETED(x)
Definition: miarm.h:198
struct _FileName FileName
Definition: fatprocs.h:884
FORCEINLINE VOID MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte, IN MMPTE InvalidPte)
Definition: miarm.h:980
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG
Definition: pedump.c:269
ULONG HeapDeCommitTotalFreeThreshold
Definition: ntddk_ex.h:277
PFN_COUNT MmNumberOfPhysicalPages
Definition: init.c:48
ULONG OSMinorVersion
Definition: ntddk_ex.h:301
_SEH2_END
Definition: create.c:4424
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
INIT_FUNCTION NTSTATUS NTAPI MmInitializeHandBuiltProcess(IN PEPROCESS Process, IN PULONG_PTR DirectoryTableBase)
Definition: procsup.c:1033
#define EXCEPTION_CHAIN_END
Definition: rtltypes.h:63
union _MMPFN::@1737 u4
NTSTATUS NTAPI NtMapUserPhysicalPages(IN PVOID VirtualAddresses, IN ULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1404
#define ROUND_TO_PAGES(Size)
ULONG HashTableSize
Definition: mmtypes.h:863
unsigned short USHORT
Definition: pedump.c:61
ULONG_PTR PteFrame
Definition: mm.h:350
ULONG_PTR KAFFINITY
Definition: compat.h:75
ULONG NumberOfImageWaiters
Definition: mmtypes.h:867
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579
ULONG FirstFree
Definition: mmtypes.h:855
SIZE_T MmHeapSegmentCommit
Definition: mminit.c:367
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
PMMPTE PteAddress
Definition: mm.h:318
ULONG NumberOfProcessors
Definition: ntddk_ex.h:269
unsigned int * PULONG
Definition: retypes.h:1
#define min(a, b)
Definition: monoChain.cc:55
#define PAGE_READONLY
Definition: compat.h:127
#define STATUS_STACK_OVERFLOW
Definition: ntstatus.h:475
FORCEINLINE VOID MiReleaseExpansionLock(KIRQL OldIrql)
Definition: miarm.h:1398
PMMWSL MmWorkingSetList
Definition: procsup.c:21
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
#define DPRINT1
Definition: precomp.h:8
#define RtlImageNtHeader
Definition: compat.h:457
PVOID OemCodePageData
Definition: ntddk_ex.h:265
#define MM_HIGHEST_VAD_ADDRESS
Definition: mm.h:43
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
VOID NTAPI MmDeleteTeb(IN PEPROCESS Process, IN PTEB Teb)
Definition: procsup.c:107
VOID NTAPI MiSessionAddProcess(IN PEPROCESS NewProcess)
Definition: session.c:427
FORCEINLINE PFN_NUMBER MiGetPfnEntryIndex(IN PMMPFN Pfn1)
Definition: mm.h:960
#define BOOLEAN
Definition: pedump.c:73
#define OUT
Definition: typedefs.h:39
ULONG CmNtCSDVersion
Definition: init.c:56
ULONG_PTR Spare
Definition: mmtypes.h:697
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:404
#define HYPER_SPACE
Definition: mm.h:14
PVOID MmHyperSpaceEnd
Definition: init.c:56
unsigned int ULONG
Definition: retypes.h:1
PMMPTE FirstPrototypePte
Definition: mmtypes.h:766
#define UNIMPLEMENTED
Definition: debug.h:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define ULONG_PTR
Definition: config.h:101
uint32_t * PULONG_PTR
Definition: typedefs.h:63
ULONG NTAPI MmGetSessionId(IN PEPROCESS Process)
Definition: session.c:180
NTSTATUS NTAPI MmInitializeProcessAddressSpace(IN PEPROCESS Process, IN PEPROCESS ProcessClone OPTIONAL, IN PVOID Section OPTIONAL, IN OUT PULONG Flags, IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL)
Definition: procsup.c:879
VOID NTAPI MiRemoveMappedView(IN PEPROCESS CurrentProcess, IN PMMVAD Vad)
Definition: section.c:780
MMPTE DemandZeroPte
Definition: init.c:39
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
#define MiAddressToPteOffset(x)
Definition: mmx86.c:21
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
ULONG OSMajorVersion
Definition: ntddk_ex.h:300
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
FORCEINLINE VOID MI_MAKE_HARDWARE_PTE_KERNEL(IN PMMPTE NewPte, IN PMMPTE MappingPte, IN ULONG_PTR ProtectionMask, IN PFN_NUMBER PageFrameNumber)
Definition: miarm.h:783
BOOLEAN InheritedAddressSpace
Definition: ntddk_ex.h:239
struct _PEB PEB
#define KeGetCurrentThread
Definition: hal.h:44
NTSTATUS NTAPI MmGrowKernelStackEx(IN PVOID StackPointer, IN ULONG GrowSize)
Definition: procsup.c:371
LIST_ENTRY MmProcessList
Definition: largepag.c:20
#define MEM_TOP_DOWN
Definition: nt_native.h:1321
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
return STATUS_SUCCESS
Definition: btrfs.c:2966
ULONG NtGlobalFlag
Definition: init.c:51
ULONG LastEntry
Definition: mmtypes.h:857
ULONG ExpAnsiCodePageDataOffset
Definition: init.c:82
FORCEINLINE VOID MmLockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1424
PVOID AnsiCodePageData
Definition: ntddk_ex.h:264
struct _MMVAD * PMMVAD
#define PFN_FROM_PTE(v)
Definition: mm.h:89
#define MmSystemRangeStart
Definition: mm.h:32
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
VOID NTAPI MmDeleteProcessAddressSpace2(IN PEPROCESS Process)
Definition: procsup.c:1326
FORCEINLINE VOID MI_MAKE_HARDWARE_PTE(IN PMMPTE NewPte, IN PMMPTE MappingPte, IN ULONG_PTR ProtectionMask, IN PFN_NUMBER PageFrameNumber)
Definition: miarm.h:806
ULONG ImageSubsystemMinorVersion
Definition: ntddk_ex.h:306
ULONG PageFrameNumber
Definition: mmtypes.h:109
union _MMVAD_LONG::@2504 u2
#define PAGE_READWRITE
Definition: nt_native.h:1304
Definition: dlist.c:348
ULONG ImageSubsystem
Definition: ntddk_ex.h:304
ULONG VadBitMapHint
Definition: mmtypes.h:868
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68