2 * Win32 virtual memory functions
4 * Copyright 1997 Alexandre Julliard
11 #ifdef HAVE_SYS_ERRNO_H
12 #include <sys/errno.h>
19 #include <sys/types.h>
20 #ifdef HAVE_SYS_MMAN_H
29 #include "debugtools.h"
31 DEFAULT_DEBUG_CHANNEL(virtual);
40 struct _FV *next; /* Next view */
41 struct _FV *prev; /* Prev view */
42 UINT base; /* Base address */
43 UINT size; /* Size in bytes */
44 UINT flags; /* Allocation flags */
45 UINT offset; /* Offset from start of mapped file */
46 HANDLE mapping; /* Handle to the file mapping */
47 HANDLERPROC handlerProc; /* Fault handler */
48 LPVOID handlerArg; /* Fault handler argument */
49 BYTE protect; /* Protection for all pages at allocation time */
50 BYTE prot[1]; /* Protection byte for each page */
54 #define VFLAG_SYSTEM 0x01
56 /* Conversion from VPROT_* to Win32 flags */
57 static const BYTE VIRTUAL_Win32Flags[16] =
59 PAGE_NOACCESS, /* 0 */
60 PAGE_READONLY, /* READ */
61 PAGE_READWRITE, /* WRITE */
62 PAGE_READWRITE, /* READ | WRITE */
63 PAGE_EXECUTE, /* EXEC */
64 PAGE_EXECUTE_READ, /* READ | EXEC */
65 PAGE_EXECUTE_READWRITE, /* WRITE | EXEC */
66 PAGE_EXECUTE_READWRITE, /* READ | WRITE | EXEC */
67 PAGE_WRITECOPY, /* WRITECOPY */
68 PAGE_WRITECOPY, /* READ | WRITECOPY */
69 PAGE_WRITECOPY, /* WRITE | WRITECOPY */
70 PAGE_WRITECOPY, /* READ | WRITE | WRITECOPY */
71 PAGE_EXECUTE_WRITECOPY, /* EXEC | WRITECOPY */
72 PAGE_EXECUTE_WRITECOPY, /* READ | EXEC | WRITECOPY */
73 PAGE_EXECUTE_WRITECOPY, /* WRITE | EXEC | WRITECOPY */
74 PAGE_EXECUTE_WRITECOPY /* READ | WRITE | EXEC | WRITECOPY */
78 static FILE_VIEW *VIRTUAL_FirstView;
81 /* These are always the same on an i386, and it will be faster this way */
82 # define page_mask 0xfff
83 # define page_shift 12
84 # define granularity_mask 0xffff
86 static UINT page_shift;
87 static UINT page_mask;
88 static UINT granularity_mask; /* Allocation granularity (usually 64k) */
91 #define ROUND_ADDR(addr) \
92 ((UINT)(addr) & ~page_mask)
94 #define ROUND_SIZE(addr,size) \
95 (((UINT)(size) + ((UINT)(addr) & page_mask) + page_mask) & ~page_mask)
97 #define VIRTUAL_DEBUG_DUMP_VIEW(view) \
98 if (!TRACE_ON(virtual)); else VIRTUAL_DumpView(view)
100 /***********************************************************************
103 static const char *VIRTUAL_GetProtStr( BYTE prot )
105 static char buffer[6];
106 buffer[0] = (prot & VPROT_COMMITTED) ? 'c' : '-';
107 buffer[1] = (prot & VPROT_GUARD) ? 'g' : '-';
108 buffer[2] = (prot & VPROT_READ) ? 'r' : '-';
109 buffer[3] = (prot & VPROT_WRITE) ?
110 ((prot & VPROT_WRITECOPY) ? 'w' : 'W') : '-';
111 buffer[4] = (prot & VPROT_EXEC) ? 'x' : '-';
117 /***********************************************************************
120 static void VIRTUAL_DumpView( FILE_VIEW *view )
123 UINT addr = view->base;
124 BYTE prot = view->prot[0];
126 DPRINTF( "View: %08x - %08x%s",
127 view->base, view->base + view->size - 1,
128 (view->flags & VFLAG_SYSTEM) ? " (system)" : "" );
130 DPRINTF( " %d @ %08x\n", view->mapping, view->offset );
132 DPRINTF( " (anonymous)\n");
134 for (count = i = 1; i < view->size >> page_shift; i++, count++)
136 if (view->prot[i] == prot) continue;
137 DPRINTF( " %08x - %08x %s\n",
138 addr, addr + (count << page_shift) - 1,
139 VIRTUAL_GetProtStr(prot) );
140 addr += (count << page_shift);
141 prot = view->prot[i];
145 DPRINTF( " %08x - %08x %s\n",
146 addr, addr + (count << page_shift) - 1,
147 VIRTUAL_GetProtStr(prot) );
151 /***********************************************************************
154 void VIRTUAL_Dump(void)
156 FILE_VIEW *view = VIRTUAL_FirstView;
157 DPRINTF( "\nDump of all virtual memory views:\n\n" );
160 VIRTUAL_DumpView( view );
166 /***********************************************************************
169 * Find the view containing a given address.
175 static FILE_VIEW *VIRTUAL_FindView(
176 UINT addr /* [in] Address */
178 FILE_VIEW *view = VIRTUAL_FirstView;
181 if (view->base > addr) return NULL;
182 if (view->base + view->size > addr) return view;
189 /***********************************************************************
192 * Create a new view and add it in the linked list.
194 static FILE_VIEW *VIRTUAL_CreateView( UINT base, UINT size, UINT offset,
195 UINT flags, BYTE vprot,
198 FILE_VIEW *view, *prev;
200 /* Create the view structure */
202 assert( !(base & page_mask) );
203 assert( !(size & page_mask) );
205 if (!(view = (FILE_VIEW *)malloc( sizeof(*view) + size - 1 ))) return NULL;
207 view->size = size << page_shift;
209 view->offset = offset;
210 view->mapping = mapping;
211 view->protect = vprot;
212 view->handlerProc = NULL;
213 memset( view->prot, vprot, size );
215 /* Duplicate the mapping handle */
217 if ((view->mapping != -1) &&
218 !DuplicateHandle( GetCurrentProcess(), view->mapping,
219 GetCurrentProcess(), &view->mapping,
220 0, FALSE, DUPLICATE_SAME_ACCESS ))
226 /* Insert it in the linked list */
228 if (!VIRTUAL_FirstView || (VIRTUAL_FirstView->base > base))
230 view->next = VIRTUAL_FirstView;
232 if (view->next) view->next->prev = view;
233 VIRTUAL_FirstView = view;
237 prev = VIRTUAL_FirstView;
238 while (prev->next && (prev->next->base < base)) prev = prev->next;
239 view->next = prev->next;
241 if (view->next) view->next->prev = view;
244 VIRTUAL_DEBUG_DUMP_VIEW( view );
249 /***********************************************************************
256 static void VIRTUAL_DeleteView(
257 FILE_VIEW *view /* [in] View */
259 FILE_munmap( (void *)view->base, 0, view->size );
260 if (view->next) view->next->prev = view->prev;
261 if (view->prev) view->prev->next = view->next;
262 else VIRTUAL_FirstView = view->next;
263 if (view->mapping) CloseHandle( view->mapping );
268 /***********************************************************************
269 * VIRTUAL_GetUnixProt
271 * Convert page protections to protection for mmap/mprotect.
273 static int VIRTUAL_GetUnixProt( BYTE vprot )
276 if ((vprot & VPROT_COMMITTED) && !(vprot & VPROT_GUARD))
278 if (vprot & VPROT_READ) prot |= PROT_READ;
279 if (vprot & VPROT_WRITE) prot |= PROT_WRITE;
280 if (vprot & VPROT_WRITECOPY) prot |= PROT_WRITE;
281 if (vprot & VPROT_EXEC) prot |= PROT_EXEC;
287 /***********************************************************************
288 * VIRTUAL_GetWin32Prot
290 * Convert page protections to Win32 flags.
295 static void VIRTUAL_GetWin32Prot(
296 BYTE vprot, /* [in] Page protection flags */
297 DWORD *protect, /* [out] Location to store Win32 protection flags */
298 DWORD *state /* [out] Location to store mem state flag */
301 *protect = VIRTUAL_Win32Flags[vprot & 0x0f];
302 /* if (vprot & VPROT_GUARD) *protect |= PAGE_GUARD;*/
303 if (vprot & VPROT_NOCACHE) *protect |= PAGE_NOCACHE;
305 if (vprot & VPROT_GUARD) *protect = PAGE_NOACCESS;
308 if (state) *state = (vprot & VPROT_COMMITTED) ? MEM_COMMIT : MEM_RESERVE;
312 /***********************************************************************
315 * Build page protections from Win32 flags.
318 * Value of page protection flags
320 static BYTE VIRTUAL_GetProt(
321 DWORD protect /* [in] Win32 protection flags */
325 switch(protect & 0xff)
331 vprot = VPROT_READ | VPROT_WRITE;
334 vprot = VPROT_READ | VPROT_WRITE | VPROT_WRITECOPY;
339 case PAGE_EXECUTE_READ:
340 vprot = VPROT_EXEC | VPROT_READ;
342 case PAGE_EXECUTE_READWRITE:
343 vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITE;
345 case PAGE_EXECUTE_WRITECOPY:
346 vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITE | VPROT_WRITECOPY;
353 if (protect & PAGE_GUARD) vprot |= VPROT_GUARD;
354 if (protect & PAGE_NOCACHE) vprot |= VPROT_NOCACHE;
359 /***********************************************************************
362 * Change the protection of a range of pages.
368 static BOOL VIRTUAL_SetProt(
369 FILE_VIEW *view, /* [in] Pointer to view */
370 UINT base, /* [in] Starting address */
371 UINT size, /* [in] Size in bytes */
372 BYTE vprot /* [in] Protections to use */
374 TRACE("%08x-%08x %s\n",
375 base, base + size - 1, VIRTUAL_GetProtStr( vprot ) );
377 if (mprotect( (void *)base, size, VIRTUAL_GetUnixProt(vprot) ))
378 return FALSE; /* FIXME: last error */
380 memset( view->prot + ((base - view->base) >> page_shift),
381 vprot, size >> page_shift );
382 VIRTUAL_DEBUG_DUMP_VIEW( view );
387 /***********************************************************************
390 * Check that all pages in a range have the given flags.
396 static BOOL VIRTUAL_CheckFlags(
397 UINT base, /* [in] Starting address */
398 UINT size, /* [in] Size in bytes */
399 BYTE flags /* [in] Flags to check for */
404 if (!size) return TRUE;
405 if (!(view = VIRTUAL_FindView( base ))) return FALSE;
406 if (view->base + view->size < base + size) return FALSE;
407 page = (base - view->base) >> page_shift;
408 size = ROUND_SIZE( base, size ) >> page_shift;
409 while (size--) if ((view->prot[page++] & flags) != flags) return FALSE;
414 /***********************************************************************
417 BOOL VIRTUAL_Init(void)
422 # ifdef HAVE_GETPAGESIZE
423 page_size = getpagesize();
426 page_size = sysconf(_SC_PAGESIZE);
428 # error Cannot get the page size on this platform
431 page_mask = page_size - 1;
432 granularity_mask = 0xffff; /* hard-coded for now */
433 /* Make sure we have a power of 2 */
434 assert( !(page_size & page_mask) );
436 while ((1 << page_shift) != page_size) page_shift++;
437 #endif /* !__i386__ */
441 /* Do not use stdio here since it may temporarily change the size
442 * of some segments (ie libc6 adds 0x1000 per open FILE)
444 int fd = open ("/proc/self/maps", O_RDONLY);
447 char buffer[512]; /* line might be rather long in 2.1 */
451 int start, end, offset;
453 BYTE vprot = VPROT_COMMITTED;
456 int count = sizeof(buffer);
457 while (1 == read(fd, ptr, 1) && *ptr != '\n' && --count > 0)
460 if (*ptr != '\n') break;
463 sscanf( buffer, "%x-%x %c%c%c%c %x",
464 &start, &end, &r, &w, &x, &p, &offset );
465 if (r == 'r') vprot |= VPROT_READ;
466 if (w == 'w') vprot |= VPROT_WRITE;
467 if (x == 'x') vprot |= VPROT_EXEC;
468 if (p == 'p') vprot |= VPROT_WRITECOPY;
469 VIRTUAL_CreateView( start, end - start, 0,
470 VFLAG_SYSTEM, vprot, -1 );
480 /***********************************************************************
481 * VIRTUAL_GetPageSize
483 DWORD VIRTUAL_GetPageSize(void)
485 return 1 << page_shift;
489 /***********************************************************************
490 * VIRTUAL_GetGranularity
492 DWORD VIRTUAL_GetGranularity(void)
494 return granularity_mask + 1;
498 /***********************************************************************
499 * VIRTUAL_SetFaultHandler
501 BOOL VIRTUAL_SetFaultHandler( LPCVOID addr, HANDLERPROC proc, LPVOID arg )
505 if (!(view = VIRTUAL_FindView((UINT)addr))) return FALSE;
506 view->handlerProc = proc;
507 view->handlerArg = arg;
511 /***********************************************************************
512 * VIRTUAL_HandleFault
514 DWORD VIRTUAL_HandleFault( LPCVOID addr )
516 FILE_VIEW *view = VIRTUAL_FindView((UINT)addr);
517 DWORD ret = EXCEPTION_ACCESS_VIOLATION;
521 if (view->handlerProc)
523 if (view->handlerProc(view->handlerArg, addr)) ret = 0; /* handled */
527 BYTE vprot = view->prot[((UINT)addr - view->base) >> page_shift];
528 UINT page = (UINT)addr & ~page_mask;
529 char *stack = (char *)NtCurrentTeb()->stack_base + SIGNAL_STACK_SIZE + page_mask + 1;
530 if (vprot & VPROT_GUARD)
532 VIRTUAL_SetProt( view, page, page_mask + 1, vprot & ~VPROT_GUARD );
533 ret = STATUS_GUARD_PAGE_VIOLATION;
535 /* is it inside the stack guard pages? */
536 if (((char *)addr >= stack) && ((char *)addr < stack + 2*(page_mask+1)))
537 ret = STATUS_STACK_OVERFLOW;
544 /***********************************************************************
545 * VirtualAlloc (KERNEL32.548)
546 * Reserves or commits a region of pages in virtual address space
549 * Base address of allocated region of pages
552 LPVOID WINAPI VirtualAlloc(
553 LPVOID addr, /* [in] Address of region to reserve or commit */
554 DWORD size, /* [in] Size of region */
555 DWORD type, /* [in] Type of allocation */
556 DWORD protect /* [in] Type of access protection */
559 UINT base, ptr, view_size;
562 TRACE("%08x %08lx %lx %08lx\n",
563 (UINT)addr, size, type, protect );
565 /* Round parameters to a page boundary */
567 if (size > 0x7fc00000) /* 2Gb - 4Mb */
569 SetLastError( ERROR_OUTOFMEMORY );
574 if (type & MEM_RESERVE) /* Round down to 64k boundary */
575 base = (UINT)addr & ~granularity_mask;
577 base = ROUND_ADDR( addr );
578 size = (((UINT)addr + size + page_mask) & ~page_mask) - base;
579 if ((base <= granularity_mask) || (base + size < base))
581 /* disallow low 64k and wrap-around */
582 SetLastError( ERROR_INVALID_PARAMETER );
589 size = (size + page_mask) & ~page_mask;
592 if (type & MEM_TOP_DOWN) {
593 /* FIXME: MEM_TOP_DOWN allocates the largest possible address.
594 * Is there _ANY_ way to do it with UNIX mmap()?
596 WARN("MEM_TOP_DOWN ignored\n");
597 type &= ~MEM_TOP_DOWN;
599 /* Compute the protection flags */
601 if (!(type & (MEM_COMMIT | MEM_RESERVE)) ||
602 (type & ~(MEM_COMMIT | MEM_RESERVE)))
604 SetLastError( ERROR_INVALID_PARAMETER );
607 if (type & MEM_COMMIT)
608 vprot = VIRTUAL_GetProt( protect ) | VPROT_COMMITTED;
611 /* Reserve the memory */
613 if ((type & MEM_RESERVE) || !base)
615 view_size = size + (base ? 0 : granularity_mask + 1);
616 ptr = (UINT)FILE_dommap( -1, (LPVOID)base, 0, view_size, 0, 0,
617 VIRTUAL_GetUnixProt( vprot ), MAP_PRIVATE );
620 SetLastError( ERROR_OUTOFMEMORY );
625 /* Release the extra memory while keeping the range */
626 /* starting on a 64k boundary. */
628 if (ptr & granularity_mask)
630 UINT extra = granularity_mask + 1 - (ptr & granularity_mask);
631 FILE_munmap( (void *)ptr, 0, extra );
635 if (view_size > size)
636 FILE_munmap( (void *)(ptr + size), 0, view_size - size );
638 else if (ptr != base)
640 /* We couldn't get the address we wanted */
641 FILE_munmap( (void *)ptr, 0, view_size );
642 SetLastError( ERROR_INVALID_ADDRESS );
645 if (!(view = VIRTUAL_CreateView( ptr, size, 0, 0, vprot, -1 )))
647 FILE_munmap( (void *)ptr, 0, size );
648 SetLastError( ERROR_OUTOFMEMORY );
651 VIRTUAL_DEBUG_DUMP_VIEW( view );
655 /* Commit the pages */
657 if (!(view = VIRTUAL_FindView( base )) ||
658 (base + size > view->base + view->size))
660 SetLastError( ERROR_INVALID_ADDRESS );
664 if (!VIRTUAL_SetProt( view, base, size, vprot )) return NULL;
669 /***********************************************************************
670 * VirtualFree (KERNEL32.550)
671 * Release or decommits a region of pages in virtual address space.
677 BOOL WINAPI VirtualFree(
678 LPVOID addr, /* [in] Address of region of committed pages */
679 DWORD size, /* [in] Size of region */
680 DWORD type /* [in] Type of operation */
685 TRACE("%08x %08lx %lx\n",
686 (UINT)addr, size, type );
688 /* Fix the parameters */
690 size = ROUND_SIZE( addr, size );
691 base = ROUND_ADDR( addr );
693 if (!(view = VIRTUAL_FindView( base )) ||
694 (base + size > view->base + view->size))
696 SetLastError( ERROR_INVALID_PARAMETER );
700 /* Compute the protection flags */
702 if ((type != MEM_DECOMMIT) && (type != MEM_RELEASE))
704 SetLastError( ERROR_INVALID_PARAMETER );
710 if (type == MEM_RELEASE)
712 if (size || (base != view->base))
714 SetLastError( ERROR_INVALID_PARAMETER );
717 VIRTUAL_DeleteView( view );
721 /* Decommit the pages by remapping zero-pages instead */
723 if (FILE_dommap( -1, (LPVOID)base, 0, size, 0, 0,
724 VIRTUAL_GetUnixProt( 0 ), MAP_PRIVATE|MAP_FIXED )
726 ERR( "Could not remap pages, expect trouble\n" );
727 return VIRTUAL_SetProt( view, base, size, 0 );
731 /***********************************************************************
732 * VirtualLock (KERNEL32.551)
733 * Locks the specified region of virtual address space
736 * Always returns TRUE
742 BOOL WINAPI VirtualLock(
743 LPVOID addr, /* [in] Address of first byte of range to lock */
744 DWORD size /* [in] Number of bytes in range to lock */
750 /***********************************************************************
751 * VirtualUnlock (KERNEL32.556)
752 * Unlocks a range of pages in the virtual address space
755 * Always returns TRUE
761 BOOL WINAPI VirtualUnlock(
762 LPVOID addr, /* [in] Address of first byte of range */
763 DWORD size /* [in] Number of bytes in range */
769 /***********************************************************************
770 * VirtualProtect (KERNEL32.552)
771 * Changes the access protection on a region of committed pages
777 BOOL WINAPI VirtualProtect(
778 LPVOID addr, /* [in] Address of region of committed pages */
779 DWORD size, /* [in] Size of region */
780 DWORD new_prot, /* [in] Desired access protection */
781 LPDWORD old_prot /* [out] Address of variable to get old protection */
787 TRACE("%08x %08lx %08lx\n",
788 (UINT)addr, size, new_prot );
790 /* Fix the parameters */
792 size = ROUND_SIZE( addr, size );
793 base = ROUND_ADDR( addr );
795 if (!(view = VIRTUAL_FindView( base )) ||
796 (base + size > view->base + view->size))
798 SetLastError( ERROR_INVALID_PARAMETER );
802 /* Make sure all the pages are committed */
804 p = view->prot + ((base - view->base) >> page_shift);
805 for (i = size >> page_shift; i; i--, p++)
807 if (!(*p & VPROT_COMMITTED))
809 SetLastError( ERROR_INVALID_PARAMETER );
814 VIRTUAL_GetWin32Prot( view->prot[0], old_prot, NULL );
815 vprot = VIRTUAL_GetProt( new_prot ) | VPROT_COMMITTED;
816 return VIRTUAL_SetProt( view, base, size, vprot );
820 /***********************************************************************
821 * VirtualProtectEx (KERNEL32.553)
822 * Changes the access protection on a region of committed pages in the
823 * virtual address space of a specified process
829 BOOL WINAPI VirtualProtectEx(
830 HANDLE handle, /* [in] Handle of process */
831 LPVOID addr, /* [in] Address of region of committed pages */
832 DWORD size, /* [in] Size of region */
833 DWORD new_prot, /* [in] Desired access protection */
834 LPDWORD old_prot /* [out] Address of variable to get old protection */ )
836 if (MapProcessHandle( handle ) == GetCurrentProcessId())
837 return VirtualProtect( addr, size, new_prot, old_prot );
838 ERR("Unsupported on other process\n");
843 /***********************************************************************
844 * VirtualQuery (KERNEL32.554)
845 * Provides info about a range of pages in virtual address space
848 * Number of bytes returned in information buffer
850 DWORD WINAPI VirtualQuery(
851 LPCVOID addr, /* [in] Address of region */
852 LPMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */
853 DWORD len /* [in] Size of buffer */
855 FILE_VIEW *view = VIRTUAL_FirstView;
856 UINT base = ROUND_ADDR( addr );
860 /* Find the view containing the address */
866 size = 0xffff0000 - alloc_base;
869 if (view->base > base)
871 size = view->base - alloc_base;
875 if (view->base + view->size > base)
877 alloc_base = view->base;
881 alloc_base = view->base + view->size;
885 /* Fill the info structure */
889 info->State = MEM_FREE;
891 info->AllocationProtect = 0;
896 BYTE vprot = view->prot[(base - alloc_base) >> page_shift];
897 VIRTUAL_GetWin32Prot( vprot, &info->Protect, &info->State );
898 for (size = base - alloc_base; size < view->size; size += page_mask+1)
899 if (view->prot[size >> page_shift] != vprot) break;
900 info->AllocationProtect = view->protect;
901 info->Type = MEM_PRIVATE; /* FIXME */
904 info->BaseAddress = (LPVOID)base;
905 info->AllocationBase = (LPVOID)alloc_base;
906 info->RegionSize = size - (base - alloc_base);
907 return sizeof(*info);
911 /***********************************************************************
912 * VirtualQueryEx (KERNEL32.555)
913 * Provides info about a range of pages in virtual address space of a
917 * Number of bytes returned in information buffer
919 DWORD WINAPI VirtualQueryEx(
920 HANDLE handle, /* [in] Handle of process */
921 LPCVOID addr, /* [in] Address of region */
922 LPMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */
923 DWORD len /* [in] Size of buffer */ )
925 if (MapProcessHandle( handle ) == GetCurrentProcessId())
926 return VirtualQuery( addr, info, len );
927 ERR("Unsupported on other process\n");
932 /***********************************************************************
933 * IsBadReadPtr (KERNEL32.354)
936 * FALSE: Process has read access to entire block
939 BOOL WINAPI IsBadReadPtr(
940 LPCVOID ptr, /* Address of memory block */
941 UINT size /* Size of block */
943 return !VIRTUAL_CheckFlags( (UINT)ptr, size,
944 VPROT_READ | VPROT_COMMITTED );
948 /***********************************************************************
949 * IsBadWritePtr (KERNEL32.357)
952 * FALSE: Process has write access to entire block
955 BOOL WINAPI IsBadWritePtr(
956 LPVOID ptr, /* [in] Address of memory block */
957 UINT size /* [in] Size of block in bytes */
959 return !VIRTUAL_CheckFlags( (UINT)ptr, size,
960 VPROT_WRITE | VPROT_COMMITTED );
964 /***********************************************************************
965 * IsBadHugeReadPtr (KERNEL32.352)
967 * FALSE: Process has read access to entire block
970 BOOL WINAPI IsBadHugeReadPtr(
971 LPCVOID ptr, /* [in] Address of memory block */
972 UINT size /* [in] Size of block */
974 return IsBadReadPtr( ptr, size );
978 /***********************************************************************
979 * IsBadHugeWritePtr (KERNEL32.353)
981 * FALSE: Process has write access to entire block
984 BOOL WINAPI IsBadHugeWritePtr(
985 LPVOID ptr, /* [in] Address of memory block */
986 UINT size /* [in] Size of block */
988 return IsBadWritePtr( ptr, size );
992 /***********************************************************************
993 * IsBadCodePtr (KERNEL32.351)
996 * FALSE: Process has read access to specified memory
999 BOOL WINAPI IsBadCodePtr(
1000 FARPROC ptr /* [in] Address of function */
1002 return !VIRTUAL_CheckFlags( (UINT)ptr, 1, VPROT_EXEC | VPROT_COMMITTED );
1006 /***********************************************************************
1007 * IsBadStringPtrA (KERNEL32.355)
1010 * FALSE: Read access to all bytes in string
1013 BOOL WINAPI IsBadStringPtrA(
1014 LPCSTR str, /* [in] Address of string */
1015 UINT max /* [in] Maximum size of string */
1020 if (!max) return FALSE;
1021 if (!(view = VIRTUAL_FindView( (UINT)str ))) return TRUE;
1022 page = ((UINT)str - view->base) >> page_shift;
1023 count = page_mask + 1 - ((UINT)str & page_mask);
1027 if ((view->prot[page] & (VPROT_READ | VPROT_COMMITTED)) !=
1028 (VPROT_READ | VPROT_COMMITTED))
1030 if (count > max) count = max;
1032 while (count--) if (!*str++) return FALSE;
1033 if (++page >= view->size >> page_shift) return TRUE;
1034 count = page_mask + 1;
1040 /***********************************************************************
1041 * IsBadStringPtrW (KERNEL32.356)
1042 * See IsBadStringPtrA
1044 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT max )
1049 if (!max) return FALSE;
1050 if (!(view = VIRTUAL_FindView( (UINT)str ))) return TRUE;
1051 page = ((UINT)str - view->base) >> page_shift;
1052 count = (page_mask + 1 - ((UINT)str & page_mask)) / sizeof(WCHAR);
1056 if ((view->prot[page] & (VPROT_READ | VPROT_COMMITTED)) !=
1057 (VPROT_READ | VPROT_COMMITTED))
1059 if (count > max) count = max;
1061 while (count--) if (!*str++) return FALSE;
1062 if (++page >= view->size >> page_shift) return TRUE;
1063 count = (page_mask + 1) / sizeof(WCHAR);
1069 /***********************************************************************
1070 * CreateFileMappingA (KERNEL32.46)
1071 * Creates a named or unnamed file-mapping object for the specified file
1075 * 0: Mapping object does not exist
1078 HANDLE WINAPI CreateFileMappingA(
1079 HFILE hFile, /* [in] Handle of file to map */
1080 SECURITY_ATTRIBUTES *sa, /* [in] Optional security attributes*/
1081 DWORD protect, /* [in] Protection for mapping object */
1082 DWORD size_high, /* [in] High-order 32 bits of object size */
1083 DWORD size_low, /* [in] Low-order 32 bits of object size */
1084 LPCSTR name /* [in] Name of file-mapping object */ )
1086 struct create_mapping_request *req = get_req_buffer();
1089 /* Check parameters */
1091 TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
1092 hFile, sa, protect, size_high, size_low, debugstr_a(name) );
1094 vprot = VIRTUAL_GetProt( protect );
1095 if (protect & SEC_RESERVE)
1097 if (hFile != INVALID_HANDLE_VALUE)
1099 SetLastError( ERROR_INVALID_PARAMETER );
1103 else vprot |= VPROT_COMMITTED;
1104 if (protect & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
1106 /* Create the server object */
1108 req->file_handle = hFile;
1109 req->size_high = size_high;
1110 req->size_low = size_low;
1111 req->protect = vprot;
1112 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
1113 server_strcpyAtoW( req->name, name );
1115 server_call( REQ_CREATE_MAPPING );
1116 if (req->handle == -1) return 0;
1121 /***********************************************************************
1122 * CreateFileMappingW (KERNEL32.47)
1123 * See CreateFileMappingA
1125 HANDLE WINAPI CreateFileMappingW( HFILE hFile, LPSECURITY_ATTRIBUTES sa,
1126 DWORD protect, DWORD size_high,
1127 DWORD size_low, LPCWSTR name )
1129 struct create_mapping_request *req = get_req_buffer();
1132 /* Check parameters */
1134 TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
1135 hFile, sa, protect, size_high, size_low, debugstr_w(name) );
1137 vprot = VIRTUAL_GetProt( protect );
1138 if (protect & SEC_RESERVE)
1140 if (hFile != INVALID_HANDLE_VALUE)
1142 SetLastError( ERROR_INVALID_PARAMETER );
1146 else vprot |= VPROT_COMMITTED;
1147 if (protect & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
1149 /* Create the server object */
1151 req->file_handle = hFile;
1152 req->size_high = size_high;
1153 req->size_low = size_low;
1154 req->protect = vprot;
1155 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
1156 server_strcpyW( req->name, name );
1158 server_call( REQ_CREATE_MAPPING );
1159 if (req->handle == -1) return 0;
1164 /***********************************************************************
1165 * OpenFileMappingA (KERNEL32.397)
1166 * Opens a named file-mapping object.
1172 HANDLE WINAPI OpenFileMappingA(
1173 DWORD access, /* [in] Access mode */
1174 BOOL inherit, /* [in] Inherit flag */
1175 LPCSTR name ) /* [in] Name of file-mapping object */
1177 struct open_mapping_request *req = get_req_buffer();
1179 req->access = access;
1180 req->inherit = inherit;
1181 server_strcpyAtoW( req->name, name );
1182 server_call( REQ_OPEN_MAPPING );
1183 if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
1188 /***********************************************************************
1189 * OpenFileMappingW (KERNEL32.398)
1190 * See OpenFileMappingA
1192 HANDLE WINAPI OpenFileMappingW( DWORD access, BOOL inherit, LPCWSTR name)
1194 struct open_mapping_request *req = get_req_buffer();
1196 req->access = access;
1197 req->inherit = inherit;
1198 server_strcpyW( req->name, name );
1199 server_call( REQ_OPEN_MAPPING );
1200 if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
1205 /***********************************************************************
1206 * MapViewOfFile (KERNEL32.385)
1207 * Maps a view of a file into the address space
1210 * Starting address of mapped view
1213 LPVOID WINAPI MapViewOfFile(
1214 HANDLE mapping, /* [in] File-mapping object to map */
1215 DWORD access, /* [in] Access mode */
1216 DWORD offset_high, /* [in] High-order 32 bits of file offset */
1217 DWORD offset_low, /* [in] Low-order 32 bits of file offset */
1218 DWORD count /* [in] Number of bytes to map */
1220 return MapViewOfFileEx( mapping, access, offset_high,
1221 offset_low, count, NULL );
1225 /***********************************************************************
1226 * MapViewOfFileEx (KERNEL32.386)
1227 * Maps a view of a file into the address space
1230 * Starting address of mapped view
1233 LPVOID WINAPI MapViewOfFileEx(
1234 HANDLE handle, /* [in] File-mapping object to map */
1235 DWORD access, /* [in] Access mode */
1236 DWORD offset_high, /* [in] High-order 32 bits of file offset */
1237 DWORD offset_low, /* [in] Low-order 32 bits of file offset */
1238 DWORD count, /* [in] Number of bytes to map */
1239 LPVOID addr /* [in] Suggested starting address for mapped view */
1242 UINT ptr = (UINT)-1, size = 0;
1243 int flags = MAP_PRIVATE;
1244 int unix_handle = -1;
1246 struct get_mapping_info_request *req = get_req_buffer();
1248 /* Check parameters */
1250 if ((offset_low & granularity_mask) ||
1251 (addr && ((UINT)addr & granularity_mask)))
1253 SetLastError( ERROR_INVALID_PARAMETER );
1257 req->handle = handle;
1258 if (server_call_fd( REQ_GET_MAPPING_INFO, -1, &unix_handle )) goto error;
1260 if (req->size_high || offset_high)
1261 ERR("Offsets larger than 4Gb not supported\n");
1263 if ((offset_low >= req->size_low) ||
1264 (count > req->size_low - offset_low))
1266 SetLastError( ERROR_INVALID_PARAMETER );
1269 if (count) size = ROUND_SIZE( offset_low, count );
1270 else size = req->size_low - offset_low;
1271 prot = req->protect;
1275 case FILE_MAP_ALL_ACCESS:
1276 case FILE_MAP_WRITE:
1277 case FILE_MAP_WRITE | FILE_MAP_READ:
1278 if (!(prot & VPROT_WRITE))
1280 SetLastError( ERROR_INVALID_PARAMETER );
1287 case FILE_MAP_COPY | FILE_MAP_READ:
1288 if (prot & VPROT_READ) break;
1291 SetLastError( ERROR_INVALID_PARAMETER );
1297 TRACE("handle=%x size=%x offset=%lx\n", handle, size, offset_low );
1299 ptr = (UINT)FILE_dommap( unix_handle, addr, 0, size, 0, offset_low,
1300 VIRTUAL_GetUnixProt( prot ), flags );
1301 if (ptr == (UINT)-1) {
1302 /* KB: Q125713, 25-SEP-1995, "Common File Mapping Problems and
1303 * Platform Differences":
1304 * Windows NT: ERROR_INVALID_PARAMETER
1305 * Windows 95: ERROR_INVALID_ADDRESS.
1306 * FIXME: So should we add a module dependend check here? -MM
1309 SetLastError( ERROR_OUTOFMEMORY );
1311 SetLastError( ERROR_INVALID_PARAMETER );
1315 if (!(view = VIRTUAL_CreateView( ptr, size, offset_low, 0, prot, handle )))
1317 SetLastError( ERROR_OUTOFMEMORY );
1320 if (unix_handle != -1) close( unix_handle );
1324 if (unix_handle != -1) close( unix_handle );
1325 if (ptr != (UINT)-1) FILE_munmap( (void *)ptr, 0, size );
1330 /***********************************************************************
1331 * FlushViewOfFile (KERNEL32.262)
1332 * Writes to the disk a byte range within a mapped view of a file
1338 BOOL WINAPI FlushViewOfFile(
1339 LPCVOID base, /* [in] Start address of byte range to flush */
1340 DWORD cbFlush /* [in] Number of bytes in range */
1343 UINT addr = ROUND_ADDR( base );
1345 TRACE("FlushViewOfFile at %p for %ld bytes\n",
1348 if (!(view = VIRTUAL_FindView( addr )))
1350 SetLastError( ERROR_INVALID_PARAMETER );
1353 if (!cbFlush) cbFlush = view->size;
1354 if (!msync( (void *)addr, cbFlush, MS_SYNC )) return TRUE;
1355 SetLastError( ERROR_INVALID_PARAMETER );
1360 /***********************************************************************
1361 * UnmapViewOfFile (KERNEL32.540)
1362 * Unmaps a mapped view of a file.
1365 * Should addr be an LPCVOID?
1371 BOOL WINAPI UnmapViewOfFile(
1372 LPVOID addr /* [in] Address where mapped view begins */
1375 UINT base = ROUND_ADDR( addr );
1376 if (!(view = VIRTUAL_FindView( base )) || (base != view->base))
1378 SetLastError( ERROR_INVALID_PARAMETER );
1381 VIRTUAL_DeleteView( view );
1385 /***********************************************************************
1388 * Helper function to map a file to memory:
1390 * [RETURN] ptr - pointer to mapped file
1392 LPVOID VIRTUAL_MapFileW( LPCWSTR name )
1394 HANDLE hFile, hMapping;
1397 hFile = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL,
1398 OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, 0);
1399 if (hFile != INVALID_HANDLE_VALUE)
1401 hMapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
1402 CloseHandle( hFile );
1405 ptr = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
1406 CloseHandle( hMapping );