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
25 #include "wine/exception.h"
26 #include "wine/unicode.h"
27 #include "wine/library.h"
28 #include "wine/port.h"
34 #include "debugtools.h"
36 DEFAULT_DEBUG_CHANNEL(virtual);
37 DECLARE_DEBUG_CHANNEL(module
);
46 struct _FV
*next
; /* Next view */
47 struct _FV
*prev
; /* Prev view */
48 UINT base
; /* Base address */
49 UINT size
; /* Size in bytes */
50 UINT flags
; /* Allocation flags */
51 HANDLE mapping
; /* Handle to the file mapping */
52 HANDLERPROC handlerProc
; /* Fault handler */
53 LPVOID handlerArg
; /* Fault handler argument */
54 BYTE protect
; /* Protection for all pages at allocation time */
55 BYTE prot
[1]; /* Protection byte for each page */
59 #define VFLAG_SYSTEM 0x01
61 /* Conversion from VPROT_* to Win32 flags */
62 static const BYTE VIRTUAL_Win32Flags
[16] =
64 PAGE_NOACCESS
, /* 0 */
65 PAGE_READONLY
, /* READ */
66 PAGE_READWRITE
, /* WRITE */
67 PAGE_READWRITE
, /* READ | WRITE */
68 PAGE_EXECUTE
, /* EXEC */
69 PAGE_EXECUTE_READ
, /* READ | EXEC */
70 PAGE_EXECUTE_READWRITE
, /* WRITE | EXEC */
71 PAGE_EXECUTE_READWRITE
, /* READ | WRITE | EXEC */
72 PAGE_WRITECOPY
, /* WRITECOPY */
73 PAGE_WRITECOPY
, /* READ | WRITECOPY */
74 PAGE_WRITECOPY
, /* WRITE | WRITECOPY */
75 PAGE_WRITECOPY
, /* READ | WRITE | WRITECOPY */
76 PAGE_EXECUTE_WRITECOPY
, /* EXEC | WRITECOPY */
77 PAGE_EXECUTE_WRITECOPY
, /* READ | EXEC | WRITECOPY */
78 PAGE_EXECUTE_WRITECOPY
, /* WRITE | EXEC | WRITECOPY */
79 PAGE_EXECUTE_WRITECOPY
/* READ | WRITE | EXEC | WRITECOPY */
83 static FILE_VIEW
*VIRTUAL_FirstView
;
84 static CRITICAL_SECTION csVirtual
= CRITICAL_SECTION_INIT
;
87 /* These are always the same on an i386, and it will be faster this way */
88 # define page_mask 0xfff
89 # define page_shift 12
90 # define page_size 0x1000
92 static UINT page_shift
;
93 static UINT page_mask
;
94 static UINT page_size
;
96 #define granularity_mask 0xffff /* Allocation granularity (usually 64k) */
98 #define ROUND_ADDR(addr) \
99 ((UINT)(addr) & ~page_mask)
101 #define ROUND_SIZE(addr,size) \
102 (((UINT)(size) + ((UINT)(addr) & page_mask) + page_mask) & ~page_mask)
104 #define VIRTUAL_DEBUG_DUMP_VIEW(view) \
105 if (!TRACE_ON(virtual)); else VIRTUAL_DumpView(view)
108 /* filter for page-fault exceptions */
109 static WINE_EXCEPTION_FILTER(page_fault
)
111 if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION
)
112 return EXCEPTION_EXECUTE_HANDLER
;
113 return EXCEPTION_CONTINUE_SEARCH
;
116 /***********************************************************************
119 static const char *VIRTUAL_GetProtStr( BYTE prot
)
121 static char buffer
[6];
122 buffer
[0] = (prot
& VPROT_COMMITTED
) ? 'c' : '-';
123 buffer
[1] = (prot
& VPROT_GUARD
) ? 'g' : '-';
124 buffer
[2] = (prot
& VPROT_READ
) ? 'r' : '-';
125 buffer
[3] = (prot
& VPROT_WRITE
) ?
126 ((prot
& VPROT_WRITECOPY
) ? 'w' : 'W') : '-';
127 buffer
[4] = (prot
& VPROT_EXEC
) ? 'x' : '-';
133 /***********************************************************************
136 static void VIRTUAL_DumpView( FILE_VIEW
*view
)
139 UINT addr
= view
->base
;
140 BYTE prot
= view
->prot
[0];
142 DPRINTF( "View: %08x - %08x%s",
143 view
->base
, view
->base
+ view
->size
- 1,
144 (view
->flags
& VFLAG_SYSTEM
) ? " (system)" : "" );
146 DPRINTF( " %d\n", view
->mapping
);
148 DPRINTF( " (anonymous)\n");
150 for (count
= i
= 1; i
< view
->size
>> page_shift
; i
++, count
++)
152 if (view
->prot
[i
] == prot
) continue;
153 DPRINTF( " %08x - %08x %s\n",
154 addr
, addr
+ (count
<< page_shift
) - 1,
155 VIRTUAL_GetProtStr(prot
) );
156 addr
+= (count
<< page_shift
);
157 prot
= view
->prot
[i
];
161 DPRINTF( " %08x - %08x %s\n",
162 addr
, addr
+ (count
<< page_shift
) - 1,
163 VIRTUAL_GetProtStr(prot
) );
167 /***********************************************************************
170 void VIRTUAL_Dump(void)
173 DPRINTF( "\nDump of all virtual memory views:\n\n" );
174 EnterCriticalSection(&csVirtual
);
175 view
= VIRTUAL_FirstView
;
178 VIRTUAL_DumpView( view
);
181 LeaveCriticalSection(&csVirtual
);
185 /***********************************************************************
188 * Find the view containing a given address.
194 static FILE_VIEW
*VIRTUAL_FindView(
195 UINT addr
/* [in] Address */
199 EnterCriticalSection(&csVirtual
);
200 view
= VIRTUAL_FirstView
;
203 if (view
->base
> addr
)
208 if (view
->base
+ view
->size
> addr
) break;
211 LeaveCriticalSection(&csVirtual
);
216 /***********************************************************************
219 * Create a new view and add it in the linked list.
221 static FILE_VIEW
*VIRTUAL_CreateView( UINT base
, UINT size
, UINT flags
,
222 BYTE vprot
, HANDLE mapping
)
224 FILE_VIEW
*view
, *prev
;
226 /* Create the view structure */
228 assert( !(base
& page_mask
) );
229 assert( !(size
& page_mask
) );
231 if (!(view
= (FILE_VIEW
*)malloc( sizeof(*view
) + size
- 1 ))) return NULL
;
233 view
->size
= size
<< page_shift
;
235 view
->mapping
= mapping
;
236 view
->protect
= vprot
;
237 view
->handlerProc
= NULL
;
238 memset( view
->prot
, vprot
, size
);
240 /* Duplicate the mapping handle */
243 !DuplicateHandle( GetCurrentProcess(), view
->mapping
,
244 GetCurrentProcess(), &view
->mapping
,
245 0, FALSE
, DUPLICATE_SAME_ACCESS
))
251 /* Insert it in the linked list */
253 EnterCriticalSection(&csVirtual
);
254 if (!VIRTUAL_FirstView
|| (VIRTUAL_FirstView
->base
> base
))
256 view
->next
= VIRTUAL_FirstView
;
258 if (view
->next
) view
->next
->prev
= view
;
259 VIRTUAL_FirstView
= view
;
263 prev
= VIRTUAL_FirstView
;
264 while (prev
->next
&& (prev
->next
->base
< base
)) prev
= prev
->next
;
265 view
->next
= prev
->next
;
267 if (view
->next
) view
->next
->prev
= view
;
270 LeaveCriticalSection(&csVirtual
);
271 VIRTUAL_DEBUG_DUMP_VIEW( view
);
276 /***********************************************************************
283 static void VIRTUAL_DeleteView(
284 FILE_VIEW
*view
/* [in] View */
286 if (!(view
->flags
& VFLAG_SYSTEM
))
287 munmap( (void *)view
->base
, view
->size
);
288 EnterCriticalSection(&csVirtual
);
289 if (view
->next
) view
->next
->prev
= view
->prev
;
290 if (view
->prev
) view
->prev
->next
= view
->next
;
291 else VIRTUAL_FirstView
= view
->next
;
292 LeaveCriticalSection(&csVirtual
);
293 if (view
->mapping
) NtClose( view
->mapping
);
298 /***********************************************************************
299 * VIRTUAL_GetUnixProt
301 * Convert page protections to protection for mmap/mprotect.
303 static int VIRTUAL_GetUnixProt( BYTE vprot
)
306 if ((vprot
& VPROT_COMMITTED
) && !(vprot
& VPROT_GUARD
))
308 if (vprot
& VPROT_READ
) prot
|= PROT_READ
;
309 if (vprot
& VPROT_WRITE
) prot
|= PROT_WRITE
;
310 if (vprot
& VPROT_WRITECOPY
) prot
|= PROT_WRITE
;
311 if (vprot
& VPROT_EXEC
) prot
|= PROT_EXEC
;
317 /***********************************************************************
318 * VIRTUAL_GetWin32Prot
320 * Convert page protections to Win32 flags.
325 static void VIRTUAL_GetWin32Prot(
326 BYTE vprot
, /* [in] Page protection flags */
327 DWORD
*protect
, /* [out] Location to store Win32 protection flags */
328 DWORD
*state
/* [out] Location to store mem state flag */
331 *protect
= VIRTUAL_Win32Flags
[vprot
& 0x0f];
332 /* if (vprot & VPROT_GUARD) *protect |= PAGE_GUARD;*/
333 if (vprot
& VPROT_NOCACHE
) *protect
|= PAGE_NOCACHE
;
335 if (vprot
& VPROT_GUARD
) *protect
= PAGE_NOACCESS
;
338 if (state
) *state
= (vprot
& VPROT_COMMITTED
) ? MEM_COMMIT
: MEM_RESERVE
;
342 /***********************************************************************
345 * Build page protections from Win32 flags.
348 * Value of page protection flags
350 static BYTE
VIRTUAL_GetProt(
351 DWORD protect
/* [in] Win32 protection flags */
355 switch(protect
& 0xff)
361 vprot
= VPROT_READ
| VPROT_WRITE
;
364 vprot
= VPROT_READ
| VPROT_WRITE
| VPROT_WRITECOPY
;
369 case PAGE_EXECUTE_READ
:
370 vprot
= VPROT_EXEC
| VPROT_READ
;
372 case PAGE_EXECUTE_READWRITE
:
373 vprot
= VPROT_EXEC
| VPROT_READ
| VPROT_WRITE
;
375 case PAGE_EXECUTE_WRITECOPY
:
376 vprot
= VPROT_EXEC
| VPROT_READ
| VPROT_WRITE
| VPROT_WRITECOPY
;
383 if (protect
& PAGE_GUARD
) vprot
|= VPROT_GUARD
;
384 if (protect
& PAGE_NOCACHE
) vprot
|= VPROT_NOCACHE
;
389 /***********************************************************************
392 * Change the protection of a range of pages.
398 static BOOL
VIRTUAL_SetProt(
399 FILE_VIEW
*view
, /* [in] Pointer to view */
400 UINT base
, /* [in] Starting address */
401 UINT size
, /* [in] Size in bytes */
402 BYTE vprot
/* [in] Protections to use */
404 TRACE("%08x-%08x %s\n",
405 base
, base
+ size
- 1, VIRTUAL_GetProtStr( vprot
) );
407 if (mprotect( (void *)base
, size
, VIRTUAL_GetUnixProt(vprot
) ))
408 return FALSE
; /* FIXME: last error */
410 memset( view
->prot
+ ((base
- view
->base
) >> page_shift
),
411 vprot
, size
>> page_shift
);
412 VIRTUAL_DEBUG_DUMP_VIEW( view
);
417 /***********************************************************************
420 * Map an executable (PE format) image into memory.
422 static LPVOID
map_image( HANDLE hmapping
, int fd
, char *base
, DWORD total_size
,
423 DWORD header_size
, HANDLE shared_file
, DWORD shared_size
)
425 IMAGE_DOS_HEADER
*dos
;
426 IMAGE_NT_HEADERS
*nt
;
427 IMAGE_SECTION_HEADER
*sec
;
429 DWORD err
= GetLastError();
430 FILE_VIEW
*view
= NULL
;
434 SetLastError( ERROR_BAD_EXE_FORMAT
); /* generic error */
436 /* zero-map the whole range */
438 if ((ptr
= wine_anon_mmap( base
, total_size
,
439 PROT_READ
| PROT_WRITE
| PROT_EXEC
, 0 )) == (char *)-1)
441 ptr
= wine_anon_mmap( NULL
, total_size
,
442 PROT_READ
| PROT_WRITE
| PROT_EXEC
, 0 );
443 if (ptr
== (char *)-1)
445 ERR_(module
)("Not enough memory for module (%ld bytes)\n", total_size
);
449 TRACE_(module
)( "mapped PE file at %p-%p\n", ptr
, ptr
+ total_size
);
451 if (!(view
= VIRTUAL_CreateView( (UINT
)ptr
, total_size
, 0,
452 VPROT_COMMITTED
|VPROT_READ
|VPROT_WRITE
|VPROT_WRITECOPY
,
455 munmap( ptr
, total_size
);
456 SetLastError( ERROR_OUTOFMEMORY
);
462 if (VIRTUAL_mmap( fd
, ptr
, header_size
, 0, PROT_READ
| PROT_WRITE
,
463 MAP_PRIVATE
| MAP_FIXED
) == (char *)-1) goto error
;
464 dos
= (IMAGE_DOS_HEADER
*)ptr
;
465 nt
= (IMAGE_NT_HEADERS
*)(ptr
+ dos
->e_lfanew
);
466 if ((char *)(nt
+ 1) > ptr
+ header_size
) goto error
;
468 sec
= (IMAGE_SECTION_HEADER
*)((char*)&nt
->OptionalHeader
+nt
->FileHeader
.SizeOfOptionalHeader
);
469 if ((char *)(sec
+ nt
->FileHeader
.NumberOfSections
) > ptr
+ header_size
) goto error
;
471 /* check the architecture */
473 if (nt
->FileHeader
.Machine
!= IMAGE_FILE_MACHINE_I386
)
475 MESSAGE("Trying to load PE image for unsupported architecture (");
476 switch (nt
->FileHeader
.Machine
)
478 case IMAGE_FILE_MACHINE_UNKNOWN
: MESSAGE("Unknown"); break;
479 case IMAGE_FILE_MACHINE_I860
: MESSAGE("I860"); break;
480 case IMAGE_FILE_MACHINE_R3000
: MESSAGE("R3000"); break;
481 case IMAGE_FILE_MACHINE_R4000
: MESSAGE("R4000"); break;
482 case IMAGE_FILE_MACHINE_R10000
: MESSAGE("R10000"); break;
483 case IMAGE_FILE_MACHINE_ALPHA
: MESSAGE("Alpha"); break;
484 case IMAGE_FILE_MACHINE_POWERPC
: MESSAGE("PowerPC"); break;
485 default: MESSAGE("Unknown-%04x", nt
->FileHeader
.Machine
); break;
491 /* retrieve the shared sections file */
495 if ((shared_fd
= FILE_GetUnixHandle( shared_file
, GENERIC_READ
)) == -1) goto error
;
496 CloseHandle( shared_file
); /* we no longer need it */
497 shared_file
= INVALID_HANDLE_VALUE
;
500 /* map all the sections */
502 for (i
= pos
= 0; i
< nt
->FileHeader
.NumberOfSections
; i
++, sec
++)
506 /* a few sanity checks */
507 size
= sec
->VirtualAddress
+ ROUND_SIZE( sec
->VirtualAddress
, sec
->Misc
.VirtualSize
);
508 if (sec
->VirtualAddress
> total_size
|| size
> total_size
|| size
< sec
->VirtualAddress
)
510 ERR_(module
)( "Section %.8s too large (%lx+%lx/%lx)\n",
511 sec
->Name
, sec
->VirtualAddress
, sec
->Misc
.VirtualSize
, total_size
);
515 if ((sec
->Characteristics
& IMAGE_SCN_MEM_SHARED
) &&
516 (sec
->Characteristics
& IMAGE_SCN_MEM_WRITE
))
518 size
= ROUND_SIZE( 0, sec
->Misc
.VirtualSize
);
519 TRACE_(module
)( "mapping shared section %.8s at %p off %lx (%x) size %lx (%lx) flags %lx\n",
520 sec
->Name
, (char *)ptr
+ sec
->VirtualAddress
,
521 sec
->PointerToRawData
, pos
, sec
->SizeOfRawData
,
522 size
, sec
->Characteristics
);
523 if (VIRTUAL_mmap( shared_fd
, (char *)ptr
+ sec
->VirtualAddress
, size
,
524 pos
, PROT_READ
|PROT_WRITE
|PROT_EXEC
,
525 MAP_SHARED
|MAP_FIXED
) == (void *)-1)
527 ERR_(module
)( "Could not map shared section %.8s\n", sec
->Name
);
534 if (sec
->Characteristics
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) continue;
535 if (!sec
->PointerToRawData
|| !sec
->SizeOfRawData
) continue;
537 TRACE_(module
)( "mapping section %.8s at %p off %lx size %lx flags %lx\n",
538 sec
->Name
, (char *)ptr
+ sec
->VirtualAddress
,
539 sec
->PointerToRawData
, sec
->SizeOfRawData
,
540 sec
->Characteristics
);
542 /* Note: if the section is not aligned properly VIRTUAL_mmap will magically
543 * fall back to read(), so we don't need to check anything here.
545 if (VIRTUAL_mmap( fd
, (char *)ptr
+ sec
->VirtualAddress
, sec
->SizeOfRawData
,
546 sec
->PointerToRawData
, PROT_READ
|PROT_WRITE
|PROT_EXEC
,
547 MAP_PRIVATE
| MAP_FIXED
) == (void *)-1)
549 ERR_(module
)( "Could not map section %.8s, file probably truncated\n", sec
->Name
);
553 if ((sec
->SizeOfRawData
< sec
->Misc
.VirtualSize
) && (sec
->SizeOfRawData
& page_mask
))
555 DWORD end
= ROUND_SIZE( 0, sec
->SizeOfRawData
);
556 if (end
> sec
->Misc
.VirtualSize
) end
= sec
->Misc
.VirtualSize
;
557 TRACE_(module
)("clearing %p - %p\n",
558 (char *)ptr
+ sec
->VirtualAddress
+ sec
->SizeOfRawData
,
559 (char *)ptr
+ sec
->VirtualAddress
+ end
);
560 memset( (char *)ptr
+ sec
->VirtualAddress
+ sec
->SizeOfRawData
, 0,
561 end
- sec
->SizeOfRawData
);
565 SetLastError( err
); /* restore last error */
567 if (shared_fd
!= -1) close( shared_fd
);
571 if (view
) VIRTUAL_DeleteView( view
);
573 if (shared_fd
!= -1) close( shared_fd
);
574 if (shared_file
!= INVALID_HANDLE_VALUE
) CloseHandle( shared_file
);
579 /***********************************************************************
583 DECL_GLOBAL_CONSTRUCTOR(VIRTUAL_Init
)
585 page_size
= getpagesize();
586 page_mask
= page_size
- 1;
587 /* Make sure we have a power of 2 */
588 assert( !(page_size
& page_mask
) );
590 while ((1 << page_shift
) != page_size
) page_shift
++;
592 #endif /* page_mask */
595 /***********************************************************************
596 * VIRTUAL_GetPageSize
598 DWORD
VIRTUAL_GetPageSize(void)
600 return 1 << page_shift
;
604 /***********************************************************************
605 * VIRTUAL_GetGranularity
607 DWORD
VIRTUAL_GetGranularity(void)
609 return granularity_mask
+ 1;
613 /***********************************************************************
614 * VIRTUAL_SetFaultHandler
616 BOOL
VIRTUAL_SetFaultHandler( LPCVOID addr
, HANDLERPROC proc
, LPVOID arg
)
620 if (!(view
= VIRTUAL_FindView((UINT
)addr
))) return FALSE
;
621 view
->handlerProc
= proc
;
622 view
->handlerArg
= arg
;
626 /***********************************************************************
627 * VIRTUAL_HandleFault
629 DWORD
VIRTUAL_HandleFault( LPCVOID addr
)
631 FILE_VIEW
*view
= VIRTUAL_FindView((UINT
)addr
);
632 DWORD ret
= EXCEPTION_ACCESS_VIOLATION
;
636 if (view
->handlerProc
)
638 if (view
->handlerProc(view
->handlerArg
, addr
)) ret
= 0; /* handled */
642 BYTE vprot
= view
->prot
[((UINT
)addr
- view
->base
) >> page_shift
];
643 UINT page
= (UINT
)addr
& ~page_mask
;
644 char *stack
= (char *)NtCurrentTeb()->stack_base
+ SIGNAL_STACK_SIZE
+ page_mask
+ 1;
645 if (vprot
& VPROT_GUARD
)
647 VIRTUAL_SetProt( view
, page
, page_mask
+ 1, vprot
& ~VPROT_GUARD
);
648 ret
= STATUS_GUARD_PAGE_VIOLATION
;
650 /* is it inside the stack guard pages? */
651 if (((char *)addr
>= stack
) && ((char *)addr
< stack
+ 2*(page_mask
+1)))
652 ret
= STATUS_STACK_OVERFLOW
;
659 /***********************************************************************
662 * Wrapper for mmap() that handles anonymous mappings portably,
663 * and falls back to read if mmap of a file fails.
665 LPVOID
VIRTUAL_mmap( int fd
, LPVOID start
, DWORD size
,
666 DWORD offset
, int prot
, int flags
)
671 if (fd
== -1) return wine_anon_mmap( start
, size
, prot
, flags
);
673 if ((ret
= mmap( start
, size
, prot
, flags
, fd
, offset
)) != (LPVOID
)-1)
676 /* mmap() failed; if this is because the file offset is not */
677 /* page-aligned (EINVAL), or because the underlying filesystem */
678 /* does not support mmap() (ENOEXEC,ENODEV), we do it by hand. */
680 if ((errno
!= ENOEXEC
) && (errno
!= EINVAL
) && (errno
!= ENODEV
)) return ret
;
681 if (prot
& PROT_WRITE
)
683 /* We cannot fake shared write mappings */
685 if (flags
& MAP_SHARED
) return ret
;
688 if (!(flags
& MAP_PRIVATE
)) return ret
;
692 /* Reserve the memory with an anonymous mmap */
693 ret
= wine_anon_mmap( start
, size
, PROT_READ
| PROT_WRITE
, flags
);
694 if (ret
== (LPVOID
)-1) return ret
;
695 /* Now read in the file */
696 if ((pos
= lseek( fd
, offset
, SEEK_SET
)) == -1)
701 read( fd
, ret
, size
);
702 lseek( fd
, pos
, SEEK_SET
); /* Restore the file pointer */
703 mprotect( ret
, size
, prot
); /* Set the right protection */
708 /***********************************************************************
709 * VirtualAlloc (KERNEL32.548)
710 * Reserves or commits a region of pages in virtual address space
713 * Base address of allocated region of pages
716 LPVOID WINAPI
VirtualAlloc(
717 LPVOID addr
, /* [in] Address of region to reserve or commit */
718 DWORD size
, /* [in] Size of region */
719 DWORD type
, /* [in] Type of allocation */
720 DWORD protect
/* [in] Type of access protection */
723 UINT base
, ptr
, view_size
;
726 TRACE("%08x %08lx %lx %08lx\n",
727 (UINT
)addr
, size
, type
, protect
);
729 /* Round parameters to a page boundary */
731 if (size
> 0x7fc00000) /* 2Gb - 4Mb */
733 SetLastError( ERROR_OUTOFMEMORY
);
738 if (type
& MEM_RESERVE
) /* Round down to 64k boundary */
739 base
= (UINT
)addr
& ~granularity_mask
;
741 base
= ROUND_ADDR( addr
);
742 size
= (((UINT
)addr
+ size
+ page_mask
) & ~page_mask
) - base
;
743 if ((base
<= granularity_mask
) || (base
+ size
< base
))
745 /* disallow low 64k and wrap-around */
746 SetLastError( ERROR_INVALID_PARAMETER
);
753 size
= (size
+ page_mask
) & ~page_mask
;
756 if (type
& MEM_TOP_DOWN
) {
757 /* FIXME: MEM_TOP_DOWN allocates the largest possible address.
758 * Is there _ANY_ way to do it with UNIX mmap()?
760 WARN("MEM_TOP_DOWN ignored\n");
761 type
&= ~MEM_TOP_DOWN
;
763 /* Compute the alloc type flags */
765 if (!(type
& (MEM_COMMIT
| MEM_RESERVE
| MEM_SYSTEM
)) ||
766 (type
& ~(MEM_COMMIT
| MEM_RESERVE
| MEM_SYSTEM
)))
768 ERR("called with wrong alloc type flags (%08lx) !\n", type
);
769 SetLastError( ERROR_INVALID_PARAMETER
);
772 if (type
& (MEM_COMMIT
| MEM_SYSTEM
))
773 vprot
= VIRTUAL_GetProt( protect
) | VPROT_COMMITTED
;
776 /* Reserve the memory */
778 if ((type
& MEM_RESERVE
) || !base
)
780 view_size
= size
+ (base
? 0 : granularity_mask
+ 1);
781 if (type
& MEM_SYSTEM
)
784 ptr
= (UINT
)wine_anon_mmap( (LPVOID
)base
, view_size
, VIRTUAL_GetUnixProt( vprot
), 0 );
787 SetLastError( ERROR_OUTOFMEMORY
);
792 /* Release the extra memory while keeping the range */
793 /* starting on a 64k boundary. */
795 if (ptr
& granularity_mask
)
797 UINT extra
= granularity_mask
+ 1 - (ptr
& granularity_mask
);
798 munmap( (void *)ptr
, extra
);
802 if (view_size
> size
)
803 munmap( (void *)(ptr
+ size
), view_size
- size
);
805 else if (ptr
!= base
)
807 /* We couldn't get the address we wanted */
808 munmap( (void *)ptr
, view_size
);
809 SetLastError( ERROR_INVALID_ADDRESS
);
812 if (!(view
= VIRTUAL_CreateView( ptr
, size
, (type
& MEM_SYSTEM
) ?
813 VFLAG_SYSTEM
: 0, vprot
, 0 )))
815 munmap( (void *)ptr
, size
);
816 SetLastError( ERROR_OUTOFMEMORY
);
822 /* Commit the pages */
824 if (!(view
= VIRTUAL_FindView( base
)) ||
825 (base
+ size
> view
->base
+ view
->size
))
827 SetLastError( ERROR_INVALID_ADDRESS
);
831 if (!VIRTUAL_SetProt( view
, base
, size
, vprot
)) return NULL
;
836 /***********************************************************************
837 * VirtualAllocEx (KERNEL32.548)
839 * Seems to be just as VirtualAlloc, but with process handle.
841 LPVOID WINAPI
VirtualAllocEx(
842 HANDLE hProcess
, /* [in] Handle of process to do mem operation */
843 LPVOID addr
, /* [in] Address of region to reserve or commit */
844 DWORD size
, /* [in] Size of region */
845 DWORD type
, /* [in] Type of allocation */
846 DWORD protect
/* [in] Type of access protection */
848 if (MapProcessHandle( hProcess
) == GetCurrentProcessId())
849 return VirtualAlloc( addr
, size
, type
, protect
);
850 ERR("Unsupported on other process\n");
855 /***********************************************************************
856 * VirtualFree (KERNEL32.550)
857 * Release or decommits a region of pages in virtual address space.
863 BOOL WINAPI
VirtualFree(
864 LPVOID addr
, /* [in] Address of region of committed pages */
865 DWORD size
, /* [in] Size of region */
866 DWORD type
/* [in] Type of operation */
871 TRACE("%08x %08lx %lx\n",
872 (UINT
)addr
, size
, type
);
874 /* Fix the parameters */
876 size
= ROUND_SIZE( addr
, size
);
877 base
= ROUND_ADDR( addr
);
879 if (!(view
= VIRTUAL_FindView( base
)) ||
880 (base
+ size
> view
->base
+ view
->size
))
882 SetLastError( ERROR_INVALID_PARAMETER
);
886 /* Compute the protection flags */
888 if ((type
!= MEM_DECOMMIT
) && (type
!= MEM_RELEASE
))
890 ERR("called with wrong free type flags (%08lx) !\n", type
);
891 SetLastError( ERROR_INVALID_PARAMETER
);
897 if (type
== MEM_RELEASE
)
899 if (size
|| (base
!= view
->base
))
901 SetLastError( ERROR_INVALID_PARAMETER
);
904 VIRTUAL_DeleteView( view
);
908 /* Decommit the pages by remapping zero-pages instead */
910 if (wine_anon_mmap( (LPVOID
)base
, size
, VIRTUAL_GetUnixProt(0), MAP_FIXED
) != (LPVOID
)base
)
911 ERR( "Could not remap pages, expect trouble\n" );
912 return VIRTUAL_SetProt( view
, base
, size
, 0 );
916 /***********************************************************************
917 * VirtualLock (KERNEL32.551)
918 * Locks the specified region of virtual address space
921 * Always returns TRUE
927 BOOL WINAPI
VirtualLock(
928 LPVOID addr
, /* [in] Address of first byte of range to lock */
929 DWORD size
/* [in] Number of bytes in range to lock */
935 /***********************************************************************
936 * VirtualUnlock (KERNEL32.556)
937 * Unlocks a range of pages in the virtual address space
940 * Always returns TRUE
946 BOOL WINAPI
VirtualUnlock(
947 LPVOID addr
, /* [in] Address of first byte of range */
948 DWORD size
/* [in] Number of bytes in range */
954 /***********************************************************************
955 * VirtualProtect (KERNEL32.552)
956 * Changes the access protection on a region of committed pages
962 BOOL WINAPI
VirtualProtect(
963 LPVOID addr
, /* [in] Address of region of committed pages */
964 DWORD size
, /* [in] Size of region */
965 DWORD new_prot
, /* [in] Desired access protection */
966 LPDWORD old_prot
/* [out] Address of variable to get old protection */
972 TRACE("%08x %08lx %08lx\n",
973 (UINT
)addr
, size
, new_prot
);
975 /* Fix the parameters */
977 size
= ROUND_SIZE( addr
, size
);
978 base
= ROUND_ADDR( addr
);
980 if (!(view
= VIRTUAL_FindView( base
)) ||
981 (base
+ size
> view
->base
+ view
->size
))
983 SetLastError( ERROR_INVALID_PARAMETER
);
987 /* Make sure all the pages are committed */
989 p
= view
->prot
+ ((base
- view
->base
) >> page_shift
);
990 for (i
= size
>> page_shift
; i
; i
--, p
++)
992 if (!(*p
& VPROT_COMMITTED
))
994 SetLastError( ERROR_INVALID_PARAMETER
);
999 if (old_prot
) VIRTUAL_GetWin32Prot( view
->prot
[0], old_prot
, NULL
);
1000 vprot
= VIRTUAL_GetProt( new_prot
) | VPROT_COMMITTED
;
1001 return VIRTUAL_SetProt( view
, base
, size
, vprot
);
1005 /***********************************************************************
1006 * VirtualProtectEx (KERNEL32.553)
1007 * Changes the access protection on a region of committed pages in the
1008 * virtual address space of a specified process
1014 BOOL WINAPI
VirtualProtectEx(
1015 HANDLE handle
, /* [in] Handle of process */
1016 LPVOID addr
, /* [in] Address of region of committed pages */
1017 DWORD size
, /* [in] Size of region */
1018 DWORD new_prot
, /* [in] Desired access protection */
1019 LPDWORD old_prot
/* [out] Address of variable to get old protection */ )
1021 if (MapProcessHandle( handle
) == GetCurrentProcessId())
1022 return VirtualProtect( addr
, size
, new_prot
, old_prot
);
1023 ERR("Unsupported on other process\n");
1028 /***********************************************************************
1029 * VirtualQuery (KERNEL32.554)
1030 * Provides info about a range of pages in virtual address space
1033 * Number of bytes returned in information buffer
1034 * or 0 if addr is >= 0xc0000000 (kernel space).
1036 DWORD WINAPI
VirtualQuery(
1037 LPCVOID addr
, /* [in] Address of region */
1038 LPMEMORY_BASIC_INFORMATION info
, /* [out] Address of info buffer */
1039 DWORD len
/* [in] Size of buffer */
1043 UINT alloc_base
= 0;
1046 if (addr
>= (void*)0xc0000000) return 0;
1048 base
= ROUND_ADDR( addr
);
1050 /* Find the view containing the address */
1052 EnterCriticalSection(&csVirtual
);
1053 view
= VIRTUAL_FirstView
;
1058 size
= 0xffff0000 - alloc_base
;
1061 if (view
->base
> base
)
1063 size
= view
->base
- alloc_base
;
1067 if (view
->base
+ view
->size
> base
)
1069 alloc_base
= view
->base
;
1073 alloc_base
= view
->base
+ view
->size
;
1076 LeaveCriticalSection(&csVirtual
);
1078 /* Fill the info structure */
1082 info
->State
= MEM_FREE
;
1084 info
->AllocationProtect
= 0;
1089 BYTE vprot
= view
->prot
[(base
- alloc_base
) >> page_shift
];
1090 VIRTUAL_GetWin32Prot( vprot
, &info
->Protect
, &info
->State
);
1091 for (size
= base
- alloc_base
; size
< view
->size
; size
+= page_mask
+1)
1092 if (view
->prot
[size
>> page_shift
] != vprot
) break;
1093 info
->AllocationProtect
= view
->protect
;
1094 info
->Type
= MEM_PRIVATE
; /* FIXME */
1097 info
->BaseAddress
= (LPVOID
)base
;
1098 info
->AllocationBase
= (LPVOID
)alloc_base
;
1099 info
->RegionSize
= size
- (base
- alloc_base
);
1100 return sizeof(*info
);
1104 /***********************************************************************
1105 * VirtualQueryEx (KERNEL32.555)
1106 * Provides info about a range of pages in virtual address space of a
1110 * Number of bytes returned in information buffer
1112 DWORD WINAPI
VirtualQueryEx(
1113 HANDLE handle
, /* [in] Handle of process */
1114 LPCVOID addr
, /* [in] Address of region */
1115 LPMEMORY_BASIC_INFORMATION info
, /* [out] Address of info buffer */
1116 DWORD len
/* [in] Size of buffer */ )
1118 if (MapProcessHandle( handle
) == GetCurrentProcessId())
1119 return VirtualQuery( addr
, info
, len
);
1120 ERR("Unsupported on other process\n");
1125 /***********************************************************************
1126 * IsBadReadPtr (KERNEL32.354)
1129 * FALSE: Process has read access to entire block
1132 BOOL WINAPI
IsBadReadPtr(
1133 LPCVOID ptr
, /* [in] Address of memory block */
1134 UINT size
) /* [in] Size of block */
1136 if (!size
) return FALSE
; /* handle 0 size case w/o reference */
1139 volatile const char *p
= ptr
;
1143 while (count
> page_size
)
1150 dummy
= p
[count
- 1];
1152 __EXCEPT(page_fault
) { return TRUE
; }
1158 /***********************************************************************
1159 * IsBadWritePtr (KERNEL32.357)
1162 * FALSE: Process has write access to entire block
1165 BOOL WINAPI
IsBadWritePtr(
1166 LPVOID ptr
, /* [in] Address of memory block */
1167 UINT size
) /* [in] Size of block in bytes */
1169 if (!size
) return FALSE
; /* handle 0 size case w/o reference */
1172 volatile char *p
= ptr
;
1175 while (count
> page_size
)
1184 __EXCEPT(page_fault
) { return TRUE
; }
1190 /***********************************************************************
1191 * IsBadHugeReadPtr (KERNEL32.352)
1193 * FALSE: Process has read access to entire block
1196 BOOL WINAPI
IsBadHugeReadPtr(
1197 LPCVOID ptr
, /* [in] Address of memory block */
1198 UINT size
/* [in] Size of block */
1200 return IsBadReadPtr( ptr
, size
);
1204 /***********************************************************************
1205 * IsBadHugeWritePtr (KERNEL32.353)
1207 * FALSE: Process has write access to entire block
1210 BOOL WINAPI
IsBadHugeWritePtr(
1211 LPVOID ptr
, /* [in] Address of memory block */
1212 UINT size
/* [in] Size of block */
1214 return IsBadWritePtr( ptr
, size
);
1218 /***********************************************************************
1219 * IsBadCodePtr (KERNEL32.351)
1222 * FALSE: Process has read access to specified memory
1225 BOOL WINAPI
IsBadCodePtr( FARPROC ptr
) /* [in] Address of function */
1227 return IsBadReadPtr( ptr
, 1 );
1231 /***********************************************************************
1232 * IsBadStringPtrA (KERNEL32.355)
1235 * FALSE: Read access to all bytes in string
1238 BOOL WINAPI
IsBadStringPtrA(
1239 LPCSTR str
, /* [in] Address of string */
1240 UINT max
) /* [in] Maximum size of string */
1244 volatile const char *p
= str
;
1245 while (p
!= str
+ max
) if (!*p
++) break;
1247 __EXCEPT(page_fault
) { return TRUE
; }
1253 /***********************************************************************
1254 * IsBadStringPtrW (KERNEL32.356)
1255 * See IsBadStringPtrA
1257 BOOL WINAPI
IsBadStringPtrW( LPCWSTR str
, UINT max
)
1261 volatile const WCHAR
*p
= str
;
1262 while (p
!= str
+ max
) if (!*p
++) break;
1264 __EXCEPT(page_fault
) { return TRUE
; }
1270 /***********************************************************************
1271 * CreateFileMappingA (KERNEL32.46)
1272 * Creates a named or unnamed file-mapping object for the specified file
1276 * 0: Mapping object does not exist
1279 HANDLE WINAPI
CreateFileMappingA(
1280 HANDLE hFile
, /* [in] Handle of file to map */
1281 SECURITY_ATTRIBUTES
*sa
, /* [in] Optional security attributes*/
1282 DWORD protect
, /* [in] Protection for mapping object */
1283 DWORD size_high
, /* [in] High-order 32 bits of object size */
1284 DWORD size_low
, /* [in] Low-order 32 bits of object size */
1285 LPCSTR name
/* [in] Name of file-mapping object */ )
1289 DWORD len
= name
? MultiByteToWideChar( CP_ACP
, 0, name
, strlen(name
), NULL
, 0 ) : 0;
1291 /* Check parameters */
1293 TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
1294 hFile
, sa
, protect
, size_high
, size_low
, debugstr_a(name
) );
1298 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1301 vprot
= VIRTUAL_GetProt( protect
);
1302 if (protect
& SEC_RESERVE
)
1304 if (hFile
!= INVALID_HANDLE_VALUE
)
1306 SetLastError( ERROR_INVALID_PARAMETER
);
1310 else vprot
|= VPROT_COMMITTED
;
1311 if (protect
& SEC_NOCACHE
) vprot
|= VPROT_NOCACHE
;
1312 if (protect
& SEC_IMAGE
) vprot
|= VPROT_IMAGE
;
1314 /* Create the server object */
1318 struct create_mapping_request
*req
= server_alloc_req( sizeof(*req
),
1319 len
* sizeof(WCHAR
) );
1320 req
->file_handle
= hFile
;
1321 req
->size_high
= size_high
;
1322 req
->size_low
= size_low
;
1323 req
->protect
= vprot
;
1324 req
->inherit
= (sa
&& (sa
->nLength
>=sizeof(*sa
)) && sa
->bInheritHandle
);
1325 if (len
) MultiByteToWideChar( CP_ACP
, 0, name
, strlen(name
), server_data_ptr(req
), len
);
1327 server_call( REQ_CREATE_MAPPING
);
1331 if (ret
== -1) ret
= 0; /* must return 0 on failure, not -1 */
1336 /***********************************************************************
1337 * CreateFileMappingW (KERNEL32.47)
1338 * See CreateFileMappingA
1340 HANDLE WINAPI
CreateFileMappingW( HANDLE hFile
, LPSECURITY_ATTRIBUTES sa
,
1341 DWORD protect
, DWORD size_high
,
1342 DWORD size_low
, LPCWSTR name
)
1346 DWORD len
= name
? strlenW(name
) : 0;
1348 /* Check parameters */
1350 TRACE("(%x,%p,%08lx,%08lx%08lx,%s)\n",
1351 hFile
, sa
, protect
, size_high
, size_low
, debugstr_w(name
) );
1355 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1359 vprot
= VIRTUAL_GetProt( protect
);
1360 if (protect
& SEC_RESERVE
)
1362 if (hFile
!= INVALID_HANDLE_VALUE
)
1364 SetLastError( ERROR_INVALID_PARAMETER
);
1368 else vprot
|= VPROT_COMMITTED
;
1369 if (protect
& SEC_NOCACHE
) vprot
|= VPROT_NOCACHE
;
1370 if (protect
& SEC_IMAGE
) vprot
|= VPROT_IMAGE
;
1372 /* Create the server object */
1376 struct create_mapping_request
*req
= server_alloc_req( sizeof(*req
),
1377 len
* sizeof(WCHAR
) );
1378 req
->file_handle
= hFile
;
1379 req
->size_high
= size_high
;
1380 req
->size_low
= size_low
;
1381 req
->protect
= vprot
;
1382 req
->inherit
= (sa
&& (sa
->nLength
>=sizeof(*sa
)) && sa
->bInheritHandle
);
1383 memcpy( server_data_ptr(req
), name
, len
* sizeof(WCHAR
) );
1385 server_call( REQ_CREATE_MAPPING
);
1389 if (ret
== -1) ret
= 0; /* must return 0 on failure, not -1 */
1394 /***********************************************************************
1395 * OpenFileMappingA (KERNEL32.397)
1396 * Opens a named file-mapping object.
1402 HANDLE WINAPI
OpenFileMappingA(
1403 DWORD access
, /* [in] Access mode */
1404 BOOL inherit
, /* [in] Inherit flag */
1405 LPCSTR name
) /* [in] Name of file-mapping object */
1408 DWORD len
= name
? MultiByteToWideChar( CP_ACP
, 0, name
, strlen(name
), NULL
, 0 ) : 0;
1411 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1416 struct open_mapping_request
*req
= server_alloc_req( sizeof(*req
), len
* sizeof(WCHAR
) );
1418 req
->access
= access
;
1419 req
->inherit
= inherit
;
1420 if (len
) MultiByteToWideChar( CP_ACP
, 0, name
, strlen(name
), server_data_ptr(req
), len
);
1421 server_call( REQ_OPEN_MAPPING
);
1425 if (ret
== -1) ret
= 0; /* must return 0 on failure, not -1 */
1430 /***********************************************************************
1431 * OpenFileMappingW (KERNEL32.398)
1432 * See OpenFileMappingA
1434 HANDLE WINAPI
OpenFileMappingW( DWORD access
, BOOL inherit
, LPCWSTR name
)
1437 DWORD len
= name
? strlenW(name
) : 0;
1440 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1445 struct open_mapping_request
*req
= server_alloc_req( sizeof(*req
), len
* sizeof(WCHAR
) );
1447 req
->access
= access
;
1448 req
->inherit
= inherit
;
1449 memcpy( server_data_ptr(req
), name
, len
* sizeof(WCHAR
) );
1450 server_call( REQ_OPEN_MAPPING
);
1454 if (ret
== -1) ret
= 0; /* must return 0 on failure, not -1 */
1459 /***********************************************************************
1460 * MapViewOfFile (KERNEL32.385)
1461 * Maps a view of a file into the address space
1464 * Starting address of mapped view
1467 LPVOID WINAPI
MapViewOfFile(
1468 HANDLE mapping
, /* [in] File-mapping object to map */
1469 DWORD access
, /* [in] Access mode */
1470 DWORD offset_high
, /* [in] High-order 32 bits of file offset */
1471 DWORD offset_low
, /* [in] Low-order 32 bits of file offset */
1472 DWORD count
/* [in] Number of bytes to map */
1474 return MapViewOfFileEx( mapping
, access
, offset_high
,
1475 offset_low
, count
, NULL
);
1479 /***********************************************************************
1480 * MapViewOfFileEx (KERNEL32.386)
1481 * Maps a view of a file into the address space
1484 * Starting address of mapped view
1487 LPVOID WINAPI
MapViewOfFileEx(
1488 HANDLE handle
, /* [in] File-mapping object to map */
1489 DWORD access
, /* [in] Access mode */
1490 DWORD offset_high
, /* [in] High-order 32 bits of file offset */
1491 DWORD offset_low
, /* [in] Low-order 32 bits of file offset */
1492 DWORD count
, /* [in] Number of bytes to map */
1493 LPVOID addr
/* [in] Suggested starting address for mapped view */
1496 UINT ptr
= (UINT
)-1, size
= 0;
1497 int flags
= MAP_PRIVATE
;
1498 int unix_handle
= -1;
1500 struct get_mapping_info_request
*req
= get_req_buffer();
1502 /* Check parameters */
1504 if ((offset_low
& granularity_mask
) ||
1505 (addr
&& ((UINT
)addr
& granularity_mask
)))
1507 SetLastError( ERROR_INVALID_PARAMETER
);
1511 req
->handle
= handle
;
1512 if (server_call_fd( REQ_GET_MAPPING_INFO
, -1, &unix_handle
)) goto error
;
1513 prot
= req
->protect
;
1515 if (prot
& VPROT_IMAGE
)
1516 return map_image( handle
, unix_handle
, req
->base
, req
->size_low
, req
->header_size
,
1517 req
->shared_file
, req
->shared_size
);
1519 if (req
->size_high
|| offset_high
)
1520 ERR("Offsets larger than 4Gb not supported\n");
1522 if ((offset_low
>= req
->size_low
) ||
1523 (count
> req
->size_low
- offset_low
))
1525 SetLastError( ERROR_INVALID_PARAMETER
);
1528 if (count
) size
= ROUND_SIZE( offset_low
, count
);
1529 else size
= req
->size_low
- offset_low
;
1533 case FILE_MAP_ALL_ACCESS
:
1534 case FILE_MAP_WRITE
:
1535 case FILE_MAP_WRITE
| FILE_MAP_READ
:
1536 if (!(prot
& VPROT_WRITE
))
1538 SetLastError( ERROR_INVALID_PARAMETER
);
1545 case FILE_MAP_COPY
| FILE_MAP_READ
:
1546 if (prot
& VPROT_READ
) break;
1549 SetLastError( ERROR_INVALID_PARAMETER
);
1553 /* FIXME: If a mapping is created with SEC_RESERVE and a process,
1554 * which has a view of this mapping commits some pages, they will
1555 * appear commited in all other processes, which have the same
1556 * view created. Since we don`t support this yet, we create the
1557 * whole mapping commited.
1559 prot
|= VPROT_COMMITTED
;
1563 TRACE("handle=%x size=%x offset=%lx\n", handle
, size
, offset_low
);
1565 ptr
= (UINT
)VIRTUAL_mmap( unix_handle
, addr
, size
, offset_low
,
1566 VIRTUAL_GetUnixProt( prot
), flags
);
1567 if (ptr
== (UINT
)-1) {
1568 /* KB: Q125713, 25-SEP-1995, "Common File Mapping Problems and
1569 * Platform Differences":
1570 * Windows NT: ERROR_INVALID_PARAMETER
1571 * Windows 95: ERROR_INVALID_ADDRESS.
1572 * FIXME: So should we add a module dependend check here? -MM
1575 SetLastError( ERROR_OUTOFMEMORY
);
1577 SetLastError( ERROR_INVALID_PARAMETER
);
1581 if (!(view
= VIRTUAL_CreateView( ptr
, size
, 0, prot
, handle
)))
1583 SetLastError( ERROR_OUTOFMEMORY
);
1586 if (unix_handle
!= -1) close( unix_handle
);
1590 if (unix_handle
!= -1) close( unix_handle
);
1591 if (ptr
!= (UINT
)-1) munmap( (void *)ptr
, size
);
1596 /***********************************************************************
1597 * FlushViewOfFile (KERNEL32.262)
1598 * Writes to the disk a byte range within a mapped view of a file
1604 BOOL WINAPI
FlushViewOfFile(
1605 LPCVOID base
, /* [in] Start address of byte range to flush */
1606 DWORD cbFlush
/* [in] Number of bytes in range */
1609 UINT addr
= ROUND_ADDR( base
);
1611 TRACE("FlushViewOfFile at %p for %ld bytes\n",
1614 if (!(view
= VIRTUAL_FindView( addr
)))
1616 SetLastError( ERROR_INVALID_PARAMETER
);
1619 if (!cbFlush
) cbFlush
= view
->size
;
1620 if (!msync( (void *)addr
, cbFlush
, MS_SYNC
)) return TRUE
;
1621 SetLastError( ERROR_INVALID_PARAMETER
);
1626 /***********************************************************************
1627 * UnmapViewOfFile (KERNEL32.540)
1628 * Unmaps a mapped view of a file.
1631 * Should addr be an LPCVOID?
1637 BOOL WINAPI
UnmapViewOfFile(
1638 LPVOID addr
/* [in] Address where mapped view begins */
1641 UINT base
= ROUND_ADDR( addr
);
1642 if (!(view
= VIRTUAL_FindView( base
)) || (base
!= view
->base
))
1644 SetLastError( ERROR_INVALID_PARAMETER
);
1647 VIRTUAL_DeleteView( view
);
1651 /***********************************************************************
1654 * Helper function to map a file to memory:
1656 * [RETURN] ptr - pointer to mapped file
1658 LPVOID
VIRTUAL_MapFileW( LPCWSTR name
)
1660 HANDLE hFile
, hMapping
;
1663 hFile
= CreateFileW( name
, GENERIC_READ
, FILE_SHARE_READ
, NULL
,
1664 OPEN_EXISTING
, FILE_FLAG_RANDOM_ACCESS
, 0);
1665 if (hFile
!= INVALID_HANDLE_VALUE
)
1667 hMapping
= CreateFileMappingA( hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
);
1668 CloseHandle( hFile
);
1671 ptr
= MapViewOfFile( hMapping
, FILE_MAP_READ
, 0, 0, 0 );
1672 CloseHandle( hMapping
);