1251 lines
35 KiB
C
1251 lines
35 KiB
C
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <memory.h>
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
|
|
#define DbgPrint printf
|
|
#define NtTerminateProcess(a,b) ExitProcess(b)
|
|
|
|
__cdecl
|
|
main(
|
|
)
|
|
|
|
{
|
|
|
|
SIZE_T size, Size;
|
|
PVOID BaseAddress;
|
|
LONG i, j;
|
|
PULONG p4, p3, p2, p1, oldp1, vp1;
|
|
SIZE_T Size1, Size2, Size3;
|
|
NTSTATUS status, alstatus;
|
|
HANDLE CurrentProcessHandle;
|
|
HANDLE GiantSection;
|
|
HANDLE Section2, Section4;
|
|
MEMORY_BASIC_INFORMATION MemInfo;
|
|
ULONG OldProtect;
|
|
STRING Name3;
|
|
HANDLE Section1;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
OBJECT_ATTRIBUTES Object1Attributes;
|
|
SIZE_T ViewSize;
|
|
LARGE_INTEGER Offset;
|
|
LARGE_INTEGER SectionSize;
|
|
UNICODE_STRING Unicode;
|
|
LOGICAL Os64Bit;
|
|
SYSTEM_PROCESSOR_INFORMATION SysInfo;
|
|
|
|
Os64Bit = FALSE;
|
|
|
|
//
|
|
// If we're running on a 64-bit OS, make large memory calls.
|
|
//
|
|
|
|
status = NtQuerySystemInformation (SystemProcessorInformation,
|
|
&SysInfo,
|
|
sizeof(SYSTEM_PROCESSOR_INFORMATION),
|
|
NULL);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
if (SysInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_ALPHA64 ||
|
|
SysInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) {
|
|
Os64Bit = TRUE;
|
|
}
|
|
}
|
|
|
|
DbgPrint("****Memory Management Tests (%d-bit) - AllocVm, FreeVm, ProtectVm, QueryVm\n", Os64Bit == TRUE ? 64 : 32);
|
|
|
|
CurrentProcessHandle = NtCurrentProcess();
|
|
|
|
p1 = (PULONG)0x20020000;
|
|
Size1 = 0xbc0000;
|
|
DbgPrint(" Test 1 - ");
|
|
alstatus = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0,
|
|
&Size1,
|
|
MEM_RESERVE | MEM_COMMIT,
|
|
PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(alstatus)) {
|
|
DbgPrint("Failed allocate with status %lx start %p size %p\n",
|
|
alstatus,
|
|
p1,
|
|
Size1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 2 - ");
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p1,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status) ||
|
|
(MemInfo.RegionSize != Size1) ||
|
|
(MemInfo.BaseAddress != p1) ||
|
|
(MemInfo.Protect != PAGE_READWRITE) ||
|
|
(MemInfo.Type != MEM_PRIVATE) ||
|
|
(MemInfo.State != MEM_COMMIT)) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
p1,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
|
|
DbgPrint(" Test 3 - ");
|
|
p2 = NULL;
|
|
Size2 = 0x100000;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
3,
|
|
&Size2,
|
|
MEM_TOP_DOWN | MEM_RESERVE | MEM_COMMIT,
|
|
PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed allocate with status %lx start %p size %p\n",
|
|
status,
|
|
p2,
|
|
Size2);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
//
|
|
// Touch every other page.
|
|
//
|
|
|
|
DbgPrint(" Test 4 - ");
|
|
try {
|
|
vp1 = p2 + 3000;
|
|
while (vp1 < (p2 + (Size2 / sizeof(ULONG)))) {
|
|
*vp1 = 938;
|
|
vp1 += 3000;
|
|
}
|
|
|
|
DbgPrint("Succeeded\n");
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
DbgPrint("Failed with an exception\n");
|
|
}
|
|
|
|
//
|
|
// Decommit pages.
|
|
//
|
|
|
|
DbgPrint(" Test 5 - ");
|
|
Size3 = Size2 - 5044;
|
|
vp1 = p2 + 3000;
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
&Size3,
|
|
MEM_DECOMMIT);
|
|
|
|
if (!(NT_SUCCESS(status))) {
|
|
DbgPrint("Failed free with status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
//
|
|
// Split the memory block using MEM_RELEASE.
|
|
//
|
|
|
|
DbgPrint(" Test 6 - ");
|
|
vp1 = p2 + 5000;
|
|
Size3 = Size2 - 50000;
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&vp1,
|
|
&Size3,
|
|
MEM_RELEASE);
|
|
|
|
if (!(NT_SUCCESS(status))) {
|
|
DbgPrint("Failed free with status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 7 - ");
|
|
vp1 = p2 + 3000;
|
|
Size3 = 41;
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&vp1,
|
|
&Size3,
|
|
MEM_RELEASE);
|
|
|
|
if (!(NT_SUCCESS(status))) {
|
|
DbgPrint("Failed free with status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
//
|
|
// free every page, ignore the status.
|
|
//
|
|
|
|
vp1 = p2;
|
|
Size3 = 30;
|
|
while (vp1 < (p2 + (Size2 / sizeof(ULONG)))) {
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&vp1,
|
|
&Size3,
|
|
MEM_RELEASE);
|
|
vp1 += 128;
|
|
}
|
|
|
|
DbgPrint(" Test 8 - ");
|
|
p2 = NULL;
|
|
Size2 = 0x10000;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
3,
|
|
&Size2,
|
|
MEM_TOP_DOWN | MEM_RESERVE | MEM_COMMIT,
|
|
PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed allocate with status %lx start %p size %p\n",
|
|
status,
|
|
p2,
|
|
Size1);
|
|
|
|
} else {
|
|
if (p2 < (PULONG)0x1fff0000) {
|
|
DbgPrint("Failed allocate at top of memory at %p\n", p2);
|
|
}
|
|
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
&Size2,
|
|
MEM_RELEASE);
|
|
|
|
if (!(NT_SUCCESS(status))) {
|
|
DbgPrint("Failed free with status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded with allocation at %p\n", p2);
|
|
}
|
|
}
|
|
|
|
DbgPrint(" Test 9 - ");
|
|
if (NT_SUCCESS(alstatus)) {
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
&Size1,
|
|
MEM_RELEASE);
|
|
|
|
if (!(NT_SUCCESS(status))) {
|
|
DbgPrint("Failed free with status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
} else {
|
|
DbgPrint("Failed allocate with status %lx\n", alstatus);
|
|
}
|
|
|
|
|
|
DbgPrint(" Test 10 - ");
|
|
p1 = NULL;
|
|
Size1 = 16 * 4096;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0,
|
|
&Size1,
|
|
MEM_RESERVE, PAGE_READWRITE | PAGE_GUARD);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed created with status %lx start %p size %p\n",
|
|
status,
|
|
p1,
|
|
Size1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 11 - ");
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p1,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status) ||
|
|
(MemInfo.RegionSize != Size1) ||
|
|
(MemInfo.BaseAddress != p1) ||
|
|
(MemInfo.AllocationProtect != (PAGE_READWRITE | PAGE_GUARD)) ||
|
|
(MemInfo.Protect != 0) ||
|
|
(MemInfo.Type != MEM_PRIVATE) ||
|
|
(MemInfo.State != MEM_RESERVE)) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
p1,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx alloc_protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.AllocationProtect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
|
|
DbgPrint(" Test 12 - ");
|
|
Size2 = 8192;
|
|
oldp1 = p1;
|
|
p1 = p1 + 14336; // 64k -8k /4
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0,
|
|
&Size2,
|
|
MEM_COMMIT, PAGE_EXECUTE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed creat with status %lx start %p size %p\n",
|
|
status,
|
|
p1,
|
|
Size1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 13 - ");
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
oldp1,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status) ||
|
|
(MemInfo.RegionSize != 56*1024) ||
|
|
(MemInfo.BaseAddress != oldp1) ||
|
|
(MemInfo.AllocationProtect != (PAGE_READWRITE | PAGE_GUARD)) ||
|
|
(MemInfo.Protect != 0) ||
|
|
(MemInfo.Type != MEM_PRIVATE) ||
|
|
(MemInfo.State != MEM_RESERVE)) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
oldp1,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx alloc_protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.AllocationProtect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 14 - ");
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p1,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status) ||
|
|
(MemInfo.RegionSize != Size2) || (MemInfo.BaseAddress != p1) ||
|
|
(MemInfo.Protect != PAGE_EXECUTE_READWRITE) || (MemInfo.Type != MEM_PRIVATE) ||
|
|
(MemInfo.State != MEM_COMMIT)
|
|
|| (MemInfo.AllocationBase != oldp1)) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
oldp1,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 15 - ");
|
|
Size1 = Size2;
|
|
status = NtProtectVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
&Size1,
|
|
PAGE_READONLY | PAGE_NOCACHE, &OldProtect);
|
|
|
|
if ((!NT_SUCCESS(status)) ||
|
|
(OldProtect != PAGE_EXECUTE_READWRITE)) {
|
|
DbgPrint("Failed protect with status %lx base %p size %p old protect %lx\n",
|
|
status,
|
|
p1,
|
|
Size1,
|
|
OldProtect);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 16 - ");
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p1,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if ((!NT_SUCCESS(status)) ||
|
|
(MemInfo.Protect != (PAGE_NOCACHE | PAGE_READONLY))) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
p1,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 17 - ");
|
|
i = *p1;
|
|
status = NtProtectVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
&Size1,
|
|
PAGE_NOACCESS | PAGE_NOCACHE, &OldProtect);
|
|
|
|
if (status != STATUS_INVALID_PAGE_PROTECTION) {
|
|
DbgPrint("Failed protect with status %lx, base %p, size %p, old protect %lx\n",
|
|
status,
|
|
p1,
|
|
Size1,
|
|
OldProtect);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 18 - ");
|
|
status = NtProtectVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
&Size1,
|
|
PAGE_READONLY,
|
|
&OldProtect);
|
|
|
|
if ((!NT_SUCCESS(status)) ||
|
|
(OldProtect != (PAGE_NOCACHE | PAGE_READONLY))) {
|
|
DbgPrint("Failed protect with status %lx base %p size %p old protect %lx\n",
|
|
status,
|
|
p1,
|
|
Size1,
|
|
OldProtect);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 19 - ");
|
|
status = NtProtectVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
&Size1,
|
|
PAGE_READWRITE,
|
|
&OldProtect);
|
|
|
|
if ((!NT_SUCCESS(status)) ||
|
|
(OldProtect != (PAGE_READONLY))) {
|
|
DbgPrint("Failed protect with status %lx base %p size %p old protect %lx\n",
|
|
status,
|
|
p1,
|
|
Size1,
|
|
OldProtect);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 20 - ");
|
|
for (i = 1; i < 12; i++) {
|
|
p2 = NULL;
|
|
Size2 = i * 4096;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
0,
|
|
&Size2,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed creat with status %lx start %p size %p\n",
|
|
status,
|
|
p2,
|
|
Size2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i == 4) {
|
|
p3 = p2;
|
|
}
|
|
|
|
if (i == 8) {
|
|
Size3 = 12000;
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p3,
|
|
&Size3,
|
|
MEM_RELEASE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed free with status %lx start %p size %p\n",
|
|
status,
|
|
p3,
|
|
Size3);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (i == 12) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 21 - ");
|
|
p3 = p1 + 8 * 1024;
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p3,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
p3,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 22 - ");
|
|
p3 = p1 - 8 * 1024;
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p3,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
p3,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 23 - ");
|
|
Size3 = 16 * 4096;
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p3,
|
|
&Size3,
|
|
MEM_RELEASE);
|
|
|
|
if (status != STATUS_UNABLE_TO_FREE_VM) {
|
|
DbgPrint("Failed free with status %lx start %p size %p\n",
|
|
status,
|
|
p3,
|
|
Size3);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 24 - ");
|
|
Size3 = 1 * 4096;
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p3,
|
|
&Size3,
|
|
MEM_RELEASE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed free with status %lx start %p size %p\n",
|
|
status,
|
|
p3,
|
|
Size3);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 25 - ");
|
|
p3 = NULL;
|
|
Size3 = 300 * 4096;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p3,
|
|
0,
|
|
&Size3,
|
|
MEM_COMMIT, PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed creat with status %lx start %p size %p\n",
|
|
status,
|
|
p3,
|
|
Size3);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 26 - ");
|
|
p1 = p3;
|
|
p2 = ((PULONG)((PUCHAR)p3 + Size3));
|
|
p4 = p1;
|
|
j = 0;
|
|
while (p3 < p2) {
|
|
j += 1;
|
|
if (j % 8 == 0) {
|
|
if (*p4 != (ULONG)((ULONG_PTR)p4)) {
|
|
DbgPrint("Failed bad value in xcell %p value is %lx\n", p4, *p4);
|
|
break;
|
|
}
|
|
|
|
p4 += 1;
|
|
*p4 = (ULONG)((ULONG_PTR)p4);
|
|
p4 = p4 + 1026;
|
|
}
|
|
|
|
*p3 = (ULONG)((ULONG_PTR)p3);
|
|
p3 += 1027;
|
|
}
|
|
|
|
if (p3 >= p2) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 27 - ");
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p3,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed query with status %lx address %p Base %p size %p\n",
|
|
status,
|
|
p3,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 28 - ");
|
|
p3 = p1;
|
|
while (p3 < p2) {
|
|
if (*p3 != (ULONG)((ULONG_PTR)p3)) {
|
|
DbgPrint("Failed bad value in 1cell %p value is %lx\n", p3, *p3);
|
|
break;
|
|
}
|
|
|
|
p3 += 1027;
|
|
}
|
|
|
|
if (p3 >= p2) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 29 - ");
|
|
p3 = p1;
|
|
while (p3 < p2) {
|
|
if (*p3 != (ULONG)((ULONG_PTR)p3)) {
|
|
DbgPrint("Failed bad value in 2cell %p value is %lx\n", p3, *p3);
|
|
break;
|
|
}
|
|
|
|
p3 += 1027;
|
|
}
|
|
|
|
if (p3 >= p2) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 30 - ");
|
|
p3 = p1;
|
|
while (p3 < p2) {
|
|
if (*p3 != (ULONG)((ULONG_PTR)p3)) {
|
|
DbgPrint("Failed bad value in 3cell %p value is %lx\n", p3, *p3);
|
|
break;
|
|
}
|
|
|
|
p3 += 1027;
|
|
}
|
|
|
|
if (p3 >= p2) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 31 - ");
|
|
p3 = p1;
|
|
while (p3 < p2) {
|
|
if (*p3 != (ULONG)((ULONG_PTR)p3)) {
|
|
DbgPrint("Failed bad value in 4cell %p value is %lx\n", p3, *p3);
|
|
break;
|
|
}
|
|
|
|
p3 += 1027;
|
|
}
|
|
|
|
if (p3 >= p2) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 32 - ");
|
|
p3 = p1;
|
|
while (p3 < p2) {
|
|
if (*p3 != (ULONG)((ULONG_PTR)p3)) {
|
|
DbgPrint("Failed bad value in 5cell %p value is %lx\n", p3, *p3);
|
|
break;
|
|
}
|
|
|
|
p3 += 1027;
|
|
}
|
|
|
|
if (p3 >= p2) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 33 - ");
|
|
p3 = p1;
|
|
while (p3 < p2) {
|
|
if (*p3 != (ULONG)((ULONG_PTR)p3)) {
|
|
DbgPrint("Failed bad value in cell %p value is %lx\n", p3, *p3);
|
|
break;
|
|
}
|
|
|
|
p3 += 1027;
|
|
}
|
|
|
|
if (p3 >= p2) {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
//
|
|
// Check physical frame mapping.
|
|
//
|
|
|
|
DbgPrint(" Test 34 - ");
|
|
RtlInitAnsiString(&Name3, "\\Device\\PhysicalMemory");
|
|
RtlAnsiStringToUnicodeString(&Unicode, &Name3, TRUE);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&Unicode,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
status = NtOpenSection(&Section1,
|
|
SECTION_MAP_READ | SECTION_MAP_WRITE,
|
|
&ObjectAttributes);
|
|
|
|
RtlFreeUnicodeString(&Unicode);
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed open physical section with status %lx\n", status);
|
|
DbgPrint(" skipping test 35\n");
|
|
goto Test36;
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 35 - ");
|
|
p1 = NULL;
|
|
Offset.QuadPart = 0x810ff033;
|
|
ViewSize = 300 * 4096;
|
|
status = NtMapViewOfSection(Section1,
|
|
NtCurrentProcess(),
|
|
(PVOID *)&p1,
|
|
0,
|
|
ViewSize,
|
|
&Offset,
|
|
&ViewSize,
|
|
ViewUnmap,
|
|
0,
|
|
PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed map physical section %lx offset %p base %p\n",
|
|
status,
|
|
Offset.QuadPart,
|
|
p1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
Test36:
|
|
DbgPrint(" Test 36 - ");
|
|
p1 = NULL;
|
|
Size1 = 8 * 1024 * 1024;
|
|
alstatus = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0,
|
|
&Size1,
|
|
MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(alstatus)) {
|
|
DbgPrint("Failed created with status %lx start %p size %p\n",
|
|
alstatus,
|
|
p1,
|
|
Size1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
try {
|
|
RtlZeroMemory(p1, Size1);
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
}
|
|
|
|
DbgPrint(" Test 37 - ");
|
|
Size1 -= 20000;
|
|
(PUCHAR)p1 += 5000;
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
&Size1 ,
|
|
MEM_DECOMMIT);
|
|
|
|
if (!(NT_SUCCESS(status))) {
|
|
DbgPrint("Failed free with status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 38 - ");
|
|
Size1 -= 20000;
|
|
(PUCHAR)p1 += 5000;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0,
|
|
&Size1,
|
|
MEM_COMMIT, PAGE_EXECUTE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed create with status %lx start %p size %p\n",
|
|
status,
|
|
p1,
|
|
Size1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
try {
|
|
RtlZeroMemory(p1, Size1);
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
}
|
|
|
|
DbgPrint(" Test 39 - ");
|
|
Size1 = 28 * 4096;
|
|
p1 = NULL;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0,
|
|
&Size1,
|
|
MEM_COMMIT, PAGE_READWRITE | PAGE_GUARD);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed create with status %lx start %p size %p\n",
|
|
status,
|
|
p1,
|
|
Size1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 40 - ");
|
|
try {
|
|
|
|
//
|
|
// attempt to write the guard page.
|
|
//
|
|
|
|
*p1 = 973;
|
|
DbgPrint("Failed guard page exception did not occur\n");
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
status = GetExceptionCode();
|
|
if (status != STATUS_GUARD_PAGE_VIOLATION) {
|
|
DbgPrint("Failed incorrect guard exception code %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
}
|
|
|
|
DbgPrint(" Test 41 - ");
|
|
p2 = NULL;
|
|
Size2 = 200 * 1024 * 1024; //200MB
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
0,
|
|
&Size2,
|
|
MEM_COMMIT, PAGE_READWRITE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed allocate with status %lx\n", status);
|
|
|
|
} else {
|
|
status = NtFreeVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
&Size2,
|
|
MEM_RELEASE);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed free with status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
}
|
|
|
|
//
|
|
// Create a giant section 2gb on 32-bit system, 4gb on 64_bit system.
|
|
//
|
|
|
|
DbgPrint(" Test 42 - ");
|
|
InitializeObjectAttributes(&Object1Attributes,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL);
|
|
|
|
#if defined(_WIN64)
|
|
|
|
SectionSize.QuadPart = 0xffffffff;
|
|
|
|
#else
|
|
|
|
SectionSize.QuadPart = 0x7f000000;
|
|
|
|
#endif
|
|
|
|
status = NtCreateSection(&GiantSection,
|
|
SECTION_MAP_READ | SECTION_MAP_WRITE,
|
|
&Object1Attributes,
|
|
&SectionSize,
|
|
PAGE_READWRITE,
|
|
SEC_RESERVE,
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed create big section with status %lx\n", status);
|
|
DbgPrint(" skipping test 43\n");
|
|
goto Test44;
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
//
|
|
// Attempt to map the section (this should fail).
|
|
//
|
|
|
|
DbgPrint(" Test 43 - ");
|
|
p1 = NULL;
|
|
ViewSize = 0;
|
|
status = NtMapViewOfSection(GiantSection,
|
|
CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0L,
|
|
0,
|
|
0,
|
|
&ViewSize,
|
|
ViewUnmap,
|
|
0,
|
|
PAGE_READWRITE );
|
|
|
|
if (status != STATUS_NO_MEMORY) {
|
|
DbgPrint("Failed map big section status %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
Test44:
|
|
DbgPrint(" Test 44 - ");
|
|
i = 0;
|
|
|
|
#if defined(_WIN64)
|
|
if (Os64Bit == TRUE) {
|
|
Size2 = (SIZE_T)(32i64 * 1024 * 1024 * 1024 + 9938);
|
|
}
|
|
else {
|
|
Size2 = 8 * 1024 * 1024 + 9938;
|
|
}
|
|
#else
|
|
Size2 = 8 * 1024 * 1024 + 9938;
|
|
#endif
|
|
|
|
do {
|
|
p2 = NULL;
|
|
i += 1;
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
0,
|
|
&Size2,
|
|
MEM_RESERVE, PAGE_READWRITE);
|
|
|
|
} while (NT_SUCCESS(status));
|
|
|
|
if (status != STATUS_NO_MEMORY) {
|
|
DbgPrint("Failed with status %lx after %d allocations\n", status, i);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded with %d allocations\n", i);
|
|
}
|
|
|
|
//
|
|
// we pass an address of 1, so mm will round it down to 0. if we
|
|
// passed 0, it looks like a not present argument
|
|
//
|
|
// N.B. We have to make two separate calls to allocatevm, because
|
|
// we want a specific virtual address. If we don't first reserve
|
|
// the address, the mm fails the commit call.
|
|
//
|
|
|
|
DbgPrint(" Test 45 - ");
|
|
Size = 50 * 1024;
|
|
size = Size - 1;
|
|
BaseAddress = (PVOID)1;
|
|
status = NtAllocateVirtualMemory(NtCurrentProcess(),
|
|
&BaseAddress,
|
|
0L,
|
|
&size,
|
|
MEM_RESERVE,
|
|
PAGE_READWRITE );
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed reserve with status = %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 46 - ");
|
|
size = Size - 1;
|
|
BaseAddress = (PVOID)1;
|
|
status = NtAllocateVirtualMemory(NtCurrentProcess(),
|
|
&BaseAddress,
|
|
0L,
|
|
&size,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE );
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed commit with status = %lx\n", status);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
//
|
|
// Test MEM_DOS_LIM support.
|
|
//
|
|
|
|
#ifdef i386
|
|
|
|
DbgPrint(" Test 47 - ");
|
|
InitializeObjectAttributes(&Object1Attributes,
|
|
NULL,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
SectionSize.QuadPart = 1575757,
|
|
status = NtCreateSection(&Section4,
|
|
SECTION_MAP_READ | SECTION_MAP_WRITE,
|
|
&Object1Attributes,
|
|
&SectionSize,
|
|
PAGE_READWRITE,
|
|
SEC_COMMIT,
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed create section with status %lx section handle %lx\n",
|
|
status,
|
|
(ULONG)Section4);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 48 - ");
|
|
p3 = (PVOID)0x9001000;
|
|
ViewSize = 8000;
|
|
status = NtMapViewOfSection(Section4,
|
|
CurrentProcessHandle,
|
|
(PVOID *)&p3,
|
|
0L,
|
|
0,
|
|
0,
|
|
&ViewSize,
|
|
ViewUnmap,
|
|
MEM_DOS_LIM,
|
|
PAGE_READWRITE );
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed map section with status %lx base %lx size %lx\n",
|
|
status,
|
|
(ULONG)p3,
|
|
ViewSize);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 49 - ");
|
|
p2 = (PVOID)0x9003000;
|
|
ViewSize = 8000;
|
|
status = NtMapViewOfSection(Section4,
|
|
CurrentProcessHandle,
|
|
(PVOID *)&p2,
|
|
0L,
|
|
0,
|
|
0,
|
|
&ViewSize,
|
|
ViewUnmap,
|
|
MEM_DOS_LIM,
|
|
PAGE_READWRITE );
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed map section with status %lx base %lx size %lx\n",
|
|
status,
|
|
(ULONG)p3,
|
|
ViewSize);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 50 - ");
|
|
status = NtQueryVirtualMemory(CurrentProcessHandle,
|
|
p3,
|
|
MemoryBasicInformation,
|
|
&MemInfo,
|
|
sizeof(MEMORY_BASIC_INFORMATION),
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DbgPrint("Failed query with status %lx address %lx Base %lx size %lx\n",
|
|
status,
|
|
p1,
|
|
MemInfo.BaseAddress,
|
|
MemInfo.RegionSize);
|
|
|
|
DbgPrint(" state %lx protect %lx type %lx\n",
|
|
MemInfo.State,
|
|
MemInfo.Protect,
|
|
MemInfo.Type);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
DbgPrint(" Test 51 - ");
|
|
*p3 = 98;
|
|
if (*p3 != *p2) {
|
|
DbgPrint("Failed compare with %lx %lx\n", *p3, *p2);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
|
|
DbgPrint(" Test 52 - ");
|
|
Size2 = 8;
|
|
p1 = (PVOID)((ULONG)p2 - 0x3000);
|
|
status = NtAllocateVirtualMemory(CurrentProcessHandle,
|
|
(PVOID *)&p1,
|
|
0,
|
|
&Size2,
|
|
MEM_COMMIT,
|
|
PAGE_EXECUTE_READWRITE);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
DbgPrint("Failed create with status %lx start %lx size %lx\n",
|
|
status,
|
|
p1,
|
|
Size1);
|
|
|
|
} else {
|
|
DbgPrint("Succeeded\n");
|
|
}
|
|
|
|
#endif
|
|
DbgPrint("****End of Memory Management Tests\n");
|
|
return 0;
|
|
}
|