ReactOS  0.4.14-dev-337-gf981a68
procsup.c File Reference
#include <ntoskrnl.h>
#include <debug.h>
#include <mm/ARM3/miarm.h>
Include dependency graph for procsup.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define MODULE_INVOLVED_IN_ARM3
 

Functions

NTSTATUS NTAPI MiCreatePebOrTeb (IN PEPROCESS Process, IN ULONG Size, OUT PULONG_PTR BaseAddress)
 
VOID NTAPI MmDeleteTeb (IN PEPROCESS Process, IN PTEB Teb)
 
VOID NTAPI MmDeleteKernelStack (IN PVOID StackBase, IN BOOLEAN GuiStack)
 
PVOID NTAPI MmCreateKernelStack (IN BOOLEAN GuiStack, IN UCHAR Node)
 
NTSTATUS NTAPI MmGrowKernelStackEx (IN PVOID StackPointer, IN ULONG GrowSize)
 
NTSTATUS NTAPI MmGrowKernelStack (IN PVOID StackPointer)
 
NTSTATUS NTAPI MmSetMemoryPriorityProcess (IN PEPROCESS Process, IN UCHAR MemoryPriority)
 
NTSTATUS NTAPI MmCreatePeb (IN PEPROCESS Process, IN PINITIAL_PEB InitialPeb, OUT PPEB *BasePeb)
 
NTSTATUS NTAPI MmCreateTeb (IN PEPROCESS Process, IN PCLIENT_ID ClientId, IN PINITIAL_TEB InitialTeb, OUT PTEB *BaseTeb)
 
VOID NTAPI MiInitializeWorkingSetList (IN PEPROCESS CurrentProcess)
 
NTSTATUS NTAPI MmInitializeProcessAddressSpace (IN PEPROCESS Process, IN PEPROCESS ProcessClone OPTIONAL, IN PVOID Section OPTIONAL, IN OUT PULONG Flags, IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL)
 
INIT_FUNCTION NTSTATUS NTAPI MmInitializeHandBuiltProcess (IN PEPROCESS Process, IN PULONG_PTR DirectoryTableBase)
 
INIT_FUNCTION NTSTATUS NTAPI MmInitializeHandBuiltProcess2 (IN PEPROCESS Process)
 
VOID NTAPI MmCleanProcessAddressSpace (IN PEPROCESS Process)
 
VOID NTAPI MmDeleteProcessAddressSpace2 (IN PEPROCESS Process)
 
