git.oblomov.eu Git - wine/blob - libs/wine/mmap.c

   1 /*
   2  * Wine memory mappings support
   3  *
   4  * Copyright 2000, 2004 Alexandre Julliard
   5  *
   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.
  10  *
  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.
  15  *
  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #include <fcntl.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #ifdef HAVE_SYS_MMAN_H
  31 #include <sys/mman.h>
  32 #endif
  33 #ifdef HAVE_UNISTD_H
  34 # include <unistd.h>
  35 #endif
  36 #ifdef HAVE_STDINT_H
  37 # include <stdint.h>
  38 #endif
  39
  40 #include "wine/library.h"
  41 #include "wine/list.h"
  42
  43 struct reserved_area
  44 {
  45     struct list entry;
  46     void       *base;
  47     size_t      size;
  48 };
  49
  50 static struct list reserved_areas = LIST_INIT(reserved_areas);
  51 static const int granularity_mask = 0xffff;  /* reserved areas have 64k granularity */
  52
  53 #ifndef MAP_NORESERVE
  54 #define MAP_NORESERVE 0
  55 #endif
  56
  57 #ifndef HAVE_MMAP
  58 static inline int munmap( void *ptr, size_t size ) { return 0; }
  59 #endif
  60
  61
  62 #if (defined(__svr4__) || defined(__NetBSD__)) && !defined(MAP_TRYFIXED)
  63 /***********************************************************************
  64  *             try_mmap_fixed
  65  *
  66  * The purpose of this routine is to emulate the behaviour of
  67  * the Linux mmap() routine if a non-NULL address is passed,
  68  * but the MAP_FIXED flag is not set.  Linux in this case tries
  69  * to place the mapping at the specified address, *unless* the
  70  * range is already in use.  Solaris, however, completely ignores
  71  * the address argument in this case.
  72  *
  73  * As Wine code occasionally relies on the Linux behaviour, e.g. to
  74  * be able to map non-relocateable PE executables to their proper
  75  * start addresses, or to map the DOS memory to 0, this routine
  76  * emulates the Linux behaviour by checking whether the desired
  77  * address range is still available, and placing the mapping there
  78  * using MAP_FIXED if so.
  79  */
  80 static int try_mmap_fixed (void *addr, size_t len, int prot, int flags,
  81                            int fildes, off_t off)
  82 {
  83     char * volatile result = NULL;
  84     int pagesize = getpagesize();
  85     pid_t pid;
  86
  87     /* We only try to map to a fixed address if
  88        addr is non-NULL and properly aligned,
  89        and MAP_FIXED isn't already specified. */
  90
  91     if ( !addr )
  92         return 0;
  93     if ( (uintptr_t)addr & (pagesize-1) )
  94         return 0;
  95     if ( flags & MAP_FIXED )
  96         return 0;
  97
  98     /* We use vfork() to freeze all threads of the
  99        current process.  This allows us to check without
 100        race condition whether the desired memory range is
 101        already in use.  Note that because vfork() shares
 102        the address spaces between parent and child, we
 103        can actually perform the mapping in the child. */
 104
 105     if ( (pid = vfork()) == -1 )
 106     {
 107         perror("try_mmap_fixed: vfork");
 108         exit(1);
 109     }
 110     if ( pid == 0 )
 111     {
 112         int i;
 113         char vec;
 114
 115         /* We call mincore() for every page in the desired range.
 116            If any of these calls succeeds, the page is already
 117            mapped and we must fail. */
 118         for ( i = 0; i < len; i += pagesize )
 119             if ( mincore( (caddr_t)addr + i, pagesize, &vec ) != -1 )
 120                _exit(1);
 121
 122         /* Perform the mapping with MAP_FIXED set.  This is safe
 123            now, as none of the pages is currently in use. */
 124         result = mmap( addr, len, prot, flags | MAP_FIXED, fildes, off );
 125         if ( result == addr )
 126             _exit(0);
 127
 128         if ( result != (void *) -1 ) /* This should never happen ... */
 129             munmap( result, len );
 130
 131        _exit(1);
 132     }
 133
 134     /* vfork() lets the parent continue only after the child
 135        has exited.  Furthermore, Wine sets SIGCHLD to SIG_IGN,
 136        so we don't need to wait for the child. */
 137
 138     return result == addr;
 139 }
 140 #endif  /* (__svr4__ || __NetBSD__) && !MAP_TRYFIXED */
 141
 142
 143 /***********************************************************************
 144  *              wine_anon_mmap
 145  *
 146  * Portable wrapper for anonymous mmaps
 147  */
 148 void *wine_anon_mmap( void *start, size_t size, int prot, int flags )
 149 {
 150 #ifdef HAVE_MMAP
 151     static int fdzero = -1;
 152
 153 #ifdef MAP_ANON
 154     flags |= MAP_ANON;
 155 #else
 156     if (fdzero == -1)
 157     {
 158         if ((fdzero = open( "/dev/zero", O_RDONLY )) == -1)
 159         {
 160             perror( "/dev/zero: open" );
 161             exit(1);
 162         }
 163     }
 164 #endif  /* MAP_ANON */
 165
 166 #ifdef MAP_SHARED
 167     flags &= ~MAP_SHARED;
 168 #endif
 169
 170     /* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */
 171 #ifdef MAP_PRIVATE
 172     flags |= MAP_PRIVATE;
 173 #endif
 174
 175     if (!(flags & MAP_FIXED))
 176     {
 177 #ifdef MAP_TRYFIXED
 178         /* If available, this will attempt a fixed mapping in-kernel */
 179         flags |= MAP_TRYFIXED;
 180 #elif defined(__svr4__) || defined(__NetBSD__)
 181         if ( try_mmap_fixed( start, size, prot, flags, fdzero, 0 ) )
 182             return start;
 183 #endif
 184     }
 185     return mmap( start, size, prot, flags, fdzero, 0 );
 186 #else
 187     return (void *)-1;
 188 #endif
 189 }
 190
 191
 192 #if defined(__i386__) && defined(HAVE_MMAP)
 193
 194 /***********************************************************************
 195  *           reserve_area
 196  *
 197  * Reserve as much memory as possible in the given area.
 198  * FIXME: probably needs a different algorithm for Solaris
 199  */
 200 static void reserve_area( void *addr, void *end )
 201 {
 202     void *ptr;
 203     size_t size = (char *)end - (char *)addr;
 204
 205     if ((ptr = wine_anon_mmap( addr, size, PROT_NONE, MAP_NORESERVE )) != (void *)-1)
 206     {
 207         if (ptr == addr)
 208         {
 209             wine_mmap_add_reserved_area( addr, size );
 210             return;
 211         }
 212         else munmap( ptr, size );
 213     }
 214     if (size > granularity_mask + 1)
 215     {
 216         size_t new_size = (size / 2) & ~granularity_mask;
 217         reserve_area( addr, (char *)addr + new_size );
 218         reserve_area( (char *)addr + new_size, end );
 219     }
 220 }
 221
 222
 223 /***********************************************************************
 224  *           mmap_init
 225  */
 226 void mmap_init(void)
 227 {
 228     static char * const user_space_limit = (char *)0x80000000;
 229     char stack;
 230     char * const stack_ptr = &stack;
 231
 232     if (stack_ptr >= user_space_limit)
 233     {
 234         char *base = stack_ptr - ((unsigned int)stack_ptr & granularity_mask) - (granularity_mask + 1);
 235         if (base > user_space_limit) reserve_area( user_space_limit, base );
 236         base = stack_ptr - ((unsigned int)stack_ptr & granularity_mask) + (granularity_mask + 1);
 237 #ifdef linux
 238         /* Linux heuristic: if the stack top is at c0000000, assume the address space */
 239         /* ends there, this avoids a lot of futile allocation attempts */
 240         if (base != (char *)0xc0000000)
 241 #endif
 242             reserve_area( base, 0 );
 243     }
 244     else reserve_area( user_space_limit, 0 );
 245 }
 246
 247 #else /* __i386__ */
 248
 249 void mmap_init(void)
 250 {
 251 }
 252
 253 #endif
 254
 255 /***********************************************************************
 256  *           wine_mmap_add_reserved_area
 257  *
 258  * Add an address range to the list of reserved areas.
 259  * Caller must have made sure the range is not used by anything else.
 260  *
 261  * Note: the reserved areas functions are not reentrant, caller is
 262  * responsible for proper locking.
 263  */
 264 void wine_mmap_add_reserved_area( void *addr, size_t size )
 265 {
 266     struct reserved_area *area;
 267     struct list *ptr;
 268
 269     if (!((char *)addr + size)) size--;  /* avoid wrap-around */
 270
 271     LIST_FOR_EACH( ptr, &reserved_areas )
 272     {
 273         area = LIST_ENTRY( ptr, struct reserved_area, entry );
 274         if (area->base > addr)
 275         {
 276             /* try to merge with the next one */
 277             if ((char *)addr + size == (char *)area->base)
 278             {
 279                 area->base = addr;
 280                 area->size += size;
 281                 return;
 282             }
 283             break;
 284         }
 285         else if ((char *)area->base + area->size == (char *)addr)
 286         {
 287             /* merge with the previous one */
 288             area->size += size;
 289
 290             /* try to merge with the next one too */
 291             if ((ptr = list_next( &reserved_areas, ptr )))
 292             {
 293                 struct reserved_area *next = LIST_ENTRY( ptr, struct reserved_area, entry );
 294                 if ((char *)addr + size == (char *)next->base)
 295                 {
 296                     area->size += next->size;
 297                     list_remove( &next->entry );
 298                     free( next );
 299                 }
 300             }
 301             return;
 302         }
 303     }
 304
 305     if ((area = malloc( sizeof(*area) )))
 306     {
 307         area->base = addr;
 308         area->size = size;
 309         list_add_before( ptr, &area->entry );
 310     }
 311 }
 312
 313
 314 /***********************************************************************
 315  *           wine_mmap_remove_reserved_area
 316  *
 317  * Remove an address range from the list of reserved areas.
 318  * If 'unmap' is non-zero the range is unmapped too.
 319  *
 320  * Note: the reserved areas functions are not reentrant, caller is
 321  * responsible for proper locking.
 322  */
 323 void wine_mmap_remove_reserved_area( void *addr, size_t size, int unmap )
 324 {
 325     struct reserved_area *area;
 326     struct list *ptr;
 327
 328     if (!((char *)addr + size)) size--;  /* avoid wrap-around */
 329
 330     ptr = list_head( &reserved_areas );
 331     /* find the first area covering address */
 332     while (ptr)
 333     {
 334         area = LIST_ENTRY( ptr, struct reserved_area, entry );
 335         if ((char *)area->base >= (char *)addr + size) break;  /* outside the range */
 336         if ((char *)area->base + area->size > (char *)addr)  /* overlaps range */
 337         {
 338             if (area->base >= addr)
 339             {
 340                 if ((char *)area->base + area->size > (char *)addr + size)
 341                 {
 342                     /* range overlaps beginning of area only -> shrink area */
 343                     if (unmap) munmap( area->base, (char *)addr + size - (char *)area->base );
 344                     area->size -= (char *)addr + size - (char *)area->base;
 345                     area->base = (char *)addr + size;
 346                     break;
 347                 }
 348                 else
 349                 {
 350                     /* range contains the whole area -> remove area completely */
 351                     ptr = list_next( &reserved_areas, ptr );
 352                     if (unmap) munmap( area->base, area->size );
 353                     list_remove( &area->entry );
 354                     free( area );
 355                     continue;
 356                 }
 357             }
 358             else
 359             {
 360                 if ((char *)area->base + area->size > (char *)addr + size)
 361                 {
 362                     /* range is in the middle of area -> split area in two */
 363                     struct reserved_area *new_area = malloc( sizeof(*new_area) );
 364                     if (new_area)
 365                     {
 366                         new_area->base = (char *)addr + size;
 367                         new_area->size = (char *)area->base + area->size - (char *)new_area->base;
 368                         list_add_after( ptr, &new_area->entry );
 369                     }
 370                     else size = (char *)area->base + area->size - (char *)addr;
 371                     area->size = (char *)addr - (char *)area->base;
 372                     if (unmap) munmap( addr, size );
 373                     break;
 374                 }
 375                 else
 376                 {
 377                     /* range overlaps end of area only -> shrink area */
 378                     if (unmap) munmap( addr, (char *)area->base + area->size - (char *)addr );
 379                     area->size = (char *)addr - (char *)area->base;
 380                 }
 381             }
 382         }
 383         ptr = list_next( &reserved_areas, ptr );
 384     }
 385 }
 386
 387
 388 /***********************************************************************
 389  *           wine_mmap_is_in_reserved_area
 390  *
 391  * Check if the specified range is included in a reserved area.
 392  * Returns 1 if range is fully included, 0 if range is not included
 393  * at all, and -1 if it is only partially included.
 394  *
 395  * Note: the reserved areas functions are not reentrant, caller is
 396  * responsible for proper locking.
 397  */
 398 int wine_mmap_is_in_reserved_area( void *addr, size_t size )
 399 {
 400     struct reserved_area *area;
 401     struct list *ptr;
 402
 403     LIST_FOR_EACH( ptr, &reserved_areas )
 404     {
 405         area = LIST_ENTRY( ptr, struct reserved_area, entry );
 406         if (area->base > addr) break;
 407         if ((char *)area->base + area->size <= (char *)addr) continue;
 408         /* area must contain block completely */
 409         if ((char *)area->base + area->size < (char *)addr + size) return -1;
 410         return 1;
 411     }
 412     return 0;
 413 }