2 * Win32 virtual memory functions
4 * Copyright 1997 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
28 #include <sys/types.h>
34 #define WIN32_NO_STATUS
35 #define NONAMELESSUNION
42 #include "wine/exception.h"
43 #include "wine/debug.h"
45 #include "kernel_private.h"
47 WINE_DECLARE_DEBUG_CHANNEL(seh
);
48 WINE_DECLARE_DEBUG_CHANNEL(file
);
51 /***********************************************************************
52 * VirtualAlloc (KERNEL32.@)
54 * Reserves or commits a region of pages in virtual address space.
57 * addr [I] Address of region to reserve or commit.
58 * size [I] Size of region.
59 * type [I] Type of allocation.
60 * protect [I] Type of access protection.
63 * Success: Base address of allocated region of pages.
66 LPVOID WINAPI
VirtualAlloc( LPVOID addr
, SIZE_T size
, DWORD type
, DWORD protect
)
68 return VirtualAllocEx( GetCurrentProcess(), addr
, size
, type
, protect
);
72 /***********************************************************************
73 * VirtualAllocEx (KERNEL32.@)
75 * Seems to be just as VirtualAlloc, but with process handle.
78 * hProcess [I] Handle to process to do mem operation.
79 * addr [I] Address of region to reserve or commit.
80 * size [I] Size of region.
81 * type [I] Type of allocation.
82 * protect [I] Type of access protection.
86 * Success: Base address of allocated region of pages.
89 LPVOID WINAPI
VirtualAllocEx( HANDLE hProcess
, LPVOID addr
, SIZE_T size
,
90 DWORD type
, DWORD protect
)
95 if ((status
= NtAllocateVirtualMemory( hProcess
, &ret
, 0, &size
, type
, protect
)))
97 SetLastError( RtlNtStatusToDosError(status
) );
104 /***********************************************************************
105 * VirtualFree (KERNEL32.@)
107 * Releases or decommits a region of pages in virtual address space.
110 * addr [I] Address of region of committed pages.
111 * size [I] Size of region.
112 * type [I] Type of operation.
118 BOOL WINAPI
VirtualFree( LPVOID addr
, SIZE_T size
, DWORD type
)
120 return VirtualFreeEx( GetCurrentProcess(), addr
, size
, type
);
124 /***********************************************************************
125 * VirtualFreeEx (KERNEL32.@)
127 * Releases or decommits a region of pages in virtual address space.
130 * process [I] Handle to process.
131 * addr [I] Address of region to free.
132 * size [I] Size of region.
133 * type [I] Type of operation.
139 BOOL WINAPI
VirtualFreeEx( HANDLE process
, LPVOID addr
, SIZE_T size
, DWORD type
)
141 NTSTATUS status
= NtFreeVirtualMemory( process
, &addr
, &size
, type
);
142 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
147 /***********************************************************************
148 * VirtualLock (KERNEL32.@)
150 * Locks the specified region of virtual address space.
153 * addr [I] Address of first byte of range to lock.
154 * size [I] Number of bytes in range to lock.
161 * Always returns TRUE.
164 BOOL WINAPI
VirtualLock( LPVOID addr
, SIZE_T size
)
166 NTSTATUS status
= NtLockVirtualMemory( GetCurrentProcess(), &addr
, &size
, 1 );
167 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
172 /***********************************************************************
173 * VirtualUnlock (KERNEL32.@)
175 * Unlocks a range of pages in the virtual address space.
178 * addr [I] Address of first byte of range.
179 * size [I] Number of bytes in range.
186 * Always returns TRUE.
189 BOOL WINAPI
VirtualUnlock( LPVOID addr
, SIZE_T size
)
191 NTSTATUS status
= NtUnlockVirtualMemory( GetCurrentProcess(), &addr
, &size
, 1 );
192 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
197 /***********************************************************************
198 * VirtualProtect (KERNEL32.@)
200 * Changes the access protection on a region of committed pages.
203 * addr [I] Address of region of committed pages.
204 * size [I] Size of region.
205 * new_prot [I] Desired access protection.
206 * old_prot [O] Address of variable to get old protection.
212 BOOL WINAPI
VirtualProtect( LPVOID addr
, SIZE_T size
, DWORD new_prot
, LPDWORD old_prot
)
214 return VirtualProtectEx( GetCurrentProcess(), addr
, size
, new_prot
, old_prot
);
218 /***********************************************************************
219 * VirtualProtectEx (KERNEL32.@)
221 * Changes the access protection on a region of committed pages in the
222 * virtual address space of a specified process.
225 * process [I] Handle of process.
226 * addr [I] Address of region of committed pages.
227 * size [I] Size of region.
228 * new_prot [I] Desired access protection.
229 * old_prot [O] Address of variable to get old protection.
235 BOOL WINAPI
VirtualProtectEx( HANDLE process
, LPVOID addr
, SIZE_T size
,
236 DWORD new_prot
, LPDWORD old_prot
)
241 /* Win9x allows passing NULL as old_prot while this fails on NT */
242 if (!old_prot
&& (GetVersion() & 0x80000000)) old_prot
= &prot
;
244 status
= NtProtectVirtualMemory( process
, &addr
, &size
, new_prot
, old_prot
);
245 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
250 /***********************************************************************
251 * VirtualQuery (KERNEL32.@)
253 * Provides info about a range of pages in virtual address space.
256 * addr [I] Address of region.
257 * info [O] Address of info buffer.
258 * len [I] Size of buffer.
261 * Number of bytes returned in information buffer or 0 if
262 * addr >= 0xc0000000 (kernel space).
264 SIZE_T WINAPI
VirtualQuery( LPCVOID addr
, PMEMORY_BASIC_INFORMATION info
,
267 return VirtualQueryEx( GetCurrentProcess(), addr
, info
, len
);
271 /***********************************************************************
272 * VirtualQueryEx (KERNEL32.@)
274 * Provides info about a range of pages in virtual address space of a
278 * process [I] Handle to process.
279 * addr [I] Address of region.
280 * info [O] Address of info buffer.
281 * len [I] Size of buffer.
284 * Number of bytes returned in information buffer.
286 SIZE_T WINAPI
VirtualQueryEx( HANDLE process
, LPCVOID addr
,
287 PMEMORY_BASIC_INFORMATION info
, SIZE_T len
)
292 if ((status
= NtQueryVirtualMemory( process
, addr
, MemoryBasicInformation
, info
, len
, &ret
)))
294 SetLastError( RtlNtStatusToDosError(status
) );
301 /***********************************************************************
302 * CreateFileMappingA (KERNEL32.@)
304 * Creates a named or unnamed file-mapping object for the specified file.
307 * hFile [I] Handle to the file to map.
308 * sa [I] Optional security attributes.
309 * protect [I] Protection for mapping object.
310 * size_high [I] High-order 32 bits of object size.
311 * size_low [I] Low-order 32 bits of object size.
312 * name [I] Name of file-mapping object.
316 * Failure: NULL. Mapping object does not exist.
318 HANDLE WINAPI
CreateFileMappingA( HANDLE hFile
, SECURITY_ATTRIBUTES
*sa
,
319 DWORD protect
, DWORD size_high
, DWORD size_low
, LPCSTR name
)
321 WCHAR buffer
[MAX_PATH
];
323 if (!name
) return CreateFileMappingW( hFile
, sa
, protect
, size_high
, size_low
, NULL
);
325 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
327 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
330 return CreateFileMappingW( hFile
, sa
, protect
, size_high
, size_low
, buffer
);
334 /***********************************************************************
335 * CreateFileMappingW (KERNEL32.@)
337 * See CreateFileMappingA.
339 HANDLE WINAPI
CreateFileMappingW( HANDLE hFile
, LPSECURITY_ATTRIBUTES sa
,
340 DWORD protect
, DWORD size_high
,
341 DWORD size_low
, LPCWSTR name
)
343 static const int sec_flags
= SEC_FILE
| SEC_IMAGE
| SEC_RESERVE
| SEC_COMMIT
| SEC_NOCACHE
;
347 DWORD access
, sec_type
;
350 sec_type
= protect
& sec_flags
;
351 protect
&= ~sec_flags
;
352 if (!sec_type
) sec_type
= SEC_COMMIT
;
354 /* Win9x compatibility */
355 if (!protect
&& (GetVersion() & 0x80000000)) protect
= PAGE_READONLY
;
361 access
= STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
;
364 access
= STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
| SECTION_MAP_WRITE
;
366 case PAGE_EXECUTE_READ
:
367 case PAGE_EXECUTE_WRITECOPY
:
368 access
= STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
| SECTION_MAP_EXECUTE
;
370 case PAGE_EXECUTE_READWRITE
:
371 access
= STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
| SECTION_MAP_WRITE
| SECTION_MAP_EXECUTE
;
374 SetLastError( ERROR_INVALID_PARAMETER
);
378 if (hFile
== INVALID_HANDLE_VALUE
)
381 if (!size_low
&& !size_high
)
383 SetLastError( ERROR_INVALID_PARAMETER
);
388 size
.u
.LowPart
= size_low
;
389 size
.u
.HighPart
= size_high
;
393 OBJECT_ATTRIBUTES attr
;
394 UNICODE_STRING nameW
;
396 attr
.Length
= sizeof(attr
);
397 attr
.RootDirectory
= 0;
398 attr
.ObjectName
= NULL
;
399 attr
.Attributes
= OBJ_OPENIF
| ((sa
&& sa
->bInheritHandle
) ? OBJ_INHERIT
: 0);
400 attr
.SecurityDescriptor
= sa
? sa
->lpSecurityDescriptor
: NULL
;
401 attr
.SecurityQualityOfService
= NULL
;
404 RtlInitUnicodeString( &nameW
, name
);
405 attr
.ObjectName
= &nameW
;
406 attr
.RootDirectory
= get_BaseNamedObjects_handle();
408 status
= NtCreateSection( &ret
, access
, &attr
, &size
, protect
, sec_type
, hFile
);
410 else status
= NtCreateSection( &ret
, access
, NULL
, &size
, protect
, sec_type
, hFile
);
412 if (status
== STATUS_OBJECT_NAME_EXISTS
)
413 SetLastError( ERROR_ALREADY_EXISTS
);
415 SetLastError( RtlNtStatusToDosError(status
) );
420 /***********************************************************************
421 * OpenFileMappingA (KERNEL32.@)
423 * Opens a named file-mapping object.
426 * access [I] Access mode.
427 * inherit [I] Inherit flag.
428 * name [I] Name of file-mapping object.
434 HANDLE WINAPI
OpenFileMappingA( DWORD access
, BOOL inherit
, LPCSTR name
)
436 WCHAR buffer
[MAX_PATH
];
438 if (!name
) return OpenFileMappingW( access
, inherit
, NULL
);
440 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
442 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
445 return OpenFileMappingW( access
, inherit
, buffer
);
449 /***********************************************************************
450 * OpenFileMappingW (KERNEL32.@)
452 * See OpenFileMappingA.
454 HANDLE WINAPI
OpenFileMappingW( DWORD access
, BOOL inherit
, LPCWSTR name
)
456 OBJECT_ATTRIBUTES attr
;
457 UNICODE_STRING nameW
;
463 SetLastError( ERROR_INVALID_PARAMETER
);
466 attr
.Length
= sizeof(attr
);
467 attr
.RootDirectory
= get_BaseNamedObjects_handle();
468 attr
.ObjectName
= &nameW
;
469 attr
.Attributes
= inherit
? OBJ_INHERIT
: 0;
470 attr
.SecurityDescriptor
= NULL
;
471 attr
.SecurityQualityOfService
= NULL
;
472 RtlInitUnicodeString( &nameW
, name
);
474 if (access
== FILE_MAP_COPY
) access
= SECTION_MAP_READ
;
476 if (GetVersion() & 0x80000000)
478 /* win9x doesn't do access checks, so try with full access first */
479 if (!NtOpenSection( &ret
, access
| SECTION_MAP_READ
| SECTION_MAP_WRITE
, &attr
)) return ret
;
482 if ((status
= NtOpenSection( &ret
, access
, &attr
)))
484 SetLastError( RtlNtStatusToDosError(status
) );
491 /***********************************************************************
492 * MapViewOfFile (KERNEL32.@)
494 * Maps a view of a file into the address space.
497 * mapping [I] File-mapping object to map.
498 * access [I] Access mode.
499 * offset_high [I] High-order 32 bits of file offset.
500 * offset_low [I] Low-order 32 bits of file offset.
501 * count [I] Number of bytes to map.
504 * Success: Starting address of mapped view.
507 LPVOID WINAPI
MapViewOfFile( HANDLE mapping
, DWORD access
,
508 DWORD offset_high
, DWORD offset_low
, SIZE_T count
)
510 return MapViewOfFileEx( mapping
, access
, offset_high
,
511 offset_low
, count
, NULL
);
515 /***********************************************************************
516 * MapViewOfFileEx (KERNEL32.@)
518 * Maps a view of a file into the address space.
521 * handle [I] File-mapping object to map.
522 * access [I] Access mode.
523 * offset_high [I] High-order 32 bits of file offset.
524 * offset_low [I] Low-order 32 bits of file offset.
525 * count [I] Number of bytes to map.
526 * addr [I] Suggested starting address for mapped view.
529 * Success: Starting address of mapped view.
532 LPVOID WINAPI
MapViewOfFileEx( HANDLE handle
, DWORD access
,
533 DWORD offset_high
, DWORD offset_low
, SIZE_T count
, LPVOID addr
)
536 LARGE_INTEGER offset
;
540 offset
.u
.LowPart
= offset_low
;
541 offset
.u
.HighPart
= offset_high
;
543 exec
= access
& FILE_MAP_EXECUTE
;
544 access
&= ~FILE_MAP_EXECUTE
;
546 if (access
== FILE_MAP_COPY
)
547 protect
= exec
? PAGE_EXECUTE_WRITECOPY
: PAGE_WRITECOPY
;
548 else if (access
& FILE_MAP_WRITE
)
549 protect
= exec
? PAGE_EXECUTE_READWRITE
: PAGE_READWRITE
;
550 else if (access
& FILE_MAP_READ
)
551 protect
= exec
? PAGE_EXECUTE_READ
: PAGE_READONLY
;
552 else protect
= PAGE_NOACCESS
;
554 if ((status
= NtMapViewOfSection( handle
, GetCurrentProcess(), &addr
, 0, 0, &offset
,
555 &count
, ViewShare
, 0, protect
)) < 0)
557 SetLastError( RtlNtStatusToDosError(status
) );
564 /***********************************************************************
565 * UnmapViewOfFile (KERNEL32.@)
567 * Unmaps a mapped view of a file.
570 * addr [I] Address where mapped view begins.
577 BOOL WINAPI
UnmapViewOfFile( LPCVOID addr
)
579 NTSTATUS status
= NtUnmapViewOfSection( GetCurrentProcess(), (void *)addr
);
580 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
585 /***********************************************************************
586 * FlushViewOfFile (KERNEL32.@)
588 * Writes to the disk a byte range within a mapped view of a file.
591 * base [I] Start address of byte range to flush.
592 * size [I] Number of bytes in range.
598 BOOL WINAPI
FlushViewOfFile( LPCVOID base
, SIZE_T size
)
600 NTSTATUS status
= NtFlushVirtualMemory( GetCurrentProcess(), &base
, &size
, 0 );
603 if (status
== STATUS_NOT_MAPPED_DATA
) status
= STATUS_SUCCESS
;
604 else SetLastError( RtlNtStatusToDosError(status
) );
610 /***********************************************************************
611 * GetWriteWatch (KERNEL32.@)
613 UINT WINAPI
GetWriteWatch( DWORD flags
, LPVOID base
, SIZE_T size
, LPVOID
*addresses
,
614 ULONG_PTR
*count
, ULONG
*granularity
)
618 status
= NtGetWriteWatch( GetCurrentProcess(), flags
, base
, size
, addresses
, count
, granularity
);
619 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
620 return status
? ~0u : 0;
624 /***********************************************************************
625 * ResetWriteWatch (KERNEL32.@)
627 UINT WINAPI
ResetWriteWatch( LPVOID base
, SIZE_T size
)
631 status
= NtResetWriteWatch( GetCurrentProcess(), base
, size
);
632 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
633 return status
? ~0u : 0;
637 /***********************************************************************
638 * IsBadReadPtr (KERNEL32.@)
640 * Check for read access on a memory block.
642 * ptr [I] Address of memory block.
643 * size [I] Size of block.
647 * Failure: FALSE. Process has read access to entire block.
649 BOOL WINAPI
IsBadReadPtr( LPCVOID ptr
, UINT_PTR size
)
651 if (!size
) return FALSE
; /* handle 0 size case w/o reference */
652 if (!ptr
) return TRUE
;
655 volatile const char *p
= ptr
;
656 char dummy
__attribute__((unused
));
657 UINT_PTR count
= size
;
659 while (count
> system_info
.PageSize
)
662 p
+= system_info
.PageSize
;
663 count
-= system_info
.PageSize
;
666 dummy
= p
[count
- 1];
670 TRACE_(seh
)("%p caused page fault during read\n", ptr
);
678 /***********************************************************************
679 * IsBadWritePtr (KERNEL32.@)
681 * Check for write access on a memory block.
684 * ptr [I] Address of memory block.
685 * size [I] Size of block in bytes.
689 * Failure: FALSE. Process has write access to entire block.
691 BOOL WINAPI
IsBadWritePtr( LPVOID ptr
, UINT_PTR size
)
693 if (!size
) return FALSE
; /* handle 0 size case w/o reference */
694 if (!ptr
) return TRUE
;
697 volatile char *p
= ptr
;
698 UINT_PTR count
= size
;
700 while (count
> system_info
.PageSize
)
703 p
+= system_info
.PageSize
;
704 count
-= system_info
.PageSize
;
711 TRACE_(seh
)("%p caused page fault during write\n", ptr
);
719 /***********************************************************************
720 * IsBadHugeReadPtr (KERNEL32.@)
722 * Check for read access on a memory block.
725 * ptr [I] Address of memory block.
726 * size [I] Size of block.
730 * Failure: FALSE. Process has read access to entire block.
732 BOOL WINAPI
IsBadHugeReadPtr( LPCVOID ptr
, UINT_PTR size
)
734 return IsBadReadPtr( ptr
, size
);
738 /***********************************************************************
739 * IsBadHugeWritePtr (KERNEL32.@)
741 * Check for write access on a memory block.
744 * ptr [I] Address of memory block.
745 * size [I] Size of block.
749 * Failure: FALSE. Process has write access to entire block.
751 BOOL WINAPI
IsBadHugeWritePtr( LPVOID ptr
, UINT_PTR size
)
753 return IsBadWritePtr( ptr
, size
);
757 /***********************************************************************
758 * IsBadCodePtr (KERNEL32.@)
760 * Check for read access on a memory address.
763 * ptr [I] Address of function.
767 * Failure: FALSE. Process has read access to specified memory.
769 BOOL WINAPI
IsBadCodePtr( FARPROC ptr
)
771 return IsBadReadPtr( ptr
, 1 );
775 /***********************************************************************
776 * IsBadStringPtrA (KERNEL32.@)
778 * Check for read access on a range of memory pointed to by a string pointer.
781 * str [I] Address of string.
782 * max [I] Maximum size of string.
786 * Failure: FALSE. Read access to all bytes in string.
788 BOOL WINAPI
IsBadStringPtrA( LPCSTR str
, UINT_PTR max
)
790 if (!str
) return TRUE
;
794 volatile const char *p
= str
;
795 while (p
!= str
+ max
) if (!*p
++) break;
799 TRACE_(seh
)("%p caused page fault during read\n", str
);
807 /***********************************************************************
808 * IsBadStringPtrW (KERNEL32.@)
810 * See IsBadStringPtrA.
812 BOOL WINAPI
IsBadStringPtrW( LPCWSTR str
, UINT_PTR max
)
814 if (!str
) return TRUE
;
818 volatile const WCHAR
*p
= str
;
819 while (p
!= str
+ max
) if (!*p
++) break;
823 TRACE_(seh
)("%p caused page fault during read\n", str
);
830 /***********************************************************************
831 * K32GetMappedFileNameA (KERNEL32.@)
833 DWORD WINAPI
K32GetMappedFileNameA(HANDLE process
, LPVOID lpv
, LPSTR file_name
, DWORD size
)
835 FIXME_(file
)("(%p, %p, %p, %d): stub\n", process
, lpv
, file_name
, size
);
837 if (file_name
&& size
)
843 /***********************************************************************
844 * K32GetMappedFileNameW (KERNEL32.@)
846 DWORD WINAPI
K32GetMappedFileNameW(HANDLE process
, LPVOID lpv
, LPWSTR file_name
, DWORD size
)
848 FIXME_(file
)("(%p, %p, %p, %d): stub\n", process
, lpv
, file_name
, size
);
850 if (file_name
&& size
)
856 /***********************************************************************
857 * K32EnumPageFilesA (KERNEL32.@)
859 BOOL WINAPI
K32EnumPageFilesA( PENUM_PAGE_FILE_CALLBACKA callback
, LPVOID context
)
861 FIXME_(file
)("(%p, %p) stub\n", callback
, context
);
865 /***********************************************************************
866 * K32EnumPageFilesW (KERNEL32.@)
868 BOOL WINAPI
K32EnumPageFilesW( PENUM_PAGE_FILE_CALLBACKW callback
, LPVOID context
)
870 FIXME_(file
)("(%p, %p) stub\n", callback
, context
);
874 /***********************************************************************
875 * K32GetWsChanges (KERNEL32.@)
877 BOOL WINAPI
K32GetWsChanges(HANDLE process
, PPSAPI_WS_WATCH_INFORMATION watchinfo
, DWORD size
)
881 TRACE_(seh
)("(%p, %p, %d)\n", process
, watchinfo
, size
);
883 status
= NtQueryInformationProcess( process
, ProcessWorkingSetWatch
, watchinfo
, size
, NULL
);
887 SetLastError( RtlNtStatusToDosError( status
) );
893 /***********************************************************************
894 * K32InitializeProcessForWsWatch (KERNEL32.@)
896 BOOL WINAPI
K32InitializeProcessForWsWatch(HANDLE process
)
898 FIXME_(seh
)("(process=%p): stub\n", process
);