NTSTATUS NTAPI NtAllocateUserPhysicalPages (IN HANDLE ProcessHandle, IN OUT PULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
 
NTSTATUS NTAPI NtMapUserPhysicalPages (IN PVOID VirtualAddresses, IN ULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
 
NTSTATUS NTAPI NtMapUserPhysicalPagesScatter (IN PVOID *VirtualAddresses, IN ULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
 
NTSTATUS NTAPI NtFreeUserPhysicalPages (IN HANDLE ProcessHandle, IN OUT PULONG_PTR NumberOfPages, IN OUT PULONG_PTR UserPfnArray)
 

Variables

ULONG MmProcessColorSeed = 0x12345678
 
PMMWSL MmWorkingSetList
 
ULONG MmMaximumDeadKernelStacks = 5
 
SLIST_HEADER MmDeadStackSListHead
 

Macro Definition Documentation

◆ MODULE_INVOLVED_IN_ARM3

#define MODULE_INVOLVED_IN_ARM3

Definition at line 15 of file procsup.c.

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file procsup.c.

Function Documentation

◆ MiCreatePebOrTeb()

NTSTATUS NTAPI MiCreatePebOrTeb ( IN PEPROCESS  Process,
IN ULONG  Size,
OUT PULONG_PTR  BaseAddress 
)

Definition at line 29 of file procsup.c.

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 }
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define TRUE
Definition: types.h:120
union _MMVAD_LONG::@2516 u1
ULONG ReadOnly
Definition: mmtypes.h:710
PMMVAD Parent
Definition: mmtypes.h:754
ULONG OneSecured
Definition: mmtypes.h:708
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:763
ULONG_PTR CommitCharge
Definition: mmtypes.h:691
LONG NTSTATUS
Definition: precomp.h:26
PCONTROL_AREA ControlArea
Definition: mmtypes.h:765
ULONG_PTR Protection
Definition: mmtypes.h:696
ULONG LongVad
Definition: mmtypes.h:711
ULONG_PTR LongFlags
Definition: mmtypes.h:762
ULONG_PTR NoChange
Definition: mmtypes.h:693
uint32_t ULONG_PTR
Definition: typedefs.h:63
ULONG LongFlags2
Definition: mmtypes.h:770
smooth NULL
Definition: ftsmooth.c:416
VOID NTAPI KeQueryTickCount(IN PLARGE_INTEGER TickCount)
Definition: clock.c:165
ULONG_PTR MemCommit
Definition: mmtypes.h:695
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
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 NT_SUCCESS(StatCode)
Definition: apphelp.c:32
MMVAD_FLAGS2 VadFlags2
Definition: mmtypes.h:771
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define BYTES_TO_PAGES(Size)
#define MM_READWRITE
Definition: inbv.c:10
ULONG LowPart
Definition: typedefs.h:104
#define PAGE_SIZE
Definition: env_spec_w32.h:49
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define _64K
Definition: miarm.h:19
Status
Definition: gdiplustypes.h:24
Definition: compat.h:492
#define ROUND_TO_PAGES(Size)
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
union _MMVAD_LONG::@2518 u2
#define MM_HIGHEST_VAD_ADDRESS
Definition: mm.h:43
union _MMVAD_LONG::@2517 u
unsigned int ULONG
Definition: retypes.h:1
PMMPTE FirstPrototypePte
Definition: mmtypes.h:766
#define ULONG_PTR
Definition: config.h:101
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define MEM_TOP_DOWN
Definition: nt_native.h:1321
return STATUS_SUCCESS
Definition: btrfs.c:2938

Referenced by MmCreatePeb(), and MmCreateTeb().

◆ MiInitializeWorkingSetList()

VOID NTAPI MiInitializeWorkingSetList ( IN PEPROCESS  CurrentProcess)

Definition at line 845 of file procsup.c.

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 }
union _MMPFN::@1746 u1
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
struct _KEVENT * PKEVENT
PVOID HashTableStart
Definition: mmtypes.h:865
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
ULONG FirstDynamic
Definition: mmtypes.h:856
PVOID HighestPermittedHashAddress
Definition: mmtypes.h:866
uint32_t ULONG_PTR
Definition: typedefs.h:63
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:951
PKEVENT Event
Definition: mm.h:311
smooth NULL
Definition: ftsmooth.c:416
PVOID FORCEINLINE MiPteToAddress(PMMPTE PointerPte)
Definition: mm.h:198
ULONG NextSlot
Definition: mmtypes.h:858
void * PVOID
Definition: retypes.h:9
#define ULL(a, b)
Definition: format_msg.c:27
ULONG CurrentProcess
Definition: shell.c:125
ULONG LastInitializedWsle
Definition: mmtypes.h:860
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
PMMWSLE Wsle
Definition: mmtypes.h:859
PMMWSLE_HASH HashTable
Definition: mmtypes.h:862
#define MM_READWRITE
Definition: inbv.c:10
Definition: mm.h:305
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:940
ULONG HashTableSize
Definition: mmtypes.h:863
ULONG_PTR PteFrame
Definition: mm.h:350
ULONG NumberOfImageWaiters
Definition: mmtypes.h:867
ULONG FirstFree
Definition: mmtypes.h:855
PMMWSL MmWorkingSetList
Definition: procsup.c:21
FORCEINLINE PFN_NUMBER MiGetPfnEntryIndex(IN PMMPFN Pfn1)
Definition: mm.h:960
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
ULONG LastEntry
Definition: mmtypes.h:857
union _MMPFN::@1751 u4
ULONG VadBitMapHint
Definition: mmtypes.h:868

Referenced by MmInitializeProcessAddressSpace().

◆ MmCleanProcessAddressSpace()

VOID NTAPI MmCleanProcessAddressSpace ( IN PEPROCESS  Process)

Definition at line 1235 of file procsup.c.

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 }
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define TRUE
Definition: types.h:120
VOID NTAPI MiSessionRemoveProcess(VOID)
Definition: session.c:396
union _MMVAD::@2514 u
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1214
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
FORCEINLINE VOID MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1431
ULONG_PTR NumberGenericTableElements
Definition: mmtypes.h:668
VOID NTAPI MiRosCleanupMemoryArea(PEPROCESS Process, PMMVAD Vad)
Definition: marea.c:522
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:734
MMADDRESS_NODE BalancedRoot
Definition: mmtypes.h:662
ULONG_PTR EndingVpn
Definition: mmtypes.h:730
PCONTROL_AREA ControlArea
Definition: mmtypes.h:736
#define USER_SHARED_DATA
Definition: pstypes.h:51
smooth NULL
Definition: ftsmooth.c:416
ULONG_PTR StartingVpn
Definition: mmtypes.h:729
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1144
ULONG_PTR PrivateMemory
Definition: mmtypes.h:698
if(!(yy_init))
Definition: macro.lex.yy.c:714
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
struct _MMADDRESS_NODE * RightChild
Definition: mmtypes.h:652
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define PAGE_SIZE
Definition: env_spec_w32.h:49
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:360
VOID NTAPI MiDeleteVirtualAddresses(IN ULONG_PTR Va, IN ULONG_PTR EndingAddress, IN PMMVAD Vad)
Definition: virtual.c:540
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
ULONG_PTR Spare
Definition: mmtypes.h:697
VOID NTAPI MiRemoveMappedView(IN PEPROCESS CurrentProcess, IN PMMVAD Vad)
Definition: section.c:780
FORCEINLINE VOID MmLockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1424
struct _MMVAD * PMMVAD
ULONG_PTR VadType
Definition: mmtypes.h:694
#define ExFreePool(addr)
Definition: env_spec_w32.h:352

