Implemented SEC_IMAGE mappings and shared PE sections (with the help of Peter Ganten).
diff --git a/include/server.h b/include/server.h index 8564b56..4ce1a19 100644 --- a/include/server.h +++ b/include/server.h
@@ -762,6 +762,7 @@ #define VPROT_GUARD 0x10 #define VPROT_NOCACHE 0x20 #define VPROT_COMMITTED 0x40 +#define VPROT_IMAGE 0x80 /* Open a mapping */ @@ -781,6 +782,10 @@ 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 @@ 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 */
diff --git a/loader/pe_image.c b/loader/pe_image.c index 06dbc1f..cc2a2df 100644 --- a/loader/pe_image.c +++ b/loader/pe_image.c
@@ -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 @@ 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 @@ */ 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; } /**********************************************************************
diff --git a/memory/virtual.c b/memory/virtual.c index 66382d3..846820c 100644 --- a/memory/virtual.c +++ b/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 @@ * * 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 @@ /*********************************************************************** + * 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 @@ 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 @@ } 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 @@ } 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 @@ 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 @@ } if (count) size = ROUND_SIZE( offset_low, count ); else size = req->size_low - offset_low; - prot = req->protect; switch(access) { @@ -1267,7 +1438,7 @@ 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;
diff --git a/server/mapping.c b/server/mapping.c index b685317..6976cf4 100644 --- a/server/mapping.c +++ b/server/mapping.c
@@ -24,6 +24,10 @@ 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 @@ (((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 @@ 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 @@ } 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 @@ { 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 @@ 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 @@ 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 ); }
diff --git a/server/trace.c b/server/trace.c index f4f9d15..79a95d8 100644 --- a/server/trace.c +++ b/server/trace.c
@@ -919,7 +919,11 @@ { 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 )