- Update to r53061
[reactos.git] / dll / win32 / kernel32 / client / virtmem.c
1 /*
2 * PROJECT: ReactOS Win32 Base API
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/win32/kernel32/client/virtmem.c
5 * PURPOSE: Handles virtual memory APIs
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include <k32.h>
12
13 #define NDEBUG
14 #include <debug.h>
15
16 /* FUNCTIONS ******************************************************************/
17
18 /*
19 * @implemented
20 */
21 LPVOID
22 NTAPI
23 VirtualAllocEx(IN HANDLE hProcess,
24 IN LPVOID lpAddress,
25 IN SIZE_T dwSize,
26 IN DWORD flAllocationType,
27 IN DWORD flProtect)
28 {
29 NTSTATUS Status;
30
31 /* Make sure the address is within the granularity of the system (64K) */
32 if ((lpAddress) &&
33 (lpAddress < (PVOID)BaseStaticServerData->SysInfo.AllocationGranularity))
34 {
35 /* Fail the call */
36 SetLastError(ERROR_INVALID_PARAMETER);
37 return NULL;
38 }
39
40 /* Handle any possible exceptions */
41 _SEH2_TRY
42 {
43 /* Allocate the memory */
44 Status = NtAllocateVirtualMemory(hProcess,
45 &lpAddress,
46 0,
47 &dwSize,
48 flAllocationType,
49 flProtect);
50 }
51 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
52 {
53 Status = _SEH2_GetExceptionCode();
54 }
55 _SEH2_END;
56
57 /* Check for status */
58 if (!NT_SUCCESS(Status))
59 {
60 /* We failed */
61 BaseSetLastNTError(Status);
62 return NULL;
63 }
64
65 /* Return the allocated address */
66 return lpAddress;
67 }
68
69 /*
70 * @implemented
71 */
72 LPVOID
73 NTAPI
74 VirtualAlloc(IN LPVOID lpAddress,
75 IN SIZE_T dwSize,
76 IN DWORD flAllocationType,
77 IN DWORD flProtect)
78 {
79 /* Call the extended API */
80 return VirtualAllocEx(GetCurrentProcess(),
81 lpAddress,
82 dwSize,
83 flAllocationType,
84 flProtect);
85 }
86
87 /*
88 * @implemented
89 */
90 BOOL
91 NTAPI
92 VirtualFreeEx(IN HANDLE hProcess,
93 IN LPVOID lpAddress,
94 IN SIZE_T dwSize,
95 IN DWORD dwFreeType)
96 {
97 NTSTATUS Status;
98
99 /* Validate size and flags */
100 if (!(dwSize) || !(dwFreeType & MEM_RELEASE))
101 {
102 /* Free the memory */
103 Status = NtFreeVirtualMemory(hProcess,
104 &lpAddress,
105 &dwSize,
106 dwFreeType);
107 if (!NT_SUCCESS(Status))
108 {
109 /* We failed */
110 BaseSetLastNTError(Status);
111 return FALSE;
112 }
113
114 /* Return success */
115 return TRUE;
116 }
117
118 /* Invalid combo */
119 BaseSetLastNTError(STATUS_INVALID_PARAMETER);
120 return FALSE;
121 }
122
123 /*
124 * @implemented
125 */
126 BOOL
127 NTAPI
128 VirtualFree(IN LPVOID lpAddress,
129 IN SIZE_T dwSize,
130 IN DWORD dwFreeType)
131 {
132 /* Call the extended API */
133 return VirtualFreeEx(GetCurrentProcess(),
134 lpAddress,
135 dwSize,
136 dwFreeType);
137 }
138
139 /*
140 * @implemented
141 */
142 BOOL
143 NTAPI
144 VirtualProtect(IN LPVOID lpAddress,
145 IN SIZE_T dwSize,
146 IN DWORD flNewProtect,
147 OUT PDWORD lpflOldProtect)
148 {
149 /* Call the extended API */
150 return VirtualProtectEx(GetCurrentProcess(),
151 lpAddress,
152 dwSize,
153 flNewProtect,
154 lpflOldProtect);
155 }
156
157 /*
158 * @implemented
159 */
160 BOOL
161 NTAPI
162 VirtualProtectEx(IN HANDLE hProcess,
163 IN LPVOID lpAddress,
164 IN SIZE_T dwSize,
165 IN DWORD flNewProtect,
166 OUT PDWORD lpflOldProtect)
167 {
168 NTSTATUS Status;
169
170 /* Change the protection */
171 Status = NtProtectVirtualMemory(hProcess,
172 &lpAddress,
173 &dwSize,
174 flNewProtect,
175 (PULONG)lpflOldProtect);
176 if (!NT_SUCCESS(Status))
177 {
178 /* We failed */
179 BaseSetLastNTError(Status);
180 return FALSE;
181 }
182
183 /* Return success */
184 return TRUE;
185 }
186
187 /*
188 * @implemented
189 */
190 BOOL
191 NTAPI
192 VirtualLock(IN LPVOID lpAddress,
193 IN SIZE_T dwSize)
194 {
195 NTSTATUS Status;
196 ULONG RegionSize = dwSize;
197 PVOID BaseAddress = lpAddress;
198
199 /* Lock the memory */
200 Status = NtLockVirtualMemory(NtCurrentProcess(),
201 &BaseAddress,
202 &RegionSize,
203 MAP_PROCESS);
204 if (!NT_SUCCESS(Status))
205 {
206 /* We failed */
207 BaseSetLastNTError(Status);
208 return FALSE;
209 }
210
211 /* Return success */
212 return TRUE;
213 }
214
215 /*
216 * @implemented
217 */
218 DWORD
219 NTAPI
220 VirtualQuery(IN LPCVOID lpAddress,
221 OUT PMEMORY_BASIC_INFORMATION lpBuffer,
222 IN SIZE_T dwLength)
223 {
224 /* Call the extended API */
225 return VirtualQueryEx(NtCurrentProcess(),
226 lpAddress,
227 lpBuffer,
228 dwLength);
229 }
230
231 /*
232 * @implemented
233 */
234 DWORD
235 NTAPI
236 VirtualQueryEx(IN HANDLE hProcess,
237 IN LPCVOID lpAddress,
238 OUT PMEMORY_BASIC_INFORMATION lpBuffer,
239 IN SIZE_T dwLength)
240 {
241 NTSTATUS Status;
242 ULONG ResultLength;
243
244 /* Query basic information */
245 Status = NtQueryVirtualMemory(hProcess,
246 (LPVOID)lpAddress,
247 MemoryBasicInformation,
248 lpBuffer,
249 dwLength,
250 &ResultLength);
251 if (!NT_SUCCESS(Status))
252 {
253 /* We failed */
254 BaseSetLastNTError(Status);
255 return 0;
256 }
257
258 /* Return the length returned */
259 return ResultLength;
260 }
261
262 /*
263 * @implemented
264 */
265 BOOL
266 NTAPI
267 VirtualUnlock(IN LPVOID lpAddress,
268 IN SIZE_T dwSize)
269 {
270 NTSTATUS Status;
271 ULONG RegionSize = dwSize;
272 PVOID BaseAddress = lpAddress;
273
274 /* Lock the memory */
275 Status = NtUnlockVirtualMemory(NtCurrentProcess(),
276 &BaseAddress,
277 &RegionSize,
278 MAP_PROCESS);
279 if (!NT_SUCCESS(Status))
280 {
281 /* We failed */
282 BaseSetLastNTError(Status);
283 return FALSE;
284 }
285
286 /* Return success */
287 return TRUE;
288 }
289
290 /*
291 * @implemented
292 */
293 UINT
294 WINAPI
295 GetWriteWatch(IN DWORD dwFlags,
296 IN PVOID lpBaseAddress,
297 IN SIZE_T dwRegionSize,
298 IN PVOID *lpAddresses,
299 OUT PULONG_PTR lpdwCount,
300 OUT PULONG lpdwGranularity)
301 {
302 NTSTATUS Status;
303
304 Status = NtGetWriteWatch(GetCurrentProcess(),
305 dwFlags,
306 lpBaseAddress,
307 dwRegionSize,
308 lpAddresses,
309 lpdwCount,
310 lpdwGranularity);
311 if (!NT_SUCCESS(Status))
312 {
313 BaseSetLastNTError(Status);
314 return -1;
315 }
316
317 return 0;
318 }
319
320 /*
321 * @implemented
322 */
323 UINT
324 WINAPI
325 ResetWriteWatch(IN LPVOID lpBaseAddress,
326 IN SIZE_T dwRegionSize)
327 {
328 NTSTATUS Status;
329
330 Status = NtResetWriteWatch(NtCurrentProcess(),
331 lpBaseAddress,
332 dwRegionSize);
333 if (!NT_SUCCESS(Status))
334 {
335 BaseSetLastNTError(Status);
336 return -1;
337 }
338
339 return 0;
340 }
341
342 /*
343 * @implemented
344 */
345 BOOL
346 WINAPI
347 AllocateUserPhysicalPages(IN HANDLE hProcess,
348 IN PULONG_PTR NumberOfPages,
349 OUT PULONG_PTR UserPfnArray)
350 {
351 NTSTATUS Status;
352
353 Status = NtAllocateUserPhysicalPages(hProcess, NumberOfPages, UserPfnArray);
354 if (!NT_SUCCESS(Status))
355 {
356 BaseSetLastNTError(Status);
357 return FALSE;
358 }
359
360 return TRUE;
361 }
362
363 /*
364 * @implemented
365 */
366 BOOL
367 WINAPI
368 FreeUserPhysicalPages(IN HANDLE hProcess,
369 IN PULONG_PTR NumberOfPages,
370 IN PULONG_PTR PageArray)
371 {
372 NTSTATUS Status;
373
374 Status = NtFreeUserPhysicalPages(hProcess, NumberOfPages, PageArray);
375 if (!NT_SUCCESS(Status))
376 {
377 BaseSetLastNTError(Status);
378 return FALSE;
379 }
380
381 return TRUE;
382 }
383
384 /*
385 * @implemented
386 */
387 BOOL
388 WINAPI
389 MapUserPhysicalPages(IN PVOID VirtualAddress,
390 IN ULONG_PTR NumberOfPages,
391 OUT PULONG_PTR PageArray OPTIONAL)
392 {
393 NTSTATUS Status;
394
395 Status = NtMapUserPhysicalPages(VirtualAddress, NumberOfPages, PageArray);
396 if (!NT_SUCCESS(Status))
397 {
398 BaseSetLastNTError(Status);
399 return FALSE;
400 }
401
402 return TRUE;
403 }
404
405 /*
406 * @implemented
407 */
408 BOOL
409 WINAPI
410 MapUserPhysicalPagesScatter(IN PVOID *VirtualAddresses,
411 IN ULONG_PTR NumberOfPages,
412 OUT PULONG_PTR PageArray OPTIONAL)
413 {
414 NTSTATUS Status;
415
416 Status = NtMapUserPhysicalPagesScatter(VirtualAddresses,
417 NumberOfPages,
418 PageArray);
419 if (!NT_SUCCESS(Status))
420 {
421 BaseSetLastNTError(Status);
422 return FALSE;
423 }
424
425 return TRUE;
426 }
427
428 /* EOF */