Referenced by PspExitProcess(), and PspExitThread().

◆ MmCreateKernelStack()

PVOID NTAPI MmCreateKernelStack ( IN BOOLEAN  GuiStack,
IN UCHAR  Node 
)

Definition at line 258 of file procsup.c.

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 }
#define MI_MAKE_SOFTWARE_PTE(p, x)
Definition: miarm.h:193
VOID NTAPI MiInitializePfn(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN BOOLEAN Modified)
Definition: pfnlist.c:969
ULONG PFN_COUNT
Definition: mmtypes.h:102
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
#define MI_GET_NEXT_COLOR()
Definition: miarm.h:246
#define MM_NOACCESS
Definition: miarm.h:69
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:901
#define KERNEL_LARGE_STACK_COMMIT
ULONG MmLargeStackSize
Definition: mminit.c:262
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:908
SLIST_HEADER MmDeadStackSListHead
Definition: procsup.c:23
PSLIST_ENTRY WINAPI InterlockedPopEntrySList(PSLIST_HEADER ListHead)
Definition: interlocked.c:55
UCHAR KIRQL
Definition: env_spec_w32.h:591
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ULONG PFN_NUMBER
Definition: ke.h:8
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:951
#define MI_SET_PROCESS2(x)
Definition: mm.h:254
#define PsGetCurrentProcess
Definition: psfuncs.h:17
smooth NULL
Definition: ftsmooth.c:416
PVOID FORCEINLINE MiPteToAddress(PMMPTE PointerPte)
Definition: mm.h:198
#define MI_SET_USAGE(x)
Definition: mm.h:253
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
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
#define KERNEL_STACK_SIZE
#define BYTES_TO_PAGES(Size)
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define MM_READWRITE
Definition: inbv.c:10
PFN_NUMBER NTAPI MiRemoveAnyPage(IN ULONG Color)
Definition: pfnlist.c:475
FORCEINLINE VOID MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte, IN MMPTE InvalidPte)
Definition: miarm.h:980
unsigned int ULONG
Definition: retypes.h:1
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
ULONG PageFrameNumber
Definition: mmtypes.h:109

◆ MmCreatePeb()

NTSTATUS NTAPI MmCreatePeb ( IN PEPROCESS  Process,
IN PINITIAL_PEB  InitialPeb,
OUT PPEB BasePeb 
)

