ReactOS 0.4.15-dev-6055-g36cdd34
marea.c File Reference
#include <ntoskrnl.h>
#include <cache/section/newmm.h>
#include <debug.h>
#include "ARM3/miarm.h"
Include dependency graph for marea.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

PMEMORY_AREA NTAPI MmLocateMemoryAreaByAddress (PMMSUPPORT AddressSpace, PVOID Address_)
 
PMEMORY_AREA NTAPI MmLocateMemoryAreaByRegion (PMMSUPPORT AddressSpace, PVOID Address_, ULONG_PTR Length)
 
VOID NTAPI MiInsertVad (IN PMMVAD Vad, IN PMM_AVL_TABLE VadRoot)
 
ULONG NTAPI MiMakeProtectionMask (IN ULONG Protect)
 
static VOID MmInsertMemoryArea (PMMSUPPORT AddressSpace, PMEMORY_AREA marea, ULONG Protect)
 
PVOID NTAPI MmFindGap (PMMSUPPORT AddressSpace, ULONG_PTR Length, ULONG_PTR Granularity, BOOLEAN TopDown)
 
VOID NTAPI MiRemoveNode (IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
 
MmFreeMemoryArea

Free an existing memory area.

Parameters
AddressSpaceAddress space to free the area from.
MemoryAreaMemory area we're about to free.
FreePageCallback function for each freed page.
FreePageContextContext passed to the callback function.
Returns
Status
Remarks
Lock the address space before calling this function.
NTSTATUS NTAPI MmFreeMemoryArea (PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_FREE_PAGE_FUNC FreePage, PVOID FreePageContext)
 
MmCreateMemoryArea

Create a memory area.

Parameters
AddressSpaceAddress space to create the area in.
TypeType of the memory area.
BaseAddressBase address for the memory area we're about the create. On input it contains either 0 (auto-assign address) or preferred address. On output it contains the starting address of the newly created area.
LengthLength of the area to allocate.
AttributesProtection attributes for the memory area.
ResultReceives a pointer to the memory area on successful exit.
Returns
Status
Remarks
Lock the address space before calling this function.
NTSTATUS NTAPI MmCreateMemoryArea (PMMSUPPORT AddressSpace, ULONG Type, PVOID *BaseAddress, ULONG_PTR Length, ULONG Protect, PMEMORY_AREA *Result, ULONG AllocationFlags, ULONG Granularity)
 
VOID NTAPI MiRosCleanupMemoryArea (PEPROCESS Process, PMMVAD Vad)
 

Variables

MEMORY_AREA MiStaticMemoryAreas [MI_STATIC_MEMORY_AREAS]
 
ULONG MiStaticMemoryAreaCount
 
MM_AVL_TABLE MiRosKernelVadRoot
 
BOOLEAN MiRosKernelVadRootInitialized
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 45 of file marea.c.

Function Documentation

◆ MiInsertVad()

VOID NTAPI MiInsertVad ( IN PMMVAD  Vad,
IN PMM_AVL_TABLE  VadRoot 
)

Definition at line 183 of file vadnode.c.

185{
188
189 /* Validate the VAD and set it as the current hint */
190 ASSERT(Vad->EndingVpn >= Vad->StartingVpn);
191 VadRoot->NodeHint = Vad;
192
193 /* Find the parent VAD and where this child should be inserted */
194 Result = RtlpFindAvlTableNodeOrParent(VadRoot, (PVOID)Vad->StartingVpn, &Parent);
196 ASSERT((Parent != NULL) || (Result == TableEmptyTree));
197
198 /* Do the actual insert operation */
199 MiInsertNode(VadRoot, (PVOID)Vad, Parent, Result);
200}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx 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:732
#define NULL
Definition: types.h:112
#define RtlpFindAvlTableNodeOrParent
Definition: miavl.h:32
#define ASSERT(a)
Definition: mode.c:44
VOID NTAPI MiInsertNode(IN PMM_AVL_TABLE Table, IN PMMADDRESS_NODE NewNode, IN PMMADDRESS_NODE Parent, IN TABLE_SEARCH_RESULT Result)
Definition: vadnode.c:128
_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
@ TableEmptyTree
Definition: rtltypes.h:363
@ TableFoundNode
Definition: rtltypes.h:364
enum _TABLE_SEARCH_RESULT TABLE_SEARCH_RESULT

Referenced by MmInsertMemoryArea().

◆ MiMakeProtectionMask()

ULONG NTAPI MiMakeProtectionMask ( IN ULONG  Protect)

Definition at line 140 of file section.c.

141{
142 ULONG Mask1, Mask2, ProtectMask;
143
144 /* PAGE_EXECUTE_WRITECOMBINE is theoretically the maximum */
146
147 /*
148 * Windows API protection mask can be understood as two bitfields, differing
149 * by whether or not execute rights are being requested
150 */
151 Mask1 = Protect & 0xF;
152 Mask2 = (Protect >> 4) & 0xF;
153
154 /* Check which field is there */
155 if (!Mask1)
156 {
157 /* Mask2 must be there, use it to determine the PTE protection */
158 if (!Mask2) return MM_INVALID_PROTECTION;
159 ProtectMask = MmUserProtectionToMask2[Mask2];
160 }
161 else
162 {
163 /* Mask2 should not be there, use Mask1 to determine the PTE mask */
164 if (Mask2) return MM_INVALID_PROTECTION;
165 ProtectMask = MmUserProtectionToMask1[Mask1];
166 }
167
168 /* Make sure the final mask is a valid one */
169 if (ProtectMask == MM_INVALID_PROTECTION) return MM_INVALID_PROTECTION;
170
171 /* Check for PAGE_GUARD option */
172 if (Protect & PAGE_GUARD)
173 {
174 /* It's not valid on no-access, nocache, or writecombine pages */
175 if ((ProtectMask == MM_NOACCESS) ||
177 {
178 /* Fail such requests */
180 }
181
182 /* This actually turns on guard page in this scenario! */
183 ProtectMask |= MM_GUARDPAGE;
184 }
185
186 /* Check for nocache option */
187 if (Protect & PAGE_NOCACHE)
188 {
189 /* The earlier check should've eliminated this possibility */
190 ASSERT((Protect & PAGE_GUARD) == 0);
191
192 /* Check for no-access page or write combine page */
193 if ((ProtectMask == MM_NOACCESS) || (Protect & PAGE_WRITECOMBINE))
194 {
195 /* Such a request is invalid */
197 }
198
199 /* Add the PTE flag */
200 ProtectMask |= MM_NOCACHE;
201 }
202
203 /* Check for write combine option */
205 {
206 /* The two earlier scenarios should've caught this */
208
209 /* Don't allow on no-access pages */
210 if (ProtectMask == MM_NOACCESS) return MM_INVALID_PROTECTION;
211
212 /* This actually turns on write-combine in this scenario! */
213 ProtectMask |= MM_NOACCESS;
214 }
215
216 /* Return the final MM PTE protection mask */
217 return ProtectMask;
218}
CHAR MmUserProtectionToMask1[16]
Definition: section.c:44
CHAR MmUserProtectionToMask2[16]
Definition: section.c:64
#define MM_GUARDPAGE
Definition: miarm.h:57
#define MM_NOCACHE
Definition: miarm.h:56
#define MM_INVALID_PROTECTION
Definition: miarm.h:67
#define MM_NOACCESS
Definition: miarm.h:65
#define PAGE_NOCACHE
Definition: nt_native.h:1311
#define PAGE_NOACCESS
Definition: nt_native.h:1302
#define PAGE_GUARD
Definition: nt_native.h:1310
uint32_t ULONG
Definition: typedefs.h:59
#define PAGE_WRITECOMBINE
Definition: mmtypes.h:78
_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:221

Referenced by MiIsProtectionCompatible(), MiSetProtectionOnSection(), MmCreateArm3Section(), MmCreateSection(), MmInsertMemoryArea(), MmMapViewOfArm3Section(), and NtMapViewOfSection().

◆ MiRemoveNode()

VOID NTAPI MiRemoveNode ( IN PMMADDRESS_NODE  Node,
IN PMM_AVL_TABLE  Table 
)

Definition at line 360 of file vadnode.c.

362{
363 PMMVAD_LONG Vad;
364
365 /* Call the AVL code */
367
368 /* Decrease element count */
369 Table->NumberGenericTableElements--;
370
371 /* Check if this node was the hint */
372 if (Table->NodeHint == Node)
373 {
374 /* Get a new hint, unless we're empty now, in which case nothing */
375 if (!Table->NumberGenericTableElements) Table->NodeHint = NULL;
376 else Table->NodeHint = Table->BalancedRoot.RightChild;
377 }
378
379 /* Free the node from ReactOS view as well */
380 Vad = (PMMVAD_LONG)Node;
381 if ((Table != &MmSectionBasedRoot) && (Vad->u.VadFlags.Spare == 0))
382 {
385
386 /* Check if this is VM VAD */
387 if (Vad->ControlArea == NULL)
388 {
389 /* We store the ReactOS MEMORY_AREA here */
391 }
392 else
393 {
394 /* This is a section VAD. We store the ReactOS MEMORY_AREA here */
396 }
397
398 /* Make sure one actually still exists */
399 if (MemoryArea)
400 {
401 /* Make sure we have not already freed it */
402 ASSERT(MemoryArea != (PVOID)(ULONG_PTR)0xDEADBAB1DEADBAB1ULL);
403
404 /* Get the process */
406
407 /* We only create fake memory-areas for ARM3 VADs */
410
411 /* Free it */
413
414 /* Check if this is VM VAD */
415 if (Vad->ControlArea == NULL)
416 {
417 /* Delete the pointer to it */
418 Vad->FirstPrototypePte = (PVOID)(ULONG_PTR)0xDEADBAB1DEADBAB1ULL;
419 }
420 else
421 {
422 /* Delete the pointer to it */
423 Vad->u4.Banked = (PVOID)(ULONG_PTR)0xDEADBAB1DEADBAB1ULL;
424 }
425 }
426 }
427}
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
ASMGENDATA Table[]
Definition: genincdata.c:61
MM_AVL_TABLE MmSectionBasedRoot
Definition: section.c:109
#define RtlpDeleteAvlTreeNode
Definition: miavl.h:36
struct _MMVAD_LONG * PMMVAD_LONG
_In_ PMEMORY_AREA MemoryArea
Definition: newmm.h:207
NTSTATUS NTAPI MmFreeMemoryArea(PMMSUPPORT AddressSpace, PMEMORY_AREA MemoryArea, PMM_FREE_PAGE_FUNC FreePage, PVOID FreePageContext)
Definition: marea.c:283
#define MEMORY_AREA_OWNED_BY_ARM3
Definition: mm.h:97
struct _MEMORY_AREA * PMEMORY_AREA
PVOID Vad
Definition: mm.h:255
ULONG Type
Definition: mm.h:251
ULONG_PTR Spare
Definition: mmtypes.h:694
PMMPTE FirstPrototypePte
Definition: mmtypes.h:763
PVOID Banked
Definition: mmtypes.h:777
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:760
PCONTROL_AREA ControlArea
Definition: mmtypes.h:762
union _MMVAD_LONG::@2591 u
union _MMVAD_LONG::@2594 u4
void * PVOID
Definition: typedefs.h:50
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
Definition: dlist.c:348

Referenced by MmFreeMemoryArea().

◆ MiRosCleanupMemoryArea()

VOID NTAPI MiRosCleanupMemoryArea ( PEPROCESS  Process,
PMMVAD  Vad 
)

Definition at line 515 of file marea.c.

518{
522
523 /* We must be called from MmCleanupAddressSpace and nowhere else!
524 Make sure things are as expected... */
526 ASSERT(Process->VmDeleted == TRUE);
527 ASSERT(((PsGetCurrentThread()->ThreadsProcess == Process) &&
528 (Process->ActiveThreads == 1)) ||
529 (Process->ActiveThreads == 0));
530
533
535 {
537 }
538#ifdef NEWCC
539 else if (MemoryArea->Type == MEMORY_AREA_CACHE)
540 {
542 }
543#endif
544 else
545 {
546 /* There shouldn't be anything else! */
547 ASSERT(FALSE);
548 }
549
550 /* Make sure this worked! */
552}
LONG NTSTATUS
Definition: precomp.h:26
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
Status
Definition: gdiplustypes.h:25
NTSTATUS NTAPI MiRosUnmapViewOfSection(IN PEPROCESS Process, IN PVOID BaseAddress, IN BOOLEAN SkipDebuggerNotify)
Definition: section.c:3567
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
NTSTATUS NTAPI MmUnmapViewOfCacheSegment(PMMSUPPORT AddressSpace, PVOID BaseAddress)
#define MA_GetStartingAddress(_MemoryArea)
Definition: mm.h:244
#define MEMORY_AREA_SECTION_VIEW
Definition: mm.h:93
#define PsGetCurrentProcess
Definition: psfuncs.h:17

Referenced by MmCleanProcessAddressSpace().

◆ MmCreateMemoryArea()

NTSTATUS NTAPI MmCreateMemoryArea ( PMMSUPPORT  AddressSpace,
ULONG  Type,
PVOID BaseAddress,
ULONG_PTR  Length,
ULONG  Protect,
PMEMORY_AREA Result,
ULONG  AllocationFlags,
ULONG  Granularity 
)

Definition at line 404 of file marea.c.

412{
413 ULONG_PTR tmpLength;
415 ULONG_PTR EndingAddress;
416
417 DPRINT("MmCreateMemoryArea(Type 0x%lx, BaseAddress %p, "
418 "*BaseAddress %p, Length %p, AllocationFlags %x, "
419 "Result %p)\n",
420 Type, BaseAddress, *BaseAddress, Length, AllocationFlags,
421 Result);
422
423 /* Is this a static memory area? */
425 {
426 /* Use the static array instead of the pool */
429 }
430 else
431 {
432 /* Allocate the memory area from nonpaged pool */
434 sizeof(MEMORY_AREA),
435 TAG_MAREA);
436 }
437
438 if (!MemoryArea)
439 {
440 DPRINT1("Not enough memory.\n");
441 return STATUS_NO_MEMORY;
442 }
443
445 MemoryArea->Type = Type & ~MEMORY_AREA_STATIC;
446 MemoryArea->Flags = AllocationFlags;
447 MemoryArea->Magic = 'erAM';
449
450 if (*BaseAddress == 0)
451 {
452 tmpLength = (ULONG_PTR)MM_ROUND_UP(Length, PAGE_SIZE);
454 tmpLength,
455 Granularity,
456 (AllocationFlags & MEM_TOP_DOWN) == MEM_TOP_DOWN);
457 if ((*BaseAddress) == 0)
458 {
459 DPRINT("No suitable gap\n");
461 return STATUS_NO_MEMORY;
462 }
463
467 }
468 else
469 {
470 EndingAddress = ((ULONG_PTR)*BaseAddress + Length - 1) | (PAGE_SIZE - 1);
472 tmpLength = EndingAddress + 1 - (ULONG_PTR)*BaseAddress;
473
475 {
476 ASSERT(FALSE);
479 }
480
483 {
484 DPRINT("Memory area for user mode address space exceeds MmSystemRangeStart\n");
487 }
488
489 /* No need to check ARM3 owned memory areas, the range MUST be free */
491 {
494 tmpLength) != NULL)
495 {
496 DPRINT("Memory area already occupied\n");
499 }
500 }
501
505 }
506
508
509 DPRINT("MmCreateMemoryArea() succeeded (%p)\n", *BaseAddress);
510 return STATUS_SUCCESS;
511}
Type
Definition: Type.h:7
#define DPRINT1
Definition: precomp.h:8
#define ULONG_PTR
Definition: config.h:101
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define NonPagedPool
Definition: env_spec_w32.h:307
PMEMORY_AREA NTAPI MmLocateMemoryAreaByRegion(PMMSUPPORT AddressSpace, PVOID Address_, ULONG_PTR Length)
Definition: marea.c:106
MEMORY_AREA MiStaticMemoryAreas[MI_STATIC_MEMORY_AREAS]
Definition: marea.c:51
ULONG MiStaticMemoryAreaCount
Definition: marea.c:52
PVOID NTAPI MmFindGap(PMMSUPPORT AddressSpace, ULONG_PTR Length, ULONG_PTR Granularity, BOOLEAN TopDown)
Definition: marea.c:215
static VOID MmInsertMemoryArea(PMMSUPPORT AddressSpace, PMEMORY_AREA marea, ULONG Protect)
Definition: marea.c:166
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define MEM_TOP_DOWN
Definition: nt_native.h:1321
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
#define MmSystemRangeStart
Definition: mm.h:32
#define MI_STATIC_MEMORY_AREAS
Definition: mm.h:90
#define MM_ROUND_UP(x, s)
Definition: mm.h:128
#define MEMORY_AREA_STATIC
Definition: mm.h:98
FORCEINLINE PEPROCESS MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
Definition: mm.h:1673
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define STATUS_CONFLICTING_ADDRESSES
Definition: ntstatus.h:261
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
ULONG Flags
Definition: mm.h:252
ULONG Magic
Definition: mm.h:254
BOOLEAN DeleteInProgress
Definition: mm.h:253
MMVAD VadNode
Definition: mm.h:249
ULONG_PTR EndingVpn
Definition: mmtypes.h:727
ULONG_PTR StartingVpn
Definition: mmtypes.h:726
#define TAG_MAREA
Definition: tag.h:107
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define ALIGN_DOWN_POINTER_BY(ptr, align)
Definition: umtypes.h:82
_In_ ULONG _In_ PHYSICAL_ADDRESS _Inout_ PULONG AddressSpace
Definition: iofuncs.h:2274

