git.oblomov.eu Git - wine/blob - dlls/ntdll/virtual.c

   1 /*
   2  * Win32 virtual memory functions
   3  *
   4  * Copyright 1997, 2002 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 <errno.h>
  26 #ifdef HAVE_SYS_ERRNO_H
  27 #include <sys/errno.h>
  28 #endif
  29 #include <fcntl.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <sys/types.h>
  37 #ifdef HAVE_SYS_MMAN_H
  38 #include <sys/mman.h>
  39 #endif
  40
  41 #define NONAMELESSUNION
  42 #define NONAMELESSSTRUCT
  43 #include "ntstatus.h"
  44 #include "thread.h"
  45 #include "winternl.h"
  46 #include "winioctl.h"
  47 #include "wine/library.h"
  48 #include "wine/server.h"
  49 #include "wine/list.h"
  50 #include "wine/debug.h"
  51 #include "ntdll_misc.h"
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(virtual);
  54 WINE_DECLARE_DEBUG_CHANNEL(module);
  55
  56 #ifndef MS_SYNC
  57 #define MS_SYNC 0
  58 #endif
  59
  60 #ifndef MAP_NORESERVE
  61 #define MAP_NORESERVE 0
  62 #endif
  63
  64 /* File view */
  65 typedef struct file_view
  66 {
  67     struct list   entry;       /* Entry in global view list */
  68     void         *base;        /* Base address */
  69     UINT          size;        /* Size in bytes */
  70     HANDLE        mapping;     /* Handle to the file mapping */
  71     HANDLERPROC   handlerProc; /* Fault handler */
  72     LPVOID        handlerArg;  /* Fault handler argument */
  73     BYTE          flags;       /* Allocation flags (VFLAG_*) */
  74     BYTE          protect;     /* Protection for all pages at allocation time */
  75     BYTE          prot[1];     /* Protection byte for each page */
  76 } FILE_VIEW;
  77
  78 /* Per-view flags */
  79 #define VFLAG_SYSTEM     0x01  /* system view (underlying mmap not under our control) */
  80 #define VFLAG_VALLOC     0x02  /* allocated by VirtualAlloc */
  81
  82 /* Conversion from VPROT_* to Win32 flags */
  83 static const BYTE VIRTUAL_Win32Flags[16] =
  84 {
  85     PAGE_NOACCESS,              /* 0 */
  86     PAGE_READONLY,              /* READ */
  87     PAGE_READWRITE,             /* WRITE */
  88     PAGE_READWRITE,             /* READ | WRITE */
  89     PAGE_EXECUTE,               /* EXEC */
  90     PAGE_EXECUTE_READ,          /* READ | EXEC */
  91     PAGE_EXECUTE_READWRITE,     /* WRITE | EXEC */
  92     PAGE_EXECUTE_READWRITE,     /* READ | WRITE | EXEC */
  93     PAGE_WRITECOPY,             /* WRITECOPY */
  94     PAGE_WRITECOPY,             /* READ | WRITECOPY */
  95     PAGE_WRITECOPY,             /* WRITE | WRITECOPY */
  96     PAGE_WRITECOPY,             /* READ | WRITE | WRITECOPY */
  97     PAGE_EXECUTE_WRITECOPY,     /* EXEC | WRITECOPY */
  98     PAGE_EXECUTE_WRITECOPY,     /* READ | EXEC | WRITECOPY */
  99     PAGE_EXECUTE_WRITECOPY,     /* WRITE | EXEC | WRITECOPY */
 100     PAGE_EXECUTE_WRITECOPY      /* READ | WRITE | EXEC | WRITECOPY */
 101 };
 102
 103 static struct list views_list = LIST_INIT(views_list);
 104
 105 static CRITICAL_SECTION csVirtual;
 106 static CRITICAL_SECTION_DEBUG critsect_debug =
 107 {
 108     0, 0, &csVirtual,
 109     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 110       0, 0, { 0, (DWORD)(__FILE__ ": csVirtual") }
 111 };
 112 static CRITICAL_SECTION csVirtual = { &critsect_debug, -1, 0, 0, 0, 0 };
 113
 114 #ifdef __i386__
 115 /* These are always the same on an i386, and it will be faster this way */
 116 # define page_mask  0xfff
 117 # define page_shift 12
 118 # define page_size  0x1000
 119 /* Note: these are Windows limits, you cannot change them. */
 120 # define ADDRESS_SPACE_LIMIT  ((void *)0xc0000000)  /* top of the total available address space */
 121 # define USER_SPACE_LIMIT     ((void *)0x80000000)  /* top of the user address space */
 122 #else
 123 static UINT page_shift;
 124 static UINT page_mask;
 125 static UINT page_size;
 126 # define ADDRESS_SPACE_LIMIT  0   /* no limit needed on other platforms */
 127 # define USER_SPACE_LIMIT     0   /* no limit needed on other platforms */
 128 #endif  /* __i386__ */
 129 #define granularity_mask 0xffff  /* Allocation granularity (usually 64k) */
 130
 131 #define ROUND_ADDR(addr,mask) \
 132    ((void *)((UINT_PTR)(addr) & ~(mask)))
 133
 134 #define ROUND_SIZE(addr,size) \
 135    (((UINT)(size) + ((UINT_PTR)(addr) & page_mask) + page_mask) & ~page_mask)
 136
 137 #define VIRTUAL_DEBUG_DUMP_VIEW(view) \
 138    if (!TRACE_ON(virtual)); else VIRTUAL_DumpView(view)
 139
 140
 141 /***********************************************************************
 142  *           VIRTUAL_GetProtStr
 143  */
 144 static const char *VIRTUAL_GetProtStr( BYTE prot )
 145 {
 146     static char buffer[6];
 147     buffer[0] = (prot & VPROT_COMMITTED) ? 'c' : '-';
 148     buffer[1] = (prot & VPROT_GUARD) ? 'g' : '-';
 149     buffer[2] = (prot & VPROT_READ) ? 'r' : '-';
 150     buffer[3] = (prot & VPROT_WRITECOPY) ? 'W' : ((prot & VPROT_WRITE) ? 'w' : '-');
 151     buffer[4] = (prot & VPROT_EXEC) ? 'x' : '-';
 152     buffer[5] = 0;
 153     return buffer;
 154 }
 155
 156
 157 /***********************************************************************
 158  *           VIRTUAL_DumpView
 159  */
 160 static void VIRTUAL_DumpView( FILE_VIEW *view )
 161 {
 162     UINT i, count;
 163     char *addr = view->base;
 164     BYTE prot = view->prot[0];
 165
 166     DPRINTF( "View: %p - %p", addr, addr + view->size - 1 );
 167     if (view->flags & VFLAG_SYSTEM)
 168         DPRINTF( " (system)\n" );
 169     else if (view->flags & VFLAG_VALLOC)
 170         DPRINTF( " (valloc)\n" );
 171     else if (view->mapping)
 172         DPRINTF( " %p\n", view->mapping );
 173     else
 174         DPRINTF( " (anonymous)\n");
 175
 176     for (count = i = 1; i < view->size >> page_shift; i++, count++)
 177     {
 178         if (view->prot[i] == prot) continue;
 179         DPRINTF( "      %p - %p %s\n",
 180                  addr, addr + (count << page_shift) - 1, VIRTUAL_GetProtStr(prot) );
 181         addr += (count << page_shift);
 182         prot = view->prot[i];
 183         count = 0;
 184     }
 185     if (count)
 186         DPRINTF( "      %p - %p %s\n",
 187                  addr, addr + (count << page_shift) - 1, VIRTUAL_GetProtStr(prot) );
 188 }
 189
 190
 191 /***********************************************************************
 192  *           VIRTUAL_Dump
 193  */
 194 void VIRTUAL_Dump(void)
 195 {
 196     struct list *ptr;
 197
 198     DPRINTF( "\nDump of all virtual memory views:\n\n" );
 199     RtlEnterCriticalSection(&csVirtual);
 200     LIST_FOR_EACH( ptr, &views_list )
 201     {
 202         VIRTUAL_DumpView( LIST_ENTRY( ptr, struct file_view, entry ) );
 203     }
 204     RtlLeaveCriticalSection(&csVirtual);
 205 }
 206
 207
 208 /***********************************************************************
 209  *           VIRTUAL_FindView
 210  *
 211  * Find the view containing a given address. The csVirtual section must be held by caller.
 212  *
 213  * RETURNS
 214  *      View: Success
 215  *      NULL: Failure
 216  */
 217 static struct file_view *VIRTUAL_FindView( const void *addr ) /* [in] Address */
 218 {
 219     struct list *ptr;
 220
 221     LIST_FOR_EACH( ptr, &views_list )
 222     {
 223         struct file_view *view = LIST_ENTRY( ptr, struct file_view, entry );
 224         if (view->base > addr) break;
 225         if ((char *)view->base + view->size > (const char *)addr) return view;
 226     }
 227     return NULL;
 228 }
 229
 230
 231 /***********************************************************************
 232  *           find_view_range
 233  *
 234  * Find the first view overlapping at least part of the specified range.
 235  * The csVirtual section must be held by caller.
 236  */
 237 static struct file_view *find_view_range( const void *addr, size_t size )
 238 {
 239     struct list *ptr;
 240
 241     LIST_FOR_EACH( ptr, &views_list )
 242     {
 243         struct file_view *view = LIST_ENTRY( ptr, struct file_view, entry );
 244         if ((char *)view->base >= (const char *)addr + size) break;
 245         if ((char *)view->base + view->size > (const char *)addr) return view;
 246     }
 247     return NULL;
 248 }
 249
 250
 251 /***********************************************************************
 252  *           add_reserved_area
 253  *
 254  * Add a reserved area to the list maintained by libwine.
 255  * The csVirtual section must be held by caller.
 256  */
 257 static void add_reserved_area( void *addr, size_t size )
 258 {
 259     TRACE( "adding %p-%p\n", addr, (char *)addr + size );
 260
 261     if (addr < USER_SPACE_LIMIT)
 262     {
 263         /* unmap the part of the area that is below the limit */
 264         assert( (char *)addr + size > (char *)USER_SPACE_LIMIT );
 265         munmap( addr, (char *)USER_SPACE_LIMIT - (char *)addr );
 266         size -= (char *)USER_SPACE_LIMIT - (char *)addr;
 267         addr = USER_SPACE_LIMIT;
 268     }
 269     wine_mmap_add_reserved_area( addr, size );
 270 }
 271
 272
 273 /***********************************************************************
 274  *           is_beyond_limit
 275  *
 276  * Check if an address range goes beyond a given limit.
 277  */
 278 static inline int is_beyond_limit( void *addr, size_t size, void *limit )
 279 {
 280     return (limit && (addr >= limit || (char *)addr + size > (char *)limit));
 281 }
 282
 283
 284 /***********************************************************************
 285  *           unmap_area
 286  *
 287  * Unmap an area, or simply replace it by an empty mapping if it is
 288  * in a reserved area. The csVirtual section must be held by caller.
 289  */
 290 static inline void unmap_area( void *addr, size_t size )
 291 {
 292     if (wine_mmap_is_in_reserved_area( addr, size ))
 293         wine_anon_mmap( addr, size, PROT_NONE, MAP_NORESERVE | MAP_FIXED );
 294     else
 295         munmap( addr, size );
 296 }
 297
 298
 299 /***********************************************************************
 300  *           delete_view
 301  *
 302  * Deletes a view. The csVirtual section must be held by caller.
 303  */
 304 static void delete_view( struct file_view *view ) /* [in] View */
 305 {
 306     if (!(view->flags & VFLAG_SYSTEM)) unmap_area( view->base, view->size );
 307     list_remove( &view->entry );
 308     if (view->mapping) NtClose( view->mapping );
 309     free( view );
 310 }
 311
 312
 313 /***********************************************************************
 314  *           create_view
 315  *
 316  * Create a view. The csVirtual section must be held by caller.
 317  */
 318 static NTSTATUS create_view( struct file_view **view_ret, void *base, size_t size, BYTE vprot )
 319 {
 320     struct file_view *view;
 321     struct list *ptr;
 322
 323     assert( !((unsigned int)base & page_mask) );
 324     assert( !(size & page_mask) );
 325
 326     /* Create the view structure */
 327
 328     if (!(view = malloc( sizeof(*view) + (size >> page_shift) - 1 ))) return STATUS_NO_MEMORY;
 329
 330     view->base    = base;
 331     view->size    = size;
 332     view->flags   = 0;
 333     view->mapping = 0;
 334     view->protect = vprot;
 335     view->handlerProc = NULL;
 336     memset( view->prot, vprot, size >> page_shift );
 337
 338     /* Insert it in the linked list */
 339
 340     LIST_FOR_EACH( ptr, &views_list )
 341     {
 342         struct file_view *next = LIST_ENTRY( ptr, struct file_view, entry );
 343         if (next->base > base) break;
 344     }
 345     list_add_before( ptr, &view->entry );
 346
 347     /* Check for overlapping views. This can happen if the previous view
 348      * was a system view that got unmapped behind our back. In that case
 349      * we recover by simply deleting it. */
 350
 351     if ((ptr = list_prev( &views_list, &view->entry )) != NULL)
 352     {
 353         struct file_view *prev = LIST_ENTRY( ptr, struct file_view, entry );
 354         if ((char *)prev->base + prev->size > (char *)base)
 355         {
 356             TRACE( "overlapping prev view %p-%p for %p-%p\n",
 357                    prev->base, (char *)prev->base + prev->size,
 358                    base, (char *)base + view->size );
 359             assert( prev->flags & VFLAG_SYSTEM );
 360             delete_view( prev );
 361         }
 362     }
 363     if ((ptr = list_next( &views_list, &view->entry )) != NULL)
 364     {
 365         struct file_view *next = LIST_ENTRY( ptr, struct file_view, entry );
 366         if ((char *)base + view->size > (char *)next->base)
 367         {
 368             TRACE( "overlapping next view %p-%p for %p-%p\n",
 369                    next->base, (char *)next->base + next->size,
 370                    base, (char *)base + view->size );
 371             assert( next->flags & VFLAG_SYSTEM );
 372             delete_view( next );
 373         }
 374     }
 375
 376     *view_ret = view;
 377     VIRTUAL_DEBUG_DUMP_VIEW( view );
 378     return STATUS_SUCCESS;
 379 }
 380
 381
 382 /***********************************************************************
 383  *           VIRTUAL_GetUnixProt
 384  *
 385  * Convert page protections to protection for mmap/mprotect.
 386  */
 387 static int VIRTUAL_GetUnixProt( BYTE vprot )
 388 {
 389     int prot = 0;
 390     if ((vprot & VPROT_COMMITTED) && !(vprot & VPROT_GUARD))
 391     {
 392         if (vprot & VPROT_READ) prot |= PROT_READ;
 393         if (vprot & VPROT_WRITE) prot |= PROT_WRITE;
 394         if (vprot & VPROT_WRITECOPY) prot |= PROT_WRITE;
 395         if (vprot & VPROT_EXEC) prot |= PROT_EXEC;
 396     }
 397     return prot;
 398 }
 399
 400
 401 /***********************************************************************
 402  *           VIRTUAL_GetWin32Prot
 403  *
 404  * Convert page protections to Win32 flags.
 405  *
 406  * RETURNS
 407  *      None
 408  */
 409 static void VIRTUAL_GetWin32Prot(
 410             BYTE vprot,     /* [in] Page protection flags */
 411             DWORD *protect, /* [out] Location to store Win32 protection flags */
 412             DWORD *state )  /* [out] Location to store mem state flag */
 413 {
 414     if (protect) {
 415         *protect = VIRTUAL_Win32Flags[vprot & 0x0f];
 416 /*      if (vprot & VPROT_GUARD) *protect |= PAGE_GUARD;*/
 417         if (vprot & VPROT_NOCACHE) *protect |= PAGE_NOCACHE;
 418
 419         if (vprot & VPROT_GUARD) *protect = PAGE_NOACCESS;
 420     }
 421
 422     if (state) *state = (vprot & VPROT_COMMITTED) ? MEM_COMMIT : MEM_RESERVE;
 423 }
 424
 425
 426 /***********************************************************************
 427  *           VIRTUAL_GetProt
 428  *
 429  * Build page protections from Win32 flags.
 430  *
 431  * RETURNS
 432  *      Value of page protection flags
 433  */
 434 static BYTE VIRTUAL_GetProt( DWORD protect )  /* [in] Win32 protection flags */
 435 {
 436     BYTE vprot;
 437
 438     switch(protect & 0xff)
 439     {
 440     case PAGE_READONLY:
 441         vprot = VPROT_READ;
 442         break;
 443     case PAGE_READWRITE:
 444         vprot = VPROT_READ | VPROT_WRITE;
 445         break;
 446     case PAGE_WRITECOPY:
 447         /* MSDN CreateFileMapping() states that if PAGE_WRITECOPY is given,
 448          * that the hFile must have been opened with GENERIC_READ and
 449          * GENERIC_WRITE access.  This is WRONG as tests show that you
 450          * only need GENERIC_READ access (at least for Win9x,
 451          * FIXME: what about NT?).  Thus, we don't put VPROT_WRITE in
 452          * PAGE_WRITECOPY and PAGE_EXECUTE_WRITECOPY.
 453          */
 454         vprot = VPROT_READ | VPROT_WRITECOPY;
 455         break;
 456     case PAGE_EXECUTE:
 457         vprot = VPROT_EXEC;
 458         break;
 459     case PAGE_EXECUTE_READ:
 460         vprot = VPROT_EXEC | VPROT_READ;
 461         break;
 462     case PAGE_EXECUTE_READWRITE:
 463         vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITE;
 464         break;
 465     case PAGE_EXECUTE_WRITECOPY:
 466         /* See comment for PAGE_WRITECOPY above */
 467         vprot = VPROT_EXEC | VPROT_READ | VPROT_WRITECOPY;
 468         break;
 469     case PAGE_NOACCESS:
 470     default:
 471         vprot = 0;
 472         break;
 473     }
 474     if (protect & PAGE_GUARD) vprot |= VPROT_GUARD;
 475     if (protect & PAGE_NOCACHE) vprot |= VPROT_NOCACHE;
 476     return vprot;
 477 }
 478
 479
 480 /***********************************************************************
 481  *           VIRTUAL_SetProt
 482  *
 483  * Change the protection of a range of pages.
 484  *
 485  * RETURNS
 486  *      TRUE: Success
 487  *      FALSE: Failure
 488  */
 489 static BOOL VIRTUAL_SetProt( FILE_VIEW *view, /* [in] Pointer to view */
 490                              void *base,      /* [in] Starting address */
 491                              UINT size,       /* [in] Size in bytes */
 492                              BYTE vprot )     /* [in] Protections to use */
 493 {
 494     TRACE("%p-%p %s\n",
 495           base, (char *)base + size - 1, VIRTUAL_GetProtStr( vprot ) );
 496
 497     if (mprotect( base, size, VIRTUAL_GetUnixProt(vprot) ))
 498         return FALSE;  /* FIXME: last error */
 499
 500     memset( view->prot + (((char *)base - (char *)view->base) >> page_shift),
 501             vprot, size >> page_shift );
 502     VIRTUAL_DEBUG_DUMP_VIEW( view );
 503     return TRUE;
 504 }
 505
 506
 507 /***********************************************************************
 508  *           map_view
 509  *
 510  * Create a view and mmap the corresponding memory area.
 511  * The csVirtual section must be held by caller.
 512  */
 513 static NTSTATUS map_view( struct file_view **view_ret, void *base, size_t size, BYTE vprot )
 514 {
 515     void *ptr;
 516     NTSTATUS status;
 517
 518     if (base)
 519     {
 520         if (is_beyond_limit( base, size, ADDRESS_SPACE_LIMIT ))
 521             return STATUS_WORKING_SET_LIMIT_RANGE;
 522
 523         switch (wine_mmap_is_in_reserved_area( base, size ))
 524         {
 525         case -1: /* partially in a reserved area */
 526             return STATUS_CONFLICTING_ADDRESSES;
 527
 528         case 0:  /* not in a reserved area, do a normal allocation */
 529             if ((ptr = wine_anon_mmap( base, size, VIRTUAL_GetUnixProt(vprot), 0 )) == (void *)-1)
 530             {
 531                 if (errno == ENOMEM) return STATUS_NO_MEMORY;
 532                 return STATUS_INVALID_PARAMETER;
 533             }
 534             if (ptr != base)
 535             {
 536                 /* We couldn't get the address we wanted */
 537                 if (is_beyond_limit( ptr, size, USER_SPACE_LIMIT )) add_reserved_area( ptr, size );
 538                 else munmap( ptr, size );
 539                 return STATUS_CONFLICTING_ADDRESSES;
 540             }
 541             break;
 542
 543         default:
 544         case 1:  /* in a reserved area, make sure the address is available */
 545             if (find_view_range( base, size )) return STATUS_CONFLICTING_ADDRESSES;
 546             /* replace the reserved area by our mapping */
 547             if ((ptr = wine_anon_mmap( base, size, VIRTUAL_GetUnixProt(vprot), MAP_FIXED )) != base)
 548                 return STATUS_INVALID_PARAMETER;
 549             break;
 550         }
 551     }
 552     else
 553     {
 554         size_t view_size = size + granularity_mask + 1;
 555
 556         for (;;)
 557         {
 558             if ((ptr = wine_anon_mmap( NULL, view_size, VIRTUAL_GetUnixProt(vprot), 0 )) == (void *)-1)
 559             {
 560                 if (errno == ENOMEM) return STATUS_NO_MEMORY;
 561                 return STATUS_INVALID_PARAMETER;
 562             }
 563             /* if we got something beyond the user limit, unmap it and retry */
 564             if (is_beyond_limit( ptr, view_size, USER_SPACE_LIMIT )) add_reserved_area( ptr, view_size );
 565             else break;
 566         }
 567
 568         /* Release the extra memory while keeping the range
 569          * starting on the granularity boundary. */
 570         if ((unsigned int)ptr & granularity_mask)
 571         {
 572             unsigned int extra = granularity_mask + 1 - ((unsigned int)ptr & granularity_mask);
 573             munmap( ptr, extra );
 574             ptr = (char *)ptr + extra;
 575             view_size -= extra;
 576         }
 577         if (view_size > size)
 578             munmap( (char *)ptr + size, view_size - size );
 579     }
 580
 581     status = create_view( view_ret, ptr, size, vprot );
 582     if (status != STATUS_SUCCESS) unmap_area( ptr, size );
 583     return status;
 584 }
 585
 586
 587 /***********************************************************************
 588  *           unaligned_mmap
 589  *
 590  * Linux kernels before 2.4.x can support non page-aligned offsets, as
 591  * long as the offset is aligned to the filesystem block size. This is
 592  * a big performance gain so we want to take advantage of it.
 593  *
 594  * However, when we use 64-bit file support this doesn't work because
 595  * glibc rejects unaligned offsets. Also glibc 2.1.3 mmap64 is broken
 596  * in that it rounds unaligned offsets down to a page boundary. For
 597  * these reasons we do a direct system call here.
 598  */
 599 static void *unaligned_mmap( void *addr, size_t length, unsigned int prot,
 600                              unsigned int flags, int fd, off_t offset )
 601 {
 602 #if defined(linux) && defined(__i386__) && defined(__GNUC__)
 603     if (!(offset >> 32) && (offset & page_mask))
 604     {
 605         int ret;
 606
 607         struct
 608         {
 609             void        *addr;
 610             unsigned int length;
 611             unsigned int prot;
 612             unsigned int flags;
 613             unsigned int fd;
 614             unsigned int offset;
 615         } args;
 616
 617         args.addr   = addr;
 618         args.length = length;
 619         args.prot   = prot;
 620         args.flags  = flags;
 621         args.fd     = fd;
 622         args.offset = offset;
 623
 624         __asm__ __volatile__("push %%ebx\n\t"
 625                              "movl %2,%%ebx\n\t"
 626                              "int $0x80\n\t"
 627                              "popl %%ebx"
 628                              : "=a" (ret)
 629                              : "0" (90), /* SYS_mmap */
 630                                "g" (&args)
 631                              : "memory" );
 632         if (ret < 0 && ret > -4096)
 633         {
 634             errno = -ret;
 635             ret = -1;
 636         }
 637         return (void *)ret;
 638     }
 639 #endif
 640     return mmap( addr, length, prot, flags, fd, offset );
 641 }
 642
 643
 644 /***********************************************************************
 645  *           map_file_into_view
 646  *
 647  * Wrapper for mmap() to map a file into a view, falling back to read if mmap fails.
 648  * The csVirtual section must be held by caller.
 649  */
 650 static NTSTATUS map_file_into_view( struct file_view *view, int fd, size_t start, size_t size,
 651                                     off_t offset, BYTE vprot, BOOL removable )
 652 {
 653     void *ptr;
 654     int prot = VIRTUAL_GetUnixProt( vprot );
 655     BOOL shared_write = (vprot & VPROT_WRITE) != 0;
 656
 657     assert( start < view->size );
 658     assert( start + size <= view->size );
 659
 660     /* only try mmap if media is not removable (or if we require write access) */
 661     if (!removable || shared_write)
 662     {
 663         int flags = MAP_FIXED | (shared_write ? MAP_SHARED : MAP_PRIVATE);
 664
 665         if (unaligned_mmap( (char *)view->base + start, size, prot, flags, fd, offset ) != (void *)-1)
 666             goto done;
 667
 668         /* mmap() failed; if this is because the file offset is not    */
 669         /* page-aligned (EINVAL), or because the underlying filesystem */
 670         /* does not support mmap() (ENOEXEC,ENODEV), we do it by hand. */
 671         if ((errno != ENOEXEC) && (errno != EINVAL) && (errno != ENODEV)) return FILE_GetNtStatus();
 672         if (shared_write) return FILE_GetNtStatus();  /* we cannot fake shared write mappings */
 673     }
 674
 675     /* Reserve the memory with an anonymous mmap */
 676     ptr = wine_anon_mmap( (char *)view->base + start, size, PROT_READ | PROT_WRITE, MAP_FIXED );
 677     if (ptr == (void *)-1) return FILE_GetNtStatus();
 678     /* Now read in the file */
 679     pread( fd, ptr, size, offset );
 680     if (prot != (PROT_READ|PROT_WRITE)) mprotect( ptr, size, prot );  /* Set the right protection */
 681 done:
 682     memset( view->prot + (start >> page_shift), vprot, size >> page_shift );
 683     return STATUS_SUCCESS;
 684 }
 685
 686
 687 /***********************************************************************
 688  *           decommit_view
 689  *
 690  * Decommit some pages of a given view.
 691  * The csVirtual section must be held by caller.
 692  */
 693 static NTSTATUS decommit_pages( struct file_view *view, size_t start, size_t size )
 694 {
 695     if (wine_anon_mmap( (char *)view->base + start, size, PROT_NONE, MAP_FIXED ) != (void *)-1)
 696     {
 697         BYTE *p = view->prot + (start >> page_shift);
 698         size >>= page_shift;
 699         while (size--) *p++ &= ~VPROT_COMMITTED;
 700         return STATUS_SUCCESS;
 701     }
 702     return FILE_GetNtStatus();
 703 }
 704
 705
 706 /***********************************************************************
 707  *           do_relocations
 708  *
 709  * Apply the relocations to a mapped PE image
 710  */
 711 static int do_relocations( char *base, const IMAGE_DATA_DIRECTORY *dir,
 712                            int delta, DWORD total_size )
 713 {
 714     IMAGE_BASE_RELOCATION *rel;
 715
 716     TRACE_(module)( "relocating from %p-%p to %p-%p\n",
 717                     base - delta, base - delta + total_size, base, base + total_size );
 718
 719     for (rel = (IMAGE_BASE_RELOCATION *)(base + dir->VirtualAddress);
 720          ((char *)rel < base + dir->VirtualAddress + dir->Size) && rel->SizeOfBlock;
 721          rel = (IMAGE_BASE_RELOCATION*)((char*)rel + rel->SizeOfBlock) )
 722     {
 723         char *page = base + rel->VirtualAddress;
 724         WORD *TypeOffset = (WORD *)(rel + 1);
 725         int i, count = (rel->SizeOfBlock - sizeof(*rel)) / sizeof(*TypeOffset);
 726
 727         if (!count) continue;
 728
 729         /* sanity checks */
 730         if ((char *)rel + rel->SizeOfBlock > base + dir->VirtualAddress + dir->Size ||
 731             page > base + total_size)
 732         {
 733             ERR_(module)("invalid relocation %p,%lx,%ld at %p,%lx,%lx\n",
 734                          rel, rel->VirtualAddress, rel->SizeOfBlock,
 735                          base, dir->VirtualAddress, dir->Size );
 736             return 0;
 737         }
 738
 739         TRACE_(module)("%ld relocations for page %lx\n", rel->SizeOfBlock, rel->VirtualAddress);
 740
 741         /* patching in reverse order */
 742         for (i = 0 ; i < count; i++)
 743         {
 744             int offset = TypeOffset[i] & 0xFFF;
 745             int type = TypeOffset[i] >> 12;
 746             switch(type)
 747             {
 748             case IMAGE_REL_BASED_ABSOLUTE:
 749                 break;
 750             case IMAGE_REL_BASED_HIGH:
 751                 *(short*)(page+offset) += HIWORD(delta);
 752                 break;
 753             case IMAGE_REL_BASED_LOW:
 754                 *(short*)(page+offset) += LOWORD(delta);
 755                 break;
 756             case IMAGE_REL_BASED_HIGHLOW:
 757                 *(int*)(page+offset) += delta;
 758                 /* FIXME: if this is an exported address, fire up enhanced logic */
 759                 break;
 760             default:
 761                 FIXME_(module)("Unknown/unsupported fixup type %d.\n", type);
 762                 break;
 763             }
 764         }
 765     }
 766     return 1;
 767 }
 768
 769
 770 /***********************************************************************
 771  *           map_image
 772  *
 773  * Map an executable (PE format) image into memory.
 774  */
 775 static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size,
 776                            DWORD header_size, int shared_fd, BOOL removable, PVOID *addr_ptr )
 777 {
 778     IMAGE_DOS_HEADER *dos;
 779     IMAGE_NT_HEADERS *nt;
 780     IMAGE_SECTION_HEADER *sec;
 781     IMAGE_DATA_DIRECTORY *imports;
 782     NTSTATUS status = STATUS_CONFLICTING_ADDRESSES;
 783     int i;
 784     off_t pos;
 785     struct file_view *view = NULL;
 786     char *ptr;
 787
 788     /* zero-map the whole range */
 789
 790     RtlEnterCriticalSection( &csVirtual );
 791
 792     if (base >= (char *)0x110000)  /* make sure the DOS area remains free */
 793         status = map_view( &view, base, total_size,
 794                            VPROT_COMMITTED | VPROT_READ | VPROT_EXEC | VPROT_WRITECOPY | VPROT_IMAGE );
 795
 796     if (status == STATUS_CONFLICTING_ADDRESSES)
 797         status = map_view( &view, NULL, total_size,
 798                            VPROT_COMMITTED | VPROT_READ | VPROT_EXEC | VPROT_WRITECOPY | VPROT_IMAGE );
 799
 800     if (status != STATUS_SUCCESS) goto error;
 801
 802     ptr = view->base;
 803     TRACE_(module)( "mapped PE file at %p-%p\n", ptr, ptr + total_size );
 804
 805     /* map the header */
 806
 807     status = STATUS_INVALID_IMAGE_FORMAT;  /* generic error */
 808     if (map_file_into_view( view, fd, 0, header_size, 0, VPROT_COMMITTED | VPROT_READ,
 809                             removable ) != STATUS_SUCCESS) goto error;
 810     dos = (IMAGE_DOS_HEADER *)ptr;
 811     nt = (IMAGE_NT_HEADERS *)(ptr + dos->e_lfanew);
 812     if ((char *)(nt + 1) > ptr + header_size) goto error;
 813
 814     sec = (IMAGE_SECTION_HEADER*)((char*)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
 815     if ((char *)(sec + nt->FileHeader.NumberOfSections) > ptr + header_size) goto error;
 816
 817     imports = nt->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_IMPORT;
 818     if (!imports->Size || !imports->VirtualAddress) imports = NULL;
 819
 820     /* check the architecture */
 821
 822     if (nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
 823     {
 824         MESSAGE("Trying to load PE image for unsupported architecture (");
 825         switch (nt->FileHeader.Machine)
 826         {
 827         case IMAGE_FILE_MACHINE_UNKNOWN: MESSAGE("Unknown"); break;
 828         case IMAGE_FILE_MACHINE_I860:    MESSAGE("I860"); break;
 829         case IMAGE_FILE_MACHINE_R3000:   MESSAGE("R3000"); break;
 830         case IMAGE_FILE_MACHINE_R4000:   MESSAGE("R4000"); break;
 831         case IMAGE_FILE_MACHINE_R10000:  MESSAGE("R10000"); break;
 832         case IMAGE_FILE_MACHINE_ALPHA:   MESSAGE("Alpha"); break;
 833         case IMAGE_FILE_MACHINE_POWERPC: MESSAGE("PowerPC"); break;
 834         default: MESSAGE("Unknown-%04x", nt->FileHeader.Machine); break;
 835         }
 836         MESSAGE(")\n");
 837         goto error;
 838     }
 839
 840     /* map all the sections */
 841
 842     for (i = pos = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
 843     {
 844         DWORD size;
 845
 846         /* a few sanity checks */
 847         size = sec->VirtualAddress + ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
 848         if (sec->VirtualAddress > total_size || size > total_size || size < sec->VirtualAddress)
 849         {
 850             ERR_(module)( "Section %.8s too large (%lx+%lx/%lx)\n",
 851                           sec->Name, sec->VirtualAddress, sec->Misc.VirtualSize, total_size );
 852             goto error;
 853         }
 854
 855         if ((sec->Characteristics & IMAGE_SCN_MEM_SHARED) &&
 856             (sec->Characteristics & IMAGE_SCN_MEM_WRITE))
 857         {
 858             size = ROUND_SIZE( 0, sec->Misc.VirtualSize );
 859             TRACE_(module)( "mapping shared section %.8s at %p off %lx (%x) size %lx (%lx) flags %lx\n",
 860                           sec->Name, ptr + sec->VirtualAddress,
 861                           sec->PointerToRawData, (int)pos, sec->SizeOfRawData,
 862                           size, sec->Characteristics );
 863             if (map_file_into_view( view, shared_fd, sec->VirtualAddress, size, pos,
 864                                     VPROT_COMMITTED | VPROT_READ | PROT_WRITE,
 865                                     FALSE ) != STATUS_SUCCESS)
 866             {
 867                 ERR_(module)( "Could not map shared section %.8s\n", sec->Name );
 868                 goto error;
 869             }
 870
 871             /* check if the import directory falls inside this section */
 872             if (imports && imports->VirtualAddress >= sec->VirtualAddress &&
 873                 imports->VirtualAddress < sec->VirtualAddress + size)
 874             {
 875                 UINT_PTR base = imports->VirtualAddress & ~page_mask;
 876                 UINT_PTR end = base + ROUND_SIZE( imports->VirtualAddress, imports->Size );
 877                 if (end > sec->VirtualAddress + size) end = sec->VirtualAddress + size;
 878                 if (end > base)
 879                     map_file_into_view( view, shared_fd, base, end - base,
 880                                         pos + (base - sec->VirtualAddress),
 881                                         VPROT_COMMITTED | VPROT_READ | VPROT_WRITECOPY,
 882                                         FALSE );
 883             }
 884             pos += size;
 885             continue;
 886         }
 887
 888         TRACE_(module)( "mapping section %.8s at %p off %lx size %lx flags %lx\n",
 889                         sec->Name, ptr + sec->VirtualAddress,
 890                         sec->PointerToRawData, sec->SizeOfRawData,
 891                         sec->Characteristics );
 892
 893         if ((sec->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) &&
 894             !(sec->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)) continue;
 895         if (!sec->PointerToRawData || !sec->SizeOfRawData) continue;
 896
 897         /* Note: if the section is not aligned properly map_file_into_view will magically
 898          *       fall back to read(), so we don't need to check anything here.
 899          */
 900         if (map_file_into_view( view, fd, sec->VirtualAddress, sec->SizeOfRawData, sec->PointerToRawData,
 901                                 VPROT_COMMITTED | VPROT_READ | VPROT_WRITECOPY,
 902                                 removable ) != STATUS_SUCCESS)
 903         {
 904             ERR_(module)( "Could not map section %.8s, file probably truncated\n", sec->Name );
 905             goto error;
 906         }
 907
 908         if ((sec->SizeOfRawData < sec->Misc.VirtualSize) && (sec->SizeOfRawData & page_mask))
 909         {
 910             DWORD end = ROUND_SIZE( 0, sec->SizeOfRawData );
 911             if (end > sec->Misc.VirtualSize) end = sec->Misc.VirtualSize;
 912             TRACE_(module)("clearing %p - %p\n",
 913                            ptr + sec->VirtualAddress + sec->SizeOfRawData,
 914                            ptr + sec->VirtualAddress + end );
 915             memset( ptr + sec->VirtualAddress + sec->SizeOfRawData, 0,
 916                     end - sec->SizeOfRawData );
 917         }
 918     }
 919
 920
 921     /* perform base relocation, if necessary */
 922
 923     if (ptr != base)
 924     {
 925         const IMAGE_DATA_DIRECTORY *relocs;
 926
 927         relocs = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
 928         if (!relocs->VirtualAddress || !relocs->Size)
 929         {
 930             if (nt->OptionalHeader.ImageBase == 0x400000) {
 931                 ERR("Image was mapped at %p: standard load address for a Win32 program (0x00400000) not available\n", ptr);
 932                 ERR("Do you have exec-shield or prelink active?\n");
 933             } else
 934                 ERR( "FATAL: Need to relocate module from addr %lx, but there are no relocation records\n",
 935                      nt->OptionalHeader.ImageBase );
 936             goto error;
 937         }
 938
 939         /* FIXME: If we need to relocate a system DLL (base > 2GB) we should
 940          *        really make sure that the *new* base address is also > 2GB.
 941          *        Some DLLs really check the MSB of the module handle :-/
 942          */
 943         if ((nt->OptionalHeader.ImageBase & 0x80000000) && !((DWORD)base & 0x80000000))
 944             ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
 945
 946         if (!do_relocations( ptr, relocs, ptr - base, total_size ))
 947         {
 948             goto error;
 949         }
 950     }
 951
 952     if (!removable)  /* don't keep handle open on removable media */
 953         NtDuplicateObject( GetCurrentProcess(), hmapping,
 954                            GetCurrentProcess(), &view->mapping,
 955                            0, 0, DUPLICATE_SAME_ACCESS );
 956
 957     /* set the image protections */
 958
 959     sec = (IMAGE_SECTION_HEADER*)((char *)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
 960     for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
 961     {
 962         DWORD size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
 963         BYTE vprot = VPROT_COMMITTED;
 964         if (sec->Characteristics & IMAGE_SCN_MEM_READ)    vprot |= VPROT_READ;
 965         if (sec->Characteristics & IMAGE_SCN_MEM_WRITE)   vprot |= VPROT_READ|VPROT_WRITECOPY;
 966         if (sec->Characteristics & IMAGE_SCN_MEM_EXECUTE) vprot |= VPROT_EXEC;
 967
 968         /* make sure the import directory is writable */
 969         if (imports && imports->VirtualAddress >= sec->VirtualAddress &&
 970             imports->VirtualAddress < sec->VirtualAddress + size)
 971             vprot |= VPROT_READ|VPROT_WRITECOPY;
 972
 973         VIRTUAL_SetProt( view, ptr + sec->VirtualAddress, size, vprot );
 974     }
 975     RtlLeaveCriticalSection( &csVirtual );
 976
 977     *addr_ptr = ptr;
 978     return STATUS_SUCCESS;
 979
 980  error:
 981     if (view) delete_view( view );
 982     RtlLeaveCriticalSection( &csVirtual );
 983     return status;
 984 }
 985
 986
 987 /***********************************************************************
 988  *           is_current_process
 989  *
 990  * Check whether a process handle is for the current process.
 991  */
 992 static BOOL is_current_process( HANDLE handle )
 993 {
 994     BOOL ret = FALSE;
 995
 996     if (handle == GetCurrentProcess()) return TRUE;
 997     SERVER_START_REQ( get_process_info )
 998     {
 999         req->handle = handle;
1000         if (!wine_server_call( req ))
1001             ret = ((DWORD)reply->pid == GetCurrentProcessId());
1002     }
1003     SERVER_END_REQ;
1004     return ret;
1005 }
1006
1007
1008 /***********************************************************************
1009  *           virtual_init
1010  */
1011 void virtual_init(void)
1012 {
1013 #ifndef page_mask
1014     page_size = getpagesize();
1015     page_mask = page_size - 1;
1016     /* Make sure we have a power of 2 */
1017     assert( !(page_size & page_mask) );
1018     page_shift = 0;
1019     while ((1 << page_shift) != page_size) page_shift++;
1020 #endif  /* page_mask */
1021 }
1022
1023
1024 /***********************************************************************
1025  *           VIRTUAL_SetFaultHandler
1026  */
1027 BOOL VIRTUAL_SetFaultHandler( LPCVOID addr, HANDLERPROC proc, LPVOID arg )
1028 {
1029     FILE_VIEW *view;
1030     BOOL ret = FALSE;
1031
1032     RtlEnterCriticalSection( &csVirtual );
1033     if ((view = VIRTUAL_FindView( addr )))
1034     {
1035         view->handlerProc = proc;
1036         view->handlerArg  = arg;
1037         ret = TRUE;
1038     }
1039     RtlLeaveCriticalSection( &csVirtual );
1040     return ret;
1041 }
1042
1043 /***********************************************************************
1044  *           VIRTUAL_HandleFault
1045  */
1046 DWORD VIRTUAL_HandleFault( LPCVOID addr )
1047 {
1048     FILE_VIEW *view;
1049     DWORD ret = EXCEPTION_ACCESS_VIOLATION;
1050
1051     RtlEnterCriticalSection( &csVirtual );
1052     if ((view = VIRTUAL_FindView( addr )))
1053     {
1054         if (view->handlerProc)
1055         {
1056             HANDLERPROC proc = view->handlerProc;
1057             void *arg = view->handlerArg;
1058             RtlLeaveCriticalSection( &csVirtual );
1059             if (proc( arg, addr )) ret = 0;  /* handled */
1060             return ret;
1061         }
1062         else
1063         {
1064             BYTE vprot = view->prot[((char *)addr - (char *)view->base) >> page_shift];
1065             void *page = (void *)((UINT_PTR)addr & ~page_mask);
1066             char *stack = NtCurrentTeb()->Tib.StackLimit;
1067             if (vprot & VPROT_GUARD)
1068             {
1069                 VIRTUAL_SetProt( view, page, page_mask + 1, vprot & ~VPROT_GUARD );
1070                 ret = STATUS_GUARD_PAGE_VIOLATION;
1071             }
1072             /* is it inside the stack guard page? */
1073             if (((char *)addr >= stack) && ((char *)addr < stack + (page_mask+1)))
1074                 ret = STATUS_STACK_OVERFLOW;
1075         }
1076     }
1077     RtlLeaveCriticalSection( &csVirtual );
1078     return ret;
1079 }
1080
1081 /***********************************************************************
1082  *           VIRTUAL_HasMapping
1083  *
1084  * Check if the specified view has an associated file mapping.
1085  */
1086 BOOL VIRTUAL_HasMapping( LPCVOID addr )
1087 {
1088     FILE_VIEW *view;
1089     BOOL ret = FALSE;
1090
1091     RtlEnterCriticalSection( &csVirtual );
1092     if ((view = VIRTUAL_FindView( addr ))) ret = (view->mapping != 0);
1093     RtlLeaveCriticalSection( &csVirtual );
1094     return ret;
1095 }
1096
1097
1098 /***********************************************************************
1099  *             NtAllocateVirtualMemory   (NTDLL.@)
1100  *             ZwAllocateVirtualMemory   (NTDLL.@)
1101  */
1102 NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, PVOID addr,
1103                                          ULONG *size_ptr, ULONG type, ULONG protect )
1104 {
1105     void *base;
1106     BYTE vprot;
1107     DWORD size = *size_ptr;
1108     NTSTATUS status = STATUS_SUCCESS;
1109     struct file_view *view;
1110
1111     if (!is_current_process( process ))
1112     {
1113         ERR("Unsupported on other process\n");
1114         return STATUS_ACCESS_DENIED;
1115     }
1116
1117     TRACE("%p %08lx %lx %08lx\n", addr, size, type, protect );
1118
1119     if (!size) return STATUS_INVALID_PARAMETER;
1120
1121     /* Round parameters to a page boundary */
1122
1123     if (size > 0x7fc00000) return STATUS_WORKING_SET_LIMIT_RANGE; /* 2Gb - 4Mb */
1124
1125     if (addr)
1126     {
1127         if (type & MEM_RESERVE) /* Round down to 64k boundary */
1128             base = ROUND_ADDR( addr, granularity_mask );
1129         else
1130             base = ROUND_ADDR( addr, page_mask );
1131         size = (((UINT_PTR)addr + size + page_mask) & ~page_mask) - (UINT_PTR)base;
1132
1133         /* disallow low 64k, wrap-around and kernel space */
1134         if (((char *)base <= (char *)granularity_mask) ||
1135             ((char *)base + size < (char *)base) ||
1136             is_beyond_limit( base, size, ADDRESS_SPACE_LIMIT ))
1137             return STATUS_INVALID_PARAMETER;
1138     }
1139     else
1140     {
1141         base = NULL;
1142         size = (size + page_mask) & ~page_mask;
1143     }
1144
1145     if (type & MEM_TOP_DOWN) {
1146         /* FIXME: MEM_TOP_DOWN allocates the largest possible address. */
1147         WARN("MEM_TOP_DOWN ignored\n");
1148         type &= ~MEM_TOP_DOWN;
1149     }
1150
1151     /* Compute the alloc type flags */
1152
1153     if (!(type & MEM_SYSTEM))
1154     {
1155         if (!(type & (MEM_COMMIT | MEM_RESERVE)) || (type & ~(MEM_COMMIT | MEM_RESERVE)))
1156         {
1157             WARN("called with wrong alloc type flags (%08lx) !\n", type);
1158             return STATUS_INVALID_PARAMETER;
1159         }
1160     }
1161     vprot = VIRTUAL_GetProt( protect );
1162     if (type & MEM_COMMIT) vprot |= VPROT_COMMITTED;
1163
1164     /* Reserve the memory */
1165
1166     RtlEnterCriticalSection( &csVirtual );
1167
1168     if (type & MEM_SYSTEM)
1169     {
1170         if (type & MEM_IMAGE) vprot |= VPROT_IMAGE;
1171         status = create_view( &view, base, size, vprot | VPROT_COMMITTED );
1172         if (status == STATUS_SUCCESS)
1173         {
1174             view->flags |= VFLAG_VALLOC | VFLAG_SYSTEM;
1175             base = view->base;
1176         }
1177     }
1178     else if ((type & MEM_RESERVE) || !base)
1179     {
1180         status = map_view( &view, base, size, vprot );
1181         if (status == STATUS_SUCCESS)
1182         {
1183             view->flags |= VFLAG_VALLOC;
1184             base = view->base;
1185         }
1186     }
1187     else  /* commit the pages */
1188     {
1189         if (!(view = VIRTUAL_FindView( base )) ||
1190             ((char *)base + size > (char *)view->base + view->size)) status = STATUS_NOT_MAPPED_VIEW;
1191         else if (!VIRTUAL_SetProt( view, base, size, vprot )) status = STATUS_ACCESS_DENIED;
1192     }
1193
1194     RtlLeaveCriticalSection( &csVirtual );
1195
1196     if (status == STATUS_SUCCESS)
1197     {
1198         *ret = base;
1199         *size_ptr = size;
1200     }
1201     return status;
1202 }
1203
1204
1205 /***********************************************************************
1206  *             NtFreeVirtualMemory   (NTDLL.@)
1207  *             ZwFreeVirtualMemory   (NTDLL.@)
1208  */
1209 NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr, ULONG type )
1210 {
1211     FILE_VIEW *view;
1212     char *base;
1213     NTSTATUS status = STATUS_SUCCESS;
1214     LPVOID addr = *addr_ptr;
1215     DWORD size = *size_ptr;
1216
1217     if (!is_current_process( process ))
1218     {
1219         ERR("Unsupported on other process\n");
1220         return STATUS_ACCESS_DENIED;
1221     }
1222
1223     TRACE("%p %08lx %lx\n", addr, size, type );
1224
1225     /* Fix the parameters */
1226
1227     size = ROUND_SIZE( addr, size );
1228     base = ROUND_ADDR( addr, page_mask );
1229
1230     RtlEnterCriticalSection(&csVirtual);
1231
1232     if (!(view = VIRTUAL_FindView( base )) ||
1233         (base + size > (char *)view->base + view->size) ||
1234         !(view->flags & VFLAG_VALLOC))
1235     {
1236         status = STATUS_INVALID_PARAMETER;
1237     }
1238     else if (type & MEM_SYSTEM)
1239     {
1240         /* return the values that the caller should use to unmap the area */
1241         *addr_ptr = view->base;
1242         *size_ptr = view->size;
1243         view->flags |= VFLAG_SYSTEM;
1244         delete_view( view );
1245     }
1246     else if (type == MEM_RELEASE)
1247     {
1248         /* Free the pages */
1249
1250         if (size || (base != view->base)) status = STATUS_INVALID_PARAMETER;
1251         else
1252         {
1253             delete_view( view );
1254             *addr_ptr = base;
1255             *size_ptr = size;
1256         }
1257     }
1258     else if (type == MEM_DECOMMIT)
1259     {
1260         status = decommit_pages( view, base - (char *)view->base, size );
1261         if (status == STATUS_SUCCESS)
1262         {
1263             *addr_ptr = base;
1264             *size_ptr = size;
1265         }
1266     }
1267     else
1268     {
1269         WARN("called with wrong free type flags (%08lx) !\n", type);
1270         status = STATUS_INVALID_PARAMETER;
1271     }
1272
1273     RtlLeaveCriticalSection(&csVirtual);
1274     return status;
1275 }
1276
1277
1278 /***********************************************************************
1279  *             NtProtectVirtualMemory   (NTDLL.@)
1280  *             ZwProtectVirtualMemory   (NTDLL.@)
1281  */
1282 NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr,
1283                                         ULONG new_prot, ULONG *old_prot )
1284 {
1285     FILE_VIEW *view;
1286     NTSTATUS status = STATUS_SUCCESS;
1287     char *base;
1288     UINT i;
1289     BYTE vprot, *p;
1290     DWORD prot, size = *size_ptr;
1291     LPVOID addr = *addr_ptr;
1292
1293     if (!is_current_process( process ))
1294     {
1295         ERR("Unsupported on other process\n");
1296         return STATUS_ACCESS_DENIED;
1297     }
1298
1299     TRACE("%p %08lx %08lx\n", addr, size, new_prot );
1300
1301     /* Fix the parameters */
1302
1303     size = ROUND_SIZE( addr, size );
1304     base = ROUND_ADDR( addr, page_mask );
1305
1306     RtlEnterCriticalSection( &csVirtual );
1307
1308     if (!(view = VIRTUAL_FindView( base )) || (base + size > (char *)view->base + view->size))
1309     {
1310         status = STATUS_INVALID_PARAMETER;
1311     }
1312     else
1313     {
1314         /* Make sure all the pages are committed */
1315
1316         p = view->prot + ((base - (char *)view->base) >> page_shift);
1317         VIRTUAL_GetWin32Prot( *p, &prot, NULL );
1318         for (i = size >> page_shift; i; i--, p++)
1319         {
1320             if (!(*p & VPROT_COMMITTED))
1321             {
1322                 status = STATUS_NOT_COMMITTED;
1323                 break;
1324             }
1325         }
1326         if (!i)
1327         {
1328             if (old_prot) *old_prot = prot;
1329             vprot = VIRTUAL_GetProt( new_prot ) | VPROT_COMMITTED;
1330             if (!VIRTUAL_SetProt( view, base, size, vprot )) status = STATUS_ACCESS_DENIED;
1331         }
1332     }
1333     RtlLeaveCriticalSection( &csVirtual );
1334
1335     if (status == STATUS_SUCCESS)
1336     {
1337         *addr_ptr = base;
1338         *size_ptr = size;
1339     }
1340     return status;
1341 }
1342
1343
1344 /***********************************************************************
1345  *             NtQueryVirtualMemory   (NTDLL.@)
1346  *             ZwQueryVirtualMemory   (NTDLL.@)
1347  */
1348 NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr,
1349                                       MEMORY_INFORMATION_CLASS info_class, PVOID buffer,
1350                                       ULONG len, ULONG *res_len )
1351 {
1352     FILE_VIEW *view;
1353     char *base, *alloc_base = 0;
1354     struct list *ptr;
1355     UINT size = 0;
1356     MEMORY_BASIC_INFORMATION *info = buffer;
1357
1358     if (info_class != MemoryBasicInformation) return STATUS_INVALID_INFO_CLASS;
1359     if (ADDRESS_SPACE_LIMIT && addr >= ADDRESS_SPACE_LIMIT)
1360         return STATUS_WORKING_SET_LIMIT_RANGE;
1361
1362     if (!is_current_process( process ))
1363     {
1364         ERR("Unsupported on other process\n");
1365         return STATUS_ACCESS_DENIED;
1366     }
1367
1368     base = ROUND_ADDR( addr, page_mask );
1369
1370     /* Find the view containing the address */
1371
1372     RtlEnterCriticalSection(&csVirtual);
1373     ptr = list_head( &views_list );
1374     for (;;)
1375     {
1376         if (!ptr)
1377         {
1378             /* make the address space end at the user limit, except if
1379              * the last view was mapped beyond that */
1380             if (alloc_base < (char *)USER_SPACE_LIMIT)
1381             {
1382                 if (USER_SPACE_LIMIT && base >= (char *)USER_SPACE_LIMIT)
1383                 {
1384                     RtlLeaveCriticalSection( &csVirtual );
1385                     return STATUS_WORKING_SET_LIMIT_RANGE;
1386                 }
1387                 size = (char *)USER_SPACE_LIMIT - alloc_base;
1388             }
1389             else size = (char *)ADDRESS_SPACE_LIMIT - alloc_base;
1390             view = NULL;
1391             break;
1392         }
1393         view = LIST_ENTRY( ptr, struct file_view, entry );
1394         if ((char *)view->base > base)
1395         {
1396             size = (char *)view->base - alloc_base;
1397             view = NULL;
1398             break;
1399         }
1400         if ((char *)view->base + view->size > base)
1401         {
1402             alloc_base = view->base;
1403             size = view->size;
1404             break;
1405         }
1406         alloc_base = (char *)view->base + view->size;
1407         ptr = list_next( &views_list, ptr );
1408     }
1409
1410     /* Fill the info structure */
1411
1412     if (!view)
1413     {
1414         info->State             = MEM_FREE;
1415         info->Protect           = 0;
1416         info->AllocationProtect = 0;
1417         info->Type              = 0;
1418     }
1419     else
1420     {
1421         BYTE vprot = view->prot[(base - alloc_base) >> page_shift];
1422         VIRTUAL_GetWin32Prot( vprot, &info->Protect, &info->State );
1423         for (size = base - alloc_base; size < view->size; size += page_mask+1)
1424             if (view->prot[size >> page_shift] != vprot) break;
1425         VIRTUAL_GetWin32Prot( view->protect, &info->AllocationProtect, NULL );
1426         if (view->protect & VPROT_IMAGE) info->Type = MEM_IMAGE;
1427         else if (view->flags & VFLAG_VALLOC) info->Type = MEM_PRIVATE;
1428         else info->Type = MEM_MAPPED;
1429     }
1430     RtlLeaveCriticalSection(&csVirtual);
1431
1432     info->BaseAddress    = (LPVOID)base;
1433     info->AllocationBase = (LPVOID)alloc_base;
1434     info->RegionSize     = size - (base - alloc_base);
1435     if (res_len) *res_len = sizeof(*info);
1436     return STATUS_SUCCESS;
1437 }
1438
1439
1440 /***********************************************************************
1441  *             NtLockVirtualMemory   (NTDLL.@)
1442  *             ZwLockVirtualMemory   (NTDLL.@)
1443  */
1444 NTSTATUS WINAPI NtLockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
1445 {
1446     if (!is_current_process( process ))
1447     {
1448         ERR("Unsupported on other process\n");
1449         return STATUS_ACCESS_DENIED;
1450     }
1451     return STATUS_SUCCESS;
1452 }
1453
1454
1455 /***********************************************************************
1456  *             NtUnlockVirtualMemory   (NTDLL.@)
1457  *             ZwUnlockVirtualMemory   (NTDLL.@)
1458  */
1459 NTSTATUS WINAPI NtUnlockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
1460 {
1461     if (!is_current_process( process ))
1462     {
1463         ERR("Unsupported on other process\n");
1464         return STATUS_ACCESS_DENIED;
1465     }
1466     return STATUS_SUCCESS;
1467 }
1468
1469
1470 /***********************************************************************
1471  *             NtCreateSection   (NTDLL.@)
1472  *             ZwCreateSection   (NTDLL.@)
1473  */
1474 NTSTATUS WINAPI NtCreateSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
1475                                  const LARGE_INTEGER *size, ULONG protect,
1476                                  ULONG sec_flags, HANDLE file )
1477 {
1478     NTSTATUS ret;
1479     BYTE vprot;
1480     DWORD len = attr->ObjectName ? attr->ObjectName->Length : 0;
1481
1482     /* Check parameters */
1483
1484     if (len > MAX_PATH*sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
1485
1486     vprot = VIRTUAL_GetProt( protect );
1487     if (sec_flags & SEC_RESERVE)
1488     {
1489         if (file) return STATUS_INVALID_PARAMETER;
1490     }
1491     else vprot |= VPROT_COMMITTED;
1492     if (sec_flags & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
1493     if (sec_flags & SEC_IMAGE) vprot |= VPROT_IMAGE;
1494
1495     /* Create the server object */
1496
1497     SERVER_START_REQ( create_mapping )
1498     {
1499         req->file_handle = file;
1500         req->size_high   = size ? size->u.HighPart : 0;
1501         req->size_low    = size ? size->u.LowPart : 0;
1502         req->protect     = vprot;
1503         req->access      = access;
1504         req->inherit     = (attr->Attributes & OBJ_INHERIT) != 0;
1505         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
1506         ret = wine_server_call( req );
1507         *handle = reply->handle;
1508     }
1509     SERVER_END_REQ;
1510     return ret;
1511 }
1512
1513
1514 /***********************************************************************
1515  *             NtOpenSection   (NTDLL.@)
1516  *             ZwOpenSection   (NTDLL.@)
1517  */
1518 NTSTATUS WINAPI NtOpenSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1519 {
1520     NTSTATUS ret;
1521     DWORD len = attr->ObjectName->Length;
1522
1523     if (len > MAX_PATH*sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
1524
1525     SERVER_START_REQ( open_mapping )
1526     {
1527         req->access  = access;
1528         req->inherit = (attr->Attributes & OBJ_INHERIT) != 0;
1529         wine_server_add_data( req, attr->ObjectName->Buffer, len );
1530         if (!(ret = wine_server_call( req ))) *handle = reply->handle;
1531     }
1532     SERVER_END_REQ;
1533     return ret;
1534 }
1535
1536
1537 /***********************************************************************
1538  *             NtMapViewOfSection   (NTDLL.@)
1539  *             ZwMapViewOfSection   (NTDLL.@)
1540  */
1541 NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_ptr, ULONG zero_bits,
1542                                     ULONG commit_size, const LARGE_INTEGER *offset, ULONG *size_ptr,
1543                                     SECTION_INHERIT inherit, ULONG alloc_type, ULONG protect )
1544 {
1545     IO_STATUS_BLOCK io;
1546     FILE_FS_DEVICE_INFORMATION device_info;
1547     NTSTATUS res;
1548     UINT size = 0;
1549     int unix_handle = -1;
1550     int prot;
1551     void *base;
1552     struct file_view *view;
1553     DWORD size_low, size_high, header_size, shared_size;
1554     HANDLE shared_file;
1555     BOOL removable = FALSE;
1556
1557     if (!is_current_process( process ))
1558     {
1559         ERR("Unsupported on other process\n");
1560         return STATUS_ACCESS_DENIED;
1561     }
1562
1563     TRACE("handle=%p addr=%p off=%lx%08lx size=%x access=%lx\n",
1564           handle, *addr_ptr, offset->u.HighPart, offset->u.LowPart, size, protect );
1565
1566     /* Check parameters */
1567
1568     if ((offset->u.LowPart & granularity_mask) ||
1569         (*addr_ptr && ((UINT_PTR)*addr_ptr & granularity_mask)))
1570         return STATUS_INVALID_PARAMETER;
1571
1572     SERVER_START_REQ( get_mapping_info )
1573     {
1574         req->handle = handle;
1575         res = wine_server_call( req );
1576         prot        = reply->protect;
1577         base        = reply->base;
1578         size_low    = reply->size_low;
1579         size_high   = reply->size_high;
1580         header_size = reply->header_size;
1581         shared_file = reply->shared_file;
1582         shared_size = reply->shared_size;
1583     }
1584     SERVER_END_REQ;
1585     if (res) return res;
1586
1587     if ((res = wine_server_handle_to_fd( handle, 0, &unix_handle, NULL, NULL ))) return res;
1588
1589     if (NtQueryVolumeInformationFile( handle, &io, &device_info, sizeof(device_info),
1590                                       FileFsDeviceInformation ) == STATUS_SUCCESS)
1591         removable = device_info.Characteristics & FILE_REMOVABLE_MEDIA;
1592
1593     if (prot & VPROT_IMAGE)
1594     {
1595         if (shared_file)
1596         {
1597             int shared_fd;
1598
1599             if ((res = wine_server_handle_to_fd( shared_file, GENERIC_READ, &shared_fd,
1600                                                  NULL, NULL ))) goto done;
1601             res = map_image( handle, unix_handle, base, size_low, header_size,
1602                              shared_fd, removable, addr_ptr );
1603             wine_server_release_fd( shared_file, shared_fd );
1604             NtClose( shared_file );
1605         }
1606         else
1607         {
1608             res = map_image( handle, unix_handle, base, size_low, header_size,
1609                              -1, removable, addr_ptr );
1610         }
1611         wine_server_release_fd( handle, unix_handle );
1612         if (!res) *size_ptr = size_low;
1613         return res;
1614     }
1615
1616     if (size_high)
1617         ERR("Sizes larger than 4Gb not supported\n");
1618
1619     if ((offset->u.LowPart >= size_low) ||
1620         (*size_ptr > size_low - offset->u.LowPart))
1621     {
1622         res = STATUS_INVALID_PARAMETER;
1623         goto done;
1624     }
1625     if (*size_ptr) size = ROUND_SIZE( offset->u.LowPart, *size_ptr );
1626     else size = size_low - offset->u.LowPart;
1627
1628     switch(protect)
1629     {
1630     case PAGE_NOACCESS:
1631         break;
1632     case PAGE_READWRITE:
1633     case PAGE_EXECUTE_READWRITE:
1634         if (!(prot & VPROT_WRITE))
1635         {
1636             res = STATUS_INVALID_PARAMETER;
1637             goto done;
1638         }
1639         removable = FALSE;
1640         /* fall through */
1641     case PAGE_READONLY:
1642     case PAGE_WRITECOPY:
1643     case PAGE_EXECUTE:
1644     case PAGE_EXECUTE_READ:
1645     case PAGE_EXECUTE_WRITECOPY:
1646         if (prot & VPROT_READ) break;
1647         /* fall through */
1648     default:
1649         res = STATUS_INVALID_PARAMETER;
1650         goto done;
1651     }
1652
1653     /* FIXME: If a mapping is created with SEC_RESERVE and a process,
1654      * which has a view of this mapping commits some pages, they will
1655      * appear commited in all other processes, which have the same
1656      * view created. Since we don`t support this yet, we create the
1657      * whole mapping commited.
1658      */
1659     prot |= VPROT_COMMITTED;
1660
1661     /* Reserve a properly aligned area */
1662
1663     RtlEnterCriticalSection( &csVirtual );
1664
1665     res = map_view( &view, *addr_ptr, size, prot );
1666     if (res)
1667     {
1668         RtlLeaveCriticalSection( &csVirtual );
1669         goto done;
1670     }
1671
1672     /* Map the file */
1673
1674     TRACE("handle=%p size=%x offset=%lx%08lx\n",
1675           handle, size, offset->u.HighPart, offset->u.LowPart );
1676
1677     res = map_file_into_view( view, unix_handle, 0, size, offset->QuadPart, prot, removable );
1678     if (res == STATUS_SUCCESS)
1679     {
1680         if (!removable)  /* don't keep handle open on removable media */
1681             NtDuplicateObject( GetCurrentProcess(), handle,
1682                                GetCurrentProcess(), &view->mapping,
1683                                0, 0, DUPLICATE_SAME_ACCESS );
1684
1685         *addr_ptr = view->base;
1686         *size_ptr = size;
1687     }
1688     else
1689     {
1690         ERR( "map_file_into_view %p %x %lx%08lx failed\n",
1691              view->base, size, offset->u.HighPart, offset->u.LowPart );
1692         delete_view( view );
1693     }
1694
1695     RtlLeaveCriticalSection( &csVirtual );
1696
1697 done:
1698     wine_server_release_fd( handle, unix_handle );
1699     return res;
1700 }
1701
1702
1703 /***********************************************************************
1704  *             NtUnmapViewOfSection   (NTDLL.@)
1705  *             ZwUnmapViewOfSection   (NTDLL.@)
1706  */
1707 NTSTATUS WINAPI NtUnmapViewOfSection( HANDLE process, PVOID addr )
1708 {
1709     FILE_VIEW *view;
1710     NTSTATUS status = STATUS_INVALID_PARAMETER;
1711     void *base = ROUND_ADDR( addr, page_mask );
1712
1713     if (!is_current_process( process ))
1714     {
1715         ERR("Unsupported on other process\n");
1716         return STATUS_ACCESS_DENIED;
1717     }
1718     RtlEnterCriticalSection( &csVirtual );
1719     if ((view = VIRTUAL_FindView( base )) && (base == view->base))
1720     {
1721         delete_view( view );
1722         status = STATUS_SUCCESS;
1723     }
1724     RtlLeaveCriticalSection( &csVirtual );
1725     return status;
1726 }
1727
1728
1729 /***********************************************************************
1730  *             NtFlushVirtualMemory   (NTDLL.@)
1731  *             ZwFlushVirtualMemory   (NTDLL.@)
1732  */
1733 NTSTATUS WINAPI NtFlushVirtualMemory( HANDLE process, LPCVOID *addr_ptr,
1734                                       ULONG *size_ptr, ULONG unknown )
1735 {
1736     FILE_VIEW *view;
1737     NTSTATUS status = STATUS_SUCCESS;
1738     void *addr = ROUND_ADDR( *addr_ptr, page_mask );
1739
1740     if (!is_current_process( process ))
1741     {
1742         ERR("Unsupported on other process\n");
1743         return STATUS_ACCESS_DENIED;
1744     }
1745     RtlEnterCriticalSection( &csVirtual );
1746     if (!(view = VIRTUAL_FindView( addr ))) status = STATUS_INVALID_PARAMETER;
1747     else
1748     {
1749         if (!*size_ptr) *size_ptr = view->size;
1750         *addr_ptr = addr;
1751         if (msync( addr, *size_ptr, MS_SYNC )) status = STATUS_NOT_MAPPED_DATA;
1752     }
1753     RtlLeaveCriticalSection( &csVirtual );
1754     return status;
1755 }
1756
1757
1758 /***********************************************************************
1759  *             NtReadVirtualMemory   (NTDLL.@)
1760  *             ZwReadVirtualMemory   (NTDLL.@)
1761  */
1762 NTSTATUS WINAPI NtReadVirtualMemory( HANDLE process, const void *addr, void *buffer,
1763                                      SIZE_T size, SIZE_T *bytes_read )
1764 {
1765     NTSTATUS status;
1766
1767     SERVER_START_REQ( read_process_memory )
1768     {
1769         req->handle = process;
1770         req->addr   = (void *)addr;
1771         wine_server_set_reply( req, buffer, size );
1772         if ((status = wine_server_call( req ))) size = 0;
1773     }
1774     SERVER_END_REQ;
1775     if (bytes_read) *bytes_read = size;
1776     return status;
1777 }
1778
1779
1780 /***********************************************************************
1781  *             NtWriteVirtualMemory   (NTDLL.@)
1782  *             ZwWriteVirtualMemory   (NTDLL.@)
1783  */
1784 NTSTATUS WINAPI NtWriteVirtualMemory( HANDLE process, void *addr, const void *buffer,
1785                                       SIZE_T size, SIZE_T *bytes_written )
1786 {
1787     static const unsigned int zero;
1788     unsigned int first_offset, last_offset, first_mask, last_mask;
1789     NTSTATUS status;
1790
1791     if (!size) return STATUS_INVALID_PARAMETER;
1792
1793     /* compute the mask for the first int */
1794     first_mask = ~0;
1795     first_offset = (unsigned int)addr % sizeof(int);
1796     memset( &first_mask, 0, first_offset );
1797
1798     /* compute the mask for the last int */
1799     last_offset = (size + first_offset) % sizeof(int);
1800     last_mask = 0;
1801     memset( &last_mask, 0xff, last_offset ? last_offset : sizeof(int) );
1802
1803     SERVER_START_REQ( write_process_memory )
1804     {
1805         req->handle     = process;
1806         req->addr       = (char *)addr - first_offset;
1807         req->first_mask = first_mask;
1808         req->last_mask  = last_mask;
1809         if (first_offset) wine_server_add_data( req, &zero, first_offset );
1810         wine_server_add_data( req, buffer, size );
1811         if (last_offset) wine_server_add_data( req, &zero, sizeof(int) - last_offset );
1812
1813         if ((status = wine_server_call( req ))) size = 0;
1814     }
1815     SERVER_END_REQ;
1816     if (bytes_written) *bytes_written = size;
1817     return status;
1818 }