Definition at line 500 of file procsup.c.

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 }
ULONG ImageSubsystemMajorVersion
Definition: ntddk_ex.h:305
#define VER_PLATFORM_WIN32_NT
Definition: rtltypes.h:236
ULONG HeapSegmentReserve
Definition: ntddk_ex.h:275
SIZE_T MmHeapDeCommitTotalFreeThreshold
Definition: mminit.c:368
#define TRUE
Definition: types.h:120
PPEB Peb
Definition: dllmain.c:27
ULONG ImageProcessAffinityMask
Definition: ntddk_ex.h:307
ULONG OSPlatformId
Definition: ntddk_ex.h:303
LONG NTSTATUS
Definition: precomp.h:26
BYTE BeingDebugged
Definition: btrfs_drv.h:1886
SIZE_T MmMinimumStackCommitInBytes
Definition: mminit.c:370
ULONG NtMajorVersion
Definition: init.c:42
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
_SEH2_TRY
Definition: create.c:4250
ULONG HeapDeCommitFreeBlockThreshold
Definition: ntddk_ex.h:278
PVOID ImageBaseAddress
Definition: ntddk_ex.h:245
ULONG NtGlobalFlag
Definition: ntddk_ex.h:270
HANDLE Mutant
Definition: ntddk_ex.h:243
LARGE_INTEGER MmCriticalSectionTimeout
Definition: mminit.c:388
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
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
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER SectionOffset
Definition: mmfuncs.h:404
#define PCHAR
Definition: match.c:90
#define STATUS_INVALID_IMAGE_PROTECT
Definition: ntstatus.h:526
ULONG HeapSegmentCommit
Definition: ntddk_ex.h:276
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
PVOID * ProcessHeaps
Definition: ntddk_ex.h:288
ULONG MaximumNumberOfHeaps
Definition: ntddk_ex.h:287
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
SIZE_T MmHeapDeCommitFreeBlockThreshold
Definition: mminit.c:369
uint64_t ULONGLONG
Definition: typedefs.h:65
NTSTATUS NTAPI MiCreatePebOrTeb(IN PEPROCESS Process, IN ULONG Size, OUT PULONG_PTR BaseAddress)
Definition: procsup.c:29
PVOID ExpNlsSectionPointer
Definition: init.c:86
ULONG NtMinorVersion
Definition: init.c:43
LARGE_INTEGER CriticalSectionTimeout
Definition: ntddk_ex.h:274
SIZE_T MinimumStackCommit
Definition: winternl.h:358
ULONG NtBuildNumber
Definition: init.c:47
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:618
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:1896
#define RtlImageDirectoryEntryToData
Definition: compat.h:468
#define IMAGE_FILE_UP_SYSTEM_ONLY
Definition: pedump.c:170
ULONG ExpUnicodeCaseTableDataOffset
Definition: init.c:83
#define PAGE_SIZE
Definition: env_spec_w32.h:49
PVOID UnicodeCaseTableData
Definition: ntddk_ex.h:266
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
Status
Definition: gdiplustypes.h:24
ULONG ExpOemCodePageDataOffset
Definition: init.c:82
ULONG_PTR SIZE_T
Definition: typedefs.h:78
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG
Definition: pedump.c:269
ULONG HeapDeCommitTotalFreeThreshold
Definition: ntddk_ex.h:277
ULONG OSMinorVersion
Definition: ntddk_ex.h:301
_SEH2_END
Definition: create.c:4424
unsigned short USHORT
Definition: pedump.c:61
ULONG_PTR KAFFINITY
Definition: compat.h:75
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579
SIZE_T MmHeapSegmentCommit
Definition: mminit.c:367
ULONG NumberOfProcessors
Definition: ntddk_ex.h:269
unsigned int * PULONG
Definition: retypes.h:1
#define PAGE_READONLY
Definition: compat.h:127
#define RtlImageNtHeader
Definition: compat.h:465
PVOID OemCodePageData
Definition: ntddk_ex.h:265
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
#define BOOLEAN
Definition: pedump.c:73
ULONG CmNtCSDVersion
Definition: init.c:56
_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
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
uint32_t * PULONG_PTR
Definition: typedefs.h:63
ULONG NTAPI MmGetSessionId(IN PEPROCESS Process)
Definition: session.c:180
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
ULONG OSMajorVersion
Definition: ntddk_ex.h:300
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
BOOLEAN InheritedAddressSpace
Definition: ntddk_ex.h:239
struct _PEB PEB
#define MEM_TOP_DOWN
Definition: nt_native.h:1321
return STATUS_SUCCESS
Definition: btrfs.c:2938
ULONG NtGlobalFlag
Definition: init.c:51
ULONG ExpAnsiCodePageDataOffset
Definition: init.c:82
PVOID AnsiCodePageData
Definition: ntddk_ex.h:264
ULONG ImageSubsystemMinorVersion
Definition: ntddk_ex.h:306
ULONG ImageSubsystem
Definition: ntddk_ex.h:304

