ReactOS  0.4.15-dev-2531-g03e8246
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 #ifdef _M_AMD64
844 static
845 NTSTATUS
846 MiInsertSharedUserPageVad(VOID)
847 {
848  PMMVAD_LONG Vad;
851 
852  /* Allocate a VAD */
853  Vad = ExAllocatePoolWithTag(NonPagedPool, sizeof(MMVAD_LONG), 'ldaV');
854  if (Vad == NULL)
855  {
856  DPRINT1("Failed to allocate VAD for shared user page\n");
858  }
859 
860  /* Setup the primary flags with the size, and make it private, RO */
861  Vad->u.LongFlags = 0;
862  Vad->u.VadFlags.CommitCharge = 0;
863  Vad->u.VadFlags.NoChange = TRUE;
864  Vad->u.VadFlags.VadType = VadNone;
865  Vad->u.VadFlags.MemCommit = FALSE;
867  Vad->u.VadFlags.PrivateMemory = TRUE;
868  Vad->u1.Parent = NULL;
869 
870  /* Setup the secondary flags to make it a secured, readonly, long VAD */
871  Vad->u2.LongFlags2 = 0;
872  Vad->u2.VadFlags2.OneSecured = TRUE;
873  Vad->u2.VadFlags2.LongVad = TRUE;
874  Vad->u2.VadFlags2.ReadOnly = FALSE;
875 
876  Vad->ControlArea = NULL; // For Memory-Area hack
877  Vad->FirstPrototypePte = NULL;
878 
879  /* Insert it into the process VAD table */
881  Status = MiInsertVadEx((PMMVAD)Vad,
882  &BaseAddress,
883  PAGE_SIZE,
885  PAGE_SIZE,
886  MEM_TOP_DOWN);
887  if (!NT_SUCCESS(Status))
888  {
889  DPRINT1("Failed to insert shared user VAD\n");
890  ExFreePoolWithTag(Vad, 'ldaV');
891  return Status;
892  }
893 
894  /* Success */
895  return STATUS_SUCCESS;
896 }
897 #endif
898 
899 NTSTATUS
900 NTAPI
902  IN PEPROCESS ProcessClone OPTIONAL,
903  IN PVOID Section OPTIONAL,
904  IN OUT PULONG Flags,
906 {
908  SIZE_T ViewSize = 0;
909  PVOID ImageBase = 0;
910  PMMPTE PointerPte;
911  KIRQL OldIrql;
912  PMMPDE PointerPde;
913  PMMPFN Pfn;
914  PFN_NUMBER PageFrameNumber;
916  PWCHAR Source;
918  USHORT Length = 0;
919  MMPTE TempPte;
920 #if (_MI_PAGING_LEVELS >= 3)
921  PMMPPE PointerPpe;
922 #endif
923 #if (_MI_PAGING_LEVELS == 4)
924  PMMPXE PointerPxe;
925 #endif
926 
927  /* We should have a PDE */
928  ASSERT(Process->Pcb.DirectoryTableBase[0] != 0);
929  ASSERT(Process->PdeUpdateNeeded == FALSE);
930 
931  /* Attach to the process */
932  KeAttachProcess(&Process->Pcb);
933 
934  /* The address space should now been in phase 1 or 0 */
935  ASSERT(Process->AddressSpaceInitialized <= 1);
936  Process->AddressSpaceInitialized = 2;
937 
938  /* Initialize the Addresss Space lock */
939  KeInitializeGuardedMutex(&Process->AddressCreationLock);
940  Process->Vm.WorkingSetExpansionLinks.Flink = NULL;
941 
942  /* Initialize AVL tree */
943  ASSERT(Process->VadRoot.NumberGenericTableElements == 0);
944  Process->VadRoot.BalancedRoot.u1.Parent = &Process->VadRoot.BalancedRoot;
945 
946 #ifdef _M_AMD64
947  /* On x64 the PFNs for the initial process are already set up */
948  if (Process != &KiInitialProcess) {
949 #endif
950  /* Lock our working set */
952 
953  /* Lock PFN database */
955 
956  /* Setup the PFN for the PDE base of this process */
957 #if (_MI_PAGING_LEVELS == 4)
958  PointerPte = MiAddressToPte(PXE_BASE);
959 #elif (_MI_PAGING_LEVELS == 3)
960  PointerPte = MiAddressToPte(PPE_BASE);
961 #else
962  PointerPte = MiAddressToPte(PDE_BASE);
963 #endif
964  PageFrameNumber = PFN_FROM_PTE(PointerPte);
965  ASSERT(Process->Pcb.DirectoryTableBase[0] == PageFrameNumber * PAGE_SIZE);
966  MiInitializePfn(PageFrameNumber, PointerPte, TRUE);
967 
968  /* Do the same for hyperspace */
969  PointerPde = MiAddressToPde(HYPER_SPACE);
970  PageFrameNumber = PFN_FROM_PTE(PointerPde);
971  MiInitializePfn(PageFrameNumber, (PMMPTE)PointerPde, TRUE);
972 #if (_MI_PAGING_LEVELS == 2)
973  ASSERT(Process->Pcb.DirectoryTableBase[1] == PageFrameNumber * PAGE_SIZE);
974 #endif
975 
976 #if (_MI_PAGING_LEVELS >= 3)
977  PointerPpe = MiAddressToPpe((PVOID)HYPER_SPACE);
978  PageFrameNumber = PFN_FROM_PTE(PointerPpe);
979  MiInitializePfn(PageFrameNumber, PointerPpe, TRUE);
980 #if (_MI_PAGING_LEVELS == 3)
981  ASSERT(Process->Pcb.DirectoryTableBase[1] == PageFrameNumber * PAGE_SIZE);
982 #endif
983 #endif
984 #if (_MI_PAGING_LEVELS == 4)
985  PointerPxe = MiAddressToPxe((PVOID)HYPER_SPACE);
986  PageFrameNumber = PFN_FROM_PTE(PointerPxe);
987  MiInitializePfn(PageFrameNumber, PointerPxe, TRUE);
988  ASSERT(Process->Pcb.DirectoryTableBase[1] == PageFrameNumber * PAGE_SIZE);
989 #endif
990 
991  /* Do the same for the Working set list */
992  PointerPte = MiAddressToPte(MmWorkingSetList);
993  PageFrameNumber = PFN_FROM_PTE(PointerPte);
994  MiInitializePfn(PageFrameNumber, PointerPte, TRUE);
995 
996  /* This should be in hyper space, but not in the mapping range */
997  Process->Vm.VmWorkingSetList = MmWorkingSetList;
999 
1000  /* Now initialize the working set list */
1001  MiInitializeWorkingSetList(&Process->Vm);
1002 
1003  /* Map the process working set in kernel space */
1004  /* FIXME: there should be no need */
1005  PointerPte = MiReserveSystemPtes(1, SystemPteSpace);
1006  MI_MAKE_HARDWARE_PTE_KERNEL(&TempPte, PointerPte, MM_READWRITE, Process->WorkingSetPage);
1007  MI_WRITE_VALID_PTE(PointerPte, TempPte);
1008  Process->Vm.VmWorkingSetList = MiPteToAddress(PointerPte);
1009 
1010  /* The rule is that the owner process is always in the FLINK of the PDE's PFN entry */
1011  Pfn = MiGetPfnEntry(Process->Pcb.DirectoryTableBase[0] >> PAGE_SHIFT);
1012  ASSERT(Pfn->u4.PteFrame == MiGetPfnEntryIndex(Pfn));
1013  ASSERT(Pfn->u1.WsIndex == 0);
1014  Pfn->u1.Event = (PKEVENT)Process;
1015 
1016  /* Sanity check */
1017  ASSERT(Process->PhysicalVadRoot == NULL);
1018 
1019  /* Release PFN lock */
1021 
1022  /* Release the process working set */
1024 #ifdef _M_AMD64
1025  } /* On x64 the PFNs for the initial process are already set up */
1026 #endif
1027 
1028 #ifdef _M_AMD64
1029  /* On x64 we need a VAD for the shared user page */
1030  Status = MiInsertSharedUserPageVad();
1031  if (!NT_SUCCESS(Status))
1032  {
1033  DPRINT1("MiCreateSharedUserPageVad() failed: 0x%lx\n", Status);
1034  return Status;
1035  }
1036 #endif
1037 
1038  /* Check if there's a Section Object */
1039  if (Section)
1040  {
1041  /* Determine the image file name and save it to EPROCESS */
1043  FileName = FileObject->FileName;
1044  Source = (PWCHAR)((PCHAR)FileName.Buffer + FileName.Length);
1045  if (FileName.Buffer)
1046  {
1047  /* Loop the file name*/
1048  while (Source > FileName.Buffer)
1049  {
1050  /* Make sure this isn't a backslash */
1051  if (*--Source == OBJ_NAME_PATH_SEPARATOR)
1052  {
1053  /* If so, stop it here */
1054  Source++;
1055  break;
1056  }
1057  else
1058  {
1059  /* Otherwise, keep going */
1060  Length++;
1061  }
1062  }
1063  }
1064 
1065  /* Copy the to the process and truncate it to 15 characters if necessary */
1066  Destination = Process->ImageFileName;
1067  Length = min(Length, sizeof(Process->ImageFileName) - 1);
1068  while (Length--) *Destination++ = (UCHAR)*Source++;
1070 
1071  /* Check if caller wants an audit name */
1072  if (AuditName)
1073  {
1074  /* Setup the audit name */
1076  if (!NT_SUCCESS(Status))
1077  {
1078  /* Fail */
1079  KeDetachProcess();
1080  return Status;
1081  }
1082  }
1083 
1084  /* Map the section */
1085  Status = MmMapViewOfSection(Section,
1086  Process,
1087  (PVOID*)&ImageBase,
1088  0,
1089  0,
1090  NULL,
1091  &ViewSize,
1092  0,
1093  MEM_COMMIT,
1094  PAGE_READWRITE);
1095 
1096  /* Save the pointer */
1097  Process->SectionBaseAddress = ImageBase;
1098  }
1099 
1100  /* Be nice and detach */
1101  KeDetachProcess();
1102 
1103  /* Return status to caller */
1104  return Status;
1105 }
1106 
1107 CODE_SEG("INIT")
1108 NTSTATUS
1109 NTAPI
1111  IN PULONG_PTR DirectoryTableBase)
1112 {
1113  /* Share the directory base with the idle process */
1114  DirectoryTableBase[0] = PsGetCurrentProcess()->Pcb.DirectoryTableBase[0];
1115  DirectoryTableBase[1] = PsGetCurrentProcess()->Pcb.DirectoryTableBase[1];
1116 
1117  /* Initialize the Addresss Space */
1118  KeInitializeGuardedMutex(&Process->AddressCreationLock);
1119  KeInitializeSpinLock(&Process->HyperSpaceLock);
1120  Process->Vm.WorkingSetExpansionLinks.Flink = NULL;
1121  ASSERT(Process->VadRoot.NumberGenericTableElements == 0);
1122  Process->VadRoot.BalancedRoot.u1.Parent = &Process->VadRoot.BalancedRoot;
1123 
1124  /* Use idle process Working set */
1125  Process->Vm.VmWorkingSetList = PsGetCurrentProcess()->Vm.VmWorkingSetList;
1126 
1127  /* Done */
1128  Process->HasAddressSpace = TRUE;//??
1129  return STATUS_SUCCESS;
1130 }
1131 
1132 CODE_SEG("INIT")
1133 NTSTATUS
1134 NTAPI
1136 {
1137  /* Lock the VAD, ARM3-owned ranges away */
1138  return STATUS_SUCCESS;
1139 }
1140 
1141 BOOLEAN
1142 NTAPI
1145  OUT PULONG_PTR DirectoryTableBase)
1146 {
1147  KIRQL OldIrql;
1148  PFN_NUMBER TableBaseIndex, HyperIndex, WsListIndex;
1149  ULONG Color;
1150 
1151  /* Make sure we don't already have a page directory setup */
1152  ASSERT(Process->Pcb.DirectoryTableBase[0] == 0);
1153  ASSERT(Process->Pcb.DirectoryTableBase[1] == 0);
1154  ASSERT(Process->WorkingSetPage == 0);
1155 
1156  /* Choose a process color */
1157  Process->NextPageColor = (USHORT)RtlRandom(&MmProcessColorSeed);
1158 
1159  /* Setup the hyperspace lock */
1160  KeInitializeSpinLock(&Process->HyperSpaceLock);
1161 
1162  /* Lock PFN database */
1164 
1165  /*
1166  * Get a page for the table base, one for hyper space & one for the working set list.
1167  * The PFNs for these pages will be initialized in MmInitializeProcessAddressSpace,
1168  * when we are already attached to the process.
1169  * The other pages (if any) are allocated in the arch-specific part.
1170  */
1173  TableBaseIndex = MiRemoveZeroPageSafe(Color);
1174  if (!TableBaseIndex)
1175  {
1176  /* No zero pages, grab a free one */
1177  TableBaseIndex = MiRemoveAnyPage(Color);
1178 
1179  /* Zero it outside the PFN lock */
1181  MiZeroPhysicalPage(TableBaseIndex);
1183  }
1186  HyperIndex = MiRemoveZeroPageSafe(Color);
1187  if (!HyperIndex)
1188  {
1189  /* No zero pages, grab a free one */
1190  HyperIndex = MiRemoveAnyPage(Color);
1191 
1192  /* Zero it outside the PFN lock */
1194  MiZeroPhysicalPage(HyperIndex);
1196  }
1199  WsListIndex = MiRemoveZeroPageSafe(Color);
1200  if (!WsListIndex)
1201  {
1202  /* No zero pages, grab a free one */
1203  WsListIndex = MiRemoveAnyPage(Color);
1204 
1205  /* Zero it outside the PFN lock */
1207  MiZeroPhysicalPage(WsListIndex);
1208  }
1209  else
1210  {
1211  /* Release the PFN lock */
1213  }
1214 
1215  /* Set the base directory pointers */
1216  Process->WorkingSetPage = WsListIndex;
1217  DirectoryTableBase[0] = TableBaseIndex << PAGE_SHIFT;
1218  DirectoryTableBase[1] = HyperIndex << PAGE_SHIFT;
1219 
1220  /* Perform the arch-specific parts */
1221  if (!MiArchCreateProcessAddressSpace(Process, DirectoryTableBase))
1222  {
1224  MiInsertPageInFreeList(WsListIndex);
1225  MiInsertPageInFreeList(HyperIndex);
1226  MiInsertPageInFreeList(TableBaseIndex);
1228  Process->WorkingSetPage = 0;
1229  DirectoryTableBase[0] = 0;
1230  DirectoryTableBase[1] = 0;
1231  return FALSE;
1232  }
1233 
1234  /* Switch to phase 1 initialization */
1235  ASSERT(Process->AddressSpaceInitialized == 0);
1236  Process->AddressSpaceInitialized = 1;
1237 
1238  /* Add the process to the session */
1240  return TRUE;
1241 }
1242 
1243 VOID
1244 NTAPI
1246 {
1247  PMMVAD Vad;
1248  PMM_AVL_TABLE VadTree;
1250 
1251  /* Only support this */
1252  ASSERT(Process->AddressSpaceInitialized == 2);
1253 
1254  /* Remove from the session */
1256 
1257  /* Lock the process address space from changes */
1260 
1261  /* VM is deleted now */
1262  Process->VmDeleted = TRUE;
1264 
1265  /* Enumerate the VADs */
1266  VadTree = &Process->VadRoot;
1267  while (VadTree->NumberGenericTableElements)
1268  {
1269  /* Grab the current VAD */
1270  Vad = (PMMVAD)VadTree->BalancedRoot.RightChild;
1271 
1272  /* Check for old-style memory areas */
1273  if (Vad->u.VadFlags.Spare == 1)
1274  {
1275  /* Let RosMm handle this */
1277  continue;
1278  }
1279 
1280  /* Lock the working set */
1282 
1283  /* Remove this VAD from the tree */
1284  ASSERT(VadTree->NumberGenericTableElements >= 1);
1285  MiRemoveNode((PMMADDRESS_NODE)Vad, VadTree);
1286 
1287  /* Only regular VADs supported for now */
1288  ASSERT(Vad->u.VadFlags.VadType == VadNone);
1289 
1290  /* Check if this is a section VAD */
1291  if (!(Vad->u.VadFlags.PrivateMemory) && (Vad->ControlArea))
1292  {
1293  /* Remove the view */
1295  }
1296  else
1297  {
1298  /* Delete the addresses */
1300  (Vad->EndingVpn << PAGE_SHIFT) | (PAGE_SIZE - 1),
1301  Vad);
1302 
1303  /* Release the working set */
1305  }
1306 
1307  /* Skip ARM3 fake VADs, they'll be freed by MmDeleteProcessAddresSpace */
1308  if (Vad->u.VadFlags.Spare == 1)
1309  {
1310  /* Set a flag so MmDeleteMemoryArea knows to free, but not to remove */
1311  Vad->u.VadFlags.Spare = 2;
1312  continue;
1313  }
1314 
1315  /* Free the VAD memory */
1316  ExFreePool(Vad);
1317  }
1318 
1319  /* Lock the working set */
1321  ASSERT(Process->CloneRoot == NULL);
1322  ASSERT(Process->PhysicalVadRoot == NULL);
1323 
1324  /* Delete the shared user data section */
1326 
1327  /* Release the working set */
1329 
1330  /* Release the address space */
1332 }
1333 
1334 VOID
1335 NTAPI
1337 {
1338  PMMPFN Pfn1, Pfn2;
1339  KIRQL OldIrql;
1340  PFN_NUMBER PageFrameIndex;
1341 
1342  //ASSERT(Process->CommitCharge == 0);
1343 
1344  /* Remove us from the list */
1346  RemoveEntryList(&Process->Vm.WorkingSetExpansionLinks);
1348 
1349  /* Acquire the PFN lock */
1351 
1352  /* Check for fully initialized process */
1353  if (Process->AddressSpaceInitialized == 2)
1354  {
1355  /* Map the working set page and its page table */
1356  Pfn1 = MiGetPfnEntry(Process->WorkingSetPage);
1357  Pfn2 = MiGetPfnEntry(Pfn1->u4.PteFrame);
1358 
1359  /* Nuke it */
1360  MI_SET_PFN_DELETED(Pfn1);
1361  MiDecrementShareCount(Pfn2, Pfn1->u4.PteFrame);
1362  MiDecrementShareCount(Pfn1, Process->WorkingSetPage);
1363  ASSERT((Pfn1->u3.e2.ReferenceCount == 0) || (Pfn1->u3.e1.WriteInProgress));
1364  MiReleaseSystemPtes(MiAddressToPte(Process->Vm.VmWorkingSetList), 1, SystemPteSpace);
1365 
1366  /* Now map hyperspace and its page table */
1367  PageFrameIndex = Process->Pcb.DirectoryTableBase[1] >> PAGE_SHIFT;
1368  Pfn1 = MiGetPfnEntry(PageFrameIndex);
1369  Pfn2 = MiGetPfnEntry(Pfn1->u4.PteFrame);
1370 
1371  /* Nuke it */
1372  MI_SET_PFN_DELETED(Pfn1);
1373  MiDecrementShareCount(Pfn2, Pfn1->u4.PteFrame);
1374  MiDecrementShareCount(Pfn1, PageFrameIndex);
1375  ASSERT((Pfn1->u3.e2.ReferenceCount == 0) || (Pfn1->u3.e1.WriteInProgress));
1376 
1377  /* Finally, nuke the PDE itself */
1378  PageFrameIndex = Process->Pcb.DirectoryTableBase[0] >> PAGE_SHIFT;
1379  Pfn1 = MiGetPfnEntry(PageFrameIndex);
1380  MI_SET_PFN_DELETED(Pfn1);
1381  MiDecrementShareCount(Pfn1, PageFrameIndex);
1382  MiDecrementShareCount(Pfn1, PageFrameIndex);
1383 
1384  /* Page table is now dead. Bye bye... */
1385  ASSERT((Pfn1->u3.e2.ReferenceCount == 0) || (Pfn1->u3.e1.WriteInProgress));
1386  }
1387  else
1388  {
1389  /* A partly-initialized process should never exit through here */
1390  ASSERT(FALSE);
1391  }
1392 
1393  /* Release the PFN lock */
1395 
1396  /* Drop a reference on the session */
1398 
1399  /* Clear out the PDE pages */
1400  Process->Pcb.DirectoryTableBase[0] = 0;
1401  Process->Pcb.DirectoryTableBase[1] = 0;
1402 }
1403 
1404 
1405 /* SYSTEM CALLS ***************************************************************/
1406 
1407 NTSTATUS
1408 NTAPI
1410  IN OUT PULONG_PTR NumberOfPages,
1411  IN OUT PULONG_PTR UserPfnArray)
1412 {
1413  UNIMPLEMENTED;
1414  return STATUS_NOT_IMPLEMENTED;
1415 }
1416 
1417 NTSTATUS
1418 NTAPI
1420  IN ULONG_PTR NumberOfPages,
1421  IN OUT PULONG_PTR UserPfnArray)
1422 {
1423  UNIMPLEMENTED;
1424  return STATUS_NOT_IMPLEMENTED;
1425 }
1426 
1427 NTSTATUS
1428 NTAPI
1430  IN ULONG_PTR NumberOfPages,
1431  IN OUT PULONG_PTR UserPfnArray)
1432 {
1433  UNIMPLEMENTED;
1434  return STATUS_NOT_IMPLEMENTED;
1435 }
1436 
1437 NTSTATUS
1438 NTAPI
1440  IN OUT PULONG_PTR NumberOfPages,
1441  IN OUT PULONG_PTR UserPfnArray)
1442 {
1443  UNIMPLEMENTED;
1444  return STATUS_NOT_IMPLEMENTED;
1445 }
1446 
1447 /* EOF */
#define MI_MAKE_SOFTWARE_PTE(p, x)
Definition: miarm.h:189
signed char * PCHAR
Definition: retypes.h:7
NTSYSAPI ULONG NTAPI RtlRandom(_Inout_ PULONG Seed)
ULONG ImageSubsystemMajorVersion
Definition: ntddk_ex.h:305
PFILE_OBJECT NTAPI MmGetFileObjectForSection(IN PVOID Section)
Definition: section.c:1734
VOID NTAPI MiInitializePfn(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN BOOLEAN Modified)
Definition: pfnlist.c:968
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define IN
Definition: typedefs.h:39
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:1245
SIZE_T MmHeapDeCommitTotalFreeThreshold
Definition: mminit.c:368
struct _KEVENT * PKEVENT
VOID NTAPI MiSessionRemoveProcess(VOID)
Definition: session.c:395
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PPEB Peb
Definition: dllmain.c:27
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ULONG ReadOnly
Definition: mmtypes.h:707
VOID NTAPI MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:604
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1222
#define MiAddressToPde(x)
Definition: mmx86.c:20
FORCEINLINE KIRQL MiAcquireExpansionLock(VOID)
Definition: miarm.h:1514
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
ULONG ImageProcessAffinityMask
Definition: ntddk_ex.h:307
union _MMPTE::@2304 u
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
ULONG OSPlatformId
Definition: ntddk_ex.h:303
PMMVAD Parent
Definition: mmtypes.h:751
VOID NTAPI MiReleaseProcessReferenceToSessionDataPage(IN PMM_SESSION_SPACE SessionGlobal)
Definition: session.c:209
ULONG PFN_COUNT
Definition: mmtypes.h:102
ULONG OneSecured
Definition: mmtypes.h:705
#define TRUE
Definition: types.h:120
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
struct _MMPFN::@1778::@1784 e2
FORCEINLINE VOID MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1545
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:760
ULONG_PTR CommitCharge
Definition: mmtypes.h:688
LONG NTSTATUS
Definition: precomp.h:26
FORCEINLINE PMMPTE MiAddressToPpe(PVOID Address)
Definition: mm.h:154
union _MMVAD_LONG::@2567 u
ULONG_PTR NumberGenericTableElements
Definition: mmtypes.h:665
#define MI_GET_NEXT_COLOR()
Definition: miarm.h:242
NTSTATUS NTAPI NtMapUserPhysicalPagesScatter(IN PVOID *VirtualAddresses, IN ULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1429
#define MM_NOACCESS
Definition: miarm.h:65
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:923
FORCEINLINE VOID MiLockProcessWorkingSet(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1107
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
PVOID ImageBaseAddress
Definition: ntddk_ex.h:245
BYTE BeingDebugged
Definition: btrfs_drv.h:1955
NTSTATUS NTAPI NtFreeUserPhysicalPages(IN HANDLE ProcessHandle, IN OUT PULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1439
PCONTROL_AREA ControlArea
Definition: mmtypes.h:762
ULONG_PTR Protection
Definition: mmtypes.h:693
ULONG LongVad
Definition: mmtypes.h:708
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
uint16_t * PWCHAR
Definition: typedefs.h:56
#define MM_SHARED_USER_DATA_VA
Definition: mmtypes.h:48
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define KERNEL_LARGE_STACK_COMMIT
union _MMVAD::@2565 u2
LCID PsDefaultThreadLocaleId
Definition: locale.c:25
ULONG_PTR LongFlags
Definition: mmtypes.h:759
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:512
union _MMPFN::@1781 u4
ULONG_PTR NoChange
Definition: mmtypes.h:690
ULONG MmLargeStackSize
Definition: mminit.c:262
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:731
ULONG NtMajorVersion
Definition: init.c:43
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:930
union _MMPFN::@1778 u3
SLIST_HEADER MmDeadStackSListHead
Definition: procsup.c:23
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:659
_SEH2_TRY
Definition: create.c:4226
uint32_t ULONG_PTR
Definition: typedefs.h:65
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
ULONG NtGlobalFlag
Definition: ntddk_ex.h:270
UCHAR KIRQL
Definition: env_spec_w32.h:591
MMPFNENTRY e1
Definition: mm.h:369
ULONG_PTR EndingVpn
Definition: mmtypes.h:727
return STATUS_NOT_IMPLEMENTED
NTSTATUS NTAPI MmCreateTeb(IN PEPROCESS Process, IN PCLIENT_ID ClientId, IN PINITIAL_TEB InitialTeb, OUT PTEB *BaseTeb)
Definition: procsup.c:740
HANDLE Mutant
Definition: ntddk_ex.h:243
#define MiAddressToPte(x)
Definition: mmx86.c:19
union _MMPFN::@1776 u1
NTSTATUS NTAPI MmGrowKernelStack(IN PVOID StackPointer)
Definition: procsup.c:459
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG
Definition: compat.h:153
ULONG PFN_NUMBER
Definition: ke.h:9
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
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:351
#define MI_SET_PROCESS2(x)
Definition: mm.h:291
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:767
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:238
FORCEINLINE PFN_NUMBER MiRemoveZeroPageSafe(IN ULONG Color)
Definition: miarm.h:2413
unsigned char BOOLEAN
PMMVAD NTAPI MiLocateAddress(IN PVOID VirtualAddress)
Definition: vadnode.c:48
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1132
#define MI_SET_USAGE(x)
Definition: mm.h:289
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:3851
void * PVOID
Definition: retypes.h:9
VOID NTAPI MiReleaseSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:264
ULONG_PTR StartingVpn
Definition: mmtypes.h:726
ULONG_PTR StartingVpn
Definition: mmtypes.h:650
NTSTATUS NTAPI NtAllocateUserPhysicalPages(IN HANDLE ProcessHandle, IN OUT PULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1409
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
VOID NTAPI KeQueryTickCount(IN PLARGE_INTEGER TickCount)
Definition: clock.c:165
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
ULONG HeapSegmentCommit
Definition: ntddk_ex.h:276
MMVAD_FLAGS2 VadFlags2
Definition: mmtypes.h:739
_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:692
USHORT WriteInProgress
Definition: mm.h:334
#define PCHAR
Definition: match.c:90
ULONG MultipleSecured
Definition: mmtypes.h:706
ULONG_PTR EndingVpn
Definition: mmtypes.h:651
Status
Definition: gdiplustypes.h:24
#define MM_READONLY
Definition: inbv.c:11
#define STATUS_INVALID_IMAGE_PROTECT
Definition: ntstatus.h:540
FORCEINLINE PMMPTE MiAddressToPxe(PVOID Address)
Definition: mm.h:164
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1152
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
ULONG HeapSegmentReserve
Definition: ntddk_ex.h:275
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1163
ULONG_PTR PrivateMemory
Definition: mmtypes.h:695
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
NTSTATUS NTAPI SeInitializeProcessAuditName(IN PFILE_OBJECT FileObject, IN BOOLEAN DoAudit, OUT POBJECT_NAME_INFORMATION *AuditInfo)
Definition: audit.c:47
#define ASSERT(a)
Definition: mode.c:45
PVOID * ProcessHeaps
Definition: ntddk_ex.h:288
ULONG MaximumNumberOfHeaps
Definition: ntddk_ex.h:287
NTSTATUS NTAPI MmInitializeHandBuiltProcess2(IN PEPROCESS Process)
Definition: procsup.c:1135
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
SIZE_T MmHeapDeCommitFreeBlockThreshold
Definition: mminit.c:369
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
uint64_t ULONGLONG
Definition: typedefs.h:67
#define MI_GET_NEXT_PROCESS_COLOR(x)
Definition: miarm.h:243
#define MI_MAPPING_RANGE_END
Definition: mm.h:48
ULONG64 Valid
Definition: mmtypes.h:150
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:87
#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:44
MMVAD_FLAGS2 VadFlags2
Definition: mmtypes.h:768
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2937
LARGE_INTEGER CriticalSectionTimeout
Definition: ntddk_ex.h:274
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
#define PSLIST_ENTRY
Definition: rtltypes.h:134
FORCEINLINE USHORT ExQueryDepthSList(_In_ PSLIST_HEADER SListHead)
Definition: exfuncs.h:153
CODE_SEG("INIT")
Definition: fsrtlpc.c:19
#define PPE_BASE
#define KERNEL_STACK_SIZE
* PFILE_OBJECT
Definition: iotypes.h:1998
SIZE_T MinimumStackCommit
Definition: winternl.h:358
ULONG NtBuildNumber
Definition: init.c:48
struct _MMADDRESS_NODE * RightChild
Definition: mmtypes.h:649
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define HYPER_SPACE_END
Definition: mm.h:15
#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:1965
#define RtlImageDirectoryEntryToData
Definition: compat.h:668
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:790
#define IMAGE_FILE_UP_SYSTEM_ONLY
Definition: pedump.c:170
#define MM_READWRITE
Definition: inbv.c:12
ULONG ExpUnicodeCaseTableDataOffset
Definition: init.c:84
Definition: mm.h:345
ULONG LowPart
Definition: typedefs.h:106
BOOLEAN NTAPI MmCreateProcessAddressSpace(IN ULONG MinWs, IN PEPROCESS Process, OUT PULONG_PTR DirectoryTableBase)
Definition: procsup.c:1143
NTSTATUS NTAPI MmSetMemoryPriorityProcess(IN PEPROCESS Process, IN UCHAR MemoryPriority)
Definition: procsup.c:469
#define PAGE_SIZE
Definition: env_spec_w32.h:49
NTKERNELAPI PSLIST_ENTRY FASTCALL InterlockedPushEntrySList(IN PSLIST_HEADER ListHead, IN PSLIST_ENTRY ListEntry)
Definition: interlocked.c:82
PVOID UnicodeCaseTableData
Definition: ntddk_ex.h:266
MM_SYSTEMSIZE MmSystemSize
Definition: mminit.c:326
#define _64K
Definition: miarm.h:23
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:962
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:360
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
EPROCESS KiInitialProcess
Definition: krnlinit.c:45
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:83
ULONG_PTR SIZE_T
Definition: typedefs.h:80
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
Definition: compat.h:694
#define PXE_BASE
#define MI_SET_PFN_DELETED(x)
Definition: miarm.h:194
struct _FileName FileName
Definition: fatprocs.h:893
FORCEINLINE VOID MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte, IN MMPTE InvalidPte)
Definition: miarm.h:984
PFN_COUNT MmNumberOfPhysicalPages
Definition: init.c:48
ULONG OSMinorVersion
Definition: ntddk_ex.h:301
_SEH2_END
Definition: create.c:4400
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
#define EXCEPTION_CHAIN_END
Definition: rtltypes.h:63
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
NTSTATUS NTAPI NtMapUserPhysicalPages(IN PVOID VirtualAddresses, IN ULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
Definition: procsup.c:1419
#define ROUND_TO_PAGES(Size)
unsigned short USHORT
Definition: pedump.c:61
ULONG_PTR PteFrame
Definition: mm.h:390
ULONG_PTR KAFFINITY
Definition: compat.h:85
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579
union _MMVAD::@2564 u
SIZE_T MmHeapSegmentCommit
Definition: mminit.c:367
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
ULONG NumberOfProcessors
Definition: ntddk_ex.h:269
unsigned int * PULONG
Definition: retypes.h:1
#define min(a, b)
Definition: monoChain.cc:55
#define NULL
Definition: types.h:112
#define PAGE_READONLY
Definition: compat.h:138
#define STATUS_STACK_OVERFLOW
Definition: ntstatus.h:489
FORCEINLINE VOID MiReleaseExpansionLock(KIRQL OldIrql)
Definition: miarm.h:1527
PMMWSL MmWorkingSetList
Definition: procsup.c:21
union _MMVAD_LONG::@2566 u1
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
union _MMVAD_LONG::@2568 u2
#define DPRINT1
Definition: precomp.h:8
#define RtlImageNtHeader
Definition: compat.h:665
PVOID OemCodePageData
Definition: ntddk_ex.h:265
#define MM_HIGHEST_VAD_ADDRESS
Definition: mm.h:46
ULONG WsIndex
Definition: mm.h:350
NTSTATUS NTAPI MmInitializeHandBuiltProcess(IN PEPROCESS Process, IN PULONG_PTR DirectoryTableBase)
Definition: procsup.c:1110
_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:426
FORCEINLINE PFN_NUMBER MiGetPfnEntryIndex(IN PMMPFN Pfn1)
Definition: mm.h:982
#define BOOLEAN
Definition: pedump.c:73
#define OUT
Definition: typedefs.h:40
ULONG CmNtCSDVersion
Definition: init.c:57
ULONG_PTR Spare
Definition: mmtypes.h:694
_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
unsigned int ULONG
Definition: retypes.h:1
PMMPTE FirstPrototypePte
Definition: mmtypes.h:763
#define UNIMPLEMENTED
Definition: debug.h:115
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define ULONG_PTR
Definition: config.h:101
uint32_t * PULONG_PTR
Definition: typedefs.h:65
ULONG NTAPI MmGetSessionId(IN PEPROCESS Process)
Definition: session.c:179
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:901
VOID NTAPI MiRemoveMappedView(IN PEPROCESS CurrentProcess, IN PMMVAD Vad)
Definition: section.c:784
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
ULONG HeapDeCommitFreeBlockThreshold
Definition: ntddk_ex.h:278
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
#define STATUS_SUCCESS
Definition: shellext.h:65
ULONG OSMajorVersion
Definition: ntddk_ex.h:300
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
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 DPRINT
Definition: sndvol32.h:71
#define KeGetCurrentThread
Definition: hal.h:49
NTSTATUS NTAPI MmGrowKernelStackEx(IN PVOID StackPointer, IN ULONG GrowSize)
Definition: procsup.c:371
FORCEINLINE PVOID MiPteToAddress(PMMPTE PointerPte)
Definition: mm.h:201
#define MEM_TOP_DOWN
Definition: nt_native.h:1321
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
ULONG NtGlobalFlag
Definition: init.c:52
ULONG ExpAnsiCodePageDataOffset
Definition: init.c:83
FORCEINLINE VOID MmLockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1538
PVOID AnsiCodePageData
Definition: ntddk_ex.h:264
struct _MMVAD * PMMVAD
#define PFN_FROM_PTE(v)
Definition: mm.h:92
ULONG_PTR VadType
Definition: mmtypes.h:691
BOOLEAN MiArchCreateProcessAddressSpace(_In_ PEPROCESS Process, _In_ PULONG_PTR DirectoryTableBase)
Definition: procsup.c:21
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
VOID NTAPI MmDeleteProcessAddressSpace2(IN PEPROCESS Process)
Definition: procsup.c:1336
FORCEINLINE VOID MiUnlockProcessWorkingSet(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1177
ULONG ImageSubsystemMinorVersion
Definition: ntddk_ex.h:306
ULONG PageFrameNumber
Definition: mmtypes.h:109
ULONG HeapDeCommitTotalFreeThreshold
Definition: ntddk_ex.h:277
#define PAGE_READWRITE
Definition: nt_native.h:1304
Definition: dlist.c:348
ULONG ImageSubsystem
Definition: ntddk_ex.h:304
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68