Referenced by MiCreateArm3StaticMemoryArea(), MiInsertNode(), and MmMapViewOfSegment().

◆ MmFindGap()

PVOID NTAPI MmFindGap ( PMMSUPPORT  AddressSpace,
ULONG_PTR  Length,
ULONG_PTR  Granularity,
BOOLEAN  TopDown 
)

Definition at line 215 of file marea.c.

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}
MM_AVL_TABLE MiRosKernelVadRoot
Definition: marea.c:54
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
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
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define MM_HIGHEST_VAD_ADDRESS
Definition: mm.h:46

Referenced by MmCreateMemoryArea(), and MmMapViewOfSection().

◆ MmFreeMemoryArea()

NTSTATUS NTAPI MmFreeMemoryArea ( PMMSUPPORT  AddressSpace,
PMEMORY_AREA  MemoryArea,
PMM_FREE_PAGE_FUNC  FreePage,
PVOID  FreePageContext 
)

Definition at line 283 of file marea.c.

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 {
300 PEPROCESS CurrentProcess = PsGetCurrentProcess();
302
303 if (Process != NULL &&
304 Process != CurrentProcess)
305 {
307 }
308
311 Address < (ULONG_PTR)EndAddress;
313 {
314 BOOLEAN Dirty = FALSE;
315 SWAPENTRY SwapEntry = 0;
316 PFN_NUMBER Page = 0;
317 BOOLEAN DoFree;
318
320 {
322 /* We'll have to do some cleanup when we're on the page file */
323 DoFree = TRUE;
324 }
325 else
326 {
327 DoFree = MmDeleteVirtualMapping(Process, (PVOID)Address, &Dirty, &Page);
328 }
329 if (DoFree && (FreePage != NULL))
330 {
331 FreePage(FreePageContext, MemoryArea, (PVOID)Address,
332 Page, SwapEntry, (BOOLEAN)Dirty);
333 }
334 }
335
336 if (Process != NULL &&
337 Process != CurrentProcess)
338 {
340 }
341
342 //if (MemoryArea->VadNode.StartingVpn < (ULONG_PTR)MmSystemRangeStart >> PAGE_SHIFT
343 if (MemoryArea->Vad)
344 {
346#ifdef NEWCC
347 ASSERT(MemoryArea->Type == MEMORY_AREA_SECTION_VIEW || MemoryArea->Type == MEMORY_AREA_CACHE);
348#else
350#endif
351
352 /* MmCleanProcessAddressSpace might have removed it (and this would be MmDeleteProcessAdressSpace) */
354 if (((PMMVAD)MemoryArea->Vad)->u.VadFlags.Spare == 1)
355 {
357 }
358
360 }
361 else
362 {
364 }
365 }
366
367#if DBG
368 MemoryArea->Magic = 'daeD';
369#endif
371
372 DPRINT("MmFreeMemoryArea() succeeded\n");
373
374 return STATUS_SUCCESS;
375}
unsigned char BOOLEAN
#define KeGetCurrentThread
Definition: hal.h:55
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:360
BOOLEAN NTAPI MmIsPageSwapEntry(struct _EPROCESS *Process, PVOID Address)
_In_ PVOID _Out_opt_ BOOLEAN _Out_opt_ PPFN_NUMBER Page
Definition: mm.h:1298
ULONG_PTR SWAPENTRY
Definition: mm.h:57
#define MA_GetEndingAddress(_MemoryArea)
Definition: mm.h:245
VOID NTAPI MmDeletePageFileMapping(struct _EPROCESS *Process, PVOID Address, SWAPENTRY *SwapEntry)
VOID NTAPI MmDeleteVirtualMapping(IN PEPROCESS Process, IN PVOID Address, OUT PBOOLEAN WasDirty, OUT PPFN_NUMBER Page)
Definition: page.c:177
static WCHAR Address[46]
Definition: ping.c:68
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:621
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:582
ULONG PFN_NUMBER
Definition: ke.h:9
union _MMVAD::@2588 u
MMVAD_FLAGS VadFlags
Definition: mmtypes.h:731
@ FreePage
Definition: ketypes.h:404