Referenced by PspCreateProcess().

◆ MmCreateTeb()

NTSTATUS NTAPI MmCreateTeb ( IN PEPROCESS  Process,
IN PCLIENT_ID  ClientId,
IN PINITIAL_TEB  InitialTeb,
OUT PTEB BaseTeb 
)

Definition at line 740 of file procsup.c.

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
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;
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  //
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 }
struct _NT_TIB * Self
Definition: compat.h:388
WCHAR StaticUnicodeBuffer[261]
Definition: compat.h:534
PPEB ProcessEnvironmentBlock
Definition: ntddk_ex.h:337
USHORT MaximumLength
Definition: env_spec_w32.h:370
LONG NTSTATUS
Definition: precomp.h:26
LCID PsDefaultThreadLocaleId
Definition: locale.c:25
_SEH2_TRY
Definition: create.c:4250
CLIENT_ID ClientId
Definition: compat.h:496
UNICODE_STRING StaticUnicodeString
Definition: compat.h:533
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
ULONG CurrentLocale
Definition: compat.h:506
smooth NULL
Definition: ftsmooth.c:416
DWORD Version
Definition: compat.h:385
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1176
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
PVOID DeallocationStack
Definition: compat.h:535
NTSTATUS NTAPI MiCreatePebOrTeb(IN PEPROCESS Process, IN ULONG Size, OUT PULONG_PTR BaseAddress)
Definition: procsup.c:29
struct _NT_TIB * PNT_TIB
struct _EXCEPTION_REGISTRATION_RECORD * ExceptionList
Definition: compat.h:379
CLIENT_ID RealClientId
Definition: compat.h:518
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:618
Status
Definition: gdiplustypes.h:24
Definition: compat.h:492
_SEH2_END
Definition: create.c:4424
#define EXCEPTION_CHAIN_END
Definition: rtltypes.h:63
PVOID StackBase
Definition: compat.h:380
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
uint32_t * PULONG_PTR
Definition: typedefs.h:63
PVOID StackLimit
Definition: compat.h:381
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
return STATUS_SUCCESS
Definition: btrfs.c:2938
NT_TIB NtTib
Definition: ntddk_ex.h:332

Referenced by PspCreateThread().

◆ MmDeleteKernelStack()

VOID NTAPI MmDeleteKernelStack ( IN PVOID  StackBase,
IN BOOLEAN  GuiStack 
)

Definition at line 169 of file procsup.c.

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 }
ULONG PFN_COUNT
Definition: mmtypes.h:102
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:901
union _MMPTE::@2254 u
ULONG MmLargeStackSize
Definition: mminit.c:262
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:908
SLIST_HEADER MmDeadStackSListHead
Definition: procsup.c:23
UCHAR KIRQL
Definition: env_spec_w32.h:591
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
ULONG PFN_NUMBER
Definition: ke.h:8
ULONG MmMaximumDeadKernelStacks
Definition: procsup.c:22
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1133
VOID NTAPI MiReleaseSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:275
ULONG64 Valid
Definition: mmtypes.h:150
#define PSLIST_ENTRY
Definition: rtltypes.h:130
FORCEINLINE USHORT ExQueryDepthSList(_In_ PSLIST_HEADER SListHead)
Definition: exfuncs.h:153
#define KERNEL_STACK_SIZE
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define BYTES_TO_PAGES(Size)
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
Definition: mm.h:305
NTKERNELAPI PSLIST_ENTRY FASTCALL InterlockedPushEntrySList(IN PSLIST_HEADER ListHead, IN PSLIST_ENTRY ListEntry)
Definition: interlocked.c:82
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:940
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
#define MI_SET_PFN_DELETED(x)
Definition: miarm.h:198
ULONG_PTR PteFrame
Definition: mm.h:350
unsigned int ULONG
Definition: retypes.h:1
#define PFN_FROM_PTE(v)
Definition: mm.h:89
union _MMPFN::@1751 u4

