ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implemented SEC_IMAGE mappings and shared PE sections (with the help 

of Peter Ganten).
This commit is contained in:
Alexandre Julliard 2000-08-14 20:20:01 +00:00
parent dcd247e55f
commit c19e1a7e19
5 changed files with 428 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/server.h
View File

@ -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 */

415
loader/pe_image.c
View File

@ -21,17 +21,6 @@
* state MUST be correct since this function can be called with the SAME image
* AGAIN. (Thats recursion for you.) That means MODREF.module and
* NE_MODULE.module32.
* - Sometimes, we can't use Linux mmap() to mmap() the images directly.
*
* The problem is, that there is not direct 1:1 mapping from a diskimage and
* a memoryimage. The headers at the start are mapped linear, but the sections
* are not. Older x86 pe binaries are 512 byte aligned in file and 4096 byte
* aligned in memory. Linux likes them 4096 byte aligned in memory (due to
* x86 pagesize, this cannot be fixed without a rather large kernel rewrite)
* and 'blocksize' file-aligned (offsets). Since we have 512/1024/2048 (CDROM)
* and other byte blocksizes, we can't always do this. We *can* do this for
* newer pe binaries produced by MSVC 5 and later, since they are also aligned
* to 4096 byte boundaries on disk.
*/
#include "config.h"
@ -399,86 +388,85 @@ DWORD fixup_imports( WINE_MODREF *wm )
return 0;
}
static int calc_vma_size( HMODULE hModule )
/***********************************************************************
* do_relocations
*
* Apply the relocations to a mapped PE image
*/
static int do_relocations( char *base, const IMAGE_NT_HEADERS *nt, const char *filename )
{
int i,vma_size = 0;
IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(hModule);
const IMAGE_DATA_DIRECTORY *dir;
const IMAGE_BASE_RELOCATION *rel;
int delta = base - (char *)nt->OptionalHeader.ImageBase;
TRACE("Dump of segment table\n");
TRACE(" Name VSz Vaddr SzRaw Fileadr *Reloc *Lineum #Reloc #Linum Char\n");
for (i = 0; i< PE_HEADER(hModule)->FileHeader.NumberOfSections; i++)
dir = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
rel = (IMAGE_BASE_RELOCATION *)(base + dir->VirtualAddress);
WARN("Info: base relocations needed for %s\n", filename);
if (!dir->VirtualAddress || !dir->Size)
{
TRACE("%8s: %4.4lx %8.8lx %8.8lx %8.8lx %8.8lx %8.8lx %4.4x %4.4x %8.8lx\n",
pe_seg->Name,
pe_seg->Misc.VirtualSize,
pe_seg->VirtualAddress,
pe_seg->SizeOfRawData,
pe_seg->PointerToRawData,
pe_seg->PointerToRelocations,
pe_seg->PointerToLinenumbers,
pe_seg->NumberOfRelocations,
pe_seg->NumberOfLinenumbers,
pe_seg->Characteristics);
vma_size=max(vma_size, pe_seg->VirtualAddress+pe_seg->SizeOfRawData);
vma_size=max(vma_size, pe_seg->VirtualAddress+pe_seg->Misc.VirtualSize);
pe_seg++;
if (nt->OptionalHeader.ImageBase == 0x400000)
ERR("Standard load address for a Win32 program not available - patched kernel ?\n");
ERR( "FATAL: Need to relocate %s, but no relocation records present (%s). Try to run that file directly !\n",
filename,
(nt->FileHeader.Characteristics&IMAGE_FILE_RELOCS_STRIPPED)?
"stripped during link" : "unknown reason" );
return 0;
}
return vma_size;
/* FIXME: If we need to relocate a system DLL (base > 2GB) we should
* really make sure that the *new* base address is also > 2GB.
* Some DLLs really check the MSB of the module handle :-/
*/
if ((nt->OptionalHeader.ImageBase & 0x80000000) && !((DWORD)base & 0x80000000))
ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
while (rel->VirtualAddress)
{
char *page = base + rel->VirtualAddress;
int i, count = (rel->SizeOfBlock - 8) / sizeof(rel->TypeOffset);
/* sanity checks */
if ((char *)rel + rel->SizeOfBlock > base + dir->VirtualAddress + dir->Size ||
page > base + nt->OptionalHeader.SizeOfImage)
{
ERR_(module)("invalid relocation %p,%lx,%ld at %p,%lx,%lx\n",
rel, rel->VirtualAddress, rel->SizeOfBlock,
base, dir->VirtualAddress, dir->Size );
return 0;
}
TRACE_(module)("%ld relocations for page %lx\n", rel->SizeOfBlock, rel->VirtualAddress);
/* patching in reverse order */
for (i = 0 ; i < count; i++)
{
int offset = rel->TypeOffset[i] & 0xFFF;
int type = rel->TypeOffset[i] >> 12;
switch(type)
{
case IMAGE_REL_BASED_ABSOLUTE:
break;
case IMAGE_REL_BASED_HIGH:
*(short*)(page+offset) += HIWORD(delta);
break;
case IMAGE_REL_BASED_LOW:
*(short*)(page+offset) += LOWORD(delta);
break;
case IMAGE_REL_BASED_HIGHLOW:
*(int*)(page+offset) += delta;
/* FIXME: if this is an exported address, fire up enhanced logic */
break;
default:
FIXME_(module)("Unknown/unsupported fixup type %d.\n", type);
break;
}
}
rel = (IMAGE_BASE_RELOCATION*)((char*)rel + rel->SizeOfBlock);
}
return 1;
}
static void do_relocations( unsigned int load_addr, IMAGE_BASE_RELOCATION *r )
{
int delta = load_addr - PE_HEADER(load_addr)->OptionalHeader.ImageBase;
int hdelta = (delta >> 16) & 0xFFFF;
int ldelta = delta & 0xFFFF;
if(delta == 0)
/* Nothing to do */
return;
while(r->VirtualAddress)
{
char *page = (char*) RVA(r->VirtualAddress);
int count = (r->SizeOfBlock - 8)/2;
int i;
TRACE_(fixup)("%x relocations for page %lx\n",
count, r->VirtualAddress);
/* patching in reverse order */
for(i=0;i<count;i++)
{
int offset = r->TypeOffset[i] & 0xFFF;
int type = r->TypeOffset[i] >> 12;
TRACE_(fixup)("patching %x type %x\n", offset, type);
switch(type)
{
case IMAGE_REL_BASED_ABSOLUTE: break;
case IMAGE_REL_BASED_HIGH:
*(short*)(page+offset) += hdelta;
break;
case IMAGE_REL_BASED_LOW:
*(short*)(page+offset) += ldelta;
break;
case IMAGE_REL_BASED_HIGHLOW:
*(int*)(page+offset) += delta;
/* FIXME: if this is an exported address, fire up enhanced logic */
break;
case IMAGE_REL_BASED_HIGHADJ:
FIXME("Don't know what to do with IMAGE_REL_BASED_HIGHADJ\n");
break;
case IMAGE_REL_BASED_MIPS_JMPADDR:
FIXME("Is this a MIPS machine ???\n");
break;
default:
FIXME("Unknown fixup type %d.\n", type);
break;
}
}
r = (IMAGE_BASE_RELOCATION*)((char*)r + r->SizeOfBlock);
}
}
/**********************************************************************
* PE_LoadImage
@ -492,246 +480,55 @@ static void do_relocations( unsigned int load_addr, IMAGE_BASE_RELOCATION *r )
*/
HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, DWORD flags )
{
HMODULE hModule;
HANDLE mapping;
IMAGE_NT_HEADERS *nt;
IMAGE_SECTION_HEADER *pe_sec;
IMAGE_DATA_DIRECTORY *dir;
BY_HANDLE_FILE_INFORMATION bhfi;
int i, rawsize, lowest_va, vma_size, file_size = 0;
DWORD load_addr = 0, aoep, reloc = 0;
struct get_read_fd_request *req = get_req_buffer();
int unix_handle = -1;
int page_size = VIRTUAL_GetPageSize();
HMODULE hModule;
HANDLE mapping;
void *base;
/* Retrieve file size */
if ( GetFileInformationByHandle( hFile, &bhfi ) )
file_size = bhfi.nFileSizeLow; /* FIXME: 64 bit */
TRACE_(module)( "loading %s\n", filename );
/* Map the PE file somewhere */
mapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY | SEC_COMMIT,
0, 0, NULL );
if (!mapping)
{
WARN("CreateFileMapping error %ld\n", GetLastError() );
return 0;
}
hModule = (HMODULE)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
mapping = CreateFileMappingA( hFile, NULL, SEC_IMAGE, 0, 0, NULL );
base = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
CloseHandle( mapping );
if (!hModule)
{
WARN("MapViewOfFile error %ld\n", GetLastError() );
return 0;
}
if ( *(WORD*)hModule !=IMAGE_DOS_SIGNATURE)
{
WARN("%s image doesn't have DOS signature, but 0x%04x\n", filename,*(WORD*)hModule);
SetLastError( ERROR_BAD_EXE_FORMAT );
goto error;
}
if (!base) return 0;
hModule = (HMODULE)base;
if (flags & LOAD_LIBRARY_AS_DATAFILE) return hModule; /* nothing else to do */
/* perform base relocation, if necessary */
nt = PE_HEADER( hModule );
/* Check signature */
if ( nt->Signature != IMAGE_NT_SIGNATURE )
if (hModule != nt->OptionalHeader.ImageBase)
{
WARN("%s image doesn't have PE signature, but 0x%08lx\n", filename, nt->Signature );
SetLastError( ERROR_BAD_EXE_FORMAT );
goto error;
}
/* Check architecture */
if ( nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386 )
{
MESSAGE("Trying to load PE image for unsupported architecture (");
switch (nt->FileHeader.Machine)
if (!do_relocations( base, nt, filename ))
{
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");
SetLastError( ERROR_BAD_EXE_FORMAT );
goto error;
}
/* Find out how large this executeable should be */
pe_sec = PE_SECTIONS( hModule );
rawsize = 0; lowest_va = 0x10000;
for (i = 0; i < nt->FileHeader.NumberOfSections; i++)
{
if (lowest_va > pe_sec[i].VirtualAddress)
lowest_va = pe_sec[i].VirtualAddress;
if (pe_sec[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
continue;
if (pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData > rawsize)
rawsize = pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData;
}
/* Check file size */
if ( file_size && file_size < rawsize )
{
ERR("PE module is too small (header: %d, filesize: %d), "
"probably truncated download?\n",
rawsize, file_size );
SetLastError( ERROR_BAD_EXE_FORMAT );
goto error;
}
/* Check entrypoint address */
aoep = nt->OptionalHeader.AddressOfEntryPoint;
if (aoep && (aoep < lowest_va))
MESSAGE("VIRUS WARNING: '%s' has an invalid entrypoint (0x%08lx) "
"below the first virtual address (0x%08x) "
"(possibly infected by Tchernobyl/SpaceFiller virus)!\n",
filename, aoep, lowest_va );
#if 0
/* FIXME: Hack! While we don't really support shared sections yet,
* this checks for those special cases where the whole DLL
* consists only of shared sections and is mapped into the
* shared address space > 2GB. In this case, we assume that
* the module got mapped at its base address. Thus we simply
* check whether the module has actually been mapped there
* and use it, if so. This is needed to get Win95 USER32.DLL
* to work (until we support shared sections properly).
*/
if ( nt->OptionalHeader.ImageBase & 0x80000000 )
{
HMODULE sharedMod = (HMODULE)nt->OptionalHeader.ImageBase;
IMAGE_NT_HEADERS *sharedNt = (PIMAGE_NT_HEADERS)
( (LPBYTE)sharedMod + ((LPBYTE)nt - (LPBYTE)hModule) );
/* Well, this check is not really comprehensive,
but should be good enough for now ... */
if ( !IsBadReadPtr( (LPBYTE)sharedMod, sizeof(IMAGE_DOS_HEADER) )
&& memcmp( (LPBYTE)sharedMod, (LPBYTE)hModule, sizeof(IMAGE_DOS_HEADER) ) == 0
&& !IsBadReadPtr( sharedNt, sizeof(IMAGE_NT_HEADERS) )
&& memcmp( sharedNt, nt, sizeof(IMAGE_NT_HEADERS) ) == 0 )
{
UnmapViewOfFile( (LPVOID)hModule );
return sharedMod;
}
}
#endif
/* Allocate memory for module */
load_addr = nt->OptionalHeader.ImageBase;
vma_size = calc_vma_size( hModule );
load_addr = (DWORD)VirtualAlloc( (void*)load_addr, vma_size,
MEM_RESERVE | MEM_COMMIT,
PAGE_EXECUTE_READWRITE );
if (!load_addr)
{
load_addr = (DWORD)VirtualAlloc( NULL, vma_size,
MEM_RESERVE | MEM_COMMIT,
PAGE_EXECUTE_READWRITE );
if (!load_addr)
{
FIXME_(win32)(
"FATAL: Couldn't load module %s (out of memory, %d needed)!\n", filename, vma_size);
goto error;
}
}
if (load_addr != nt->OptionalHeader.ImageBase && !(flags & LOAD_LIBRARY_AS_DATAFILE))
{
/* We need to perform base relocations */
WARN("Info: base relocations needed for %s\n", filename);
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BASERELOC;
if (dir->Size)
reloc = dir->VirtualAddress;
else
{
if (nt->OptionalHeader.ImageBase == 0x400000)
ERR("Standard load address for a Win32 program not available - patched kernel ?\n");
FIXME( "FATAL: Need to relocate %s, but no relocation records present (%s). Try to run that file directly !\n",
filename,
(nt->FileHeader.Characteristics&IMAGE_FILE_RELOCS_STRIPPED)?
"stripped during link" : "unknown reason" );
UnmapViewOfFile( base );
SetLastError( ERROR_BAD_EXE_FORMAT );
goto error;
return 0;
}
/* FIXME: If we need to relocate a system DLL (base > 2GB) we should
* really make sure that the *new* base address is also > 2GB.
* Some DLLs really check the MSB of the module handle :-/
*/
if ((nt->OptionalHeader.ImageBase & 0x80000000) && !(load_addr & 0x80000000))
ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
}
TRACE("Load addr is %lx (base %lx), range %x\n",
load_addr, nt->OptionalHeader.ImageBase, vma_size );
TRACE_(segment)("Loading %s at %lx, range %x\n",
filename, load_addr, vma_size );
/* virus check */
req->handle = hFile;
server_call_fd( REQ_GET_READ_FD, -1, &unix_handle );
if (unix_handle == -1) goto error;
/* Map the header */
if (FILE_dommap( unix_handle, (void *)load_addr, 0, nt->OptionalHeader.SizeOfHeaders,
0, 0, PROT_EXEC | PROT_WRITE | PROT_READ,
MAP_PRIVATE | MAP_FIXED ) != (void*)load_addr)
if (nt->OptionalHeader.AddressOfEntryPoint)
{
ERR_(win32)( "Critical Error: failed to map PE header to necessary address.\n");
goto error;
int i;
IMAGE_SECTION_HEADER *sec = (IMAGE_SECTION_HEADER*)((char*)&nt->OptionalHeader +
nt->FileHeader.SizeOfOptionalHeader);
for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
{
if (nt->OptionalHeader.AddressOfEntryPoint < sec->VirtualAddress)
continue;
if (nt->OptionalHeader.AddressOfEntryPoint < sec->VirtualAddress+sec->Misc.VirtualSize)
break;
}
if (i == nt->FileHeader.NumberOfSections)
MESSAGE("VIRUS WARNING: PE module has an invalid entrypoint (0x%08lx) "
"outside all sections (possibly infected by Tchernobyl/SpaceFiller virus)!\n",
nt->OptionalHeader.AddressOfEntryPoint );
}
/* Copy sections into module image */
pe_sec = PE_SECTIONS( hModule );
for (i = 0; i < nt->FileHeader.NumberOfSections; i++, pe_sec++)
{
if (!pe_sec->SizeOfRawData || !pe_sec->PointerToRawData) continue;
TRACE("%s: mmaping section %s at %p off %lx size %lx/%lx\n",
filename, pe_sec->Name, (void*)RVA(pe_sec->VirtualAddress),
pe_sec->PointerToRawData, pe_sec->SizeOfRawData, pe_sec->Misc.VirtualSize );
if (FILE_dommap( unix_handle, (void*)RVA(pe_sec->VirtualAddress),
0, pe_sec->SizeOfRawData, 0, pe_sec->PointerToRawData,
PROT_EXEC | PROT_WRITE | PROT_READ,
MAP_PRIVATE | MAP_FIXED ) != (void*)RVA(pe_sec->VirtualAddress))
{
/* We failed to map to the right place (huh?) */
ERR_(win32)( "Critical Error: failed to map PE section to necessary address.\n");
goto error;
}
if ((pe_sec->SizeOfRawData < pe_sec->Misc.VirtualSize) &&
(pe_sec->SizeOfRawData & (page_size-1)))
{
DWORD end = (pe_sec->SizeOfRawData & ~(page_size-1)) + page_size;
if (end > pe_sec->Misc.VirtualSize) end = pe_sec->Misc.VirtualSize;
TRACE("clearing %p - %p\n",
RVA(pe_sec->VirtualAddress) + pe_sec->SizeOfRawData,
RVA(pe_sec->VirtualAddress) + end );
memset( (char*)RVA(pe_sec->VirtualAddress) + pe_sec->SizeOfRawData, 0,
end - pe_sec->SizeOfRawData );
}
}
/* Perform base relocation, if necessary */
if ( reloc )
do_relocations( load_addr, (IMAGE_BASE_RELOCATION *)RVA(reloc) );
/* We don't need the orignal mapping any more */
UnmapViewOfFile( (LPVOID)hModule );
close( unix_handle );
return (HMODULE)load_addr;
error:
if (unix_handle != -1) close( unix_handle );
if (load_addr) VirtualFree( (LPVOID)load_addr, 0, MEM_RELEASE );
UnmapViewOfFile( (LPVOID)hModule );
return 0;
return hModule;
}
/**********************************************************************

183
memory/virtual.c
View File

@ -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;
@ -392,6 +392,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
*/
@ -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;

140
server/mapping.c
View File

@ -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 );
}

6
server/trace.c
View File

@ -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 )