Implemented SEC_IMAGE mappings and shared PE sections (with the help

include/server.h

@@ -762,6 +762,7 @@ struct create_mapping_request
 #define VPROT_GUARD      0x10
 #define VPROT_NOCACHE    0x20
 #define VPROT_COMMITTED  0x40
+#define VPROT_IMAGE      0x80
 
 
 /* Open a mapping */
@@ -781,6 +782,10 @@ struct get_mapping_info_request
     OUT int          size_high;     /* mapping size */
     OUT int          size_low;      /* mapping size */
     OUT int          protect;       /* protection flags */
+    OUT int          header_size;   /* header size (for VPROT_IMAGE mapping) */
+    OUT void*        base;          /* default base addr (for VPROT_IMAGE mapping) */
+    OUT int          shared_file;   /* shared mapping file handle */
+    OUT int          shared_size;   /* shared mapping size */
 };
 
 
@@ -1298,7 +1303,7 @@ enum request
     REQ_NB_REQUESTS
 };
 
-#define SERVER_PROTOCOL_VERSION 15
+#define SERVER_PROTOCOL_VERSION 16
 
 /* ### make_requests end ### */
 /* Everything above this line is generated automatically by tools/make_requests */

memory/virtual.c

@@ -30,6 +30,7 @@
 #include "debugtools.h"
 
 DEFAULT_DEBUG_CHANNEL(virtual);
+DECLARE_DEBUG_CHANNEL(module);
 
 #ifndef MS_SYNC
 #define MS_SYNC 0