◆ MmDeleteProcessAddressSpace2()

VOID NTAPI MmDeleteProcessAddressSpace2 ( IN PEPROCESS  Process)

Definition at line 1326 of file procsup.c.

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 }
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
struct _MMPFN::@1748::@1754 e2
VOID NTAPI MiReleaseProcessReferenceToSessionDataPage(IN PMM_SESSION_SPACE SessionGlobal)
Definition: session.c:210
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:901
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:908
UCHAR KIRQL
Definition: env_spec_w32.h:591
MMPFNENTRY e1
Definition: mm.h:329
#define MiAddressToPte(x)
Definition: mmx86.c:19
ULONG PFN_NUMBER
Definition: ke.h:8
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1133
VOID NTAPI MiReleaseSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:275
USHORT WriteInProgress
Definition: mm.h:294
union _MMPFN::@1748 u3
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
Definition: mm.h:305
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:940
#define MI_SET_PFN_DELETED(x)
Definition: miarm.h:198
ULONG_PTR PteFrame
Definition: mm.h:350
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
union _MMPFN::@1751 u4

Referenced by MmDeleteProcessAddressSpace().

◆ MmDeleteTeb()

VOID NTAPI MmDeleteTeb ( IN PEPROCESS  Process,
IN PTEB  Teb 
)

Definition at line 107 of file procsup.c.

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 }
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define TRUE
Definition: types.h:120
union _MMVAD::@2514 u
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1214
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
ULONG OneSecured
Definition: mmtypes.h:708
ULONG_PTR NumberGenericTableElements
Definition: mmtypes.h:668
union _MMVAD::@2515 u2
ULONG_PTR NoChange
Definition: mmtypes.h:693
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:734
uint32_t ULONG_PTR
Definition: typedefs.h:63
ULONG_PTR EndingVpn
Definition: mmtypes.h:730
smooth NULL
Definition: ftsmooth.c:416
PMMVAD NTAPI MiLocateAddress(IN PVOID VirtualAddress)
Definition: vadnode.c:48
void DPRINT(...)
Definition: polytest.cpp:61
ULONG_PTR StartingVpn
Definition: mmtypes.h:729
MMVAD_FLAGS2 VadFlags2
Definition: mmtypes.h:742
ULONG MultipleSecured
Definition: mmtypes.h:709
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1144
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:618
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:360
VOID NTAPI MiDeleteVirtualAddresses(IN ULONG_PTR Va, IN ULONG_PTR EndingAddress, IN PMMVAD Vad)
Definition: virtual.c:540
Definition: compat.h:492
#define ROUND_TO_PAGES(Size)
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
#define DPRINT1
Definition: precomp.h:8
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
#define ULONG_PTR
Definition: config.h:101
#define ExFreePool(addr)
Definition: env_spec_w32.h:352

◆ MmGrowKernelStack()

NTSTATUS NTAPI MmGrowKernelStack ( IN PVOID  StackPointer)

Definition at line 459 of file procsup.c.

460 {
461  //
462  // Call the extended version
463  //
464  return MmGrowKernelStackEx(StackPointer, KERNEL_LARGE_STACK_COMMIT);
465 }
#define KERNEL_LARGE_STACK_COMMIT
NTSTATUS NTAPI MmGrowKernelStackEx(IN PVOID StackPointer, IN ULONG GrowSize)
Definition: procsup.c:371

Referenced by KiUserModeCallout().

◆ MmGrowKernelStackEx()

NTSTATUS NTAPI MmGrowKernelStackEx ( IN PVOID  StackPointer,
IN ULONG  GrowSize 
)

