ReactOS 0.4.16-dev-2284-g3529151
NtAllocateVirtualMemory.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS API Tests
3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4 * PURPOSE: Test for NtAllocateVirtualMemory
5 * COPYRIGHT: Copyright 2011 Thomas Faber <thomas.faber@reactos.org>
6 * Copyright 2013 Timo Kreuzer <timo.kreuzer@reactos.org>
7 * Copyright 2015 Jérôme Gardou <jerome.gardou@reactos.org>
8 * Copyright 2018 Serge Gautherie <reactos-git_serge_171003@gautherie.fr>
9 */
10
11#include "precomp.h"
12
13#include <pseh/pseh2.h>
14
15static PVOID Allocations[4096] = { NULL };
16static ULONG CurrentAllocation = 0;
17
18static
19VOID
20ValidateAllocations(VOID)
21{
22 ULONG i;
23
24 ASSERT(CurrentAllocation < sizeof(Allocations) / sizeof(Allocations[0]));
25 for (i = 0; i < CurrentAllocation; ++i)
26 {
27 PUCHAR UserBuffer = Allocations[i];
28 SIZE_T AllocationSize;
29 SIZE_T DataSize;
30
31 if (UserBuffer == NULL)
32 continue;
33
34 AllocationSize = ((PSIZE_T)UserBuffer)[-2];
35 DataSize = ((PSIZE_T)UserBuffer)[-1];
36 ASSERT(AllocationSize != 0);
37 ASSERT(AllocationSize % PAGE_SIZE == 0);
38 ASSERT(DataSize != 0);
39 ASSERT(((SIZE_T)UserBuffer + DataSize) % PAGE_SIZE == 0);
40 }
41}
42
43static
44PVOID
45Allocate(
46 SIZE_T DataSize)
47{
48 NTSTATUS Status;
49 PVOID AllocationStart = NULL;
50 SIZE_T AllocationSize = PAGE_ROUND_UP(DataSize + PAGE_SIZE + 2 * sizeof(SIZE_T));
51 PVOID FirstPageStart;
52 SIZE_T NumberOfPages = AllocationSize / PAGE_SIZE;
53 SIZE_T Size;
54 PUCHAR UserBuffer;
55
56 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &AllocationStart, 0, &AllocationSize, MEM_RESERVE, PAGE_NOACCESS);
57
58 if (!NT_SUCCESS(Status))
59 return NULL;
60
61 FirstPageStart = (PUCHAR)AllocationStart + AllocationSize - PAGE_SIZE * NumberOfPages;
62 Size = (NumberOfPages - 1) * PAGE_SIZE;
63 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &FirstPageStart, 0, &Size, MEM_COMMIT, PAGE_READWRITE);
64 if (!NT_SUCCESS(Status))
65 {
66 AllocationSize = 0;
67 Status = NtFreeVirtualMemory(NtCurrentProcess(), &AllocationStart, &AllocationSize, MEM_RELEASE);
68 ASSERT(Status == STATUS_SUCCESS);
69 return NULL;
70 }
71 ASSERT(Size % sizeof(ULONG) == 0);
72 ASSERT(RtlCompareMemoryUlong(FirstPageStart, Size, 0) == Size);
73
74 UserBuffer = AllocationStart;
75 UserBuffer += AllocationSize - PAGE_SIZE - DataSize;
76 RtlFillMemory(FirstPageStart, UserBuffer - (PUCHAR)FirstPageStart, 0xae);
77 RtlZeroMemory(UserBuffer, DataSize);
78 ((PSIZE_T)UserBuffer)[-2] = AllocationSize;
79 ((PSIZE_T)UserBuffer)[-1] = DataSize;
80
81 Allocations[CurrentAllocation++] = UserBuffer;
82 ValidateAllocations();
83 return UserBuffer;
84}
85
86static
87VOID
88Free(
89 PVOID UserBuffer)
90{
91 NTSTATUS Status;
92 PVOID AllocationStart;
93 SIZE_T Zero = 0;
94 SIZE_T AllocationSize;
95 SIZE_T DataSize;
96 ULONG i;
97
98 AllocationSize = ((PSIZE_T)UserBuffer)[-2];
99 DataSize = ((PSIZE_T)UserBuffer)[-1];
100 ASSERT(DataSize != 0);
101
102 AllocationStart = (PUCHAR)UserBuffer + DataSize + PAGE_SIZE - AllocationSize;
103 ASSERT((SIZE_T)AllocationStart % PAGE_SIZE == 0);
104
105 RtlFillMemory(UserBuffer, DataSize, 0xbe);
106 ((PSIZE_T)UserBuffer)[-1] = 0;
107 ((PSIZE_T)UserBuffer)[-2] = 0xFAFBFCFD;
108
109 for (i = 0; i < CurrentAllocation; ++i)
110 if (Allocations[i] == UserBuffer)
111 {
112 Allocations[i] = NULL;
113 break;
114 }
115 ValidateAllocations();
116
117 Status = NtFreeVirtualMemory(NtCurrentProcess(), &AllocationStart, &Zero, MEM_RELEASE);
118 ASSERT(Status == STATUS_SUCCESS);
119}
120
121static
122PVOID
123ReAllocate(
124 PVOID OldUserBuffer,
125 SIZE_T NewDataSize)
126{
127 PVOID NewUserBuffer;
128 SIZE_T OldDataSize;
129
130 OldDataSize = ((PSIZE_T)OldUserBuffer)[-1];
131 ASSERT(OldDataSize != 0);
132
133 NewUserBuffer = Allocate(NewDataSize);
134 ASSERT(((PSIZE_T)OldUserBuffer)[-1] == OldDataSize);
135 RtlCopyMemory(NewUserBuffer, OldUserBuffer, min(OldDataSize, NewDataSize));
136 ASSERT(((PSIZE_T)OldUserBuffer)[-1] == OldDataSize);
137 Free(OldUserBuffer);
138 return NewUserBuffer;
139}
140
141static
142VOID
143AccessMemory1(
144 PVOID UserBuffer,
145 SIZE_T DataSize)
146{
147 PBYTE Buffer = UserBuffer;
148 SIZE_T i;
149
150 for (i = 0; i < DataSize; ++i)
151 Buffer[i] = LOBYTE(i);
152}
153
154static
155BOOLEAN
156CheckMemory1(
157 PVOID UserBuffer,
158 SIZE_T DataSize)
159{
160 PBYTE Buffer = UserBuffer;
161 SIZE_T i;
162
163 for (i = 0; i < DataSize; ++i)
164 if (Buffer[i] != LOBYTE(i))
165 {
166 trace("Mismatch in region %p at index %lu. Value=%02x\n", UserBuffer, (ULONG)i, Buffer[i]);
167 ASSERT(FALSE);
168 return FALSE;
169 }
170 return TRUE;
171}
172
173static
174VOID
175AccessMemory2(
176 PVOID UserBuffer,
177 SIZE_T DataSize)
178{
179 PBYTE Buffer = UserBuffer;
180 SIZE_T i;
181
182 for (i = 0; i < DataSize; ++i)
183 Buffer[i] = UCHAR_MAX - LOBYTE(i);
184}
185
186static
187BOOLEAN
188CheckMemory2(
189 PVOID UserBuffer,
190 SIZE_T DataSize)
191{
192 PBYTE Buffer = UserBuffer;
193 SIZE_T i;
194
195 for (i = 0; i < DataSize; ++i)
196 if (Buffer[i] != UCHAR_MAX - LOBYTE(i))
197 {
198 trace("Mismatch in region %p at index %lu. Value=%02x\n", UserBuffer, (ULONG)i, Buffer[i]);
199 ASSERT(FALSE);
200 return FALSE;
201 }
202 return TRUE;
203}
204
205VOID
206CheckSize(ULONG_PTR Base, SIZE_T InSize, SIZE_T ExpectedSize)
207{
208 NTSTATUS Status;
209 PVOID BaseAddress;
210 SIZE_T Size;
211
212 /* Reserve memory */
213 BaseAddress = (PVOID)Base;
214 Size = InSize;
215 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
216 &BaseAddress,
217 0,
218 &Size,
219 MEM_RESERVE,
220 PAGE_NOACCESS);
221 ok(NT_SUCCESS(Status), "NtAllocateVirtualMemory failed!\n");
222 ok(BaseAddress == (PVOID)(Base & ~((ULONG_PTR)0xFFFF)), "Got back wrong base address: %p\n", BaseAddress);
223 ok(Size == ExpectedSize, "Alloc of 0x%Ix: got back wrong size: 0x%Ix, expected 0x%Ix\n", InSize, Size, ExpectedSize);
224 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
225 ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed!\n");
226}
227
228VOID
229CheckAlignment()
230{
231 NTSTATUS Status;
232 PVOID BaseAddress;
233 SIZE_T Size;
234
235 CheckSize(0x50000000, 0x0001, 0x1000);
236 CheckSize(0x50008000, 0x0001, 0x9000);
237 CheckSize(0x50000010, 0x1000, 0x2000);
238 CheckSize(0x50010000, 0x2000, 0x2000);
239 CheckSize(0x5000FFFF, 0x3000, 0x13000);
240 CheckSize(0x50001010, 0x7000, 0x9000);
241 CheckSize(0x50001010, 0xC000, 0xe000);
242
243 /* Reserve memory not aligned to allocation granularity */
244 BaseAddress = UlongToPtr(0x50001010);
245 Size = 0x1000;
246 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
247 &BaseAddress,
248 0,
249 &Size,
250 MEM_RESERVE,
251 PAGE_NOACCESS);
252 ok_ntstatus(Status, STATUS_SUCCESS);
253 ok(BaseAddress == UlongToPtr(0x50000000), "Got back wrong base address: %p", BaseAddress);
254 ok(Size == 0x3000, "Got back wrong size: 0x%Ix", Size);
255
256 /* Try to reserve again in the same 64k region */
257 BaseAddress = UlongToPtr(0x50008000);
258 Size = 0x1000;
259 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
260 &BaseAddress,
261 0,
262 &Size,
263 MEM_RESERVE,
264 PAGE_NOACCESS);
265 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
266
267 /* Commit memory */
268 BaseAddress = UlongToPtr(0x50002000);
269 Size = 0x1000;
270 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
271 &BaseAddress,
272 0,
273 &Size,
274 MEM_COMMIT,
275 PAGE_NOACCESS);
276 ok_ntstatus(Status, STATUS_SUCCESS);
277 ok(BaseAddress == UlongToPtr(0x50002000), "Got back wrong base address: %p", BaseAddress);
278 ok(Size == 0x1000, "Got back wrong size: 0x%Ix", Size);
279
280 /* Commit the same address again with a different protection */
281 BaseAddress = UlongToPtr(0x50002000);
282 Size = 0x1000;
283 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
284 &BaseAddress,
285 0,
286 &Size,
287 MEM_COMMIT,
288 PAGE_READWRITE);
289 ok_ntstatus(Status, STATUS_SUCCESS);
290 ok(BaseAddress == UlongToPtr(0x50002000), "Got back wrong base address: %p", BaseAddress);
291 ok(Size == 0x1000, "Got back wrong size: 0x%Ix", Size);
292
293 /* Commit memory at a too high address */
294 BaseAddress = UlongToPtr(0x50003000);
295 Size = 0x1000;
296 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
297 &BaseAddress,
298 0,
299 &Size,
300 MEM_COMMIT,
301 PAGE_NOACCESS);
302 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
303
304 /* Decommit the memory, even those pages that were not committed */
305 BaseAddress = UlongToPtr(0x50000000);
306 Size = 0x3000;
307 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_DECOMMIT);
308 ok_ntstatus(Status, STATUS_SUCCESS);
309
310 /* Try to release memory in a different 64k region */
311 BaseAddress = UlongToPtr(0x50010000);
312 Size = 0x1000;
313 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
314 ok_ntstatus(Status, STATUS_MEMORY_NOT_ALLOCATED);
315
316 /* Release the memory in the same 64k region at a different address */
317 BaseAddress = UlongToPtr(0x50008000);
318 Size = 0x1000;
319 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
320 ok_ntstatus(Status, STATUS_MEMORY_NOT_ALLOCATED);
321
322 /* Release the memory at the correct address but with wrong size */
323 BaseAddress = UlongToPtr(0x50000000);
324 Size = 0x4000;
325 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
326 ok_ntstatus(Status, STATUS_UNABLE_TO_FREE_VM);
327
328 /* Release the memory */
329 BaseAddress = UlongToPtr(0x50000000);
330 Size = 0x3000;
331 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
332 ok_ntstatus(Status, STATUS_SUCCESS);
333
334 /* Reserve and commit at once */
335 BaseAddress = UlongToPtr(0x50004080);
336 Size = 0x1000;
337 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
338 &BaseAddress,
339 0,
340 &Size,
341 MEM_RESERVE | MEM_COMMIT,
342 PAGE_READWRITE);
343 ok_ntstatus(Status, STATUS_SUCCESS);
344 ok(BaseAddress == UlongToPtr(0x50000000), "Got back wrong base address: %p", BaseAddress);
345 ok(Size == 0x6000, "Got back wrong size: 0x%Ix", Size);
346
347 _SEH2_TRY
348 {
349 *(int*)BaseAddress = 1;
350 *(int*)UlongToPtr(0x50004080) = 1;
351 }
352 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
353 {
354 ok(0, "Got exception\n");
355 }
356 _SEH2_END;
357
358 /* Release the memory */
359 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
360 ok_ntstatus(Status, STATUS_SUCCESS);
361
362}
363
364static
365VOID
366CheckAdjacentVADs()
367{
368 NTSTATUS Status;
369 PVOID BaseAddress;
370 SIZE_T Size;
371 MEMORY_BASIC_INFORMATION MemoryBasicInfo;
372
373 /* Reserve a full 64k region */
374 BaseAddress = UlongToPtr(0x50000000);
375 Size = 0x10000;
376 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
377 &BaseAddress,
378 0,
379 &Size,
380 MEM_RESERVE,
381 PAGE_NOACCESS);
382 ok_ntstatus(Status, STATUS_SUCCESS);
383 if (!NT_SUCCESS(Status))
384 return;
385
386 /* Reserve another 64k region, but with 64k between */
387 BaseAddress = UlongToPtr(0x50020000);
388 Size = 0x10000;
389 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
390 &BaseAddress,
391 0,
392 &Size,
393 MEM_RESERVE,
394 PAGE_NOACCESS);
395 ok_ntstatus(Status, STATUS_SUCCESS);
396 if (!NT_SUCCESS(Status))
397 return;
398
399 /* Try to free the whole at once */
400 BaseAddress = UlongToPtr(0x50000000);
401 Size = 0x30000;
402 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
403 ok_ntstatus(Status, STATUS_UNABLE_TO_FREE_VM);
404
405 /* Reserve the part in the middle */
406 BaseAddress = UlongToPtr(0x50010000);
407 Size = 0x10000;
408 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
409 &BaseAddress,
410 0,
411 &Size,
412 MEM_RESERVE,
413 PAGE_NOACCESS);
414 ok_ntstatus(Status, STATUS_SUCCESS);
415
416 /* Try to commit memory covering 2 allocations */
417 BaseAddress = UlongToPtr(0x50004000);
418 Size = 0x10000;
419 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
420 &BaseAddress,
421 0,
422 &Size,
423 MEM_COMMIT,
424 PAGE_NOACCESS);
425 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
426
427 /* Commit a page */
428 BaseAddress = UlongToPtr(0x50000000);
429 Size = 0x1000;
430 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
431 &BaseAddress,
432 0,
433 &Size,
434 MEM_COMMIT,
435 PAGE_READWRITE);
436 ok_ntstatus(Status, STATUS_SUCCESS);
437
438 /* Commit another page */
439 BaseAddress = UlongToPtr(0x50002000);
440 Size = 0x1000;
441 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
442 &BaseAddress,
443 0,
444 &Size,
445 MEM_COMMIT,
446 PAGE_NOACCESS);
447 ok_ntstatus(Status, STATUS_SUCCESS);
448
449 _SEH2_TRY
450 {
451 *(int*)UlongToPtr(0x50000000) = 1;
452 }
453 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
454 {
455 ok(0, "Got exception\n");
456 }
457 _SEH2_END;
458
459 _SEH2_TRY
460 {
461 (void)*(volatile int*)UlongToPtr(0x50002000);
462 }
463 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
464 {
465 Status = _SEH2_GetExceptionCode();
466 }
467 _SEH2_END;
468 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
469
470 /* Allocate 3 pages, on top of the previous 2 */
471 BaseAddress = UlongToPtr(0x50000000);
472 Size = 0x3000;
473 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
474 &BaseAddress,
475 0,
476 &Size,
477 MEM_COMMIT,
478 PAGE_READONLY);
479 ok_ntstatus(Status, STATUS_SUCCESS);
480
481 _SEH2_TRY
482 {
483 *(int*)UlongToPtr(0x50000000) = 1;
484 }
485 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
486 {
487 Status = _SEH2_GetExceptionCode();
488 }
489 _SEH2_END;
490 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
491
492 /* Commit a page at the end of the first region */
493 BaseAddress = UlongToPtr(0x5000F000);
494 Size = 0x1000;
495 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
496 &BaseAddress,
497 0,
498 &Size,
499 MEM_COMMIT,
500 PAGE_READWRITE);
501 ok_ntstatus(Status, STATUS_SUCCESS);
502 ok_ptr(BaseAddress, UlongToPtr(0x5000F000));
503
504 /* See where is the base of this newly committed area
505 * (choose a base address in the middle of it) */
506 Status = NtQueryVirtualMemory(NtCurrentProcess(),
507 UlongToPtr(0x5000F700),
508 MemoryBasicInformation,
509 &MemoryBasicInfo,
510 sizeof(MemoryBasicInfo),
511 NULL);
512 ok_ntstatus(Status, STATUS_SUCCESS);
513 /* The base address is the beginning of the committed area */
514 ok_ptr(MemoryBasicInfo.BaseAddress, UlongToPtr(0x5000F000));
515 /* The allocation base address is the beginning of the whole region */
516 ok_ptr(MemoryBasicInfo.AllocationBase, UlongToPtr(0x50000000));
517 /* This is the protection of the memory when it was reserved. */
518 ok_long(MemoryBasicInfo.AllocationProtect, PAGE_NOACCESS);
519 /* This is the size of the committed region. (ie, smallest chunk size) */
520 ok_long(MemoryBasicInfo.RegionSize, 0x1000);
521 /* This is the state of the queried address */
522 ok_long(MemoryBasicInfo.State, MEM_COMMIT);
523 /* This is the protection of the queried address */
524 ok_long(MemoryBasicInfo.Protect, PAGE_READWRITE);
525 /* NtAllocateVirtualMemory makes it MEM_PRIVATE */
526 ok_long(MemoryBasicInfo.Type, MEM_PRIVATE);
527
528 /* Try to free the whole region at once */
529 BaseAddress = UlongToPtr(0x50000000);
530 Size = 0x30000;
531 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
532 ok_ntstatus(Status, STATUS_UNABLE_TO_FREE_VM);
533
534 BaseAddress = UlongToPtr(0x50000000);
535 Size = 0x10000;
536 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
537 ok_ntstatus(Status, STATUS_SUCCESS);
538
539 BaseAddress = UlongToPtr(0x50010000);
540 Size = 0x10000;
541 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
542 ok_ntstatus(Status, STATUS_SUCCESS);
543
544 BaseAddress = UlongToPtr(0x50020000);
545 Size = 0x10000;
546 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
547 ok_ntstatus(Status, STATUS_SUCCESS);
548
549 /* Reserve 3 full 64k region */
550 BaseAddress = UlongToPtr(0x50000000);
551 Size = 0x30000;
552 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
553 &BaseAddress,
554 0,
555 &Size,
556 MEM_RESERVE,
557 PAGE_NOACCESS);
558 ok_ntstatus(Status, STATUS_SUCCESS);
559 if (!NT_SUCCESS(Status))
560 return;
561
562 /* Release the 64k region in the middle */
563 BaseAddress = UlongToPtr(0x50010000);
564 Size = 0x10000;
565 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
566 ok_ntstatus(Status, STATUS_SUCCESS);
567
568}
569
570static
571VOID
572CheckSomeDefaultAddresses(VOID)
573{
574 NTSTATUS Status;
575 PVOID BaseAddress;
576 SIZE_T Size;
577
578 // NULL.
579
580 /* Reserve memory dynamically, not at 0x00000000 */
581 BaseAddress = NULL;
582 Size = 0x1000;
583 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
584 &BaseAddress,
585 0,
586 &Size,
587 MEM_RESERVE,
588 PAGE_READWRITE);
589 ok_ntstatus(Status, STATUS_SUCCESS);
590 ok(BaseAddress != 0x00000000, "Unexpected BaseAddress = 0x00000000\n");
591 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
592 ok_ntstatus(Status, STATUS_SUCCESS);
593
594 /* Try to reserve memory at the shared user page */
595 BaseAddress = (PVOID)USER_SHARED_DATA;
596 Size = 0x1000;
597 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
598 &BaseAddress,
599 0,
600 &Size,
601 MEM_RESERVE,
602 PAGE_READWRITE);
603 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_VISTA) ? STATUS_CONFLICTING_ADDRESSES : STATUS_INVALID_PARAMETER_2);
604
605 /* Try to unmap the shared user page */
606 BaseAddress = (PVOID)USER_SHARED_DATA;
607 Size = 0x1000;
608 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
609 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_VISTA) ? STATUS_INVALID_PAGE_PROTECTION : STATUS_MEMORY_NOT_ALLOCATED);
610
611 // 0x00000000, 64k: Free on XP/2K3, reserved later.
612
613 /* Reserve and commit memory at 0x00000000, after round down */
614 BaseAddress = UlongToPtr(0x00000000 + 0x0FFF);
615 Size = 0x1000;
616 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
617 &BaseAddress,
618 0,
619 &Size,
620 MEM_RESERVE | MEM_COMMIT,
621 PAGE_READWRITE);
622 if (GetNTVersion() >= _WIN32_WINNT_WIN10)
623 {
624 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
625 }
626 else if (GetNTVersion() >= _WIN32_WINNT_VISTA)
627 {
628 ok_ntstatus(Status, STATUS_INVALID_PARAMETER_2);
629 }
630 else
631 {
632 ok_ntstatus(Status, GetNTVersion() >= _WIN32_WINNT_VISTA ? STATUS_INVALID_PARAMETER_2 : STATUS_SUCCESS);
633 ok_ptr(BaseAddress, 0x00000000);
634
635 // Double-check that it is not forbidden "in order to catch null pointer accesses".
636 StartSeh()
637 *(int*)UlongToPtr(0x00000000) = 1;
638 EndSeh(STATUS_SUCCESS)
639
640 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
641 ok_ntstatus(Status, STATUS_SUCCESS);
642 }
643
644 /* Reserve memory above 0x00000000 */
645 BaseAddress = UlongToPtr(0x00000000 + 0x1000);
646 Size = 0x1000;
647 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
648 &BaseAddress,
649 0,
650 &Size,
651 MEM_RESERVE,
652 PAGE_READWRITE);
653 if (GetNTVersion() >= _WIN32_WINNT_WIN10)
654 {
655 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
656 }
657 else if (GetNTVersion() >= _WIN32_WINNT_VISTA)
658 {
659 ok_ntstatus(Status, STATUS_INVALID_PARAMETER_2);
660 }
661 else
662 {
663 ok_ntstatus(Status, STATUS_SUCCESS);
664 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
665 ok_ntstatus(Status, STATUS_SUCCESS);
666 }
667
668 // 0x00010000, 4k: Private Data.
669 // 0x00011000, 60k: Unusable.
670
671 /* Reserve memory below 0x00010000 */
672 BaseAddress = UlongToPtr(0x00010000 - 0x1000);
673 Size = 0x1000;
674 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
675 &BaseAddress,
676 0,
677 &Size,
678 MEM_RESERVE,
679 PAGE_READWRITE);
680 if (GetNTVersion() >= _WIN32_WINNT_WIN10)
681 {
682 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
683 }
684 else if (GetNTVersion() >= _WIN32_WINNT_VISTA)
685 {
686 ok_ntstatus(Status, STATUS_INVALID_PARAMETER_2);
687 }
688 else
689 {
690 ok_ntstatus(Status, STATUS_SUCCESS);
691 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
692 ok_ntstatus(Status, STATUS_SUCCESS);
693 }
694
695 /* The following checks assume very default addresses,
696 * no address space layout randomization (ASLR). */
697 if (GetNTVersion() >= _WIN32_WINNT_VISTA)
698 {
699 skip("Skipping default address checks on Vista+\n");
700 }
701 else
702 {
703
704 /* Reserve memory at 0x00010000:
705 * Windows NT legacy default executable image base */
706 BaseAddress = UlongToPtr(0x00010000);
707 Size = 0x1000;
708 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
709 &BaseAddress,
710 0,
711 &Size,
712 MEM_RESERVE,
713 PAGE_READWRITE);
714 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
715 if (NT_SUCCESS(Status))
716 { // Unexpected, cleanup.
717 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
718 ok_ntstatus(Status, STATUS_SUCCESS);
719 }
720
721 // 0x00400000: Image base.
722
723 /* Reserve memory below 0x00400000 */
724 BaseAddress = UlongToPtr(0x00400000 - 0x1000);
725 Size = 0x1000;
726 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
727 &BaseAddress,
728 0,
729 &Size,
730 MEM_RESERVE,
731 PAGE_READWRITE);
732 if (NT_SUCCESS(Status))
733 {
734 trace("Below 0x00400000 is available, as on ReactOS and Windows S03\n");
735 // 0x003F0000, 64k: Free.
736 ok_ntstatus(Status, STATUS_SUCCESS);
737 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
738 ok_ntstatus(Status, STATUS_SUCCESS);
739 }
740 else
741 {
742 trace("Below 0x00400000 is not available, as on Windows XP\n");
743 // 0x003F0000, 4k: Shareable.
744 // 0x003F1000, 60k: Unusable.
745 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
746 }
747
748 /* Reserve memory at 0x00400000:
749 * Windows NT legacy default DLL image base,
750 * (ReactOS and) Windows 95 new default executable image base */
751 BaseAddress = UlongToPtr(0x00400000);
752 Size = 0x1000;
753 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
754 &BaseAddress,
755 0,
756 &Size,
757 MEM_RESERVE,
758 PAGE_READWRITE);
759 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
760 if (NT_SUCCESS(Status))
761 { // Unexpected, cleanup.
762 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
763 ok_ntstatus(Status, STATUS_SUCCESS);
764 }
765
766 // 0x10000000: Free.
767
768 /* Reserve memory below 0x10000000 */
769 BaseAddress = UlongToPtr(0x10000000 - 0x1000);
770 Size = 0x1000;
771 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
772 &BaseAddress,
773 0,
774 &Size,
775 MEM_RESERVE,
776 PAGE_READWRITE);
777 ok_ntstatus(Status, STATUS_SUCCESS);
778 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
779 ok_ntstatus(Status, STATUS_SUCCESS);
780
781 /* Reserve memory at 0x10000000:
782 * Windows new default non-OS DLL image base */
783 BaseAddress = UlongToPtr(0x10000000);
784 Size = 0x1000;
785 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
786 &BaseAddress,
787 0,
788 &Size,
789 MEM_RESERVE,
790 PAGE_READWRITE);
791 ok_ntstatus(Status, STATUS_SUCCESS);
792 Status = NtFreeVirtualMemory(NtCurrentProcess(), &BaseAddress, &Size, MEM_RELEASE);
793 ok_ntstatus(Status, STATUS_SUCCESS);
794 }
795}
796
797#define RUNS 32
798
799START_TEST(NtAllocateVirtualMemory)
800{
801 PVOID Mem1, Mem2;
802 SIZE_T Size1, Size2;
803 ULONG i;
804
805 CheckAlignment();
806 CheckAdjacentVADs();
807 CheckSomeDefaultAddresses();
808
809 Size1 = 32;
810 Mem1 = Allocate(Size1);
811 AccessMemory1(Mem1, Size1);
812 Size2 = 128;
813 Mem2 = Allocate(Size2);
814 AccessMemory2(Mem2, Size2);
815 for (i = 0; i < RUNS; ++i)
816 {
817 PVOID New;
818 ok(CheckMemory1(Mem1, Size1) == TRUE, "CheckMemory1 failure\n");
819 New = ReAllocate(Mem1, Size1 * 3 / 2);
820 if (New == NULL)
821 {
822 skip("Realloc failure\n");
823 break;
824 }
825 Mem1 = New;
826 ok(CheckMemory1(Mem1, Size1) == TRUE, "CheckMemory1 failure\n");
827 Size1 = Size1 * 3 / 2;
828 AccessMemory1(Mem1, Size1);
829
830 ok(CheckMemory2(Mem2, Size2) == TRUE, "CheckMemory2 failure\n");
831 New = ReAllocate(Mem2, Size2 + 128);
832 if (New == NULL)
833 {
834 skip("Realloc failure\n");
835 break;
836 }
837 Mem2 = New;
838 ok(CheckMemory2(Mem2, Size2) == TRUE, "CheckMemory2 failure\n");
839 Size2 += 128;
840 AccessMemory2(Mem2, Size2);
841 }
842 ok(CheckMemory2(Mem2, Size2) == TRUE, "CheckMemory2 failure\n");
843 Free(Mem2);
844 ok(CheckMemory1(Mem1, Size1) == TRUE, "CheckMemory1 failure\n");
845 Free(Mem1);
846}
CheckSize
VOID CheckSize(ULONG_PTR Base, SIZE_T InSize, SIZE_T ExpectedSize)
Definition: NtAllocateVirtualMemory.c:206
ValidateAllocations
static VOID ValidateAllocations(VOID)
Definition: NtAllocateVirtualMemory.c:20
AccessMemory1
static VOID AccessMemory1(PVOID UserBuffer, SIZE_T DataSize)
Definition: NtAllocateVirtualMemory.c:143
CheckMemory2
static BOOLEAN CheckMemory2(PVOID UserBuffer, SIZE_T DataSize)
Definition: NtAllocateVirtualMemory.c:188
CheckAdjacentVADs
static VOID CheckAdjacentVADs()
Definition: NtAllocateVirtualMemory.c:366
CurrentAllocation
static ULONG CurrentAllocation
Definition: NtAllocateVirtualMemory.c:16
RUNS
#define RUNS
Definition: NtAllocateVirtualMemory.c:797
AccessMemory2
static VOID AccessMemory2(PVOID UserBuffer, SIZE_T DataSize)
Definition: NtAllocateVirtualMemory.c:175
CheckMemory1
static BOOLEAN CheckMemory1(PVOID UserBuffer, SIZE_T DataSize)
Definition: NtAllocateVirtualMemory.c:156
Allocations
static PVOID Allocations[4096]
Definition: NtAllocateVirtualMemory.c:15
ReAllocate
static PVOID ReAllocate(PVOID OldUserBuffer, SIZE_T NewDataSize)
Definition: NtAllocateVirtualMemory.c:123
CheckAlignment
VOID CheckAlignment()
Definition: NtAllocateVirtualMemory.c:229
CheckSomeDefaultAddresses
static VOID CheckSomeDefaultAddresses(VOID)
Definition: NtAllocateVirtualMemory.c:572
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17
StartSeh
#define StartSeh()
Definition: apitest.h:93
EndSeh
#define EndSeh(ExpectedStatus)
Definition: apitest.h:99
ok_ntstatus
#define ok_ntstatus(status, expected)
Definition: atltest.h:135
ok_long
#define ok_long(expression, result)
Definition: atltest.h:133
trace
#define trace
Definition: atltest.h:70
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ok_ptr
#define ok_ptr(expression, result)
Definition: atltest.h:108
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
Buffer
Definition: bufpool.h:45
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
PAGE_READONLY
#define PAGE_READONLY
Definition: compat.h:138
UCHAR_MAX
#define UCHAR_MAX
Definition: limits.h:11
UlongToPtr
#define UlongToPtr(u)
Definition: config.h:106
PAGE_SIZE
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Zero
IN PVCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN IN BOOLEAN Zero
Definition: fatprocs.h:419
AllocationSize
IN PFCB IN PFILE_OBJECT FileObject IN ULONG AllocationSize
Definition: fatprocs.h:323
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
Status
Status
Definition: gdiplustypes.h:25
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
USER_SHARED_DATA
#define USER_SHARED_DATA
Definition: pstypes.h:51
RtlFillMemory
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:603
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
LOBYTE
#define LOBYTE(W)
Definition: jmemdos.c:487
ASSERT
#define ASSERT(a)
Definition: mode.c:44
min
#define min(a, b)
Definition: monoChain.cc:55
DataSize
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4755
BaseAddress
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
MemoryBasicInformation
@ MemoryBasicInformation
Definition: mmtypes.h:183
PAGE_ROUND_UP
#define PAGE_ROUND_UP(x)
Definition: mmtypes.h:38
Base
_In_opt_ ULONG Base
Definition: rtlfuncs.h:2486
MEM_DECOMMIT
#define MEM_DECOMMIT
Definition: nt_native.h:1318
PAGE_READWRITE
#define PAGE_READWRITE
Definition: nt_native.h:1307
MEM_PRIVATE
#define MEM_PRIVATE
Definition: nt_native.h:1321
NtCurrentProcess
#define NtCurrentProcess()
Definition: nt_native.h:1660
MEM_RESERVE
#define MEM_RESERVE
Definition: nt_native.h:1317
MEM_RELEASE
#define MEM_RELEASE
Definition: nt_native.h:1319
MEM_COMMIT
#define MEM_COMMIT
Definition: nt_native.h:1316
PAGE_NOACCESS
#define PAGE_NOACCESS
Definition: nt_native.h:1305
NtFreeVirtualMemory
NTSTATUS NTAPI NtFreeVirtualMemory(IN HANDLE ProcessHandle, IN PVOID *UBaseAddress, IN PSIZE_T URegionSize, IN ULONG FreeType)
Definition: virtual.c:5192
NtQueryVirtualMemory
NTSTATUS NTAPI NtQueryVirtualMemory(IN HANDLE ProcessHandle, IN PVOID BaseAddress, IN MEMORY_INFORMATION_CLASS MemoryInformationClass, OUT PVOID MemoryInformation, IN SIZE_T MemoryInformationLength, OUT PSIZE_T ReturnLength)
Definition: virtual.c:4374
NtAllocateVirtualMemory
NTSTATUS NTAPI NtAllocateVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UBaseAddress, IN ULONG_PTR ZeroBits, IN OUT PSIZE_T URegionSize, IN ULONG AllocationType, IN ULONG Protect)
Definition: virtual.c:4457
STATUS_UNABLE_TO_FREE_VM
#define STATUS_UNABLE_TO_FREE_VM
Definition: ntstatus.h:356
STATUS_MEMORY_NOT_ALLOCATED
#define STATUS_MEMORY_NOT_ALLOCATED
Definition: ntstatus.h:490
STATUS_INVALID_PARAMETER_2
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:570
STATUS_CONFLICTING_ADDRESSES
#define STATUS_CONFLICTING_ADDRESSES
Definition: ntstatus.h:354
STATUS_INVALID_PAGE_PROTECTION
#define STATUS_INVALID_PAGE_PROTECTION
Definition: ntstatus.h:399
PBYTE
BYTE * PBYTE
Definition: pedump.c:66
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71
_WIN32_WINNT_WIN10
#define _WIN32_WINNT_WIN10
Definition: sdkddkver.h:32
_WIN32_WINNT_VISTA
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_MEMORY_BASIC_INFORMATION
Definition: mmtypes.h:971
_MEMORY_BASIC_INFORMATION::RegionSize
SIZE_T RegionSize
Definition: mmtypes.h:975
_MEMORY_BASIC_INFORMATION::AllocationBase
PVOID AllocationBase
Definition: mmtypes.h:973
_MEMORY_BASIC_INFORMATION::AllocationProtect
ULONG AllocationProtect
Definition: mmtypes.h:974
_MEMORY_BASIC_INFORMATION::State
ULONG State
Definition: mmtypes.h:976
_MEMORY_BASIC_INFORMATION::Type
ULONG Type
Definition: mmtypes.h:978
_MEMORY_BASIC_INFORMATION::BaseAddress
PVOID BaseAddress
Definition: mmtypes.h:972
_MEMORY_BASIC_INFORMATION::Protect
ULONG Protect
Definition: mmtypes.h:977
PSIZE_T
ULONG_PTR * PSIZE_T
Definition: typedefs.h:80
PVOID
void * PVOID
Definition: typedefs.h:50
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
ULONG
uint32_t ULONG
Definition: typedefs.h:59
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4539
Allocate
_In_opt_ PALLOCATE_FUNCTION Allocate
Definition: exfuncs.h:814
Free
_In_opt_ PALLOCATE_FUNCTION _In_opt_ PFREE_FUNCTION Free
Definition: exfuncs.h:815
RtlCompareMemoryUlong
_Must_inspect_result_ NTSYSAPI SIZE_T NTAPI RtlCompareMemoryUlong(_In_reads_bytes_(Length) PVOID Source, _In_ SIZE_T Length, _In_ ULONG Pattern)