Referenced by MiRemoveNode(), and MmUnmapViewOfSegment().

◆ MmInsertMemoryArea()

static VOID MmInsertMemoryArea ( PMMSUPPORT  AddressSpace,
PMEMORY_AREA  marea,
ULONG  Protect 
)
static

Definition at line 166 of file marea.c.

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}
VOID NTAPI MiInsertVad(IN PMMVAD Vad, IN PMM_AVL_TABLE VadRoot)
Definition: vadnode.c:183
BOOLEAN MiRosKernelVadRootInitialized
Definition: marea.c:55
ULONG NTAPI MiMakeProtectionMask(IN ULONG Protect)
Definition: section.c:140
FORCEINLINE VOID MiLockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1265
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1239
FORCEINLINE VOID MiUnlockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1351
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1169
MMSUPPORT MmSystemCacheWs
Definition: init.c:55
union _MMADDRESS_NODE::@2586 u1
struct _MMADDRESS_NODE * Parent
Definition: mmtypes.h:646
ULONG_PTR Protection
Definition: mmtypes.h:693
ULONG_PTR Unused
Definition: mmtypes.h:661
MMADDRESS_NODE BalancedRoot
Definition: mmtypes.h:659

Referenced by MmCreateMemoryArea().

◆ MmLocateMemoryAreaByAddress()