Definition at line 371 of file procsup.c.

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 }
#define MI_MAKE_SOFTWARE_PTE(p, x)
Definition: miarm.h:193
VOID NTAPI MiInitializePfn(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN BOOLEAN Modified)
Definition: pfnlist.c:969
#define MI_GET_NEXT_COLOR()
Definition: miarm.h:246
#define MM_NOACCESS
Definition: miarm.h:69
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:901
union _MMPTE::@2254 u
ULONG MmLargeStackSize
Definition: mminit.c:262
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:908
uint32_t ULONG_PTR
Definition: typedefs.h:63
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define MiAddressToPte(x)
Definition: mmx86.c:19
ULONG PFN_NUMBER
Definition: ke.h:8
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:951
#define MI_SET_PROCESS2(x)
Definition: mm.h:254
#define PsGetCurrentProcess
Definition: psfuncs.h:17
PVOID FORCEINLINE MiPteToAddress(PMMPTE PointerPte)
Definition: mm.h:198
#define MI_SET_USAGE(x)
Definition: mm.h:253
ULONG64 Valid
Definition: mmtypes.h:150
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define MM_READWRITE
Definition: inbv.c:10
#define PAGE_SIZE
Definition: env_spec_w32.h:49
PFN_NUMBER NTAPI MiRemoveAnyPage(IN ULONG Color)
Definition: pfnlist.c:475
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
FORCEINLINE VOID MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte, IN MMPTE InvalidPte)
Definition: miarm.h:980
#define STATUS_STACK_OVERFLOW
Definition: ntstatus.h:475
#define ULONG_PTR
Definition: config.h:101
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
#define KeGetCurrentThread
Definition: hal.h:44
return STATUS_SUCCESS
Definition: btrfs.c:2938

Referenced by MmGrowKernelStack().

◆ MmInitializeHandBuiltProcess()

INIT_FUNCTION NTSTATUS NTAPI MmInitializeHandBuiltProcess ( IN PEPROCESS  Process,
IN PULONG_PTR  DirectoryTableBase 
)

Definition at line 1033 of file procsup.c.

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 }
#define TRUE
Definition: types.h:120
#define PsGetCurrentProcess
Definition: psfuncs.h:17
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
smooth NULL
Definition: ftsmooth.c:416
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
return STATUS_SUCCESS
Definition: btrfs.c:2938

Referenced by PspCreateProcess().

◆ MmInitializeHandBuiltProcess2()

INIT_FUNCTION NTSTATUS NTAPI MmInitializeHandBuiltProcess2 ( IN PEPROCESS  Process)

Definition at line 1058 of file procsup.c.

1059 {
1060  /* Lock the VAD, ARM3-owned ranges away */
1061  return STATUS_SUCCESS;
1062 }
return STATUS_SUCCESS
Definition: btrfs.c:2938

Referenced by PspCreateProcess().

◆ MmInitializeProcessAddressSpace()

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 at line 879 of file procsup.c.

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 }
_Must_inspect_result_ _Outptr_ PVOID * SectionObject
Definition: fsrtlfuncs.h:860
signed char * PCHAR
Definition: retypes.h:7
VOID NTAPI MiInitializePfn(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN BOOLEAN Modified)
Definition: pfnlist.c:969
#define TRUE
Definition: types.h:120
#define MiAddressToPde(x)
Definition: mmx86.c:20
LONG NTSTATUS
Definition: precomp.h:26
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:901
union _MMPTE::@2254 u
uint16_t * PWCHAR
Definition: typedefs.h:54
#define MEM_COMMIT
Definition: nt_native.h:1313
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:908
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define MiAddressToPte(x)
Definition: mmx86.c:19
ULONG PFN_NUMBER
Definition: ke.h:8
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:951
#define ANSI_NULL
#define PDE_BASE
Definition: winldr.c:21
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
smooth NULL
Definition: ftsmooth.c:416
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 NTAPI MiInitializeWorkingSetList(IN PEPROCESS CurrentProcess)
Definition: procsup.c:845
NTSTATUS NTAPI SeInitializeProcessAuditName(IN PFILE_OBJECT FileObject, IN BOOLEAN DoAudit, OUT POBJECT_NAME_INFORMATION *AuditInfo)
Definition: audit.c:47
#define MI_WORKING_SET_LIST
Definition: mm.h:48
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2891
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:618
unsigned char UCHAR
Definition: xmlstorage.h:181
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define MM_READWRITE
Definition: inbv.c:10
PMMPTE FORCEINLINE MiAddressToPxe(PVOID Address)
Definition: mm.h:161
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Status
Definition: gdiplustypes.h:24
ULONG_PTR Long
Definition: mmtypes.h:215
ULONG_PTR SIZE_T
Definition: typedefs.h:78
#define PXE_BASE
struct _FileName FileName
Definition: fatprocs.h:884
FORCEINLINE VOID MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte, IN MMPTE InvalidPte)
Definition: miarm.h:980
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
unsigned short USHORT
Definition: pedump.c:61
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579
#define min(a, b)
Definition: monoChain.cc:55
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
_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
MMPTE DemandZeroPte
Definition: init.c:37
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
return STATUS_SUCCESS
Definition: btrfs.c:2938
#define PFN_FROM_PTE(v)
Definition: mm.h:89
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 PageFrameNumber
Definition: mmtypes.h:109
#define PAGE_READWRITE
Definition: nt_native.h:1304

