ReactOS  0.4.15-dev-2355-gaf9df93
marea.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1998-2005 ReactOS Team (and the authors from the programmers section)
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  *
19  * PROJECT: ReactOS kernel
20  * FILE: ntoskrnl/mm/marea.c
21  * PURPOSE: Implements memory areas
22  *
23  * PROGRAMMERS: Rex Jolliff
24  * David Welch
25  * Eric Kohl
26  * Philip Susi
27  * Casper Hornstrup
28  * Eric Kohl
29  * Ge van Geldorp
30  * Royce Mitchell III
31  * Aleksey Bragin
32  * Jason Filby
33  * Thomas Weidenmueller
34  * Gunnar Andre' Dalsnes
35  * Mike Nordell
36  * Alex Ionescu
37  * Filip Navara
38  * Herve Poussineau
39  * Steven Edwards
40  */
41 
42 /* INCLUDES *****************************************************************/
43 
44 #include <ntoskrnl.h>
45 #define NDEBUG
46 #include <cache/section/newmm.h>
47 #include <debug.h>
48 
49 #include "ARM3/miarm.h"
50 
53 
56 
57 /* FUNCTIONS *****************************************************************/
58 
62  PVOID Address_)
63 {
64  ULONG_PTR StartVpn = (ULONG_PTR)Address_ / PAGE_SIZE;
70  PMMVAD_LONG Vad;
71 
73  Table = (Process != NULL) ? &Process->VadRoot : &MiRosKernelVadRoot;
74 
75  Result = MiCheckForConflictingNode(StartVpn, StartVpn, Table, &Node);
76  if (Result != TableFoundNode)
77  {
78  return NULL;
79  }
80 
81  Vad = (PMMVAD_LONG)Node;
82  if (Vad->u.VadFlags.Spare == 0)
83  {
84  /* Check if this is VM VAD */
85  if (Vad->ControlArea == NULL)
86  {
87  /* We store the reactos MEMORY_AREA here */
89  }
90  else
91  {
92  /* This is a section VAD. Store the MAREA here for now */
94  }
95  }
96  else
97  {
99  }
100 
101  return MemoryArea;
102 }
103 
105 NTAPI
108  PVOID Address_,
110 {
111  ULONG_PTR StartVpn = (ULONG_PTR)Address_ / PAGE_SIZE;
112  ULONG_PTR EndVpn = ((ULONG_PTR)Address_ + Length - 1) / PAGE_SIZE;
118  PMMVAD_LONG Vad;
119 
121  Table = (Process != NULL) ? &Process->VadRoot : &MiRosKernelVadRoot;
122 
123  Result = MiCheckForConflictingNode(StartVpn, EndVpn, Table, &Node);
124  if (Result != TableFoundNode)
125  {
126  return NULL;
127  }
128 
129  Vad = (PMMVAD_LONG)Node;
130  if (Vad->u.VadFlags.Spare == 0)
131  {
132  /* Check if this is VM VAD */
133  if (Vad->ControlArea == NULL)
134  {
135  /* We store the reactos MEMORY_AREA here */
137  }
138  else
139  {
140  /* This is a section VAD. Store the MAREA here for now */
142  }
143  }
144  else
145  {
147  }
148 
149  ASSERT(MemoryArea != NULL);
150  return MemoryArea;
151 }
152 
153 VOID
154 NTAPI
155 MiInsertVad(IN PMMVAD Vad,
156  IN PMM_AVL_TABLE VadRoot);
157 
158 ULONG
159 NTAPI
162 );
163 
164 
165 static VOID
168  PMEMORY_AREA marea,
169  ULONG Protect)
170 {
172 
173  marea->VadNode.u.VadFlags.Spare = 1;
175 
176  /* Build a lame VAD if this is a user-space allocation */
178  {
179  ASSERT(Process != NULL);
180  if (marea->Type != MEMORY_AREA_OWNED_BY_ARM3)
181  {
182 #ifdef NEWCC
183  ASSERT(marea->Type == MEMORY_AREA_SECTION_VIEW || marea->Type == MEMORY_AREA_CACHE);
184 #else
186 #endif
187 
188  /* Insert the VAD */
190  MiInsertVad(&marea->VadNode, &Process->VadRoot);
192  marea->Vad = &marea->VadNode;
193  }
194  }
195  else
196  {
197  ASSERT(Process == NULL);
198 
200  {
204  }
205 
206  /* Insert the VAD */
210  marea->Vad = NULL;
211  }
212 }
213 
214 PVOID NTAPI
218  ULONG_PTR Granularity,
219  BOOLEAN TopDown)
220 {
222  PMM_AVL_TABLE VadRoot;
225  ULONG_PTR StartingAddress, HighestAddress;
226 
228  VadRoot = Process ? &Process->VadRoot : &MiRosKernelVadRoot;
229  if (TopDown)
230  {
231  /* Find an address top-down */
232  HighestAddress = Process ? (ULONG_PTR)MM_HIGHEST_VAD_ADDRESS : (LONG_PTR)-1;
234  HighestAddress,
235  Granularity,
236  VadRoot,
237  &StartingAddress,
238  &Parent);
239  }
240  else
241  {
243  Granularity,
244  VadRoot,
245  &Parent,
246  &StartingAddress);
247  }
248 
249  if (Result == TableFoundNode)
250  {
251  return NULL;
252  }
253 
254  return (PVOID)StartingAddress;
255 }
256 
257 VOID
258 NTAPI
261 
262 
287  PVOID FreePageContext)
288 {
290  PVOID EndAddress;
291 
292  /* Make sure we own the address space lock! */
293  ASSERT(CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock.Owner == KeGetCurrentThread());
294 
295  /* Check magic */
296  ASSERT(MemoryArea->Magic == 'erAM');
297 
299  {
302 
303  if (Process != NULL &&
305  {
306  KeAttachProcess(&Process->Pcb);
307  }
308 
311  Address < (ULONG_PTR)EndAddress;
312  Address += PAGE_SIZE)
313  {
314  BOOLEAN Dirty = FALSE;
315  SWAPENTRY SwapEntry = 0;
316  PFN_NUMBER Page = 0;
317 
319  {
321  }
322  else
323  {
325  }
326  if (FreePage != NULL)
327  {
328  FreePage(FreePageContext, MemoryArea, (PVOID)Address,
329  Page, SwapEntry, (BOOLEAN)Dirty);
330  }
331  }
332 
333  if (Process != NULL &&
335  {
336  KeDetachProcess();
337  }
338 
339  //if (MemoryArea->VadNode.StartingVpn < (ULONG_PTR)MmSystemRangeStart >> PAGE_SHIFT
340  if (MemoryArea->Vad)
341  {
343 #ifdef NEWCC
344  ASSERT(MemoryArea->Type == MEMORY_AREA_SECTION_VIEW || MemoryArea->Type == MEMORY_AREA_CACHE);
345 #else
347 #endif
348 
349  /* MmCleanProcessAddressSpace might have removed it (and this would be MmDeleteProcessAdressSpace) */
351  if (((PMMVAD)MemoryArea->Vad)->u.VadFlags.Spare == 1)
352  {
354  }
355 
356  MemoryArea->Vad = NULL;
357  }
358  else
359  {
361  }
362  }
363 
364 #if DBG
365  MemoryArea->Magic = 'daeD';
366 #endif
368 
369  DPRINT("MmFreeMemoryArea() succeeded\n");
370 
371  return STATUS_SUCCESS;
372 }
373 
402  ULONG Type,
405  ULONG Protect,
407  ULONG AllocationFlags,
408  ULONG Granularity)
409 {
410  ULONG_PTR tmpLength;
412  ULONG_PTR EndingAddress;
413 
414  DPRINT("MmCreateMemoryArea(Type 0x%lx, BaseAddress %p, "
415  "*BaseAddress %p, Length %p, AllocationFlags %x, "
416  "Result %p)\n",
417  Type, BaseAddress, *BaseAddress, Length, AllocationFlags,
418  Result);
419 
420  /* Is this a static memory area? */
421  if (Type & MEMORY_AREA_STATIC)
422  {
423  /* Use the static array instead of the pool */
426  }
427  else
428  {
429  /* Allocate the memory area from nonpaged pool */
431  sizeof(MEMORY_AREA),
432  TAG_MAREA);
433  }
434 
435  if (!MemoryArea)
436  {
437  DPRINT1("Not enough memory.\n");
438  return STATUS_NO_MEMORY;
439  }
440 
443  MemoryArea->Flags = AllocationFlags;
444  MemoryArea->Magic = 'erAM';
446 
447  if (*BaseAddress == 0)
448  {
449  tmpLength = (ULONG_PTR)MM_ROUND_UP(Length, PAGE_SIZE);
451  tmpLength,
452  Granularity,
453  (AllocationFlags & MEM_TOP_DOWN) == MEM_TOP_DOWN);
454  if ((*BaseAddress) == 0)
455  {
456  DPRINT("No suitable gap\n");
458  return STATUS_NO_MEMORY;
459  }
460 
462  MemoryArea->VadNode.EndingVpn = ((ULONG_PTR)*BaseAddress + tmpLength - 1) >> PAGE_SHIFT;
464  }
465  else
466  {
467  EndingAddress = ((ULONG_PTR)*BaseAddress + Length - 1) | (PAGE_SIZE - 1);
469  tmpLength = EndingAddress + 1 - (ULONG_PTR)*BaseAddress;
470 
472  {
473  ASSERT(FALSE);
476  }
477 
480  {
481  DPRINT("Memory area for user mode address space exceeds MmSystemRangeStart\n");
484  }
485 
486  /* No need to check ARM3 owned memory areas, the range MUST be free */
488  {
490  *BaseAddress,
491  tmpLength) != NULL)
492  {
493  DPRINT("Memory area already occupied\n");
496  }
497  }
498 
500  MemoryArea->VadNode.EndingVpn = ((ULONG_PTR)*BaseAddress + tmpLength - 1) >> PAGE_SHIFT;
502  }
503 
504  *Result = MemoryArea;
505 
506  DPRINT("MmCreateMemoryArea() succeeded (%p)\n", *BaseAddress);
507  return STATUS_SUCCESS;
508 }
509 
510 VOID
511 NTAPI
514  PMMVAD Vad)
515 {
519 
520  /* We must be called from MmCleanupAddressSpace and nowhere else!
521  Make sure things are as expected... */
523  ASSERT(Process->VmDeleted == TRUE);
524  ASSERT(((PsGetCurrentThread()->ThreadsProcess == Process) &&
525  (Process->ActiveThreads == 1)) ||
526  (Process->ActiveThreads == 0));
527 
528  MemoryArea = (PMEMORY_AREA)Vad;
530 
532  {
534  }
535 #ifdef NEWCC
536  else if (MemoryArea->Type == MEMORY_AREA_CACHE)
537  {
539  }
540 #endif
541  else
542  {
543  /* There shouldn't be anything else! */
544  ASSERT(FALSE);
545  }
546 
547  /* Make sure this worked! */
549 }
550 
551 VOID
552 NTAPI
554 
555 NTSTATUS
556 NTAPI
558 {
559 #ifndef _M_AMD64
560  KIRQL OldIrql;
561 #endif
562 
563  DPRINT("MmDeleteProcessAddressSpace(Process %p (%s))\n", Process,
564  Process->ImageFileName);
565 
566 #ifndef _M_AMD64
568  RemoveEntryList(&Process->MmProcessLinks);
570 #endif
572 
573 #if (_MI_PAGING_LEVELS == 2)
574  {
575  KIRQL OldIrql;
576  PVOID Address;
577  PMMPDE pointerPde;
578 
579  /* Attach to Process */
580  KeAttachProcess(&Process->Pcb);
581 
582  /* Acquire PFN lock */
584 
588  {
589  /* At this point all references should be dead */
591  {
592  DPRINT1("Process %p, Address %p, UsedPageTableEntries %lu\n",
593  Process,
594  Address,
597  }
598 
599  pointerPde = MiAddressToPde(Address);
600  /* Unlike in ARM3, we don't necesarrily free the PDE page as soon as reference reaches 0,
601  * so we must clean up a bit when process closes */
602  if (pointerPde->u.Hard.Valid)
603  MiDeletePte(pointerPde, MiPdeToPte(pointerPde), Process, NULL);
604  ASSERT(pointerPde->u.Hard.Valid == 0);
605  }
606 
607  /* Release lock */
609 
610  /* Detach */
611  KeDetachProcess();
612  }
613 #endif
614 
616 
617  DPRINT("Finished MmDeleteProcessAddressSpace()\n");
619  return(STATUS_SUCCESS);
620 }
621 
622 /* EOF */
MM_AVL_TABLE MiRosKernelVadRoot
Definition: marea.c:54
ULONG NTAPI MiMakeProtectionMask(IN ULONG Protect)
Definition: section.c:158
NTSTATUS NTAPI MmDeleteProcessAddressSpace(PEPROCESS Process)
Definition: marea.c:557
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define IN
Definition: typedefs.h:39
ASMGENDATA Table[]
Definition: genincdata.c:61
TABLE_SEARCH_RESULT NTAPI MiFindEmptyAddressRangeDownTree(IN SIZE_T Length, IN ULONG_PTR BoundaryAddress, IN ULONG_PTR Alignment, IN PMM_AVL_TABLE Table, OUT PULONG_PTR Base, OUT PMMADDRESS_NODE *Parent)
Definition: vadnode.c:597
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:360
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ULONG Type
Definition: mm.h:219
struct _MEMORY_AREA * PMEMORY_AREA
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1214
#define MiAddressToPde(x)
Definition: mmx86.c:20
FORCEINLINE KIRQL MiAcquireExpansionLock(VOID)
Definition: miarm.h:1385
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
union _MMPTE::@2304 u
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T _In_ SECTION_INHERIT _In_ ULONG _In_ ULONG Protect
Definition: zwfuncs.h:214
#define TRUE
Definition: types.h:120
#define MI_LOWEST_VAD_ADDRESS
Definition: miarm.h:11
_In_ ULONG _In_ PHYSICAL_ADDRESS _Inout_ PULONG AddressSpace
Definition: iofuncs.h:2268
FORCEINLINE VOID MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1541
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:760
enum _TABLE_SEARCH_RESULT TABLE_SEARCH_RESULT
LONG NTSTATUS
Definition: precomp.h:26
union _MMVAD_LONG::@2567 u
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:919
FORCEINLINE USHORT MiQueryPageTableReferences(IN PVOID Address)
Definition: miarm.h:1696
VOID(* PMM_FREE_PAGE_FUNC)(PVOID Context, PMEMORY_AREA MemoryArea, PVOID Address, PFN_NUMBER Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
Definition: mm.h:494
ULONG_PTR Unused
Definition: mmtypes.h:661
PCONTROL_AREA ControlArea
Definition: mmtypes.h:762
ULONG_PTR Protection
Definition: mmtypes.h:693
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:728
VOID NTAPI MmDeletePageFileMapping(struct _EPROCESS *Process, PVOID Address, SWAPENTRY *SwapEntry)
#define MEMORY_AREA_STATIC
Definition: mm.h:76
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:731
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:926
VOID NTAPI MiDeletePte(IN PMMPTE PointerPte, IN PVOID VirtualAddress, IN PEPROCESS CurrentProcess, IN PMMPTE PrototypePte)
Definition: virtual.c:391
MMADDRESS_NODE BalancedRoot
Definition: mmtypes.h:659
uint32_t ULONG_PTR
Definition: typedefs.h:65
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
UCHAR KIRQL
Definition: env_spec_w32.h:591
ULONG_PTR EndingVpn
Definition: mmtypes.h:727
ULONG Magic
Definition: mm.h:222
ULONG PFN_NUMBER
Definition: ke.h:9
#define MEMORY_AREA_OWNED_BY_ARM3
Definition: mm.h:75
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
union node Node
Definition: types.h:1255
NTSTATUS NTAPI MmCreateMemoryArea(PMMSUPPORT AddressSpace, ULONG Type, PVOID *BaseAddress, ULONG_PTR Length, ULONG Protect, PMEMORY_AREA *Result, ULONG AllocationFlags, ULONG Granularity)
Definition: marea.c:401
#define TAG_MAREA
Definition: tag.h:120
#define PsGetCurrentProcess
Definition: psfuncs.h:17
TABLE_SEARCH_RESULT NTAPI MiFindEmptyAddressRangeInTree(IN SIZE_T Length, IN ULONG_PTR Alignment, IN PMM_AVL_TABLE Table, OUT PMMADDRESS_NODE *PreviousVad, OUT PULONG_PTR Base)
Definition: vadnode.c:502
unsigned char BOOLEAN
MMSUPPORT MmSystemCacheWs
Definition: init.c:55
static WCHAR Address[46]
Definition: ping.c:68
VOID NTAPI MmDeleteVirtualMapping(struct _EPROCESS *Process, PVOID Address, BOOLEAN *WasDirty, PPFN_NUMBER Page)
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
PVOID Banked
Definition: mmtypes.h:777
VOID NTAPI MmDeleteProcessAddressSpace2(IN PEPROCESS Process)
Definition: procsup.c:1353
FORCEINLINE VOID MiUnlockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1284
PFN_NUMBER Page
Definition: section.c:4756
void * PVOID
Definition: retypes.h:9
ULONG_PTR StartingVpn
Definition: mmtypes.h:726
#define MEMORY_AREA_SECTION_VIEW
Definition: mm.h:71
TABLE_SEARCH_RESULT NTAPI MiCheckForConflictingNode(IN ULONG_PTR StartVpn, IN ULONG_PTR EndVpn, IN PMM_AVL_TABLE Table, OUT PMMADDRESS_NODE *NodeOrParent)
Definition: vadnode.c:78
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define MM_ROUND_UP(x, s)
Definition: mm.h:106
Status
Definition: gdiplustypes.h:24
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1144
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
ULONG CurrentProcess
Definition: shell.c:125
#define ASSERT(a)
Definition: mode.c:45
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
PMEMORY_AREA NTAPI MmLocateMemoryAreaByAddress(PMMSUPPORT AddressSpace, PVOID Address_)
Definition: marea.c:60
struct _MMVAD_LONG * PMMVAD_LONG
union _MMADDRESS_NODE::@2562 u1
ULONG64 Valid
Definition: mmtypes.h:150
BOOLEAN DeleteInProgress
Definition: mm.h:221
Type
Definition: Type.h:6
#define PTE_PER_PAGE
Definition: mm.h:20
#define MA_GetEndingAddress(_MemoryArea)
Definition: mm.h:213
BOOLEAN NTAPI MmIsPageSwapEntry(struct _EPROCESS *Process, PVOID Address)
MMVAD VadNode
Definition: mm.h:217
MEMORY_AREA MiStaticMemoryAreas[MI_STATIC_MEMORY_AREAS]
Definition: marea.c:51
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:618
NTSTATUS NTAPI MmFreeMemoryArea(PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_FREE_PAGE_FUNC FreePage, PVOID FreePageContext)
Definition: marea.c:283
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:790
static VOID MmInsertMemoryArea(PMMSUPPORT AddressSpace, PMEMORY_AREA marea, ULONG Protect)
Definition: marea.c:166
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define MA_GetStartingAddress(_MemoryArea)
Definition: mm.h:212
NTSTATUS NTAPI MmUnmapViewOfCacheSegment(PMMSUPPORT AddressSpace, PVOID BaseAddress)
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
VOID NTAPI MiRosCleanupMemoryArea(PEPROCESS Process, PMMVAD Vad)
Definition: marea.c:512
#define MiPdeToPte(_Pde)
Definition: mm.h:235
BOOLEAN MiRosKernelVadRootInitialized
Definition: marea.c:55
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579
ULONG MiStaticMemoryAreaCount
Definition: marea.c:52
ULONG_PTR SWAPENTRY
Definition: mm.h:47
union _MMVAD::@2564 u
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
FORCEINLINE PEPROCESS MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
Definition: mm.h:1548
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define NULL
Definition: types.h:112
FORCEINLINE VOID MiReleaseExpansionLock(KIRQL OldIrql)
Definition: miarm.h:1398
#define DPRINT1
Definition: precomp.h:8
#define MM_HIGHEST_VAD_ADDRESS
Definition: mm.h:46
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
#define MI_STATIC_MEMORY_AREAS
Definition: mm.h:68
ULONG_PTR Spare
Definition: mmtypes.h:694
unsigned int ULONG
Definition: retypes.h:1
PMMPTE FirstPrototypePte
Definition: mmtypes.h:763
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
VOID NTAPI MiInsertVad(IN PMMVAD Vad, IN PMM_AVL_TABLE VadRoot)
Definition: vadnode.c:183
#define ULONG_PTR
Definition: config.h:101
#define STATUS_SUCCESS
Definition: shellext.h:65
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
FORCEINLINE VOID MiLockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1240
#define DPRINT
Definition: sndvol32.h:71
#define KeGetCurrentThread
Definition: hal.h:49
PVOID NTAPI MmFindGap(PMMSUPPORT AddressSpace, ULONG_PTR Length, ULONG_PTR Granularity, BOOLEAN TopDown)
Definition: marea.c:215
PMEMORY_AREA NTAPI MmLocateMemoryAreaByRegion(PMMSUPPORT AddressSpace, PVOID Address_, ULONG_PTR Length)
Definition: marea.c:106
#define MEM_TOP_DOWN
Definition: nt_native.h:1321
#define STATUS_CONFLICTING_ADDRESSES
Definition: ntstatus.h:261
#define ALIGN_DOWN_POINTER_BY(ptr, align)
Definition: umtypes.h:82
NTSTATUS NTAPI MiRosUnmapViewOfSection(IN PEPROCESS Process, IN PVOID BaseAddress, IN BOOLEAN SkipDebuggerNotify)
Definition: section.c:3502
struct _MEMORY_AREA * MemoryArea
Definition: newmm.h:37
PVOID Vad
Definition: mm.h:223
FORCEINLINE VOID MmLockAddressSpace(PMMSUPPORT AddressSpace)
Definition: mm.h:1534
#define MmSystemRangeStart
Definition: mm.h:32
ULONG Flags
Definition: mm.h:220
struct _MMADDRESS_NODE * Parent
Definition: mmtypes.h:646
Definition: dlist.c:348
union _MMVAD_LONG::@2570 u4