PMEMORY_AREA NTAPI MmLocateMemoryAreaByAddress ( PMMSUPPORT  AddressSpace,
PVOID  Address_ 
)

Definition at line 60 of file marea.c.

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);
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}
union node Node
Definition: types.h:1255
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

Referenced by MiProtectVirtualMemory(), MiQueryMemoryBasicInformation(), MiRosProtectVirtualMemory(), MiRosUnmapViewOfSection(), MiUnmapViewOfSection(), MmAccessFault(), MmAlterViewAttributes(), MmArePagesResident(), MmMakePagesDirty(), MmNotPresentFault(), MmpAccessFault(), MmPageOutPhysicalAddress(), MmpPageOutPhysicalAddress(), MmUnmapViewInSystemSpace(), MmUnmapViewOfSegment(), NtAllocateVirtualMemory(), and NtFreeVirtualMemory().

◆ MmLocateMemoryAreaByRegion()

PMEMORY_AREA NTAPI MmLocateMemoryAreaByRegion ( PMMSUPPORT  AddressSpace,
PVOID  Address_,
ULONG_PTR  Length 
)

Definition at line 106 of file marea.c.

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
150 return MemoryArea;
151}

Referenced by MmCreateMemoryArea(), and MmMapViewOfSection().

Variable Documentation

◆ MiRosKernelVadRoot

◆ MiRosKernelVadRootInitialized

BOOLEAN MiRosKernelVadRootInitialized

Definition at line 55 of file marea.c.

Referenced by MmInsertMemoryArea().

◆ MiStaticMemoryAreaCount

ULONG MiStaticMemoryAreaCount

Definition at line 52 of file marea.c.

Referenced by MmCreateMemoryArea().

◆ MiStaticMemoryAreas

MEMORY_AREA MiStaticMemoryAreas[MI_STATIC_MEMORY_AREAS]

Definition at line 51 of file marea.c.

Referenced by MmCreateMemoryArea().