projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
2002-10-01 Casper S. Hornstrup <chorns@users.sourceforge.net>
[reactos.git] / reactos / ntoskrnl / mm / anonmem.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id: anonmem.c,v 1.7 2002/10/01 19:27:22 chorns Exp $
20 *
21 * PROJECT: ReactOS kernel
22 * FILE: ntoskrnl/mm/anonmem.c
23 * PURPOSE: Implementing anonymous memory.
24 * PROGRAMMER: David Welch
25 */
26
27 /* INCLUDE *****************************************************************/
28
29 #include <ddk/ntddk.h>
30 #include <internal/mm.h>
31 #include <internal/ob.h>
32 #include <internal/io.h>
33 #include <internal/ps.h>
34 #include <internal/pool.h>
35
36 #define NDEBUG
37 #include <internal/debug.h>
38
39 /* FUNCTIONS *****************************************************************/
40
41 NTSTATUS
42 MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
43 PMEMORY_AREA MemoryArea,
44 PVOID Address,
45 PMM_PAGEOP PageOp)
46 {
47 SWAPENTRY SwapEntry;
48 LARGE_INTEGER PhysicalAddress;
49 PMDL Mdl;
50 NTSTATUS Status;
51
52 /*
53 * Check for paging out from a deleted virtual memory area.
54 */
55 if (MemoryArea->DeleteInProgress)
56 {
57 PageOp->Status = STATUS_UNSUCCESSFUL;
58 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
59 MmReleasePageOp(PageOp);
60 return(STATUS_UNSUCCESSFUL);
61 }
62
63 PhysicalAddress =
64 MmGetPhysicalAddressForProcess(AddressSpace->Process, Address);
65
66 /*
67 * Get that the page actually is dirty.
68 */
69 if (!MmIsDirtyPage(MemoryArea->Process, Address))
70 {
71 PageOp->Status = STATUS_SUCCESS;
72 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
73 MmReleasePageOp(PageOp);
74 return(STATUS_SUCCESS);
75 }
76
77 /*
78 * Speculatively set the mapping to clean.
79 */
80 MmSetCleanPage(MemoryArea->Process, Address);
81
82 /*
83 * If necessary, allocate an entry in the paging file for this page
84 */
85 SwapEntry = MmGetSavedSwapEntryPage(PhysicalAddress);
86 if (SwapEntry == 0)
87 {
88 SwapEntry = MmAllocSwapPage();
89 if (SwapEntry == 0)
90 {
91 MmSetDirtyPage(MemoryArea->Process, Address);
92 PageOp->Status = STATUS_PAGEFILE_QUOTA_EXCEEDED;
93 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
94 MmReleasePageOp(PageOp);
95 return(STATUS_PAGEFILE_QUOTA_EXCEEDED);
96 }
97 }
98
99 /*
100 * Write the page to the pagefile
101 */
102 Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
103 MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
104 Status = MmWriteToSwapPage(SwapEntry, Mdl);
105 if (!NT_SUCCESS(Status))
106 {
107 DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
108 Status);
109 MmSetDirtyPage(MemoryArea->Process, Address);
110 PageOp->Status = STATUS_UNSUCCESSFUL;
111 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
112 MmReleasePageOp(PageOp);
113 return(STATUS_UNSUCCESSFUL);
114 }
115
116 /*
117 * Otherwise we have succeeded.
118 */
119 MmSetSavedSwapEntryPage(PhysicalAddress, SwapEntry);
120 PageOp->Status = STATUS_SUCCESS;
121 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
122 MmReleasePageOp(PageOp);
123 return(STATUS_SUCCESS);
124 }
125
126 NTSTATUS
127 MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
128 PMEMORY_AREA MemoryArea,
129 PVOID Address,
130 PMM_PAGEOP PageOp)
131 {
132 PHYSICAL_ADDRESS PhysicalAddress;
133 BOOL WasDirty;
134 SWAPENTRY SwapEntry;
135 NTSTATUS Status;
136 PMDL Mdl;
137
138 DPRINT("MmPageOutVirtualMemory(Address 0x%.8X) PID %d\n",
139 Address, MemoryArea->Process->UniqueProcessId);
140
141 /*
142 * Check for paging out from a deleted virtual memory area.
143 */
144 if (MemoryArea->DeleteInProgress)
145 {
146 PageOp->Status = STATUS_UNSUCCESSFUL;
147 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
148 MmReleasePageOp(PageOp);
149 return(STATUS_UNSUCCESSFUL);
150 }
151
152 /*
153 * Disable the virtual mapping.
154 */
155 MmDisableVirtualMapping(MemoryArea->Process, Address,
156 &WasDirty, &PhysicalAddress);
157 if (PhysicalAddress.QuadPart == 0)
158 {
159 KeBugCheck(0);
160 }
161
162 /*
163 * Paging out non-dirty data is easy.
164 */
165 if (!WasDirty)
166 {
167 MmDeleteVirtualMapping(MemoryArea->Process, Address, FALSE, NULL, NULL);
168 MmDeleteAllRmaps(PhysicalAddress, NULL, NULL);
169 if ((SwapEntry = MmGetSavedSwapEntryPage(PhysicalAddress)) != 0)
170 {
171 MmCreatePageFileMapping(MemoryArea->Process, Address, SwapEntry);
172 MmSetSavedSwapEntryPage(PhysicalAddress, 0);
173 }
174 MmReleasePageMemoryConsumer(MC_USER, PhysicalAddress);
175 PageOp->Status = STATUS_SUCCESS;
176 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
177 MmReleasePageOp(PageOp);
178 return(STATUS_SUCCESS);
179 }
180
181 /*
182 * If necessary, allocate an entry in the paging file for this page
183 */
184 SwapEntry = MmGetSavedSwapEntryPage(PhysicalAddress);
185 if (SwapEntry == 0)
186 {
187 SwapEntry = MmAllocSwapPage();
188 if (SwapEntry == 0)
189 {
190 MmShowOutOfSpaceMessagePagingFile();
191 MmEnableVirtualMapping(MemoryArea->Process, Address);
192 PageOp->Status = STATUS_UNSUCCESSFUL;
193 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
194 MmReleasePageOp(PageOp);
195 return(STATUS_UNSUCCESSFUL);
196 }
197 }
198
199 /*
200 * Write the page to the pagefile
201 */
202 Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
203 MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
204 Status = MmWriteToSwapPage(SwapEntry, Mdl);
205 if (!NT_SUCCESS(Status))
206 {
207 DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
208 Status);
209 MmEnableVirtualMapping(MemoryArea->Process, Address);
210 PageOp->Status = STATUS_UNSUCCESSFUL;
211 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
212 MmReleasePageOp(PageOp);
213 return(STATUS_UNSUCCESSFUL);
214 }
215
216 /*
217 * Otherwise we have succeeded, free the page
218 */
219 DPRINT("MM: Swapped out virtual memory page 0x%.8X!\n", PhysicalAddress);
220 MmDeleteVirtualMapping(MemoryArea->Process, Address, FALSE, NULL, NULL);
221 MmCreatePageFileMapping(MemoryArea->Process, Address, SwapEntry);
222 MmDeleteAllRmaps(PhysicalAddress, NULL, NULL);
223 MmSetSavedSwapEntryPage(PhysicalAddress, 0);
224 MmReleasePageMemoryConsumer(MC_USER, PhysicalAddress);
225 PageOp->Status = STATUS_SUCCESS;
226 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
227 MmReleasePageOp(PageOp);
228 return(STATUS_SUCCESS);
229 }
230
231 NTSTATUS
232 MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
233 MEMORY_AREA* MemoryArea,
234 PVOID Address,
235 BOOLEAN Locked)
236 /*
237 * FUNCTION: Move data into memory to satisfy a page not present fault
238 * ARGUMENTS:
239 * AddressSpace = Address space within which the fault occurred
240 * MemoryArea = The memory area within which the fault occurred
241 * Address = The absolute address of fault
242 * RETURNS: Status
243 * NOTES: This function is called with the address space lock held.
244 */
245 {
246 PHYSICAL_ADDRESS Page;
247 NTSTATUS Status;
248 PMM_REGION Region;
249 PMM_PAGEOP PageOp;
250
251 /*
252 * There is a window between taking the page fault and locking the
253 * address space when another thread could load the page so we check
254 * that.
255 */
256 if (MmIsPagePresent(NULL, Address))
257 {
258 if (Locked)
259 {
260 MmLockPage(MmGetPhysicalAddressForProcess(NULL, Address));
261 }
262 return(STATUS_SUCCESS);
263 }
264
265 /*
266 * Check for the virtual memory area being deleted.
267 */
268 if (MemoryArea->DeleteInProgress)
269 {
270 return(STATUS_UNSUCCESSFUL);
271 }
272
273 /*
274 * Get the segment corresponding to the virtual address
275 */
276 Region = MmFindRegion(MemoryArea->BaseAddress,
277 &MemoryArea->Data.VirtualMemoryData.RegionListHead,
278 Address, NULL);
279 if (Region->Type == MEM_RESERVE)
280 {
281 return(STATUS_UNSUCCESSFUL);
282 }
283
284 /*
285 * Get or create a page operation
286 */
287 PageOp = MmGetPageOp(MemoryArea, (ULONG)PsGetCurrentProcessId(),
288 (PVOID)PAGE_ROUND_DOWN(Address), NULL, 0,
289 MM_PAGEOP_PAGEIN);
290 if (PageOp == NULL)
291 {
292 DPRINT1("MmGetPageOp failed");
293 KeBugCheck(0);
294 }
295
296 /*
297 * Check if someone else is already handling this fault, if so wait
298 * for them
299 */
300 if (PageOp->Thread != PsGetCurrentThread())
301 {
302 MmUnlockAddressSpace(AddressSpace);
303 Status = KeWaitForSingleObject(&PageOp->CompletionEvent,
304 0,
305 KernelMode,
306 FALSE,
307 NULL);
308 /*
309 * Check for various strange conditions
310 */
311 if (Status != STATUS_SUCCESS)
312 {
313 DPRINT1("Failed to wait for page op\n");
314 KeBugCheck(0);
315 }
316 if (PageOp->Status == STATUS_PENDING)
317 {
318 DPRINT1("Woke for page op before completion\n");
319 KeBugCheck(0);
320 }
321 /*
322 * If this wasn't a pagein then we need to restart the handling
323 */
324 if (PageOp->OpType != MM_PAGEOP_PAGEIN)
325 {
326 MmLockAddressSpace(AddressSpace);
327 MmReleasePageOp(PageOp);
328 return(STATUS_MM_RESTART_OPERATION);
329 }
330 /*
331 * If the thread handling this fault has failed then we don't retry
332 */
333 if (!NT_SUCCESS(PageOp->Status))
334 {
335 MmLockAddressSpace(AddressSpace);
336 MmReleasePageOp(PageOp);
337 return(Status);
338 }
339 MmLockAddressSpace(AddressSpace);
340 if (Locked)
341 {
342 MmLockPage(MmGetPhysicalAddressForProcess(NULL, Address));
343 }
344 MmReleasePageOp(PageOp);
345 return(STATUS_SUCCESS);
346 }
347
348 /*
349 * Try to allocate a page
350 */
351 Status = MmRequestPageMemoryConsumer(MC_USER, FALSE, &Page);
352 if (Status == STATUS_NO_MEMORY)
353 {
354 MmUnlockAddressSpace(AddressSpace);
355 Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
356 MmLockAddressSpace(AddressSpace);
357 }
358
359 /*
360 * Handle swapped out pages.
361 */
362 if (MmIsPageSwapEntry(NULL, Address))
363 {
364 SWAPENTRY SwapEntry;
365 PMDL Mdl;
366
367 MmDeletePageFileMapping(NULL, Address, &SwapEntry);
368 Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
369 MmBuildMdlFromPages(Mdl, (PULONG)&Page);
370 Status = MmReadFromSwapPage(SwapEntry, Mdl);
371 if (!NT_SUCCESS(Status))
372 {
373 KeBugCheck(0);
374 }
375 MmSetSavedSwapEntryPage(Page, SwapEntry);
376 }
377
378 /*
379 * Set the page. If we fail because we are out of memory then
380 * try again
381 */
382 Status = MmCreateVirtualMapping(PsGetCurrentProcess(),
383 Address,
384 MemoryArea->Attributes,
385 Page,
386 FALSE);
387 while (Status == STATUS_NO_MEMORY)
388 {
389 MmUnlockAddressSpace(AddressSpace);
390 Status = MmCreateVirtualMapping(PsGetCurrentProcess(),
391 Address,
392 MemoryArea->Attributes,
393 Page,
394 TRUE);
395 MmLockAddressSpace(AddressSpace);
396 }
397 if (!NT_SUCCESS(Status))
398 {
399 DPRINT1("MmCreateVirtualMapping failed, not out of memory\n");
400 KeBugCheck(0);
401 return(Status);
402 }
403
404 /*
405 * Add the page to the process's working set
406 */
407 MmInsertRmap(Page, PsGetCurrentProcess(), (PVOID)PAGE_ROUND_DOWN(Address));
408
409 /*
410 * Finish the operation
411 */
412 if (Locked)
413 {
414 MmLockPage(MmGetPhysicalAddressForProcess(NULL, Address));
415 }
416 PageOp->Status = STATUS_SUCCESS;
417 KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
418 MmReleasePageOp(PageOp);
419 return(STATUS_SUCCESS);
420 }
421
422 VOID STATIC
423 MmModifyAttributes(PMADDRESS_SPACE AddressSpace,
424 PVOID BaseAddress,
425 ULONG RegionSize,
426 ULONG OldType,
427 ULONG OldProtect,
428 ULONG NewType,
429 ULONG NewProtect)
430 /*
431 * FUNCTION: Modify the attributes of a memory region
432 */
433 {
434 /*
435 * If we are switching a previously committed region to reserved then
436 * free any allocated pages within the region
437 */
438 if (NewType == MEM_RESERVE && OldType == MEM_COMMIT)
439 {
440 ULONG i;
441
442 for (i=0; i <= (RegionSize/PAGE_SIZE); i++)
443 {
444 LARGE_INTEGER PhysicalAddr;
445
446 if (MmIsPageSwapEntry(AddressSpace->Process,
447 BaseAddress + (i * PAGE_SIZE)))
448 {
449 SWAPENTRY SwapEntry;
450
451 MmDeletePageFileMapping(AddressSpace->Process,
452 BaseAddress + (i * PAGE_SIZE),
453 &SwapEntry);
454 MmFreeSwapPage(SwapEntry);
455 }
456 else
457 {
458 PhysicalAddr = MmGetPhysicalAddress(BaseAddress + (i*PAGE_SIZE));
459 MmDeleteVirtualMapping(AddressSpace->Process,
460 BaseAddress + (i*PAGE_SIZE),
461 FALSE, NULL, NULL);
462 if (PhysicalAddr.QuadPart != 0)
463 {
464 SWAPENTRY SavedSwapEntry;
465 SavedSwapEntry = MmGetSavedSwapEntryPage(PhysicalAddr);
466 if (SavedSwapEntry != 0)
467 {
468 MmFreeSwapPage(SavedSwapEntry);
469 MmSetSavedSwapEntryPage(PhysicalAddr, 0);
470 }
471 MmDeleteRmap(PhysicalAddr, AddressSpace->Process,
472 BaseAddress + (i * PAGE_SIZE));
473 MmReleasePageMemoryConsumer(MC_USER, PhysicalAddr);
474 }
475 }
476 }
477 }
478
479 /*
480 * If we are changing the protection attributes of a committed region then
481 * alter the attributes for any allocated pages within the region
482 */
483 if (NewType == MEM_COMMIT && OldType == MEM_COMMIT &&
484 OldProtect != NewProtect)
485 {
486 ULONG i;
487
488 for (i=0; i <= (RegionSize/PAGE_SIZE); i++)
489 {
490 if (MmIsPagePresent(AddressSpace->Process,
491 BaseAddress + (i*PAGE_SIZE)))
492 {
493 MmSetPageProtect(AddressSpace->Process,
494 BaseAddress + (i*PAGE_SIZE),
495 NewProtect);
496 }
497 }
498 }
499 }
500
501 NTSTATUS STDCALL
502 NtAllocateVirtualMemory(IN HANDLE ProcessHandle,
503 IN OUT PVOID* UBaseAddress,
504 IN ULONG ZeroBits,
505 IN OUT PULONG URegionSize,
506 IN ULONG AllocationType,
507 IN ULONG Protect)
508 /*
509 * FUNCTION: Allocates a block of virtual memory in the process address space
510 * ARGUMENTS:
511 * ProcessHandle = The handle of the process which owns the virtual memory
512 * BaseAddress = A pointer to the virtual memory allocated. If you
513 * supply a non zero value the system will try to
514 * allocate the memory at the address supplied. It round
515 * it down to a multiple of the page size.
516 * ZeroBits = (OPTIONAL) You can specify the number of high order bits
517 * that must be zero, ensuring that the memory will be
518 * allocated at a address below a certain value.
519 * RegionSize = The number of bytes to allocate
520 * AllocationType = Indicates the type of virtual memory you like to
521 * allocated, can be a combination of MEM_COMMIT,
522 * MEM_RESERVE, MEM_RESET, MEM_TOP_DOWN.
523 * Protect = Indicates the protection type of the pages allocated, can be
524 * a combination of PAGE_READONLY, PAGE_READWRITE,
525 * PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE, PAGE_GUARD,
526 * PAGE_NOACCESS
527 * RETURNS: Status
528 */
529 {
530 PEPROCESS Process;
531 MEMORY_AREA* MemoryArea;
532 ULONG Type;
533 NTSTATUS Status;
534 PMADDRESS_SPACE AddressSpace;
535 PVOID BaseAddress;
536 ULONG RegionSize;
537 PVOID PBaseAddress;
538 ULONG PRegionSize;
539
540 DPRINT("NtAllocateVirtualMemory(*UBaseAddress %x, "
541 "ZeroBits %d, *URegionSize %x, AllocationType %x, Protect %x)\n",
542 *UBaseAddress,ZeroBits,*URegionSize,AllocationType,
543 Protect);
544
545 /*
546 * Check the validity of the parameters
547 */
548 if ((Protect & PAGE_FLAGS_VALID_FROM_USER_MODE) != Protect)
549 {
550 return(STATUS_INVALID_PAGE_PROTECTION);
551 }
552 if ((AllocationType & (MEM_COMMIT | MEM_RESERVE)) == 0)
553 {
554 return(STATUS_INVALID_PARAMETER);
555 }
556
557 PBaseAddress = *UBaseAddress;
558 PRegionSize = *URegionSize;
559
560 BaseAddress = (PVOID)PAGE_ROUND_DOWN(PBaseAddress);
561 RegionSize = PAGE_ROUND_UP(PBaseAddress + PRegionSize) -
562 PAGE_ROUND_DOWN(PBaseAddress);
563
564 Status = ObReferenceObjectByHandle(ProcessHandle,
565 PROCESS_VM_OPERATION,
566 NULL,
567 UserMode,
568 (PVOID*)(&Process),
569 NULL);
570 if (!NT_SUCCESS(Status))
571 {
572 DPRINT("NtAllocateVirtualMemory() = %x\n",Status);
573 return(Status);
574 }
575
576 Type = (AllocationType & MEM_COMMIT) ? MEM_COMMIT : MEM_RESERVE;
577 DPRINT("Type %x\n", Type);
578
579 AddressSpace = &Process->AddressSpace;
580 MmLockAddressSpace(AddressSpace);
581
582 if (PBaseAddress != 0)
583 {
584 MemoryArea = MmOpenMemoryAreaByAddress(&Process->AddressSpace,
585 BaseAddress);
586
587 if (MemoryArea != NULL &&
588 MemoryArea->Type == MEMORY_AREA_VIRTUAL_MEMORY &&
589 MemoryArea->Length >= RegionSize)
590 {
591 Status =
592 MmAlterRegion(&Process->AddressSpace,
593 MemoryArea->BaseAddress,
594 &MemoryArea->Data.VirtualMemoryData.RegionListHead,
595 PBaseAddress, RegionSize,
596 Type, Protect, MmModifyAttributes);
597 MmUnlockAddressSpace(AddressSpace);
598 ObDereferenceObject(Process);
599 DPRINT("NtAllocateVirtualMemory() = %x\n",Status);
600 return(Status);
601 }
602 else if (MemoryArea != NULL)
603 {
604 MmUnlockAddressSpace(AddressSpace);
605 ObDereferenceObject(Process);
606 return(STATUS_UNSUCCESSFUL);
607 }
608 }
609
610 Status = MmCreateMemoryArea(Process,
611 &Process->AddressSpace,
612 MEMORY_AREA_VIRTUAL_MEMORY,
613 &BaseAddress,
614 RegionSize,
615 Protect,
616 &MemoryArea,
617 PBaseAddress != 0);
618
619 if (!NT_SUCCESS(Status))
620 {
621 MmUnlockAddressSpace(AddressSpace);
622 ObDereferenceObject(Process);
623 DPRINT("NtAllocateVirtualMemory() = %x\n",Status);
624 return(Status);
625 }
626 MmInitialiseRegion(&MemoryArea->Data.VirtualMemoryData.RegionListHead,
627 RegionSize, Type, Protect);
628
629 if ((AllocationType & MEM_COMMIT) &&
630 ((Protect & PAGE_READWRITE) ||
631 (Protect & PAGE_EXECUTE_READWRITE)))
632 {
633 MmReserveSwapPages(RegionSize);
634 }
635
636 *UBaseAddress = BaseAddress;
637 *URegionSize = RegionSize;
638 DPRINT("*UBaseAddress %x *URegionSize %x\n", BaseAddress, RegionSize);
639
640 MmUnlockAddressSpace(AddressSpace);
641 ObDereferenceObject(Process);
642 return(STATUS_SUCCESS);
643 }
644
645 VOID STATIC
646 MmFreeVirtualMemoryPage(PVOID Context,
647 MEMORY_AREA* MemoryArea,
648 PVOID Address,
649 PHYSICAL_ADDRESS PhysicalAddr,
650 SWAPENTRY SwapEntry,
651 BOOLEAN Dirty)
652 {
653 PEPROCESS Process = (PEPROCESS)Context;
654
655 if (PhysicalAddr.QuadPart != 0)
656 {
657 SWAPENTRY SavedSwapEntry;
658 SavedSwapEntry = MmGetSavedSwapEntryPage(PhysicalAddr);
659 if (SavedSwapEntry != 0)
660 {
661 MmFreeSwapPage(SavedSwapEntry);
662 MmSetSavedSwapEntryPage(PhysicalAddr, 0);
663 }
664 MmDeleteRmap(PhysicalAddr, Process, Address);
665 MmReleasePageMemoryConsumer(MC_USER, PhysicalAddr);
666 }
667 else if (SwapEntry != 0)
668 {
669 MmFreeSwapPage(SwapEntry);
670 }
671 }
672
673 VOID
674 MmFreeVirtualMemory(PEPROCESS Process,
675 PMEMORY_AREA MemoryArea)
676 {
677 PLIST_ENTRY current_entry;
678 PMM_REGION current;
679 ULONG i;
680
681 DPRINT("MmFreeVirtualMemory(Process %p MemoryArea %p)\n", Process,
682 MemoryArea);
683
684 /* Mark this memory area as about to be deleted. */
685 MemoryArea->DeleteInProgress = TRUE;
686
687 /*
688 * Wait for any ongoing paging operations. Notice that since we have
689 * flagged this memory area as deleted no more page ops will be added.
690 */
691 if (MemoryArea->PageOpCount > 0)
692 {
693 for (i = 0; i < (PAGE_ROUND_UP(MemoryArea->Length) / PAGE_SIZE); i++)
694 {
695 PMM_PAGEOP PageOp;
696
697 if (MemoryArea->PageOpCount == 0)
698 {
699 break;
700 }
701
702 PageOp = MmCheckForPageOp(MemoryArea, Process->UniqueProcessId,
703 MemoryArea->BaseAddress + (i * PAGE_SIZE),
704 NULL, 0);
705 if (PageOp != NULL)
706 {
707 NTSTATUS Status;
708 MmUnlockAddressSpace(&Process->AddressSpace);
709 Status = KeWaitForSingleObject(&PageOp->CompletionEvent,
710 0,
711 KernelMode,
712 FALSE,
713 NULL);
714 if (Status != STATUS_SUCCESS)
715 {
716 DPRINT1("Failed to wait for page op\n");
717 KeBugCheck(0);
718 }
719 MmLockAddressSpace(&Process->AddressSpace);
720 MmReleasePageOp(PageOp);
721 }
722 }
723 }
724
725 /* Free all the individual segments. */
726 current_entry = MemoryArea->Data.VirtualMemoryData.RegionListHead.Flink;
727 while (current_entry != &MemoryArea->Data.VirtualMemoryData.RegionListHead)
728 {
729 current = CONTAINING_RECORD(current_entry, MM_REGION, RegionListEntry);
730 current_entry = current_entry->Flink;
731 ExFreePool(current);
732 }
733
734 /* Actually free the memory area. */
735 MmFreeMemoryArea(&Process->AddressSpace,
736 MemoryArea->BaseAddress,
737 0,
738 MmFreeVirtualMemoryPage,
739 (PVOID)Process);
740 }
741
742 NTSTATUS STDCALL
743 NtFreeVirtualMemory(IN HANDLE ProcessHandle,
744 IN PVOID* PBaseAddress,
745 IN PULONG PRegionSize,
746 IN ULONG FreeType)
747 /*
748 * FUNCTION: Frees a range of virtual memory
749 * ARGUMENTS:
750 * ProcessHandle = Points to the process that allocated the virtual
751 * memory
752 * BaseAddress = Points to the memory address, rounded down to a
753 * multiple of the pagesize
754 * RegionSize = Limits the range to free, rounded up to a multiple of
755 * the paging size
756 * FreeType = Can be one of the values: MEM_DECOMMIT, or MEM_RELEASE
757 * RETURNS: Status
758 */
759 {
760 MEMORY_AREA* MemoryArea;
761 NTSTATUS Status;
762 PEPROCESS Process;
763 PMADDRESS_SPACE AddressSpace;
764 PVOID BaseAddress;
765 ULONG RegionSize;
766
767 DPRINT("NtFreeVirtualMemory(ProcessHandle %x, *PBaseAddress %x, "
768 "*PRegionSize %x, FreeType %x)\n",ProcessHandle,*PBaseAddress,
769 *PRegionSize,FreeType);
770
771 BaseAddress = (PVOID)PAGE_ROUND_DOWN((*PBaseAddress));
772 RegionSize = PAGE_ROUND_UP((*PBaseAddress) + (*PRegionSize)) -
773 PAGE_ROUND_DOWN((*PBaseAddress));
774
775 Status = ObReferenceObjectByHandle(ProcessHandle,
776 PROCESS_VM_OPERATION,
777 PsProcessType,
778 UserMode,
779 (PVOID*)(&Process),
780 NULL);
781 if (!NT_SUCCESS(Status))
782 {
783 return(Status);
784 }
785
786 AddressSpace = &Process->AddressSpace;
787
788 MmLockAddressSpace(AddressSpace);
789 MemoryArea = MmOpenMemoryAreaByAddress(AddressSpace,
790 BaseAddress);
791 if (MemoryArea == NULL)
792 {
793 MmUnlockAddressSpace(AddressSpace);
794 ObDereferenceObject(Process);
795 return(STATUS_UNSUCCESSFUL);
796 }
797
798 switch (FreeType)
799 {
800 case MEM_RELEASE:
801 /* We can only free a memory area in one step. */
802 if (MemoryArea->BaseAddress != BaseAddress)
803 {
804 MmUnlockAddressSpace(AddressSpace);
805 ObDereferenceObject(Process);
806 return(STATUS_UNSUCCESSFUL);
807 }
808 MmFreeVirtualMemory(Process, MemoryArea);
809 MmUnlockAddressSpace(AddressSpace);
810 ObDereferenceObject(Process);
811 return(STATUS_SUCCESS);
812
813 case MEM_DECOMMIT:
814 Status =
815 MmAlterRegion(AddressSpace,
816 MemoryArea->BaseAddress,
817 &MemoryArea->Data.VirtualMemoryData.RegionListHead,
818 BaseAddress,
819 RegionSize,
820 MEM_RESERVE,
821 PAGE_NOACCESS,
822 MmModifyAttributes);
823 MmUnlockAddressSpace(AddressSpace);
824 ObDereferenceObject(Process);
825 return(Status);
826 }
827 MmUnlockAddressSpace(AddressSpace);
828 ObDereferenceObject(Process);
829 return(STATUS_NOT_IMPLEMENTED);
830 }
831
832 NTSTATUS
833 MmProtectAnonMem(PMADDRESS_SPACE AddressSpace,
834 PMEMORY_AREA MemoryArea,
835 PVOID BaseAddress,
836 ULONG Length,
837 ULONG Protect,
838 PULONG OldProtect)
839 {
840 PMM_REGION Region;
841 NTSTATUS Status;
842
843 Region = MmFindRegion(MemoryArea->BaseAddress,
844 &MemoryArea->Data.VirtualMemoryData.RegionListHead,
845 BaseAddress, NULL);
846 *OldProtect = Region->Protect;
847 Status = MmAlterRegion(AddressSpace, MemoryArea->BaseAddress,
848 &MemoryArea->Data.VirtualMemoryData.RegionListHead,
849 BaseAddress, Length, Region->Type, Protect,
850 MmModifyAttributes);
851 return(Status);
852 }
853
854 NTSTATUS STDCALL
855 MmQueryAnonMem(PMEMORY_AREA MemoryArea,
856 PVOID Address,
857 PMEMORY_BASIC_INFORMATION Info,
858 PULONG ResultLength)
859 {
860 PMM_REGION Region;
861 PVOID RegionBase;
862
863 Info->BaseAddress = (PVOID)PAGE_ROUND_DOWN(Address);
864
865 Region = MmFindRegion(MemoryArea->BaseAddress,
866 &MemoryArea->Data.VirtualMemoryData.RegionListHead,
867 Address, &RegionBase);
868 Info->AllocationBase = RegionBase;
869 Info->AllocationProtect = Region->Protect; /* FIXME */
870 Info->RegionSize = Region->Length;
871 Info->State = Region->Type;
872 Info->Protect = Region->Protect;
873 Info->Type = MEM_PRIVATE;
874 return(STATUS_SUCCESS);
875 }
876
877 /* EOF */
A free Windows-compatible Operating System