Implemented SEC_IMAGE mappings and shared PE sections (with the help
of Peter Ganten).
This commit is contained in:
parent
dcd247e55f
commit
c19e1a7e19
|
@ -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 */
|
||||
|
|
|
@ -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
183
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;
|
||||
|
||||
|
@ -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
140
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 );
|
||||
}
|
||||
|
|
|
@ -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 )
|
||||
|
|
Loading…
Reference in New Issue