◆ MmSetMemoryPriorityProcess()

NTSTATUS NTAPI MmSetMemoryPriorityProcess ( IN PEPROCESS  Process,
IN UCHAR  MemoryPriority 
)

Definition at line 469 of file procsup.c.

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 }
#define MEMORY_PRIORITY_BACKGROUND
Definition: pstypes.h:124
unsigned char UCHAR
Definition: xmlstorage.h:181
#define PAGE_SIZE
Definition: env_spec_w32.h:49
MM_SYSTEMSIZE MmSystemSize
Definition: mminit.c:326
PFN_COUNT MmNumberOfPhysicalPages
Definition: init.c:48
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219

Referenced by NtSetInformationProcess(), and PspComputeQuantumAndPriority().

◆ NtAllocateUserPhysicalPages()

NTSTATUS NTAPI NtAllocateUserPhysicalPages ( IN HANDLE  ProcessHandle,
IN OUT PULONG_PTR  NumberOfPages,
IN OUT PULONG_PTR  UserPfnArray 
)

Definition at line 1394 of file procsup.c.

1397 {
1398  UNIMPLEMENTED;
1399  return STATUS_NOT_IMPLEMENTED;
1400 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by AllocateUserPhysicalPages().

◆ NtFreeUserPhysicalPages()

NTSTATUS NTAPI NtFreeUserPhysicalPages ( IN HANDLE  ProcessHandle,
IN OUT PULONG_PTR  NumberOfPages,
IN OUT PULONG_PTR  UserPfnArray 
)

Definition at line 1424 of file procsup.c.

1427 {
1428  UNIMPLEMENTED;
1429  return STATUS_NOT_IMPLEMENTED;
1430 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by FreeUserPhysicalPages().

◆ NtMapUserPhysicalPages()

NTSTATUS NTAPI NtMapUserPhysicalPages ( IN PVOID  VirtualAddresses,
IN ULONG_PTR  NumberOfPages,
IN OUT PULONG_PTR  UserPfnArray 
)

Definition at line 1404 of file procsup.c.

1407 {
1408  UNIMPLEMENTED;
1409  return STATUS_NOT_IMPLEMENTED;
1410 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by MapUserPhysicalPages().

◆ NtMapUserPhysicalPagesScatter()

NTSTATUS NTAPI NtMapUserPhysicalPagesScatter ( IN PVOID VirtualAddresses,
IN ULONG_PTR  NumberOfPages,
IN OUT PULONG_PTR  UserPfnArray 
)

Definition at line 1414 of file procsup.c.

1417 {
1418  UNIMPLEMENTED;
1419  return STATUS_NOT_IMPLEMENTED;
1420 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by MapUserPhysicalPagesScatter().

Variable Documentation

◆ MmDeadStackSListHead

SLIST_HEADER MmDeadStackSListHead

Definition at line 23 of file procsup.c.

Referenced by MmArmInitSystem(), MmCreateKernelStack(), and MmDeleteKernelStack().

◆ MmMaximumDeadKernelStacks

ULONG MmMaximumDeadKernelStacks = 5

Definition at line 22 of file procsup.c.

Referenced by MmArmInitSystem(), and MmDeleteKernelStack().

◆ MmProcessColorSeed

ULONG MmProcessColorSeed = 0x12345678

Definition at line 20 of file procsup.c.

Referenced by MmCreateProcessAddressSpace().

◆ MmWorkingSetList