@@ -199,9 +200,8 @@ static FILE_VIEW *VIRTUAL_FindView(
  *
  * Create a new view and add it in the linked list.
  */
-static FILE_VIEW *VIRTUAL_CreateView( UINT base, UINT size, UINT offset,
-                                      UINT flags, BYTE vprot,
-                                      HANDLE mapping )
+static FILE_VIEW *VIRTUAL_CreateView( UINT base, UINT size, UINT flags,
+                                      BYTE vprot, HANDLE mapping )
 {
     FILE_VIEW *view, *prev;
 
@@ -393,6 +393,171 @@ static BOOL VIRTUAL_SetProt(
 
 
 /***********************************************************************
+ *           map_image
+ *
+ * Map an executable (PE format) image into memory.
+ */
+static LPVOID map_image( HANDLE hmapping, int fd, char *base, DWORD total_size,
+                         DWORD header_size, HANDLE shared_file, DWORD shared_size )
+{
+    IMAGE_DOS_HEADER *dos;
+    IMAGE_NT_HEADERS *nt;
+    IMAGE_SECTION_HEADER *sec;
+    int i, pos;
+    DWORD err = GetLastError();
+    FILE_VIEW *view = NULL;
+    char *ptr;
+    int shared_fd = -1;
+
+    SetLastError( ERROR_BAD_EXE_FORMAT );  /* generic error */
+
+    /* zero-map the whole range */
+
+    if ((ptr = FILE_dommap( -1, base, 0, total_size, 0, 0, PROT_READ|PROT_WRITE|PROT_EXEC,
+                            MAP_PRIVATE )) == (char *)-1)
+    {
+        ptr = FILE_dommap( -1, NULL, 0, total_size, 0, 0,
+                           PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE );
+        if (ptr == (char *)-1)
+        {
+            ERR_(module)("Not enough memory for module (%ld bytes)\n", total_size);
+            goto error;
+        }
+    }
+    TRACE_(module)( "mapped PE file at %p-%p\n", ptr, ptr + total_size );
+
+    if (!(view = VIRTUAL_CreateView( (UINT)ptr, total_size, 0,
+                                     VPROT_COMMITTED|VPROT_READ|VPROT_WRITE|VPROT_WRITECOPY,
+                                     hmapping )))
+    {
+        FILE_munmap( ptr, 0, total_size );
+        SetLastError( ERROR_OUTOFMEMORY );
+        goto error;
+    }
+
+    /* map the header */
+
+    if (FILE_dommap( fd, ptr, 0, header_size, 0, 0,
+                     PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED ) == (char *)-1) goto error;
+    dos = (IMAGE_DOS_HEADER *)ptr;
+    nt = (IMAGE_NT_HEADERS *)(ptr + dos->e_lfanew);
+    if ((char *)(nt + 1) > ptr + header_size) goto error;
+
+    sec = (IMAGE_SECTION_HEADER*)((char*)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
+    if ((char *)(sec + nt->FileHeader.NumberOfSections) > ptr + header_size) goto error;
+
+    /* check the architecture */
+
+    if (nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
+    {
+        MESSAGE("Trying to load PE image for unsupported architecture (");
+        switch (nt->FileHeader.Machine)
+        {
+        case IMAGE_FILE_MACHINE_UNKNOWN: MESSAGE("Unknown"); break;
+        case IMAGE_FILE_MACHINE_I860:    MESSAGE("I860"); break;
+        case IMAGE_FILE_MACHINE_R3000:   MESSAGE("R3000"); break;
+        case IMAGE_FILE_MACHINE_R4000:   MESSAGE("R4000"); break;
+        case IMAGE_FILE_MACHINE_R10000:  MESSAGE("R10000"); break;
+        case IMAGE_FILE_MACHINE_ALPHA:   MESSAGE("Alpha"); break;
+        case IMAGE_FILE_MACHINE_POWERPC: MESSAGE("PowerPC"); break;
+        default: MESSAGE("Unknown-%04x", nt->FileHeader.Machine); break;
+        }
+        MESSAGE(")\n");
+        goto error;
+    }
+    
+    /* retrieve the shared sections file */
+
+    if (shared_size)
+    {
+        struct get_read_fd_request *req = get_req_buffer();
+        req->handle = shared_file;
+        server_call_fd( REQ_GET_READ_FD, -1, &shared_fd );
+        if (shared_fd == -1) goto error;
+        CloseHandle( shared_file );  /* we no longer need it */
+        shared_file = INVALID_HANDLE_VALUE; 
+    }
+
+    /* map all the sections */
+
+    for (i = pos = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
+    {
+        DWORD size;
+
+        /* a few sanity checks */
+        size = sec->VirtualAddress + ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
+        if (sec->VirtualAddress > total_size || size > total_size || size < sec->VirtualAddress)
+        {
+            ERR_(module)( "Section %.8s too large (%lx+%lx/%lx)\n",
+                          sec->Name, sec->VirtualAddress, sec->Misc.VirtualSize, total_size );
+            goto error;
+        }
+
+        if ((sec->Characteristics & IMAGE_SCN_MEM_SHARED) &&
+            (sec->Characteristics & IMAGE_SCN_MEM_WRITE))
+        {
+            size = ROUND_SIZE( 0, sec->Misc.VirtualSize );
+            TRACE_(module)( "mapping shared section %.8s at %p off %lx (%x) size %lx (%lx) flags %lx\n",
+                          sec->Name, (char *)ptr + sec->VirtualAddress,
+                          sec->PointerToRawData, pos, sec->SizeOfRawData,
+                          size, sec->Characteristics );
+            if (FILE_dommap( shared_fd, (char *)ptr + sec->VirtualAddress, 0, size,
+                             0, pos, PROT_READ|PROT_WRITE|PROT_EXEC,
+                             MAP_SHARED|MAP_FIXED ) == (void *)-1)
+            {
+                ERR_(module)( "Could not map shared section %.8s\n", sec->Name );
+                goto error;
+            }
+            pos += size;
+            continue;
+        }
+
+    	if (sec->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) continue;
+        if (!sec->PointerToRawData || !sec->SizeOfRawData) continue;
+
+        TRACE_(module)( "mapping section %.8s at %p off %lx size %lx flags %lx\n",
+                        sec->Name, (char *)ptr + sec->VirtualAddress,
+                        sec->PointerToRawData, sec->SizeOfRawData,
+                        sec->Characteristics );
+
+        /* Note: if the section is not aligned properly FILE_dommap will magically
+         *       fall back to read(), so we don't need to check anything here.
+         */
+        if (FILE_dommap( fd, (char *)ptr + sec->VirtualAddress, 0, sec->SizeOfRawData,
+                         0, sec->PointerToRawData, PROT_READ|PROT_WRITE|PROT_EXEC,
+                         MAP_PRIVATE | MAP_FIXED ) == (void *)-1)
+        {
+            ERR_(module)( "Could not map section %.8s, file probably truncated\n", sec->Name );
+            goto error;
+        }
+
+        if ((sec->SizeOfRawData < sec->Misc.VirtualSize) && (sec->SizeOfRawData & page_mask))
+        {
+            DWORD end = ROUND_SIZE( 0, sec->SizeOfRawData );
+            if (end > sec->Misc.VirtualSize) end = sec->Misc.VirtualSize;
+            TRACE_(module)("clearing %p - %p\n",
+                           (char *)ptr + sec->VirtualAddress + sec->SizeOfRawData,
+                           (char *)ptr + sec->VirtualAddress + end );
+            memset( (char *)ptr + sec->VirtualAddress + sec->SizeOfRawData, 0,
+                    end - sec->SizeOfRawData );
+        }
+    }
+
+    SetLastError( err );  /* restore last error */
+    close( fd );
+    if (shared_fd != -1) close( shared_fd );
+    return ptr;
+
+ error:
+    if (view) VIRTUAL_DeleteView( view );
+    close( fd );
+    if (shared_fd != -1) close( shared_fd );
+    if (shared_file != INVALID_HANDLE_VALUE) CloseHandle( shared_file );
+    return NULL;
+}
+
+
+/***********************************************************************
  *           VIRTUAL_Init
  */
 #ifndef page_mask
@@ -586,7 +751,7 @@ LPVOID WINAPI VirtualAlloc(
 	    SetLastError( ERROR_INVALID_ADDRESS );
 	    return NULL;
         }
-        if (!(view = VIRTUAL_CreateView( ptr, size, 0, (type & MEM_SYSTEM) ?
+        if (!(view = VIRTUAL_CreateView( ptr, size, (type & MEM_SYSTEM) ?
                                          VFLAG_SYSTEM : 0, vprot, -1 )))
         {
             FILE_munmap( (void *)ptr, 0, size );
@@ -1049,6 +1214,7 @@ HANDLE WINAPI CreateFileMappingA(
     }
     else vprot |= VPROT_COMMITTED;
     if (protect & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
+    if (protect & SEC_IMAGE) vprot |= VPROT_IMAGE;
 
     /* Create the server object */
 
@@ -1092,6 +1258,7 @@ HANDLE WINAPI CreateFileMappingW( HFILE hFile, LPSECURITY_ATTRIBUTES sa,
     }
     else vprot |= VPROT_COMMITTED;
     if (protect & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
+    if (protect & SEC_IMAGE) vprot |= VPROT_IMAGE;
 
     /* Create the server object */
 
@@ -1203,6 +1370,11 @@ LPVOID WINAPI MapViewOfFileEx(
 
     req->handle = handle;
     if (server_call_fd( REQ_GET_MAPPING_INFO, -1, &unix_handle )) goto error;
+    prot = req->protect;
+
+    if (prot & VPROT_IMAGE)
+        return map_image( handle, unix_handle, req->base, req->size_low, req->header_size,
+                          req->shared_file, req->shared_size );
 
     if (req->size_high || offset_high)
         ERR("Offsets larger than 4Gb not supported\n");
@@ -1215,7 +1387,6 @@ LPVOID WINAPI MapViewOfFileEx(
     }
     if (count) size = ROUND_SIZE( offset_low, count );
     else size = req->size_low - offset_low;
-    prot = req->protect;
 
     switch(access)
     {
@@ -1267,7 +1438,7 @@ LPVOID WINAPI MapViewOfFileEx(
         goto error;
     }
 
-    if (!(view = VIRTUAL_CreateView( ptr, size, offset_low, 0, prot, handle )))
+    if (!(view = VIRTUAL_CreateView( ptr, size, 0, prot, handle )))
     {
         SetLastError( ERROR_OUTOFMEMORY );
         goto error;

server/mapping.c

@@ -24,6 +24,10 @@ struct mapping
     int            size_low;        /* mapping size */
     int            protect;         /* protection flags */
     struct file   *file;            /* file mapped */
+    int            header_size;     /* size of headers (for PE image mapping) */
+    void          *base;            /* default base addr (for PE image mapping) */
+    struct file   *shared_file;     /* temp file for shared PE mapping */
+    int            shared_size;     /* shared mapping total size */
 };
 
 static void mapping_dump( struct object *obj, int verbose );
@@ -84,6 +88,110 @@ static void init_page_size(void)
    (((int)(size) + ((int)(addr) & page_mask) + page_mask) & ~page_mask)
 
 
+/* allocate and fill the temp file for a shared PE image mapping */
+static int build_shared_mapping( struct mapping *mapping, int fd,
+                                 IMAGE_SECTION_HEADER *sec, int nb_sec )
+{
+    int i, max_size, total_size, pos;
+    char *buffer = NULL; 
+    int shared_fd = -1;
+
+    /* compute the total size of the shared mapping */
+
+    total_size = max_size = 0;
+    for (i = 0; i < nb_sec; i++)
+    {
+        if ((sec[i].Characteristics & IMAGE_SCN_MEM_SHARED) &&
+            (sec[i].Characteristics & IMAGE_SCN_MEM_WRITE))
+        {
+            int size = ROUND_SIZE( 0, sec[i].Misc.VirtualSize );
+            if (size > max_size) max_size = size;
+            total_size += size;
+        }
+    }
+    if (!(mapping->shared_size = total_size)) return 1;  /* nothing to do */
+
+    /* create a temp file for the mapping */
+
+    if (!(mapping->shared_file = create_temp_file( GENERIC_READ|GENERIC_WRITE ))) goto error;
+    if (!grow_file( mapping->shared_file, 0, total_size )) goto error;
+    if ((shared_fd = file_get_mmap_fd( mapping->shared_file )) == -1) goto error;
+
+    if (!(buffer = malloc( max_size ))) goto error;
+
+    /* copy the shared sections data into the temp file */
+
+    for (i = pos = 0; i < nb_sec; i++)
+    {
+        if (!(sec[i].Characteristics & IMAGE_SCN_MEM_SHARED)) continue;
+        if (!(sec[i].Characteristics & IMAGE_SCN_MEM_WRITE)) continue;
+        if (lseek( shared_fd, pos, SEEK_SET ) != pos) goto error;
+        pos += ROUND_SIZE( 0, sec[i].Misc.VirtualSize );
+    	if (sec->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) continue;
+        if (!sec->PointerToRawData || !sec->SizeOfRawData) continue;
+        if (lseek( fd, sec[i].PointerToRawData, SEEK_SET ) != sec[i].PointerToRawData) goto error;
+        if (read( fd, buffer, sec[i].SizeOfRawData ) != sec[i].SizeOfRawData) goto error;
+        if (write( shared_fd, buffer, sec[i].SizeOfRawData ) != sec[i].SizeOfRawData) goto error;
+    }
+    close( shared_fd );
+    free( buffer );
+    return 1;
+
+ error:
+    if (shared_fd != -1) close( shared_fd );
+    if (buffer) free( buffer );
+    return 0;
+}
+
+/* retrieve the mapping parameters for an executable (PE) image */
+static int get_image_params( struct mapping *mapping )
+{
+    IMAGE_DOS_HEADER dos;
+    IMAGE_NT_HEADERS nt;
+    IMAGE_SECTION_HEADER *sec = NULL;
+    int fd, filepos, size;
+
+    /* load the headers */
+
+    if ((fd = file_get_mmap_fd( mapping->file )) == -1) return 0;
+    filepos = lseek( fd, 0, SEEK_SET );
+    if (read( fd, &dos, sizeof(dos) ) != sizeof(dos)) goto error;
+    if (dos.e_magic != IMAGE_DOS_SIGNATURE) goto error;
+    if (lseek( fd, dos.e_lfanew, SEEK_SET ) == -1) goto error;
+    if (read( fd, &nt, sizeof(nt) ) != sizeof(nt)) goto error;
+    if (nt.Signature != IMAGE_NT_SIGNATURE) goto error;
+
+    /* load the section headers */
+
+    size = sizeof(*sec) * nt.FileHeader.NumberOfSections;
+    if (!(sec = malloc( size ))) goto error;
+    if (read( fd, sec, size ) != size) goto error;
+
+    if (!build_shared_mapping( mapping, fd, sec, nt.FileHeader.NumberOfSections )) goto error;
+
+    mapping->size_low    = ROUND_SIZE( 0, nt.OptionalHeader.SizeOfImage );
+    mapping->size_high   = 0;
+    mapping->base        = (void *)nt.OptionalHeader.ImageBase;
+    mapping->header_size = ROUND_SIZE( mapping->base, nt.OptionalHeader.SizeOfHeaders );
+    mapping->protect     = VPROT_IMAGE;
+
+    /* sanity check */
+    if (mapping->header_size > mapping->size_low) goto error;
+
+    lseek( fd, filepos, SEEK_SET );
+    close( fd );
+    free( sec );
+    return 1;
+
+ error:
+    lseek( fd, filepos, SEEK_SET );
+    close( fd );
+    if (sec) free( sec );
+    set_error( STATUS_INVALID_FILE_FOR_SECTION );
+    return 0;
+}
+
+
 static struct object *create_mapping( int size_high, int size_low, int protect,
                                       int handle, const WCHAR *name, size_t len )
 {
@@ -97,12 +205,22 @@ static struct object *create_mapping( int size_high, int size_low, int protect,
     if (get_error() == STATUS_OBJECT_NAME_COLLISION)
         return &mapping->obj;  /* Nothing else to do */
 
+    mapping->header_size = 0;
+    mapping->base        = NULL;
+    mapping->shared_file = NULL;
+    mapping->shared_size = 0;
+
     if (protect & VPROT_READ) access |= GENERIC_READ;
     if (protect & VPROT_WRITE) access |= GENERIC_WRITE;
 
     if (handle != -1)
     {
         if (!(mapping->file = get_file_obj( current->process, handle, access ))) goto error;
+        if (protect & VPROT_IMAGE)
+        {
+            if (!get_image_params( mapping )) goto error;
+            return &mapping->obj;
+        }
         if (!size_high && !size_low)
         {
             struct get_file_info_request req;
@@ -115,7 +233,7 @@ static struct object *create_mapping( int size_high, int size_low, int protect,
     }
     else  /* Anonymous mapping (no associated file) */
     {
-        if (!size_high && !size_low)
+        if ((!size_high && !size_low) || (protect & VPROT_IMAGE))
         {
             set_error( STATUS_INVALID_PARAMETER );
             mapping->file = NULL;
@@ -138,8 +256,10 @@ static void mapping_dump( struct object *obj, int verbose )
 {
     struct mapping *mapping = (struct mapping *)obj;
     assert( obj->ops == &mapping_ops );
-    fprintf( stderr, "Mapping size=%08x%08x prot=%08x file=%p ",
-             mapping->size_high, mapping->size_low, mapping->protect, mapping->file );
+    fprintf( stderr, "Mapping size=%08x%08x prot=%08x file=%p header_size=%08x base=%p "
+             "shared_file=%p shared_size=%08x ",
+             mapping->size_high, mapping->size_low, mapping->protect, mapping->file,
+             mapping->header_size, mapping->base, mapping->shared_file, mapping->shared_size );
     dump_object_name( &mapping->obj );
     fputc( '\n', stderr );
 }
@@ -149,6 +269,7 @@ static void mapping_destroy( struct object *obj )
     struct mapping *mapping = (struct mapping *)obj;
     assert( obj->ops == &mapping_ops );
     if (mapping->file) release_object( mapping->file );
+    if (mapping->shared_file) release_object( mapping->shared_file );
 }
 
 int get_page_size(void)
@@ -189,9 +310,16 @@ DECL_HANDLER(get_mapping_info)
     if ((mapping = (struct mapping *)get_handle_obj( current->process, req->handle,
                                                      0, &mapping_ops )))
     {
-        req->size_high = mapping->size_high;
-        req->size_low  = mapping->size_low;
-        req->protect   = mapping->protect;
+        req->size_high   = mapping->size_high;
+        req->size_low    = mapping->size_low;
+        req->protect     = mapping->protect;
+        req->header_size = mapping->header_size;
+        req->base        = mapping->base;
+        req->shared_file = -1;
+        req->shared_size = mapping->shared_size;
+        if (mapping->shared_file)
+            req->shared_file = alloc_handle( current->process, mapping->shared_file,
+                                             GENERIC_READ|GENERIC_WRITE, 0 );
         if (mapping->file) set_reply_fd( current, file_get_mmap_fd( mapping->file ) );
         release_object( mapping );
     }

server/trace.c

@@ -919,7 +919,11 @@ static void dump_get_mapping_info_reply( const struct get_mapping_info_request *
 {
     fprintf( stderr, " size_high=%d,", req->size_high );
     fprintf( stderr, " size_low=%d,", req->size_low );
-    fprintf( stderr, " protect=%d", req->protect );
+    fprintf( stderr, " protect=%d,", req->protect );
+    fprintf( stderr, " header_size=%d,", req->header_size );
+    fprintf( stderr, " base=%p,", req->base );
+    fprintf( stderr, " shared_file=%d,", req->shared_file );
+    fprintf( stderr, " shared_size=%d", req->shared_size );
 }
 
 static void dump_create_device_request( const struct create_device_request *req )