2 * Win32 virtual memory functions
4 * Copyright 1997 Alexandre Julliard
11 #ifdef HAVE_SYS_ERRNO_H
12 #include <sys/errno.h>
18 #include <sys/types.h>
19 #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_EXEC) prot |= PROT_EXEC;
286 /***********************************************************************
287 * VIRTUAL_GetWin32Prot
289 * Convert page protections to Win32 flags.
294 static void VIRTUAL_GetWin32Prot(
295 BYTE vprot, /* [in] Page protection flags */
296 DWORD *protect, /* [out] Location to store Win32 protection flags */
297 DWORD *state /* [out] Location to store mem state flag */
300 *protect = VIRTUAL_Win32Flags[vprot & 0x0f];
301 /* if (vprot & VPROT_GUARD) *protect |= PAGE_GUARD;*/
302 if (vprot & VPROT_NOCACHE) *protect |= PAGE_NOCACHE;
304 if (vprot & VPROT_GUARD) *protect = PAGE_NOACCESS;
307 if (state) *state = (vprot & VPROT_COMMITTED) ? MEM_COMMIT : MEM_RESERVE;
311 /***********************************************************************
314 * Build page protections from Win32 flags.
317 * Value of page protection flags
319 static BYTE VIRTUAL_GetProt(
320 DWORD protect /* [in] Win32 protection flags */
324 switch(protect & 0xff)
330 vprot = VPROT_READ | VPROT_WRITE;
333 vprot = VPROT_READ | VPROT_WRITE | VPROT_WRITECOPY;
338 case PAGE_EXECUTE_READ:
339 vprot = VPROT_EXEC | VPROT_READ;
341 case PAGE_EXECUTE_READWRITE:
342 vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITE | VPROT_WRITECOPY;
344 case PAGE_EXECUTE_WRITECOPY:
345 vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITE;
352 if (protect & PAGE_GUARD) vprot |= VPROT_GUARD;
353 if (protect & PAGE_NOCACHE) vprot |= VPROT_NOCACHE;
358 /***********************************************************************
361 * Change the protection of a range of pages.
367 static BOOL VIRTUAL_SetProt(
368 FILE_VIEW *view, /* [in] Pointer to view */
369 UINT base, /* [in] Starting address */
370 UINT size, /* [in] Size in bytes */
371 BYTE vprot /* [in] Protections to use */
373 TRACE("%08x-%08x %s\n",
374 base, base + size - 1, VIRTUAL_GetProtStr( vprot ) );
376 if (mprotect( (void *)base, size, VIRTUAL_GetUnixProt(vprot) ))
377 return FALSE; /* FIXME: last error */
379 memset( view->prot + ((base - view->base) >> page_shift),
380 vprot, size >> page_shift );
381 VIRTUAL_DEBUG_DUMP_VIEW( view );
386 /***********************************************************************
389 * Check that all pages in a range have the given flags.
395 static BOOL VIRTUAL_CheckFlags(
396 UINT base, /* [in] Starting address */
397 UINT size, /* [in] Size in bytes */
398 BYTE flags /* [in] Flags to check for */
403 if (!size) return TRUE;
404 if (!(view = VIRTUAL_FindView( base ))) return FALSE;
405 if (view->base + view->size < base + size) return FALSE;
406 page = (base - view->base) >> page_shift;
407 size = ROUND_SIZE( base, size ) >> page_shift;
408 while (size--) if ((view->prot[page++] & flags) != flags) return FALSE;
413 /***********************************************************************
416 BOOL VIRTUAL_Init(void)
421 # ifdef HAVE_GETPAGESIZE
422 page_size = getpagesize();
425 page_size = sysconf(_SC_PAGESIZE);
427 # error Cannot get the page size on this platform
430 page_mask = page_size - 1;
431 granularity_mask = 0xffff; /* hard-coded for now */
432 /* Make sure we have a power of 2 */
433 assert( !(page_size & page_mask) );
435 while ((1 << page_shift) != page_size) page_shift++;
436 #endif /* !__i386__ */
440 /* Do not use stdio here since it may temporarily change the size
441 * of some segments (ie libc6 adds 0x1000 per open FILE)
443 int fd = open ("/proc/self/maps", O_RDONLY);
446 char buffer[512]; /* line might be rather long in 2.1 */
450 int start, end, offset;
452 BYTE vprot = VPROT_COMMITTED;
455 int count = sizeof(buffer);
456 while (1 == read(fd, ptr, 1) && *ptr != '\n' && --count > 0)
459 if (*ptr != '\n') break;
462 sscanf( buffer, "%x-%x %c%c%c%c %x",
463 &start, &end, &r, &w, &x, &p, &offset );
464 if (r == 'r') vprot |= VPROT_READ;
465 if (w == 'w') vprot |= VPROT_WRITE;
466 if (x == 'x') vprot |= VPROT_EXEC;
467 if (p == 'p') vprot |= VPROT_WRITECOPY;
468 VIRTUAL_CreateView( start, end - start, 0,
469 VFLAG_SYSTEM, vprot, -1 );
479 /***********************************************************************
480 * VIRTUAL_GetPageSize
482 DWORD VIRTUAL_GetPageSize(void)
484 return 1 << page_shift;
488 /***********************************************************************
489 * VIRTUAL_GetGranularity
491 DWORD VIRTUAL_GetGranularity(void)
493 return granularity_mask + 1;
497 /***********************************************************************
498 * VIRTUAL_SetFaultHandler
500 BOOL VIRTUAL_SetFaultHandler( LPCVOID addr, HANDLERPROC proc, LPVOID arg )
504 if (!(view = VIRTUAL_FindView((UINT)addr))) return FALSE;
505 view->handlerProc = proc;
506 view->handlerArg = arg;
510 /***********************************************************************
511 * VIRTUAL_HandleFault
513 BOOL VIRTUAL_HandleFault( LPCVOID addr )
515 FILE_VIEW *view = VIRTUAL_FindView((UINT)addr);
517 if (view && view->handlerProc)
518 return view->handlerProc(view->handlerArg, addr);
523 /***********************************************************************
524 * VirtualAlloc (KERNEL32.548)
525 * Reserves or commits a region of pages in virtual address space
528 * Base address of allocated region of pages
531 LPVOID WINAPI VirtualAlloc(
532 LPVOID addr, /* [in] Address of region to reserve or commit */
533 DWORD size, /* [in] Size of region */
534 DWORD type, /* [in] Type of allocation */
535 DWORD protect /* [in] Type of access protection */
538 UINT base, ptr, view_size;
541 TRACE("%08x %08lx %lx %08lx\n",
542 (UINT)addr, size, type, protect );
544 /* Round parameters to a page boundary */
546 if (size > 0x7fc00000) /* 2Gb - 4Mb */
548 SetLastError( ERROR_OUTOFMEMORY );
553 if (type & MEM_RESERVE) /* Round down to 64k boundary */
554 base = (UINT)addr & ~granularity_mask;
556 base = ROUND_ADDR( addr );
557 size = (((UINT)addr + size + page_mask) & ~page_mask) - base;
558 if ((base <= granularity_mask) || (base + size < base))
560 /* disallow low 64k and wrap-around */
561 SetLastError( ERROR_INVALID_PARAMETER );
568 size = (size + page_mask) & ~page_mask;
571 if (type & MEM_TOP_DOWN) {
572 /* FIXME: MEM_TOP_DOWN allocates the largest possible address.
573 * Is there _ANY_ way to do it with UNIX mmap()?
575 WARN("MEM_TOP_DOWN ignored\n");
576 type &= ~MEM_TOP_DOWN;
578 /* Compute the protection flags */
580 if (!(type & (MEM_COMMIT | MEM_RESERVE)) ||
581 (type & ~(MEM_COMMIT | MEM_RESERVE)))
583 SetLastError( ERROR_INVALID_PARAMETER );
586 if (type & MEM_COMMIT)
587 vprot = VIRTUAL_GetProt( protect ) | VPROT_COMMITTED;
590 /* Reserve the memory */
592 if ((type & MEM_RESERVE) || !base)
594 view_size = size + (base ? 0 : granularity_mask + 1);
595 ptr = (UINT)FILE_dommap( -1, (LPVOID)base, 0, view_size, 0, 0,
596 VIRTUAL_GetUnixProt( vprot ), MAP_PRIVATE );
599 SetLastError( ERROR_OUTOFMEMORY );
604 /* Release the extra memory while keeping the range */
605 /* starting on a 64k boundary. */
607 if (ptr & granularity_mask)
609 UINT extra = granularity_mask + 1 - (ptr & granularity_mask);
610 FILE_munmap( (void *)ptr, 0, extra );
614 if (view_size > size)
615 FILE_munmap( (void *)(ptr + size), 0, view_size - size );
617 else if (ptr != base)
619 /* We couldn't get the address we wanted */
620 FILE_munmap( (void *)ptr, 0, view_size );
621 SetLastError( ERROR_INVALID_ADDRESS );
624 if (!(view = VIRTUAL_CreateView( ptr, size, 0, 0, vprot, -1 )))
626 FILE_munmap( (void *)ptr, 0, size );
627 SetLastError( ERROR_OUTOFMEMORY );
630 VIRTUAL_DEBUG_DUMP_VIEW( view );
634 /* Commit the pages */
636 if (!(view = VIRTUAL_FindView( base )) ||
637 (base + size > view->base + view->size))
639 SetLastError( ERROR_INVALID_ADDRESS );
643 if (!VIRTUAL_SetProt( view, base, size, vprot )) return NULL;
648 /***********************************************************************
649 * VirtualFree (KERNEL32.550)
650 * Release or decommits a region of pages in virtual address space.
656 BOOL WINAPI VirtualFree(
657 LPVOID addr, /* [in] Address of region of committed pages */
658 DWORD size, /* [in] Size of region */
659 DWORD type /* [in] Type of operation */
664 TRACE("%08x %08lx %lx\n",
665 (UINT)addr, size, type );
667 /* Fix the parameters */
669 size = ROUND_SIZE( addr, size );
670 base = ROUND_ADDR( addr );
672 if (!(view = VIRTUAL_FindView( base )) ||
673 (base + size > view->base + view->size))
675 SetLastError( ERROR_INVALID_PARAMETER );
679 /* Compute the protection flags */
681 if ((type != MEM_DECOMMIT) && (type != MEM_RELEASE))
683 SetLastError( ERROR_INVALID_PARAMETER );
689 if (type == MEM_RELEASE)
691 if (size || (base != view->base))
693 SetLastError( ERROR_INVALID_PARAMETER );
696 VIRTUAL_DeleteView( view );
700 /* Decommit the pages by remapping zero-pages instead */
702 if (FILE_dommap( -1, (LPVOID)base, 0, size, 0, 0,
703 VIRTUAL_GetUnixProt( 0 ), MAP_PRIVATE|MAP_FIXED )
705 ERR( "Could not remap pages, expect trouble\n" );
706 return VIRTUAL_SetProt( view, base, size, 0 );
710 /***********************************************************************
711 * VirtualLock (KERNEL32.551)
712 * Locks the specified region of virtual address space
715 * Always returns TRUE
721 BOOL WINAPI VirtualLock(
722 LPVOID addr, /* [in] Address of first byte of range to lock */
723 DWORD size /* [in] Number of bytes in range to lock */
729 /***********************************************************************
730 * VirtualUnlock (KERNEL32.556)
731 * Unlocks a range of pages in the virtual address space
734 * Always returns TRUE
740 BOOL WINAPI VirtualUnlock(
741 LPVOID addr, /* [in] Address of first byte of range */
742 DWORD size /* [in] Number of bytes in range */
748 /***********************************************************************
749 * VirtualProtect (KERNEL32.552)
750 * Changes the access protection on a region of committed pages
756 BOOL WINAPI VirtualProtect(
757 LPVOID addr, /* [in] Address of region of committed pages */
758 DWORD size, /* [in] Size of region */
759 DWORD new_prot, /* [in] Desired access protection */
760 LPDWORD old_prot /* [out] Address of variable to get old protection */
766 TRACE("%08x %08lx %08lx\n",
767 (UINT)addr, size, new_prot );
769 /* Fix the parameters */
771 size = ROUND_SIZE( addr, size );
772 base = ROUND_ADDR( addr );
774 if (!(view = VIRTUAL_FindView( base )) ||
775 (base + size > view->base + view->size))
777 SetLastError( ERROR_INVALID_PARAMETER );
781 /* Make sure all the pages are committed */
783 p = view->prot + ((base - view->base) >> page_shift);
784 for (i = size >> page_shift; i; i--, p++)
786 if (!(*p & VPROT_COMMITTED))
788 SetLastError( ERROR_INVALID_PARAMETER );
793 VIRTUAL_GetWin32Prot( view->prot[0], old_prot, NULL );
794 vprot = VIRTUAL_GetProt( new_prot ) | VPROT_COMMITTED;
795 return VIRTUAL_SetProt( view, base, size, vprot );
799 /***********************************************************************
800 * VirtualProtectEx (KERNEL32.553)
801 * Changes the access protection on a region of committed pages in the
802 * virtual address space of a specified process
808 BOOL WINAPI VirtualProtectEx(
809 HANDLE handle, /* [in] Handle of process */
810 LPVOID addr, /* [in] Address of region of committed pages */
811 DWORD size, /* [in] Size of region */
812 DWORD new_prot, /* [in] Desired access protection */
813 LPDWORD old_prot /* [out] Address of variable to get old protection */ )
815 if (PROCESS_IsCurrent( handle ))
816 return VirtualProtect( addr, size, new_prot, old_prot );
817 ERR("Unsupported on other process\n");
822 /***********************************************************************
823 * VirtualQuery (KERNEL32.554)
824 * Provides info about a range of pages in virtual address space
827 * Number of bytes returned in information buffer
829 DWORD WINAPI VirtualQuery(
830 LPCVOID addr, /* [in] Address of region */
831 LPMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */
832 DWORD len /* [in] Size of buffer */
834 FILE_VIEW *view = VIRTUAL_FirstView;
835 UINT base = ROUND_ADDR( addr );
839 /* Find the view containing the address */
845 size = 0xffff0000 - alloc_base;
848 if (view->base > base)
850 size = view->base - alloc_base;
854 if (view->base + view->size > base)
856 alloc_base = view->base;
860 alloc_base = view->base + view->size;
864 /* Fill the info structure */
868 info->State = MEM_FREE;
870 info->AllocationProtect = 0;
875 BYTE vprot = view->prot[(base - alloc_base) >> page_shift];
876 VIRTUAL_GetWin32Prot( vprot, &info->Protect, &info->State );
877 for (size = base - alloc_base; size < view->size; size += page_mask+1)
878 if (view->prot[size >> page_shift] != vprot) break;
879 info->AllocationProtect = view->protect;
880 info->Type = MEM_PRIVATE; /* FIXME */
883 info->BaseAddress = (LPVOID)base;
884 info->AllocationBase = (LPVOID)alloc_base;
885 info->RegionSize = size - (base - alloc_base);
886 return sizeof(*info);
890 /***********************************************************************
891 * VirtualQueryEx (KERNEL32.555)
892 * Provides info about a range of pages in virtual address space of a
896 * Number of bytes returned in information buffer
898 DWORD WINAPI VirtualQueryEx(
899 HANDLE handle, /* [in] Handle of process */
900 LPCVOID addr, /* [in] Address of region */
901 LPMEMORY_BASIC_INFORMATION info, /* [out] Address of info buffer */
902 DWORD len /* [in] Size of buffer */ )
904 if (PROCESS_IsCurrent( handle ))
905 return VirtualQuery( addr, info, len );
906 ERR("Unsupported on other process\n");
911 /***********************************************************************
912 * IsBadReadPtr32 (KERNEL32.354)
915 * FALSE: Process has read access to entire block
918 BOOL WINAPI IsBadReadPtr(
919 LPCVOID ptr, /* Address of memory block */
920 UINT size /* Size of block */
922 return !VIRTUAL_CheckFlags( (UINT)ptr, size,
923 VPROT_READ | VPROT_COMMITTED );
927 /***********************************************************************
928 * IsBadWritePtr32 (KERNEL32.357)
931 * FALSE: Process has write access to entire block
934 BOOL WINAPI IsBadWritePtr(
935 LPVOID ptr, /* [in] Address of memory block */
936 UINT size /* [in] Size of block in bytes */
938 return !VIRTUAL_CheckFlags( (UINT)ptr, size,
939 VPROT_WRITE | VPROT_COMMITTED );
943 /***********************************************************************
944 * IsBadHugeReadPtr32 (KERNEL32.352)
946 * FALSE: Process has read access to entire block
949 BOOL WINAPI IsBadHugeReadPtr(
950 LPCVOID ptr, /* [in] Address of memory block */
951 UINT size /* [in] Size of block */
953 return IsBadReadPtr( ptr, size );
957 /***********************************************************************
958 * IsBadHugeWritePtr32 (KERNEL32.353)
960 * FALSE: Process has write access to entire block
963 BOOL WINAPI IsBadHugeWritePtr(
964 LPVOID ptr, /* [in] Address of memory block */
965 UINT size /* [in] Size of block */
967 return IsBadWritePtr( ptr, size );
971 /***********************************************************************
972 * IsBadCodePtr32 (KERNEL32.351)
975 * FALSE: Process has read access to specified memory
978 BOOL WINAPI IsBadCodePtr(
979 FARPROC ptr /* [in] Address of function */
981 return !VIRTUAL_CheckFlags( (UINT)ptr, 1, VPROT_EXEC | VPROT_COMMITTED );
985 /***********************************************************************
986 * IsBadStringPtr32A (KERNEL32.355)
989 * FALSE: Read access to all bytes in string
992 BOOL WINAPI IsBadStringPtrA(
993 LPCSTR str, /* [in] Address of string */
994 UINT max /* [in] Maximum size of string */
999 if (!max) return FALSE;
1000 if (!(view = VIRTUAL_FindView( (UINT)str ))) return TRUE;
1001 page = ((UINT)str - view->base) >> page_shift;
1002 count = page_mask + 1 - ((UINT)str & page_mask);
1006 if ((view->prot[page] & (VPROT_READ | VPROT_COMMITTED)) !=
1007 (VPROT_READ | VPROT_COMMITTED))
1009 if (count > max) count = max;
1011 while (count--) if (!*str++) return FALSE;
1012 if (++page >= view->size >> page_shift) return TRUE;
1013 count = page_mask + 1;
1019 /***********************************************************************
1020 * IsBadStringPtr32W (KERNEL32.356)
1021 * See IsBadStringPtr32A
1023 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT max )
1028 if (!max) return FALSE;
1029 if (!(view = VIRTUAL_FindView( (UINT)str ))) return TRUE;
1030 page = ((UINT)str - view->base) >> page_shift;
1031 count = (page_mask + 1 - ((UINT)str & page_mask)) / sizeof(WCHAR);
1035 if ((view->prot[page] & (VPROT_READ | VPROT_COMMITTED)) !=
1036 (VPROT_READ | VPROT_COMMITTED))
1038 if (count > max) count = max;
1040 while (count--) if (!*str++) return FALSE;
1041 if (++page >= view->size >> page_shift) return TRUE;
1042 count = (page_mask + 1) / sizeof(WCHAR);
1048 /***********************************************************************
1049 * CreateFileMapping32A (KERNEL32.46)
1050 * Creates a named or unnamed file-mapping object for the specified file
1054 * 0: Mapping object does not exist
1057 HANDLE WINAPI CreateFileMappingA(
1058 HFILE hFile, /* [in] Handle of file to map */
1059 SECURITY_ATTRIBUTES *sa, /* [in] Optional security attributes*/
1060 DWORD protect, /* [in] Protection for mapping object */
1061 DWORD size_high, /* [in] High-order 32 bits of object size */
1062 DWORD size_low, /* [in] Low-order 32 bits of object size */
1063 LPCSTR name /* [in] Name of file-mapping object */ )
1065 struct create_mapping_request *req = get_req_buffer();
1068 /* Check parameters */
1070 TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
1071 hFile, sa, protect, size_high, size_low, debugstr_a(name) );
1073 vprot = VIRTUAL_GetProt( protect );
1074 if (protect & SEC_RESERVE)
1076 if (hFile != INVALID_HANDLE_VALUE)
1078 SetLastError( ERROR_INVALID_PARAMETER );
1082 else vprot |= VPROT_COMMITTED;
1083 if (protect & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
1085 /* Create the server object */
1087 req->file_handle = hFile;
1088 req->size_high = size_high;
1089 req->size_low = size_low;
1090 req->protect = vprot;
1091 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
1092 server_strcpyAtoW( req->name, name );
1094 server_call( REQ_CREATE_MAPPING );
1095 if (req->handle == -1) return 0;
1100 /***********************************************************************
1101 * CreateFileMapping32W (KERNEL32.47)
1102 * See CreateFileMapping32A
1104 HANDLE WINAPI CreateFileMappingW( HFILE hFile, LPSECURITY_ATTRIBUTES sa,
1105 DWORD protect, DWORD size_high,
1106 DWORD size_low, LPCWSTR name )
1108 struct create_mapping_request *req = get_req_buffer();
1111 /* Check parameters */
1113 TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
1114 hFile, sa, protect, size_high, size_low, debugstr_w(name) );
1116 vprot = VIRTUAL_GetProt( protect );
1117 if (protect & SEC_RESERVE)
1119 if (hFile != INVALID_HANDLE_VALUE)
1121 SetLastError( ERROR_INVALID_PARAMETER );
1125 else vprot |= VPROT_COMMITTED;
1126 if (protect & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
1128 /* Create the server object */
1130 req->file_handle = hFile;
1131 req->size_high = size_high;
1132 req->size_low = size_low;
1133 req->protect = vprot;
1134 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
1135 server_strcpyW( req->name, name );
1137 server_call( REQ_CREATE_MAPPING );
1138 if (req->handle == -1) return 0;
1143 /***********************************************************************
1144 * OpenFileMapping32A (KERNEL32.397)
1145 * Opens a named file-mapping object.
1151 HANDLE WINAPI OpenFileMappingA(
1152 DWORD access, /* [in] Access mode */
1153 BOOL inherit, /* [in] Inherit flag */
1154 LPCSTR name ) /* [in] Name of file-mapping object */
1156 struct open_mapping_request *req = get_req_buffer();
1158 req->access = access;
1159 req->inherit = inherit;
1160 server_strcpyAtoW( req->name, name );
1161 server_call( REQ_OPEN_MAPPING );
1162 if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
1167 /***********************************************************************
1168 * OpenFileMapping32W (KERNEL32.398)
1169 * See OpenFileMapping32A
1171 HANDLE WINAPI OpenFileMappingW( DWORD access, BOOL inherit, LPCWSTR name)
1173 struct open_mapping_request *req = get_req_buffer();
1175 req->access = access;
1176 req->inherit = inherit;
1177 server_strcpyW( req->name, name );
1178 server_call( REQ_OPEN_MAPPING );
1179 if (req->handle == -1) return 0; /* must return 0 on failure, not -1 */
1184 /***********************************************************************
1185 * MapViewOfFile (KERNEL32.385)
1186 * Maps a view of a file into the address space
1189 * Starting address of mapped view
1192 LPVOID WINAPI MapViewOfFile(
1193 HANDLE mapping, /* [in] File-mapping object to map */
1194 DWORD access, /* [in] Access mode */
1195 DWORD offset_high, /* [in] High-order 32 bits of file offset */
1196 DWORD offset_low, /* [in] Low-order 32 bits of file offset */
1197 DWORD count /* [in] Number of bytes to map */
1199 return MapViewOfFileEx( mapping, access, offset_high,
1200 offset_low, count, NULL );
1204 /***********************************************************************
1205 * MapViewOfFileEx (KERNEL32.386)
1206 * Maps a view of a file into the address space
1209 * Starting address of mapped view
1212 LPVOID WINAPI MapViewOfFileEx(
1213 HANDLE handle, /* [in] File-mapping object to map */
1214 DWORD access, /* [in] Access mode */
1215 DWORD offset_high, /* [in] High-order 32 bits of file offset */
1216 DWORD offset_low, /* [in] Low-order 32 bits of file offset */
1217 DWORD count, /* [in] Number of bytes to map */
1218 LPVOID addr /* [in] Suggested starting address for mapped view */
1221 UINT ptr = (UINT)-1, size = 0;
1222 int flags = MAP_PRIVATE;
1223 int unix_handle = -1;
1225 struct get_mapping_info_request *req = get_req_buffer();
1227 /* Check parameters */
1229 if ((offset_low & granularity_mask) ||
1230 (addr && ((UINT)addr & granularity_mask)))
1232 SetLastError( ERROR_INVALID_PARAMETER );
1236 req->handle = handle;
1237 if (server_call_fd( REQ_GET_MAPPING_INFO, -1, &unix_handle )) goto error;
1239 if (req->size_high || offset_high)
1240 ERR("Offsets larger than 4Gb not supported\n");
1242 if ((offset_low >= req->size_low) ||
1243 (count > req->size_low - offset_low))
1245 SetLastError( ERROR_INVALID_PARAMETER );
1248 if (count) size = ROUND_SIZE( offset_low, count );
1249 else size = req->size_low - offset_low;
1250 prot = req->protect;
1254 case FILE_MAP_ALL_ACCESS:
1255 case FILE_MAP_WRITE:
1256 case FILE_MAP_WRITE | FILE_MAP_READ:
1257 if (!(prot & VPROT_WRITE))
1259 SetLastError( ERROR_INVALID_PARAMETER );
1266 case FILE_MAP_COPY | FILE_MAP_READ:
1267 if (prot & VPROT_READ) break;
1270 SetLastError( ERROR_INVALID_PARAMETER );
1276 TRACE("handle=%x size=%x offset=%lx\n", handle, size, offset_low );
1278 ptr = (UINT)FILE_dommap( unix_handle, addr, 0, size, 0, offset_low,
1279 VIRTUAL_GetUnixProt( prot ), flags );
1280 if (ptr == (UINT)-1) {
1281 /* KB: Q125713, 25-SEP-1995, "Common File Mapping Problems and
1282 * Platform Differences":
1283 * Windows NT: ERROR_INVALID_PARAMETER
1284 * Windows 95: ERROR_INVALID_ADDRESS.
1285 * FIXME: So should we add a module dependend check here? -MM
1288 SetLastError( ERROR_OUTOFMEMORY );
1290 SetLastError( ERROR_INVALID_PARAMETER );
1294 if (!(view = VIRTUAL_CreateView( ptr, size, offset_low, 0, prot, handle )))
1296 SetLastError( ERROR_OUTOFMEMORY );
1299 if (unix_handle != -1) close( unix_handle );
1303 if (unix_handle != -1) close( unix_handle );
1304 if (ptr != (UINT)-1) FILE_munmap( (void *)ptr, 0, size );
1309 /***********************************************************************
1310 * FlushViewOfFile (KERNEL32.262)
1311 * Writes to the disk a byte range within a mapped view of a file
1317 BOOL WINAPI FlushViewOfFile(
1318 LPCVOID base, /* [in] Start address of byte range to flush */
1319 DWORD cbFlush /* [in] Number of bytes in range */
1322 UINT addr = ROUND_ADDR( base );
1324 TRACE("FlushViewOfFile at %p for %ld bytes\n",
1327 if (!(view = VIRTUAL_FindView( addr )))
1329 SetLastError( ERROR_INVALID_PARAMETER );
1332 if (!cbFlush) cbFlush = view->size;
1333 if (!msync( (void *)addr, cbFlush, MS_SYNC )) return TRUE;
1334 SetLastError( ERROR_INVALID_PARAMETER );
1339 /***********************************************************************
1340 * UnmapViewOfFile (KERNEL32.540)
1341 * Unmaps a mapped view of a file.
1344 * Should addr be an LPCVOID?
1350 BOOL WINAPI UnmapViewOfFile(
1351 LPVOID addr /* [in] Address where mapped view begins */
1354 UINT base = ROUND_ADDR( addr );
1355 if (!(view = VIRTUAL_FindView( base )) || (base != view->base))
1357 SetLastError( ERROR_INVALID_PARAMETER );
1360 VIRTUAL_DeleteView( view );
1364 /***********************************************************************
1367 * Helper function to map a file to memory:
1369 * [RETURN] ptr - pointer to mapped file
1371 LPVOID VIRTUAL_MapFileW( LPCWSTR name )
1373 HANDLE hFile, hMapping;
1376 hFile = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL,
1377 OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, 0);
1378 if (hFile != INVALID_HANDLE_VALUE)
1380 hMapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
1381 CloseHandle( hFile );
1384 ptr = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
1385 CloseHandle( hMapping );