modules/rostests/apitests/ntdll/NtFreeVirtualMemory.c

   1 /*
   2  * PROJECT:     ReactOS API Tests
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     Test for NtFreeVirtualMemory
   5  * COPYRIGHT:   Copyright 2011 Jérôme Gardou <jerome.gardou@reactos.org>
   6  */
   7
   8 #include "precomp.h"
   9
  10 static void Test_NtFreeVirtualMemory(void)
  11 {
  12     PVOID Buffer = NULL, Buffer2;
  13     SIZE_T Length = PAGE_SIZE;
  14     NTSTATUS Status;
  15
  16     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
  17                                      &Buffer,
  18                                      0,
  19                                      &Length,
  20                                      MEM_RESERVE,
  21                                      PAGE_READWRITE);
  22     ok(NT_SUCCESS(Status), "NtAllocateVirtualMemory failed : 0x%08lx\n", Status);
  23     ok(Length == PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
  24     ok(((ULONG_PTR)Buffer % PAGE_SIZE) == 0, "The buffer is not aligned to PAGE_SIZE.\n");
  25
  26     Status = NtFreeVirtualMemory(NtCurrentProcess(),
  27                                  &Buffer,
  28                                  &Length,
  29                                  MEM_DECOMMIT);
  30     ok(Status == STATUS_SUCCESS, "NtFreeVirtualMemory failed : 0x%08lx\n", Status);
  31
  32     /* Now try to free more than we got */
  33     Length++;
  34     Status = NtFreeVirtualMemory(NtCurrentProcess(),
  35                                  &Buffer,
  36                                  &Length,
  37                                  MEM_DECOMMIT);
  38     ok(Status == STATUS_UNABLE_TO_FREE_VM, "NtFreeVirtualMemory returned status : 0x%08lx\n", Status);
  39
  40     Status = NtFreeVirtualMemory(NtCurrentProcess(),
  41                                  &Buffer,
  42                                  &Length,
  43                                  MEM_RELEASE);
  44     ok(Status == STATUS_UNABLE_TO_FREE_VM, "NtFreeVirtualMemory returned status : 0x%08lx\n", Status);
  45
  46     /* Free out of bounds from the wrong origin */
  47     Length = PAGE_SIZE;
  48     Buffer2 = (PVOID)((ULONG_PTR)Buffer+1);
  49
  50     Status = NtFreeVirtualMemory(NtCurrentProcess(),
  51                                  &Buffer2,
  52                                  &Length,
  53                                  MEM_DECOMMIT);
  54     ok(Status == STATUS_UNABLE_TO_FREE_VM, "NtFreeVirtualMemory returned status : 0x%08lx\n", Status);
  55
  56     Buffer2 = (PVOID)((ULONG_PTR)Buffer+1);
  57     Length = PAGE_SIZE;
  58     Status = NtFreeVirtualMemory(NtCurrentProcess(),
  59                                  &Buffer2,
  60                                  &Length,
  61                                  MEM_RELEASE);
  62     ok(Status == STATUS_UNABLE_TO_FREE_VM, "NtFreeVirtualMemory returned status : 0x%08lx\n", Status);
  63
  64     /* Same but in bounds */
  65     Length = PAGE_SIZE - 1;
  66     Buffer2 = (PVOID)((ULONG_PTR)Buffer+1);
  67
  68     Status = NtFreeVirtualMemory(NtCurrentProcess(),
  69                                  &Buffer2,
  70                                  &Length,
  71                                  MEM_DECOMMIT);
  72     ok(Status == STATUS_SUCCESS, "NtFreeVirtualMemory returned status : 0x%08lx\n", Status);
  73     ok(Buffer2 == Buffer, "NtFreeVirtualMemory set wrong buffer.\n");
  74     ok(Length == PAGE_SIZE, "NtFreeVirtualMemory did not round Length to PAGE_SIZE.\n");
  75
  76     Buffer2 = (PVOID)((ULONG_PTR)Buffer+1);
  77     Length = PAGE_SIZE-1;
  78     Status = NtFreeVirtualMemory(NtCurrentProcess(),
  79                                  &Buffer2,
  80                                  &Length,
  81                                  MEM_RELEASE);
  82     ok(Status == STATUS_SUCCESS, "NtFreeVirtualMemory returned status : 0x%08lx\n", Status);
  83     ok(Buffer2 == Buffer, "NtFreeVirtualMemory set wrong buffer.\n");
  84     ok(Length == PAGE_SIZE, "NtFreeVirtualMemory did not round Length to PAGE_SIZE.\n");
  85
  86     /* Now allocate two pages and try to free them one after the other */
  87     Length = 2*PAGE_SIZE;
  88     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
  89                                      &Buffer,
  90                                      0,
  91                                      &Length,
  92                                      MEM_RESERVE,
  93                                      PAGE_READWRITE);
  94     ok(NT_SUCCESS(Status), "NtAllocateVirtualMemory failed : 0x%08lx\n", Status);
  95     ok(Length == 2*PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
  96     ok(((ULONG_PTR)Buffer % PAGE_SIZE) == 0, "The buffer is not aligned to PAGE_SIZE.\n");
  97
  98     Buffer2 = Buffer;
  99     Length = PAGE_SIZE;
 100     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 101                                  &Buffer2,
 102                                  &Length,
 103                                  MEM_RELEASE);
 104     ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed : 0x%08lx\n", Status);
 105     ok(Length == PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
 106     ok(Buffer2 == Buffer, "The buffer is not aligned to PAGE_SIZE.\n");
 107
 108     Buffer2 = (PVOID)((ULONG_PTR)Buffer+PAGE_SIZE);
 109     Length = PAGE_SIZE;
 110     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 111                                  &Buffer2,
 112                                  &Length,
 113                                  MEM_RELEASE);
 114     ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed : 0x%08lx\n", Status);
 115     ok(Length == PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
 116     ok(Buffer2 == (PVOID)((ULONG_PTR)Buffer+PAGE_SIZE), "The buffer is not aligned to PAGE_SIZE.\n");
 117
 118     /* Same, but try to free the second page before the first one */
 119     Length = 2*PAGE_SIZE;
 120     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 121                                      &Buffer,
 122                                      0,
 123                                      &Length,
 124                                      MEM_RESERVE,
 125                                      PAGE_READWRITE);
 126     ok(NT_SUCCESS(Status), "NtAllocateVirtualMemory failed : 0x%08lx\n", Status);
 127     ok(Length == 2*PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
 128     ok(((ULONG_PTR)Buffer % PAGE_SIZE) == 0, "The buffer is not aligned to PAGE_SIZE.\n");
 129
 130     Buffer2 = (PVOID)((ULONG_PTR)Buffer+PAGE_SIZE);
 131     Length = PAGE_SIZE;
 132     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 133                                  &Buffer2,
 134                                  &Length,
 135                                  MEM_RELEASE);
 136     ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed : 0x%08lx\n", Status);
 137     ok(Length == PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
 138     ok(Buffer2 == (PVOID)((ULONG_PTR)Buffer+PAGE_SIZE), "The buffer is not aligned to PAGE_SIZE.\n");
 139
 140     Buffer2 = Buffer;
 141     Length = PAGE_SIZE;
 142     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 143                                  &Buffer2,
 144                                  &Length,
 145                                  MEM_RELEASE);
 146     ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed : 0x%08lx\n", Status);
 147     ok(Length == PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
 148     ok(Buffer2 == Buffer, "The buffer is not aligned to PAGE_SIZE.\n");
 149
 150     /* Now allocate two pages and try to free them in the middle */
 151     Length = 2*PAGE_SIZE;
 152     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 153                                      &Buffer,
 154                                      0,
 155                                      &Length,
 156                                      MEM_RESERVE,
 157                                      PAGE_READWRITE);
 158     ok(NT_SUCCESS(Status), "NtAllocateVirtualMemory failed : 0x%08lx\n", Status);
 159     ok(Length == 2*PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
 160     ok(((ULONG_PTR)Buffer % PAGE_SIZE) == 0, "The buffer is not aligned to PAGE_SIZE.\n");
 161
 162     Buffer2 = (PVOID)((ULONG_PTR)Buffer+1);
 163     Length = PAGE_SIZE;
 164     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 165                                  &Buffer2,
 166                                  &Length,
 167                                  MEM_RELEASE);
 168     ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed : 0x%08lx\n", Status);
 169     ok(Length == 2*PAGE_SIZE, "Length mismatch : 0x%08lx\n", (ULONG)Length);
 170     ok(Buffer2 == Buffer, "The buffer is not aligned to PAGE_SIZE.\n");
 171 }
 172
 173 START_TEST(NtFreeVirtualMemory)
 174 {
 175     Test_NtFreeVirtualMemory();
 176 }