2 * Wine memory mappings support
4 * Copyright 2000, 2004 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
30 #include <sys/types.h>
31 #ifdef HAVE_SYS_MMAN_H
41 #include "wine/library.h"
42 #include "wine/list.h"
51 static struct list reserved_areas = LIST_INIT(reserved_areas);
52 static const int granularity_mask = 0xffff; /* reserved areas have 64k granularity */
57 #define MAP_NORESERVE 0
66 static inline int get_fdzero(void)
70 if (MAP_ANON == 0 && fd == -1)
72 if ((fd = open( "/dev/zero", O_RDONLY )) == -1)
74 perror( "/dev/zero: open" );
81 #if (defined(__svr4__) || defined(__NetBSD__)) && !defined(MAP_TRYFIXED)
82 /***********************************************************************
85 * The purpose of this routine is to emulate the behaviour of
86 * the Linux mmap() routine if a non-NULL address is passed,
87 * but the MAP_FIXED flag is not set. Linux in this case tries
88 * to place the mapping at the specified address, *unless* the
89 * range is already in use. Solaris, however, completely ignores
90 * the address argument in this case.
92 * As Wine code occasionally relies on the Linux behaviour, e.g. to
93 * be able to map non-relocateable PE executables to their proper
94 * start addresses, or to map the DOS memory to 0, this routine
95 * emulates the Linux behaviour by checking whether the desired
96 * address range is still available, and placing the mapping there
97 * using MAP_FIXED if so.
99 static int try_mmap_fixed (void *addr, size_t len, int prot, int flags,
100 int fildes, off_t off)
102 char * volatile result = NULL;
103 int pagesize = getpagesize();
106 /* We only try to map to a fixed address if
107 addr is non-NULL and properly aligned,
108 and MAP_FIXED isn't already specified. */
112 if ( (uintptr_t)addr & (pagesize-1) )
114 if ( flags & MAP_FIXED )
117 /* We use vfork() to freeze all threads of the
118 current process. This allows us to check without
119 race condition whether the desired memory range is
120 already in use. Note that because vfork() shares
121 the address spaces between parent and child, we
122 can actually perform the mapping in the child. */
124 if ( (pid = vfork()) == -1 )
126 perror("try_mmap_fixed: vfork");
134 /* We call mincore() for every page in the desired range.
135 If any of these calls succeeds, the page is already
136 mapped and we must fail. */
137 for ( i = 0; i < len; i += pagesize )
138 if ( mincore( (caddr_t)addr + i, pagesize, &vec ) != -1 )
141 /* Perform the mapping with MAP_FIXED set. This is safe
142 now, as none of the pages is currently in use. */
143 result = mmap( addr, len, prot, flags | MAP_FIXED, fildes, off );
144 if ( result == addr )
147 if ( result != (void *) -1 ) /* This should never happen ... */
148 munmap( result, len );
153 /* vfork() lets the parent continue only after the child
154 has exited. Furthermore, Wine sets SIGCHLD to SIG_IGN,
155 so we don't need to wait for the child. */
157 return result == addr;
160 #elif defined(__APPLE__)
162 #include <mach/mach_init.h>
163 #include <mach/vm_map.h>
166 * On Darwin, we can use the Mach call vm_allocate to allocate
167 * anonymous memory at the specified address, and then use mmap with
168 * MAP_FIXED to replace the mapping.
170 static int try_mmap_fixed (void *addr, size_t len, int prot, int flags,
171 int fildes, off_t off)
173 vm_address_t result = (vm_address_t)addr;
175 if (!vm_allocate(mach_task_self(),&result,len,0))
177 if (mmap( (void *)result, len, prot, flags | MAP_FIXED, fildes, off ) != MAP_FAILED)
179 vm_deallocate(mach_task_self(),result,len);
184 #endif /* (__svr4__ || __NetBSD__) && !MAP_TRYFIXED */
187 /***********************************************************************
190 * Portable wrapper for anonymous mmaps
192 void *wine_anon_mmap( void *start, size_t size, int prot, int flags )
195 flags &= ~MAP_SHARED;
198 /* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */
199 flags |= MAP_PRIVATE | MAP_ANON;
201 if (!(flags & MAP_FIXED))
203 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
204 /* Even FreeBSD 5.3 does not properly support NULL here. */
205 if( start == NULL ) start = (void *)0x110000;
209 /* If available, this will attempt a fixed mapping in-kernel */
210 flags |= MAP_TRYFIXED;
211 #elif defined(__svr4__) || defined(__NetBSD__) || defined(__APPLE__)
212 if ( try_mmap_fixed( start, size, prot, flags, get_fdzero(), 0 ) )
216 return mmap( start, size, prot, flags, get_fdzero(), 0 );
220 /***********************************************************************
223 * mmap wrapper used for reservations, only maps the specified address
225 static inline int mmap_reserve( void *addr, size_t size )
228 int flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE;
231 flags |= MAP_TRYFIXED;
232 #elif defined(__APPLE__)
233 return try_mmap_fixed( addr, size, PROT_NONE, flags, get_fdzero(), 0 );
235 ptr = mmap( addr, size, PROT_NONE, flags, get_fdzero(), 0 );
236 if (ptr != addr && ptr != (void *)-1) munmap( ptr, size );
237 return (ptr == addr);
241 /***********************************************************************
244 * Reserve as much memory as possible in the given area.
246 static void reserve_area( void *addr, void *end )
248 size_t size = (char *)end - (char *)addr;
250 #if (defined(__svr4__) || defined(__NetBSD__)) && !defined(MAP_TRYFIXED)
251 /* try_mmap_fixed is inefficient when using vfork, so we need a different algorithm here */
252 /* we assume no other thread is running at this point */
253 size_t i, pagesize = getpagesize();
258 for (i = 0; i < size; i += pagesize)
259 if (mincore( (caddr_t)addr + i, pagesize, &vec ) != -1) break;
261 i &= ~granularity_mask;
262 if (i && mmap( addr, i, PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
263 get_fdzero(), 0 ) != (void *)-1)
264 wine_mmap_add_reserved_area( addr, i );
266 i += granularity_mask + 1;
267 if ((char *)addr + i < (char *)addr) break; /* overflow */
268 addr = (char *)addr + i;
269 if (addr >= end) break;
270 size = (char *)end - (char *)addr;
275 if (mmap_reserve( addr, size ))
277 wine_mmap_add_reserved_area( addr, size );
280 if (size > granularity_mask + 1)
282 size_t new_size = (size / 2) & ~granularity_mask;
283 reserve_area( addr, (char *)addr + new_size );
284 reserve_area( (char *)addr + new_size, end );
290 /***********************************************************************
293 * Reserve the DOS area (0x00000000-0x00110000).
295 static void reserve_dos_area(void)
297 const size_t page_size = getpagesize();
298 const size_t dos_area_size = 0x110000;
301 /* first page has to be handled specially */
302 ptr = wine_anon_mmap( (void *)page_size, dos_area_size - page_size, PROT_NONE, MAP_NORESERVE );
303 if (ptr != (void *)page_size)
305 if (ptr != (void *)-1) munmap( ptr, dos_area_size - page_size );
308 /* now add first page with MAP_FIXED */
309 wine_anon_mmap( NULL, page_size, PROT_NONE, MAP_NORESERVE|MAP_FIXED );
310 wine_mmap_add_reserved_area( NULL, dos_area_size );
314 /***********************************************************************
319 struct reserved_area *area;
321 #if defined(__i386__) && !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__) /* commented out until FreeBSD gets fixed */
323 char * const stack_ptr = &stack;
324 char *user_space_limit = (char *)0x7ffe0000;
326 /* check for a reserved area starting at the user space limit */
327 /* to avoid wasting time trying to allocate it again */
328 LIST_FOR_EACH( ptr, &reserved_areas )
330 area = LIST_ENTRY( ptr, struct reserved_area, entry );
331 if ((char *)area->base > user_space_limit) break;
332 if ((char *)area->base + area->size > user_space_limit)
334 user_space_limit = (char *)area->base + area->size;
339 if (stack_ptr >= user_space_limit)
341 char *base = stack_ptr - ((unsigned int)stack_ptr & granularity_mask) - (granularity_mask + 1);
342 if (base > user_space_limit) reserve_area( user_space_limit, base );
343 base = stack_ptr - ((unsigned int)stack_ptr & granularity_mask) + (granularity_mask + 1);
345 /* Linux heuristic: if the stack top is at c0000000, assume the address space */
346 /* ends there, this avoids a lot of futile allocation attempts */
347 if (base != (char *)0xc0000000)
349 reserve_area( base, 0 );
351 else reserve_area( user_space_limit, 0 );
352 #endif /* __i386__ */
354 /* reserve the DOS area if not already done */
356 ptr = list_head( &reserved_areas );
359 area = LIST_ENTRY( ptr, struct reserved_area, entry );
360 if (!area->base) return; /* already reserved */
365 #else /* HAVE_MMAP */
367 void *wine_anon_mmap( void *start, size_t size, int prot, int flags )
372 static inline int munmap( void *ptr, size_t size )
383 /***********************************************************************
384 * wine_mmap_add_reserved_area
386 * Add an address range to the list of reserved areas.
387 * Caller must have made sure the range is not used by anything else.
389 * Note: the reserved areas functions are not reentrant, caller is
390 * responsible for proper locking.
392 void wine_mmap_add_reserved_area( void *addr, size_t size )
394 struct reserved_area *area;
397 if (!((char *)addr + size)) size--; /* avoid wrap-around */
399 LIST_FOR_EACH( ptr, &reserved_areas )
401 area = LIST_ENTRY( ptr, struct reserved_area, entry );
402 if (area->base > addr)
404 /* try to merge with the next one */
405 if ((char *)addr + size == (char *)area->base)
413 else if ((char *)area->base + area->size == (char *)addr)
415 /* merge with the previous one */
418 /* try to merge with the next one too */
419 if ((ptr = list_next( &reserved_areas, ptr )))
421 struct reserved_area *next = LIST_ENTRY( ptr, struct reserved_area, entry );
422 if ((char *)addr + size == (char *)next->base)
424 area->size += next->size;
425 list_remove( &next->entry );
433 if ((area = malloc( sizeof(*area) )))
437 list_add_before( ptr, &area->entry );
442 /***********************************************************************
443 * wine_mmap_remove_reserved_area
445 * Remove an address range from the list of reserved areas.
446 * If 'unmap' is non-zero the range is unmapped too.
448 * Note: the reserved areas functions are not reentrant, caller is
449 * responsible for proper locking.
451 void wine_mmap_remove_reserved_area( void *addr, size_t size, int unmap )
453 struct reserved_area *area;
456 if (!((char *)addr + size)) size--; /* avoid wrap-around */
458 ptr = list_head( &reserved_areas );
459 /* find the first area covering address */
462 area = LIST_ENTRY( ptr, struct reserved_area, entry );
463 if ((char *)area->base >= (char *)addr + size) break; /* outside the range */
464 if ((char *)area->base + area->size > (char *)addr) /* overlaps range */
466 if (area->base >= addr)
468 if ((char *)area->base + area->size > (char *)addr + size)
470 /* range overlaps beginning of area only -> shrink area */
471 if (unmap) munmap( area->base, (char *)addr + size - (char *)area->base );
472 area->size -= (char *)addr + size - (char *)area->base;
473 area->base = (char *)addr + size;
478 /* range contains the whole area -> remove area completely */
479 ptr = list_next( &reserved_areas, ptr );
480 if (unmap) munmap( area->base, area->size );
481 list_remove( &area->entry );
488 if ((char *)area->base + area->size > (char *)addr + size)
490 /* range is in the middle of area -> split area in two */
491 struct reserved_area *new_area = malloc( sizeof(*new_area) );
494 new_area->base = (char *)addr + size;
495 new_area->size = (char *)area->base + area->size - (char *)new_area->base;
496 list_add_after( ptr, &new_area->entry );
498 else size = (char *)area->base + area->size - (char *)addr;
499 area->size = (char *)addr - (char *)area->base;
500 if (unmap) munmap( addr, size );
505 /* range overlaps end of area only -> shrink area */
506 if (unmap) munmap( addr, (char *)area->base + area->size - (char *)addr );
507 area->size = (char *)addr - (char *)area->base;
511 ptr = list_next( &reserved_areas, ptr );
516 /***********************************************************************
517 * wine_mmap_is_in_reserved_area
519 * Check if the specified range is included in a reserved area.
520 * Returns 1 if range is fully included, 0 if range is not included
521 * at all, and -1 if it is only partially included.
523 * Note: the reserved areas functions are not reentrant, caller is
524 * responsible for proper locking.
526 int wine_mmap_is_in_reserved_area( void *addr, size_t size )
528 struct reserved_area *area;
531 LIST_FOR_EACH( ptr, &reserved_areas )
533 area = LIST_ENTRY( ptr, struct reserved_area, entry );
534 if (area->base > addr) break;
535 if ((char *)area->base + area->size <= (char *)addr) continue;
536 /* area must contain block completely */
537 if ((char *)area->base + area->size < (char *)addr + size) return -1;
544 /***********************************************************************
545 * wine_mmap_enum_reserved_areas
547 * Enumerate the list of reserved areas, sorted by addresses.
548 * If enum_func returns a non-zero value, enumeration is stopped and the value is returned.
550 * Note: the reserved areas functions are not reentrant, caller is
551 * responsible for proper locking.
553 int wine_mmap_enum_reserved_areas( int (*enum_func)(void *base, size_t size, void *arg), void *arg,
561 for (ptr = reserved_areas.prev; ptr != &reserved_areas; ptr = ptr->prev)
563 struct reserved_area *area = LIST_ENTRY( ptr, struct reserved_area, entry );
564 if ((ret = enum_func( area->base, area->size, arg ))) break;
569 for (ptr = reserved_areas.next; ptr != &reserved_areas; ptr = ptr->next)
571 struct reserved_area *area = LIST_ENTRY( ptr, struct reserved_area, entry );
572 if ((ret = enum_func( area->base, area->size, arg ))) break;