Skip to content

W
wine-cw
Commit eb04fd22 authored by Alexandre Julliard's avatar Alexandre Julliard
Browse files
Options

Converted the memory views list to use the standard functions from

wine/list.h. Restructured some functions to always return proper NT status codes. A couple of optimizations. Added a few tests for file mappings.
parent 7f4e77bc
Hide whitespace changes
Inline Side-by-side
Showing with 493 additions and 331 deletions
dlls/kernel/tests/virtual.c
View file @ eb04fd22
...@@ -107,7 +107,162 @@ static void test_VirtualAlloc(void) ...@@ -107,7 +107,162 @@ static void test_VirtualAlloc(void)
ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n"); ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
} }
static void test_MapViewOfFile(void)
{
static const char testfile[] = "testfile.xxx";
HANDLE file, mapping;
void *ptr;
file = CreateFileA( testfile, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
ok( file != INVALID_HANDLE_VALUE, "Failed to create test file\n" );
SetFilePointer( file, 4096, NULL, FILE_BEGIN );
SetEndOfFile( file );
/* read/write mapping */
mapping = CreateFileMappingA( file, NULL, PAGE_READWRITE, 0, 4096, NULL );
ok( mapping != 0, "CreateFileMapping failed\n" );
ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile FILE_MAPE_READ failed\n" );
UnmapViewOfFile( ptr );
/* this fails on win9x but succeeds on NT */
ptr = MapViewOfFile( mapping, FILE_MAP_COPY, 0, 0, 4096 );
if (ptr) UnmapViewOfFile( ptr );
else ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error %lx\n", GetLastError() );
ptr = MapViewOfFile( mapping, 0, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile 0 failed\n" );
UnmapViewOfFile( ptr );
ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile FILE_MAP_WRITE failed\n" );
UnmapViewOfFile( ptr );
CloseHandle( mapping );
/* read-only mapping */
mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
ok( mapping != 0, "CreateFileMapping failed\n" );
ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ failed\n" );
UnmapViewOfFile( ptr );
/* this fails on win9x but succeeds on NT */
ptr = MapViewOfFile( mapping, FILE_MAP_COPY, 0, 0, 4096 );
if (ptr) UnmapViewOfFile( ptr );
else ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error %lx\n", GetLastError() );
ptr = MapViewOfFile( mapping, 0, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile 0 failed\n" );
UnmapViewOfFile( ptr );
ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 4096 );
ok( !ptr, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER ||
GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %lx\n", GetLastError() );
CloseHandle( mapping );
/* copy-on-write mapping */
mapping = CreateFileMappingA( file, NULL, PAGE_WRITECOPY, 0, 4096, NULL );
ok( mapping != 0, "CreateFileMapping failed\n" );
ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ failed\n" );
UnmapViewOfFile( ptr );
ptr = MapViewOfFile( mapping, FILE_MAP_COPY, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile FILE_MAP_COPY failed\n" );
UnmapViewOfFile( ptr );
ptr = MapViewOfFile( mapping, 0, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile 0 failed\n" );
UnmapViewOfFile( ptr );
ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 4096 );
ok( !ptr, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER ||
GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %lx\n", GetLastError() );
CloseHandle( mapping );
/* no access mapping */
mapping = CreateFileMappingA( file, NULL, PAGE_NOACCESS, 0, 4096, NULL );
/* fails on NT but succeeds on win9x */
if (!mapping) ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error %lx\n", GetLastError() );
else
{
ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ failed\n" );
UnmapViewOfFile( ptr );
ptr = MapViewOfFile( mapping, FILE_MAP_COPY, 0, 0, 4096 );
ok( !ptr, "MapViewOfFile FILE_MAP_COPY succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error %lx\n", GetLastError() );
ptr = MapViewOfFile( mapping, 0, 0, 0, 4096 );
ok( ptr != NULL, "MapViewOfFile 0 failed\n" );
UnmapViewOfFile( ptr );
ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 4096 );
ok( !ptr, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error %lx\n", GetLastError() );
CloseHandle( mapping );
}
CloseHandle( file );
/* now try read-only file */
file = CreateFileA( testfile, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0 );
ok( file != INVALID_HANDLE_VALUE, "Failed to create test file\n" );
mapping = CreateFileMappingA( file, NULL, PAGE_READWRITE, 0, 4096, NULL );
ok( !mapping, "CreateFileMapping PAGE_READWRITE succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER ||
GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %lx\n", GetLastError() );
mapping = CreateFileMappingA( file, NULL, PAGE_WRITECOPY, 0, 4096, NULL );
ok( mapping != 0, "CreateFileMapping PAGE_WRITECOPY failed\n" );
CloseHandle( mapping );
mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
ok( mapping != 0, "CreateFileMapping PAGE_READONLY failed\n" );
CloseHandle( mapping );
CloseHandle( file );
/* now try no access file */
file = CreateFileA( testfile, 0, 0, NULL, OPEN_EXISTING, 0, 0 );
ok( file != INVALID_HANDLE_VALUE, "Failed to create test file\n" );
mapping = CreateFileMappingA( file, NULL, PAGE_READWRITE, 0, 4096, NULL );
ok( !mapping, "CreateFileMapping PAGE_READWRITE succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER ||
GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %lx\n", GetLastError() );
mapping = CreateFileMappingA( file, NULL, PAGE_WRITECOPY, 0, 4096, NULL );
ok( !mapping, "CreateFileMapping PAGE_WRITECOPY succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER ||
GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %lx\n", GetLastError() );
mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
ok( !mapping, "CreateFileMapping PAGE_READONLY succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER ||
GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %lx\n", GetLastError() );
CloseHandle( file );
CloseHandle( file );
DeleteFileA( testfile );
}
START_TEST(virtual) START_TEST(virtual)
{ {
test_VirtualAlloc(); test_VirtualAlloc();
test_MapViewOfFile();
} }
dlls/kernel/virtual.c
View file @ eb04fd22
...@@ -321,6 +321,8 @@ HANDLE WINAPI CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES sa, ...@@ -321,6 +321,8 @@ HANDLE WINAPI CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES sa,
switch(protect) switch(protect)
{ {
case 0: case 0:
protect = PAGE_READONLY; /* Win9x compatibility */
/* fall through */
case PAGE_READONLY: case PAGE_READONLY:
case PAGE_WRITECOPY: case PAGE_WRITECOPY:
access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ; access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ;
......
dlls/ntdll/virtual.c
View file @ eb04fd22
...@@ -46,6 +46,7 @@ ...@@ -46,6 +46,7 @@
#include "winioctl.h" #include "winioctl.h"
#include "wine/library.h" #include "wine/library.h"
#include "wine/server.h" #include "wine/server.h"
#include "wine/list.h"
#include "wine/debug.h" #include "wine/debug.h"
#include "ntdll_misc.h" #include "ntdll_misc.h"
...@@ -57,22 +58,21 @@ WINE_DECLARE_DEBUG_CHANNEL(module); ...@@ -57,22 +58,21 @@ WINE_DECLARE_DEBUG_CHANNEL(module);
#endif #endif
/* File view */ /* File view */
typedef struct _FV typedef struct file_view
{ {
struct _FV *next; /* Next view */ struct list entry; /* Entry in global view list */
struct _FV *prev; /* Prev view */
void *base; /* Base address */ void *base; /* Base address */
UINT size; /* Size in bytes */ UINT size; /* Size in bytes */
UINT flags; /* Allocation flags */
HANDLE mapping; /* Handle to the file mapping */ HANDLE mapping; /* Handle to the file mapping */
HANDLERPROC handlerProc; /* Fault handler */ HANDLERPROC handlerProc; /* Fault handler */
LPVOID handlerArg; /* Fault handler argument */ LPVOID handlerArg; /* Fault handler argument */
BYTE flags; /* Allocation flags (VFLAG_*) */
BYTE protect; /* Protection for all pages at allocation time */ BYTE protect; /* Protection for all pages at allocation time */
BYTE prot[1]; /* Protection byte for each page */ BYTE prot[1]; /* Protection byte for each page */
} FILE_VIEW; } FILE_VIEW;
/* Per-view flags */ /* Per-view flags */
#define VFLAG_SYSTEM 0x01 #define VFLAG_SYSTEM 0x01 /* system view (underlying mmap not under our control) */
#define VFLAG_VALLOC 0x02 /* allocated by VirtualAlloc */ #define VFLAG_VALLOC 0x02 /* allocated by VirtualAlloc */
/* Conversion from VPROT_* to Win32 flags */ /* Conversion from VPROT_* to Win32 flags */
...@@ -96,8 +96,7 @@ static const BYTE VIRTUAL_Win32Flags[16] = ...@@ -96,8 +96,7 @@ static const BYTE VIRTUAL_Win32Flags[16] =
PAGE_EXECUTE_WRITECOPY /* READ | WRITE | EXEC | WRITECOPY */ PAGE_EXECUTE_WRITECOPY /* READ | WRITE | EXEC | WRITECOPY */
}; };
static struct list views_list = LIST_INIT(views_list);
static FILE_VIEW *VIRTUAL_FirstView;
static CRITICAL_SECTION csVirtual; static CRITICAL_SECTION csVirtual;
static CRITICAL_SECTION_DEBUG critsect_debug = static CRITICAL_SECTION_DEBUG critsect_debug =
...@@ -135,9 +134,6 @@ static UINT page_size; ...@@ -135,9 +134,6 @@ static UINT page_size;
#define VIRTUAL_DEBUG_DUMP_VIEW(view) \ #define VIRTUAL_DEBUG_DUMP_VIEW(view) \
if (!TRACE_ON(virtual)); else VIRTUAL_DumpView(view) if (!TRACE_ON(virtual)); else VIRTUAL_DumpView(view)
static LPVOID VIRTUAL_mmap( int fd, LPVOID start, DWORD size, DWORD offset_low,
DWORD offset_high, int prot, int flags, BOOL *removable );
/*********************************************************************** /***********************************************************************
* VIRTUAL_GetProtStr * VIRTUAL_GetProtStr
...@@ -148,8 +144,7 @@ static const char *VIRTUAL_GetProtStr( BYTE prot ) ...@@ -148,8 +144,7 @@ static const char *VIRTUAL_GetProtStr( BYTE prot )
buffer[0] = (prot & VPROT_COMMITTED) ? 'c' : '-'; buffer[0] = (prot & VPROT_COMMITTED) ? 'c' : '-';
buffer[1] = (prot & VPROT_GUARD) ? 'g' : '-'; buffer[1] = (prot & VPROT_GUARD) ? 'g' : '-';
buffer[2] = (prot & VPROT_READ) ? 'r' : '-'; buffer[2] = (prot & VPROT_READ) ? 'r' : '-';
buffer[3] = (prot & VPROT_WRITE) ? buffer[3] = (prot & VPROT_WRITECOPY) ? 'W' : ((prot & VPROT_WRITE) ? 'w' : '-');
((prot & VPROT_WRITECOPY) ? 'w' : 'W') : '-';
buffer[4] = (prot & VPROT_EXEC) ? 'x' : '-'; buffer[4] = (prot & VPROT_EXEC) ? 'x' : '-';
buffer[5] = 0; buffer[5] = 0;
return buffer; return buffer;
...@@ -195,14 +190,13 @@ static void VIRTUAL_DumpView( FILE_VIEW *view ) ...@@ -195,14 +190,13 @@ static void VIRTUAL_DumpView( FILE_VIEW *view )
*/ */
void VIRTUAL_Dump(void) void VIRTUAL_Dump(void)
{ {
FILE_VIEW *view; struct list *ptr;
DPRINTF( "\nDump of all virtual memory views:\n\n" ); DPRINTF( "\nDump of all virtual memory views:\n\n" );
RtlEnterCriticalSection(&csVirtual); RtlEnterCriticalSection(&csVirtual);
view = VIRTUAL_FirstView; LIST_FOR_EACH( ptr, &views_list )
while (view)
{ {
VIRTUAL_DumpView( view ); VIRTUAL_DumpView( LIST_ENTRY( ptr, struct file_view, entry ) );
view = view->next;
} }
RtlLeaveCriticalSection(&csVirtual); RtlLeaveCriticalSection(&csVirtual);
} }
...@@ -217,21 +211,17 @@ void VIRTUAL_Dump(void) ...@@ -217,21 +211,17 @@ void VIRTUAL_Dump(void)
* View: Success * View: Success
* NULL: Failure * NULL: Failure
*/ */
static FILE_VIEW *VIRTUAL_FindView( const void *addr ) /* [in] Address */ static struct file_view *VIRTUAL_FindView( const void *addr ) /* [in] Address */
{ {
FILE_VIEW *view = VIRTUAL_FirstView; struct list *ptr;
while (view) LIST_FOR_EACH( ptr, &views_list )
{ {
if (view->base > addr) struct file_view *view = LIST_ENTRY( ptr, struct file_view, entry );
{ if (view->base > addr) break;
view = NULL; if ((char*)view->base + view->size > (char*)addr) return view;
break;
}
if ((char*)view->base + view->size > (char*)addr) break;
view = view->next;
} }
return view; return NULL;
} }
...@@ -243,96 +233,82 @@ static FILE_VIEW *VIRTUAL_FindView( const void *addr ) /* [in] Address */ ...@@ -243,96 +233,82 @@ static FILE_VIEW *VIRTUAL_FindView( const void *addr ) /* [in] Address */
* RETURNS * RETURNS
* None * None
*/ */
static void VIRTUAL_DeleteView( FILE_VIEW *view ) /* [in] View */ static void VIRTUAL_DeleteView( struct file_view *view ) /* [in] View */
{ {
if (!(view->flags & VFLAG_SYSTEM)) if (!(view->flags & VFLAG_SYSTEM))
munmap( (void *)view->base, view->size ); munmap( (void *)view->base, view->size );
if (view->next) view->next->prev = view->prev; list_remove( &view->entry );
if (view->prev) view->prev->next = view->next;
else VIRTUAL_FirstView = view->next;
if (view->mapping) NtClose( view->mapping ); if (view->mapping) NtClose( view->mapping );
free( view ); free( view );
} }
/*********************************************************************** /***********************************************************************
* VIRTUAL_CreateView * create_view
* *
* Create a new view and add it in the linked list. * Create a view. The csVirtual section must be held by caller.
*/ */
static FILE_VIEW *VIRTUAL_CreateView( void *base, UINT size, UINT flags, static NTSTATUS create_view( struct file_view **view_ret, void *base, size_t size, BYTE vprot )
BYTE vprot, HANDLE mapping )
{ {
FILE_VIEW *view, *prev; struct file_view *view;
struct list *ptr;
/* Create the view structure */
assert( !((unsigned int)base & page_mask) ); assert( !((unsigned int)base & page_mask) );
assert( !(size & page_mask) ); assert( !(size & page_mask) );
size >>= page_shift;
if (!(view = (FILE_VIEW *)malloc( sizeof(*view) + size - 1 ))) return NULL; /* Create the view structure */
if (!(view = malloc( sizeof(*view) + (size >> page_shift) - 1 ))) return STATUS_NO_MEMORY;
view->base = base; view->base = base;
view->size = size << page_shift; view->size = size;
view->flags = flags; view->flags = 0;
view->mapping = mapping; view->mapping = 0;
view->protect = vprot; view->protect = vprot;
view->handlerProc = NULL; view->handlerProc = NULL;
memset( view->prot, vprot, size ); memset( view->prot, vprot, size >> page_shift );
/* Duplicate the mapping handle */ /* Insert it in the linked list */
if (view->mapping && LIST_FOR_EACH( ptr, &views_list )
NtDuplicateObject( GetCurrentProcess(), view->mapping,
GetCurrentProcess(), &view->mapping,
0, 0, DUPLICATE_SAME_ACCESS ))
{ {
free( view ); struct file_view *next = LIST_ENTRY( ptr, struct file_view, entry );
return NULL; if (next->base > base) break;
} }
list_add_before( ptr, &view->entry );
/* Insert it in the linked list */ /* Check for overlapping views. This can happen if the previous view
* was a system view that got unmapped behind our back. In that case
* we recover by simply deleting it. */
RtlEnterCriticalSection(&csVirtual); if ((ptr = list_prev( &views_list, &view->entry )) != NULL)
if (!VIRTUAL_FirstView || (VIRTUAL_FirstView->base > base))
{ {
view->next = VIRTUAL_FirstView; struct file_view *prev = LIST_ENTRY( ptr, struct file_view, entry );
view->prev = NULL;
if (view->next) view->next->prev = view;
VIRTUAL_FirstView = view;
}
else
{
prev = VIRTUAL_FirstView;
while (prev->next && (prev->next->base < base)) prev = prev->next;
view->next = prev->next;
view->prev = prev;
if (view->next) view->next->prev = view;
prev->next = view;
/* Check for overlapping views. This can happen if the previous view
* was a system view that got unmapped behind our back. In that case
* we recover by simply deleting it. */
if ((char *)prev->base + prev->size > (char *)base) if ((char *)prev->base + prev->size > (char *)base)
{ {
TRACE( "overlapping prev view %p-%p for %p-%p\n", TRACE( "overlapping prev view %p-%p for %p-%p\n",
prev->base, (char *)prev->base + prev->size, prev->base, (char *)prev->base + prev->size,
base, (char *)base + view->size ); base, (char *)base + view->size );
assert( view->prev->flags & VFLAG_SYSTEM ); assert( prev->flags & VFLAG_SYSTEM );
VIRTUAL_DeleteView( view->prev ); VIRTUAL_DeleteView( prev );
} }
} }
/* check for overlap with next too */ if ((ptr = list_next( &views_list, &view->entry )) != NULL)
if (view->next && (char *)base + view->size > (char *)view->next->base)
{ {
TRACE( "overlapping next view %p-%p for %p-%p\n", struct file_view *next = LIST_ENTRY( ptr, struct file_view, entry );
view->next->base, (char *)view->next->base + view->next->size, if ((char *)base + view->size > (char *)next->base)
base, (char *)base + view->size ); {
assert( view->next->flags & VFLAG_SYSTEM ); TRACE( "overlapping next view %p-%p for %p-%p\n",
VIRTUAL_DeleteView( view->next ); next->base, (char *)next->base + next->size,
base, (char *)base + view->size );
assert( next->flags & VFLAG_SYSTEM );
VIRTUAL_DeleteView( next );
}
} }
RtlLeaveCriticalSection(&csVirtual);
*view_ret = view;
VIRTUAL_DEBUG_DUMP_VIEW( view ); VIRTUAL_DEBUG_DUMP_VIEW( view );
return view; return STATUS_SUCCESS;
} }
...@@ -462,23 +438,40 @@ static BOOL VIRTUAL_SetProt( FILE_VIEW *view, /* [in] Pointer to view */ ...@@ -462,23 +438,40 @@ static BOOL VIRTUAL_SetProt( FILE_VIEW *view, /* [in] Pointer to view */
/*********************************************************************** /***********************************************************************
* anon_mmap_aligned * map_view
* *
* Create an anonymous mapping aligned to the allocation granularity. * Create a view and mmap the corresponding memory area.
* The csVirtual section must be held by caller.
*/ */
static NTSTATUS anon_mmap_aligned( void **addr, unsigned int size, int prot, int flags ) static NTSTATUS map_view( struct file_view **view_ret, void *base, size_t size, BYTE vprot )
{ {
void *ptr, *base = *addr; void *ptr;
unsigned int view_size = size + (base ? 0 : granularity_mask + 1); NTSTATUS status;
if ((ptr = wine_anon_mmap( base, view_size, prot, flags )) == (void *)-1) if (base)
{ {
if (errno == ENOMEM) return STATUS_NO_MEMORY; if ((ptr = wine_anon_mmap( base, size, VIRTUAL_GetUnixProt(vprot), 0 )) == (void *)-1)
return STATUS_INVALID_PARAMETER; {
if (errno == ENOMEM) return STATUS_NO_MEMORY;
return STATUS_INVALID_PARAMETER;
}
if (ptr != base)
{
/* We couldn't get the address we wanted */
munmap( ptr, size );
return STATUS_CONFLICTING_ADDRESSES;
}
} }
else
if (!base)
{ {
size_t view_size = size + granularity_mask + 1;
if ((ptr = wine_anon_mmap( NULL, view_size, VIRTUAL_GetUnixProt(vprot), 0 )) == (void *)-1)
{
if (errno == ENOMEM) return STATUS_NO_MEMORY;
return STATUS_INVALID_PARAMETER;
}
/* Release the extra memory while keeping the range /* Release the extra memory while keeping the range
* starting on the granularity boundary. */ * starting on the granularity boundary. */
if ((unsigned int)ptr & granularity_mask) if ((unsigned int)ptr & granularity_mask)
...@@ -491,18 +484,133 @@ static NTSTATUS anon_mmap_aligned( void **addr, unsigned int size, int prot, int ...@@ -491,18 +484,133 @@ static NTSTATUS anon_mmap_aligned( void **addr, unsigned int size, int prot, int
if (view_size > size) if (view_size > size)
munmap( (char *)ptr + size, view_size - size ); munmap( (char *)ptr + size, view_size - size );
} }
else if (ptr != base)
status = create_view( view_ret, ptr, size, vprot );
if (status != STATUS_SUCCESS) munmap( ptr, size );
return status;
}
/***********************************************************************
* unaligned_mmap
*
* Linux kernels before 2.4.x can support non page-aligned offsets, as
* long as the offset is aligned to the filesystem block size. This is
* a big performance gain so we want to take advantage of it.
*
* However, when we use 64-bit file support this doesn't work because
* glibc rejects unaligned offsets. Also glibc 2.1.3 mmap64 is broken
* in that it rounds unaligned offsets down to a page boundary. For
* these reasons we do a direct system call here.
*/
static void *unaligned_mmap( void *addr, size_t length, unsigned int prot,
unsigned int flags, int fd, off_t offset )
{
#if defined(linux) && defined(__i386__) && defined(__GNUC__)
if (!(offset >> 32) && (offset & page_mask))
{ {
/* We couldn't get the address we wanted */ int ret;
munmap( ptr, view_size );
return STATUS_CONFLICTING_ADDRESSES; struct
{
void *addr;
unsigned int length;
unsigned int prot;
unsigned int flags;
unsigned int fd;
unsigned int offset;
} args;
args.addr = addr;
args.length = length;
args.prot = prot;
args.flags = flags;
args.fd = fd;
args.offset = offset;
__asm__ __volatile__("push %%ebx\n\t"
"movl %2,%%ebx\n\t"
"int $0x80\n\t"
"popl %%ebx"
: "=a" (ret)
: "0" (90), /* SYS_mmap */
"g" (&args)
: "memory" );
if (ret < 0 && ret > -4096)
{
errno = -ret;
ret = -1;
}
return (void *)ret;
}
#endif
return mmap( addr, length, prot, flags, fd, offset );
}
/***********************************************************************
* map_file_into_view
*
* Wrapper for mmap() to map a file into a view, falling back to read if mmap fails.
* The csVirtual section must be held by caller.
*/
static NTSTATUS map_file_into_view( struct file_view *view, int fd, size_t start, size_t size,
off_t offset, BYTE vprot, BOOL removable )
{
void *ptr;
int prot = VIRTUAL_GetUnixProt( vprot );
BOOL shared_write = (vprot & VPROT_WRITE) != 0;
assert( start < view->size );
assert( start + size <= view->size );
/* only try mmap if media is not removable (or if we require write access) */
if (!removable || shared_write)
{
int flags = MAP_FIXED | (shared_write ? MAP_SHARED : MAP_PRIVATE);
if (unaligned_mmap( (char *)view->base + start, size, prot, flags, fd, offset ) != (void *)-1)
goto done;
/* mmap() failed; if this is because the file offset is not */
/* page-aligned (EINVAL), or because the underlying filesystem */
/* does not support mmap() (ENOEXEC,ENODEV), we do it by hand. */
if ((errno != ENOEXEC) && (errno != EINVAL) && (errno != ENODEV)) return FILE_GetNtStatus();
if (shared_write) return FILE_GetNtStatus(); /* we cannot fake shared write mappings */
} }
*addr = ptr;
/* Reserve the memory with an anonymous mmap */
ptr = wine_anon_mmap( (char *)view->base + start, size, PROT_READ | PROT_WRITE, MAP_FIXED );
if (ptr == (void *)-1) return FILE_GetNtStatus();
/* Now read in the file */
pread( fd, ptr, size, offset );
if (prot != (PROT_READ|PROT_WRITE)) mprotect( ptr, size, prot ); /* Set the right protection */
done:
memset( view->prot + (start >> page_shift), vprot, size >> page_shift );
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
/*********************************************************************** /***********************************************************************
* decommit_view
*
* Decommit some pages of a given view.
* The csVirtual section must be held by caller.
*/
static NTSTATUS decommit_pages( struct file_view *view, size_t start, size_t size )
{
if (wine_anon_mmap( (char *)view->base + start, size, PROT_NONE, MAP_FIXED ) != (void *)-1)
{
BYTE *p = view->prot + (start >> page_shift);
size >>= page_shift;
while (size--) *p++ &= ~VPROT_COMMITTED;
return STATUS_SUCCESS;
}
return FILE_GetNtStatus();
}
/***********************************************************************
* do_relocations * do_relocations
* *
* Apply the relocations to a mapped PE image * Apply the relocations to a mapped PE image
...@@ -578,31 +686,34 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size ...@@ -578,31 +686,34 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size
IMAGE_NT_HEADERS *nt; IMAGE_NT_HEADERS *nt;
IMAGE_SECTION_HEADER *sec; IMAGE_SECTION_HEADER *sec;
IMAGE_DATA_DIRECTORY *imports; IMAGE_DATA_DIRECTORY *imports;
NTSTATUS status = STATUS_INVALID_IMAGE_FORMAT; /* generic error (FIXME) */ NTSTATUS status = STATUS_CONFLICTING_ADDRESSES;
int i, pos; int i;
FILE_VIEW *view; off_t pos;
struct file_view *view = NULL;
char *ptr; char *ptr;
/* zero-map the whole range */ /* zero-map the whole range */
if (base < (char *)0x110000 || /* make sure the DOS area remains free */ RtlEnterCriticalSection( &csVirtual );
(ptr = wine_anon_mmap( base, total_size,
PROT_READ | PROT_WRITE | PROT_EXEC, 0 )) == (char *)-1) if (base >= (char *)0x110000) /* make sure the DOS area remains free */
{ status = map_view( &view, base, total_size,
ptr = wine_anon_mmap( NULL, total_size, VPROT_COMMITTED | VPROT_READ | VPROT_EXEC | VPROT_WRITECOPY | VPROT_IMAGE );
PROT_READ | PROT_WRITE | PROT_EXEC, 0 );
if (ptr == (char *)-1) if (status == STATUS_CONFLICTING_ADDRESSES)
{ status = map_view( &view, NULL, total_size,
ERR_(module)("Not enough memory for module (%ld bytes)\n", total_size); VPROT_COMMITTED | VPROT_READ | VPROT_EXEC | VPROT_WRITECOPY | VPROT_IMAGE );
goto error;
} if (status != STATUS_SUCCESS) goto error;
}
ptr = view->base;
TRACE_(module)( "mapped PE file at %p-%p\n", ptr, ptr + total_size ); TRACE_(module)( "mapped PE file at %p-%p\n", ptr, ptr + total_size );
/* map the header */ /* map the header */
if (VIRTUAL_mmap( fd, ptr, header_size, 0, 0, PROT_READ, status = STATUS_INVALID_IMAGE_FORMAT; /* generic error */
MAP_PRIVATE | MAP_FIXED, &removable ) == (char *)-1) goto error; if (map_file_into_view( view, fd, 0, header_size, 0, VPROT_COMMITTED | VPROT_READ,
removable ) != STATUS_SUCCESS) goto error;
dos = (IMAGE_DOS_HEADER *)ptr; dos = (IMAGE_DOS_HEADER *)ptr;
nt = (IMAGE_NT_HEADERS *)(ptr + dos->e_lfanew); nt = (IMAGE_NT_HEADERS *)(ptr + dos->e_lfanew);
if ((char *)(nt + 1) > ptr + header_size) goto error; if ((char *)(nt + 1) > ptr + header_size) goto error;
...@@ -654,11 +765,11 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size ...@@ -654,11 +765,11 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size
size = ROUND_SIZE( 0, sec->Misc.VirtualSize ); size = ROUND_SIZE( 0, sec->Misc.VirtualSize );
TRACE_(module)( "mapping shared section %.8s at %p off %lx (%x) size %lx (%lx) flags %lx\n", TRACE_(module)( "mapping shared section %.8s at %p off %lx (%x) size %lx (%lx) flags %lx\n",
sec->Name, ptr + sec->VirtualAddress, sec->Name, ptr + sec->VirtualAddress,
sec->PointerToRawData, pos, sec->SizeOfRawData, sec->PointerToRawData, (int)pos, sec->SizeOfRawData,
size, sec->Characteristics ); size, sec->Characteristics );
if (VIRTUAL_mmap( shared_fd, ptr + sec->VirtualAddress, size, if (map_file_into_view( view, shared_fd, sec->VirtualAddress, size, pos,
pos, 0, PROT_READ | PROT_WRITE, VPROT_COMMITTED | VPROT_READ | PROT_WRITE,
MAP_SHARED|MAP_FIXED, NULL ) == (void *)-1) FALSE ) != STATUS_SUCCESS)
{ {
ERR_(module)( "Could not map shared section %.8s\n", sec->Name ); ERR_(module)( "Could not map shared section %.8s\n", sec->Name );
goto error; goto error;
...@@ -671,9 +782,11 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size ...@@ -671,9 +782,11 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size
UINT_PTR base = imports->VirtualAddress & ~page_mask; UINT_PTR base = imports->VirtualAddress & ~page_mask;
UINT_PTR end = base + ROUND_SIZE( imports->VirtualAddress, imports->Size ); UINT_PTR end = base + ROUND_SIZE( imports->VirtualAddress, imports->Size );
if (end > sec->VirtualAddress + size) end = sec->VirtualAddress + size; if (end > sec->VirtualAddress + size) end = sec->VirtualAddress + size;
if (end > base) VIRTUAL_mmap( shared_fd, ptr + base, end - base, if (end > base)
pos + (base - sec->VirtualAddress), 0, map_file_into_view( view, shared_fd, base, end - base,
PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, NULL ); pos + (base - sec->VirtualAddress),
VPROT_COMMITTED | VPROT_READ | VPROT_WRITECOPY,
FALSE );
} }
pos += size; pos += size;
continue; continue;
...@@ -688,12 +801,12 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size ...@@ -688,12 +801,12 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size
!(sec->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)) continue; !(sec->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)) continue;
if (!sec->PointerToRawData || !sec->SizeOfRawData) continue; if (!sec->PointerToRawData || !sec->SizeOfRawData) continue;
/* Note: if the section is not aligned properly VIRTUAL_mmap will magically /* Note: if the section is not aligned properly map_file_into_view will magically
* fall back to read(), so we don't need to check anything here. * fall back to read(), so we don't need to check anything here.
*/ */
if (VIRTUAL_mmap( fd, ptr + sec->VirtualAddress, sec->SizeOfRawData, if (map_file_into_view( view, fd, sec->VirtualAddress, sec->SizeOfRawData, sec->PointerToRawData,
sec->PointerToRawData, 0, PROT_READ | PROT_WRITE, VPROT_COMMITTED | VPROT_READ | VPROT_WRITECOPY,
MAP_PRIVATE | MAP_FIXED, &removable ) == (void *)-1) removable ) != STATUS_SUCCESS)
{ {
ERR_(module)( "Could not map section %.8s, file probably truncated\n", sec->Name ); ERR_(module)( "Could not map section %.8s, file probably truncated\n", sec->Name );
goto error; goto error;
...@@ -743,33 +856,26 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size ...@@ -743,33 +856,26 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size
} }
} }
if (removable) hmapping = 0; /* don't keep handle open on removable media */ if (!removable) /* don't keep handle open on removable media */
RtlEnterCriticalSection( &csVirtual ); NtDuplicateObject( GetCurrentProcess(), hmapping,
if (!(view = VIRTUAL_CreateView( ptr, total_size, 0, GetCurrentProcess(), &view->mapping,
VPROT_COMMITTED | VPROT_READ | VPROT_WRITE | 0, 0, DUPLICATE_SAME_ACCESS );
VPROT_EXEC | VPROT_WRITECOPY | VPROT_IMAGE, hmapping )))
{
RtlLeaveCriticalSection( &csVirtual );
status = STATUS_NO_MEMORY;
goto error;
}
/* set the image protections */ /* set the image protections */
VIRTUAL_SetProt( view, ptr, header_size, VPROT_COMMITTED | VPROT_READ );
sec = (IMAGE_SECTION_HEADER*)((char *)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader); sec = (IMAGE_SECTION_HEADER*)((char *)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++) for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
{ {
DWORD size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize ); DWORD size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
BYTE vprot = VPROT_COMMITTED; BYTE vprot = VPROT_COMMITTED;
if (sec->Characteristics & IMAGE_SCN_MEM_READ) vprot |= VPROT_READ; if (sec->Characteristics & IMAGE_SCN_MEM_READ) vprot |= VPROT_READ;
if (sec->Characteristics & IMAGE_SCN_MEM_WRITE) vprot |= VPROT_READ|VPROT_WRITE|VPROT_WRITECOPY; if (sec->Characteristics & IMAGE_SCN_MEM_WRITE) vprot |= VPROT_READ|VPROT_WRITECOPY;
if (sec->Characteristics & IMAGE_SCN_MEM_EXECUTE) vprot |= VPROT_EXEC; if (sec->Characteristics & IMAGE_SCN_MEM_EXECUTE) vprot |= VPROT_EXEC;
/* make sure the import directory is writable */ /* make sure the import directory is writable */
if (imports && imports->VirtualAddress >= sec->VirtualAddress && if (imports && imports->VirtualAddress >= sec->VirtualAddress &&
imports->VirtualAddress < sec->VirtualAddress + size) imports->VirtualAddress < sec->VirtualAddress + size)
vprot |= VPROT_READ|VPROT_WRITE|VPROT_WRITECOPY; vprot |= VPROT_READ|VPROT_WRITECOPY;
VIRTUAL_SetProt( view, ptr + sec->VirtualAddress, size, vprot ); VIRTUAL_SetProt( view, ptr + sec->VirtualAddress, size, vprot );
} }
...@@ -779,7 +885,8 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size ...@@ -779,7 +885,8 @@ static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size
return STATUS_SUCCESS; return STATUS_SUCCESS;
error: error:
if (ptr != (char *)-1) munmap( ptr, total_size ); if (view) VIRTUAL_DeleteView( view );
RtlLeaveCriticalSection( &csVirtual );
return status; return status;
} }
...@@ -895,120 +1002,6 @@ BOOL VIRTUAL_HasMapping( LPCVOID addr ) ...@@ -895,120 +1002,6 @@ BOOL VIRTUAL_HasMapping( LPCVOID addr )
} }
/***********************************************************************
* unaligned_mmap
*
* Linux kernels before 2.4.x can support non page-aligned offsets, as
* long as the offset is aligned to the filesystem block size. This is
* a big performance gain so we want to take advantage of it.
*
* However, when we use 64-bit file support this doesn't work because
* glibc rejects unaligned offsets. Also glibc 2.1.3 mmap64 is broken
* in that it rounds unaligned offsets down to a page boundary. For
* these reasons we do a direct system call here.
*/
static void *unaligned_mmap( void *addr, size_t length, unsigned int prot,
unsigned int flags, int fd, unsigned int offset_low,
unsigned int offset_high )
{
#if defined(linux) && defined(__i386__) && defined(__GNUC__)
if (!offset_high && (offset_low & page_mask))
{
int ret;
struct
{
void *addr;
unsigned int length;
unsigned int prot;
unsigned int flags;
unsigned int fd;
unsigned int offset;
} args;
args.addr = addr;
args.length = length;
args.prot = prot;
args.flags = flags;
args.fd = fd;
args.offset = offset_low;
__asm__ __volatile__("push %%ebx\n\t"
"movl %2,%%ebx\n\t"
"int $0x80\n\t"
"popl %%ebx"
: "=a" (ret)
: "0" (90), /* SYS_mmap */
"g" (&args)
: "memory" );
if (ret < 0 && ret > -4096)
{
errno = -ret;
ret = -1;
}
return (void *)ret;
}
#endif
return mmap( addr, length, prot, flags, fd, ((off_t)offset_high << 32) | offset_low );
}
/***********************************************************************
* VIRTUAL_mmap
*
* Wrapper for mmap() that handles anonymous mappings portably,
* and falls back to read if mmap of a file fails.
*/
static LPVOID VIRTUAL_mmap( int fd, LPVOID start, DWORD size,
DWORD offset_low, DWORD offset_high,
int prot, int flags, BOOL *removable )
{
LPVOID ret;
off_t offset;
BOOL is_shared_write = FALSE;
if (fd == -1) return wine_anon_mmap( start, size, prot, flags );
if (prot & PROT_WRITE)
{
#ifdef MAP_SHARED
if (flags & MAP_SHARED) is_shared_write = TRUE;
#endif
#ifdef MAP_PRIVATE
if (!(flags & MAP_PRIVATE)) is_shared_write = TRUE;
#endif
}
if (removable && *removable)
{
/* if on removable media, try using read instead of mmap */
if (!is_shared_write) goto fake_mmap;
*removable = FALSE;
}
if ((ret = unaligned_mmap( start, size, prot, flags, fd,
offset_low, offset_high )) != (LPVOID)-1) return ret;
/* mmap() failed; if this is because the file offset is not */
/* page-aligned (EINVAL), or because the underlying filesystem */
/* does not support mmap() (ENOEXEC,ENODEV), we do it by hand. */
if ((errno != ENOEXEC) && (errno != EINVAL) && (errno != ENODEV)) return ret;
if (is_shared_write) return ret; /* we cannot fake shared write mappings */
fake_mmap:
/* Reserve the memory with an anonymous mmap */
ret = wine_anon_mmap( start, size, PROT_READ | PROT_WRITE, flags );
if (ret == (LPVOID)-1) return ret;
/* Now read in the file */
offset = ((off_t)offset_high << 32) | offset_low;
pread( fd, ret, size, offset );
mprotect( ret, size, prot ); /* Set the right protection */
return ret;
}
/*********************************************************************** /***********************************************************************
* NtAllocateVirtualMemory (NTDLL.@) * NtAllocateVirtualMemory (NTDLL.@)
* ZwAllocateVirtualMemory (NTDLL.@) * ZwAllocateVirtualMemory (NTDLL.@)
...@@ -1019,6 +1012,8 @@ NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, PVOID addr, ...@@ -1019,6 +1012,8 @@ NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, PVOID addr,
void *base; void *base;
BYTE vprot; BYTE vprot;
DWORD size = *size_ptr; DWORD size = *size_ptr;
NTSTATUS status = STATUS_SUCCESS;
struct file_view *view;
if (!is_current_process( process )) if (!is_current_process( process ))
{ {
...@@ -1055,69 +1050,62 @@ NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, PVOID addr, ...@@ -1055,69 +1050,62 @@ NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, PVOID addr,
} }
if (type & MEM_TOP_DOWN) { if (type & MEM_TOP_DOWN) {
/* FIXME: MEM_TOP_DOWN allocates the largest possible address. /* FIXME: MEM_TOP_DOWN allocates the largest possible address. */
* Is there _ANY_ way to do it with UNIX mmap()?
*/
WARN("MEM_TOP_DOWN ignored\n"); WARN("MEM_TOP_DOWN ignored\n");
type &= ~MEM_TOP_DOWN; type &= ~MEM_TOP_DOWN;
} }
/* Compute the alloc type flags */ /* Compute the alloc type flags */
if (type & MEM_SYSTEM) if (!(type & MEM_SYSTEM))
{
vprot = VIRTUAL_GetProt( protect ) | VPROT_COMMITTED;
if (type & MEM_IMAGE) vprot |= VPROT_IMAGE;
}
else
{ {
if (!(type & (MEM_COMMIT | MEM_RESERVE)) || (type & ~(MEM_COMMIT | MEM_RESERVE))) if (!(type & (MEM_COMMIT | MEM_RESERVE)) || (type & ~(MEM_COMMIT | MEM_RESERVE)))
{ {
WARN("called with wrong alloc type flags (%08lx) !\n", type); WARN("called with wrong alloc type flags (%08lx) !\n", type);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
if (type & MEM_COMMIT)
vprot = VIRTUAL_GetProt( protect ) | VPROT_COMMITTED;
else
vprot = 0;
} }
vprot = VIRTUAL_GetProt( protect );
if (type & MEM_COMMIT) vprot |= VPROT_COMMITTED;
/* Reserve the memory */ /* Reserve the memory */
RtlEnterCriticalSection( &csVirtual );
if (type & MEM_SYSTEM) if (type & MEM_SYSTEM)
{ {
if (!VIRTUAL_CreateView( base, size, VFLAG_VALLOC | VFLAG_SYSTEM, vprot, 0 )) if (type & MEM_IMAGE) vprot |= VPROT_IMAGE;
return STATUS_NO_MEMORY; status = create_view( &view, base, size, vprot | VPROT_COMMITTED );
if (status == STATUS_SUCCESS)
{
view->flags |= VFLAG_VALLOC | VFLAG_SYSTEM;
base = view->base;
}
} }
else if ((type & MEM_RESERVE) || !base) else if ((type & MEM_RESERVE) || !base)
{ {
NTSTATUS res = anon_mmap_aligned( &base, size, VIRTUAL_GetUnixProt( vprot ), 0 ); status = map_view( &view, base, size, vprot );
if (res) return res; if (status == STATUS_SUCCESS)
if (!VIRTUAL_CreateView( base, size, VFLAG_VALLOC, vprot, 0 ))
{ {
munmap( base, size ); view->flags |= VFLAG_VALLOC;
return STATUS_NO_MEMORY; base = view->base;
} }
} }
else else /* commit the pages */
{ {
FILE_VIEW *view;
NTSTATUS status = STATUS_SUCCESS;
/* Commit the pages */
RtlEnterCriticalSection( &csVirtual );
if (!(view = VIRTUAL_FindView( base )) || if (!(view = VIRTUAL_FindView( base )) ||
((char *)base + size > (char *)view->base + view->size)) status = STATUS_NOT_MAPPED_VIEW; ((char *)base + size > (char *)view->base + view->size)) status = STATUS_NOT_MAPPED_VIEW;
else if (!VIRTUAL_SetProt( view, base, size, vprot )) status = STATUS_ACCESS_DENIED; else if (!VIRTUAL_SetProt( view, base, size, vprot )) status = STATUS_ACCESS_DENIED;
RtlLeaveCriticalSection( &csVirtual );
if (status != STATUS_SUCCESS) return status;
} }
*ret = base; RtlLeaveCriticalSection( &csVirtual );
*size_ptr = size;
return STATUS_SUCCESS; if (status == STATUS_SUCCESS)
{
*ret = base;
*size_ptr = size;
}
return status;
} }
...@@ -1176,12 +1164,8 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *siz ...@@ -1176,12 +1164,8 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *siz
} }
else if (type == MEM_DECOMMIT) else if (type == MEM_DECOMMIT)
{ {
/* Decommit the pages by remapping zero-pages instead */ status = decommit_pages( view, base - (char *)view->base, size );
if (status == STATUS_SUCCESS)
if (wine_anon_mmap( (LPVOID)base, size, VIRTUAL_GetUnixProt(0), MAP_FIXED ) != (LPVOID)base)
ERR( "Could not remap pages, expect trouble\n" );
if (!VIRTUAL_SetProt( view, base, size, 0 )) status = STATUS_ACCESS_DENIED; /* FIXME */
else
{ {
*addr_ptr = base; *addr_ptr = base;
*size_ptr = size; *size_ptr = size;
...@@ -1274,6 +1258,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr, ...@@ -1274,6 +1258,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr,
{ {
FILE_VIEW *view; FILE_VIEW *view;
char *base, *alloc_base = 0; char *base, *alloc_base = 0;
struct list *ptr;
UINT size = 0; UINT size = 0;
MEMORY_BASIC_INFORMATION *info = buffer; MEMORY_BASIC_INFORMATION *info = buffer;
...@@ -1292,14 +1277,16 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr, ...@@ -1292,14 +1277,16 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr,
/* Find the view containing the address */ /* Find the view containing the address */
RtlEnterCriticalSection(&csVirtual); RtlEnterCriticalSection(&csVirtual);
view = VIRTUAL_FirstView; ptr = list_head( &views_list );
for (;;) for (;;)
{ {
if (!view) if (!ptr)
{ {
size = (char *)ADDRESS_SPACE_LIMIT - alloc_base; size = (char *)ADDRESS_SPACE_LIMIT - alloc_base;
view = NULL;
break; break;
} }
view = LIST_ENTRY( ptr, struct file_view, entry );
if ((char *)view->base > base) if ((char *)view->base > base)
{ {
size = (char *)view->base - alloc_base; size = (char *)view->base - alloc_base;
...@@ -1313,7 +1300,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr, ...@@ -1313,7 +1300,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr,
break; break;
} }
alloc_base = (char *)view->base + view->size; alloc_base = (char *)view->base + view->size;
view = view->next; ptr = list_next( &views_list, ptr );
} }
/* Fill the info structure */ /* Fill the info structure */
...@@ -1455,10 +1442,10 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p ...@@ -1455,10 +1442,10 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
FILE_FS_DEVICE_INFORMATION device_info; FILE_FS_DEVICE_INFORMATION device_info;
NTSTATUS res; NTSTATUS res;
UINT size = 0; UINT size = 0;
int flags = MAP_PRIVATE;
int unix_handle = -1; int unix_handle = -1;
int prot; int prot;
void *base, *ptr = (void *)-1, *ret; void *base;
struct file_view *view;
DWORD size_low, size_high, header_size, shared_size; DWORD size_low, size_high, header_size, shared_size;
HANDLE shared_file; HANDLE shared_file;
BOOL removable = FALSE; BOOL removable = FALSE;
...@@ -1506,7 +1493,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p ...@@ -1506,7 +1493,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
int shared_fd; int shared_fd;
if ((res = wine_server_handle_to_fd( shared_file, GENERIC_READ, &shared_fd, if ((res = wine_server_handle_to_fd( shared_file, GENERIC_READ, &shared_fd,
NULL, NULL ))) goto error; NULL, NULL ))) goto done;
res = map_image( handle, unix_handle, base, size_low, header_size, res = map_image( handle, unix_handle, base, size_low, header_size,
shared_fd, removable, addr_ptr ); shared_fd, removable, addr_ptr );
wine_server_release_fd( shared_file, shared_fd ); wine_server_release_fd( shared_file, shared_fd );
...@@ -1529,7 +1516,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p ...@@ -1529,7 +1516,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
(*size_ptr > size_low - offset->u.LowPart)) (*size_ptr > size_low - offset->u.LowPart))
{ {
res = STATUS_INVALID_PARAMETER; res = STATUS_INVALID_PARAMETER;
goto error; goto done;
} }
if (*size_ptr) size = ROUND_SIZE( offset->u.LowPart, *size_ptr ); if (*size_ptr) size = ROUND_SIZE( offset->u.LowPart, *size_ptr );
else size = size_low - offset->u.LowPart; else size = size_low - offset->u.LowPart;
...@@ -1543,9 +1530,9 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p ...@@ -1543,9 +1530,9 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
if (!(prot & VPROT_WRITE)) if (!(prot & VPROT_WRITE))
{ {
res = STATUS_INVALID_PARAMETER; res = STATUS_INVALID_PARAMETER;
goto error; goto done;
} }
flags = MAP_SHARED; removable = FALSE;
/* fall through */ /* fall through */
case PAGE_READONLY: case PAGE_READONLY:
case PAGE_WRITECOPY: case PAGE_WRITECOPY:
...@@ -1556,7 +1543,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p ...@@ -1556,7 +1543,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
/* fall through */ /* fall through */
default: default:
res = STATUS_INVALID_PARAMETER; res = STATUS_INVALID_PARAMETER;
goto error; goto done;
} }
/* FIXME: If a mapping is created with SEC_RESERVE and a process, /* FIXME: If a mapping is created with SEC_RESERVE and a process,
...@@ -1569,36 +1556,42 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p ...@@ -1569,36 +1556,42 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p
/* Reserve a properly aligned area */ /* Reserve a properly aligned area */
if ((res = anon_mmap_aligned( addr_ptr, size, PROT_NONE, 0 ))) goto error; RtlEnterCriticalSection( &csVirtual );
ptr = *addr_ptr;
res = map_view( &view, *addr_ptr, size, prot );
if (res)
{
RtlLeaveCriticalSection( &csVirtual );
goto done;
}
/* Map the file */ /* Map the file */
TRACE("handle=%p size=%x offset=%lx\n", handle, size, offset->u.LowPart ); TRACE("handle=%p size=%x offset=%lx%08lx\n",
handle, size, offset->u.HighPart, offset->u.LowPart );
ret = VIRTUAL_mmap( unix_handle, ptr, size, offset->u.LowPart, offset->u.HighPart, res = map_file_into_view( view, unix_handle, 0, size, offset->QuadPart, prot, removable );
VIRTUAL_GetUnixProt( prot ), flags | MAP_FIXED, &removable ); if (res == STATUS_SUCCESS)
if (ret != ptr)
{ {
ERR( "VIRTUAL_mmap %p %x %lx%08lx failed\n", if (!removable) /* don't keep handle open on removable media */
ptr, size, offset->u.HighPart, offset->u.LowPart ); NtDuplicateObject( GetCurrentProcess(), handle,
res = STATUS_NO_MEMORY; /* FIXME */ GetCurrentProcess(), &view->mapping,
goto error; 0, 0, DUPLICATE_SAME_ACCESS );
}
if (removable) handle = 0; /* don't keep handle open on removable media */
if (!VIRTUAL_CreateView( ptr, size, 0, prot, handle )) *addr_ptr = view->base;
*size_ptr = size;
}
else
{ {
res = STATUS_NO_MEMORY; ERR( "map_file_into_view %p %x %lx%08lx failed\n",
goto error; view->base, size, offset->u.HighPart, offset->u.LowPart );
VIRTUAL_DeleteView( view );
} }
wine_server_release_fd( handle, unix_handle );
*size_ptr = size;
return STATUS_SUCCESS;
error: RtlLeaveCriticalSection( &csVirtual );
done:
wine_server_release_fd( handle, unix_handle ); wine_server_release_fd( handle, unix_handle );
if (ptr != (void *)-1) munmap( ptr, size );
return res; return res;
} }
......
include/wine/list.h
View file @ eb04fd22
...@@ -27,22 +27,34 @@ struct list ...@@ -27,22 +27,34 @@ struct list
struct list *prev; struct list *prev;
}; };
/* add an element after the specified one */
inline static void list_add_after( struct list *elem, struct list *to_add )
{
to_add->next = elem->next;
to_add->prev = elem;
elem->next->prev = to_add;
elem->next = to_add;
}
/* add an element before the specified one */
inline static void list_add_before( struct list *elem, struct list *to_add )
{
to_add->next = elem;
to_add->prev = elem->prev;
elem->prev->next = to_add;
elem->prev = to_add;
}
/* add element at the head of the list */ /* add element at the head of the list */
inline static void list_add_head( struct list *list, struct list *elem ) inline static void list_add_head( struct list *list, struct list *elem )
{ {
elem->next = list->next; list_add_after( list, elem );
elem->prev = list;
list->next->prev = elem;
list->next = elem;
} }
/* add element at the tail of the list */ /* add element at the tail of the list */
inline static void list_add_tail( struct list *list, struct list *elem ) inline static void list_add_tail( struct list *list, struct list *elem )
{ {
elem->next = list; list_add_before( list, elem );
elem->prev = list->prev;
list->prev->next = elem;
list->prev = elem;
} }
/* remove an element from its list */ /* remove an element from its list */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment