1932 lines
59 KiB
C
1932 lines
59 KiB
C
/*
|
|
* Win32 VxD functions
|
|
*
|
|
* Copyright 1998 Marcus Meissner
|
|
* Copyright 1998 Ulrich Weigand
|
|
* Copyright 1998 Patrik Stridvall
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SYS_STAT_H
|
|
# include <sys/stat.h>
|
|
#endif
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#define NONAMELESSUNION
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winerror.h"
|
|
#include "winternl.h"
|
|
#include "winioctl.h"
|
|
#include "kernel16_private.h"
|
|
#include "dosexe.h"
|
|
#include "wine/library.h"
|
|
#include "wine/unicode.h"
|
|
#include "wine/server.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(vxd);
|
|
|
|
typedef DWORD (WINAPI *VxDCallProc)(DWORD, CONTEXT *);
|
|
typedef BOOL (WINAPI *DeviceIoProc)(DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
|
|
|
|
struct vxd_module
|
|
{
|
|
LARGE_INTEGER index;
|
|
HANDLE handle;
|
|
HMODULE module;
|
|
DeviceIoProc proc;
|
|
};
|
|
|
|
struct vxdcall_service
|
|
{
|
|
WCHAR name[12];
|
|
DWORD service;
|
|
HMODULE module;
|
|
VxDCallProc proc;
|
|
};
|
|
|
|
#define MAX_VXD_MODULES 32
|
|
|
|
static struct vxd_module vxd_modules[MAX_VXD_MODULES];
|
|
|
|
static struct vxdcall_service vxd_services[] =
|
|
{
|
|
{ {'v','m','m','.','v','x','d',0}, 0x0001, NULL, NULL },
|
|
{ {'v','w','i','n','3','2','.','v','x','d',0}, 0x002a, NULL, NULL }
|
|
};
|
|
|
|
#define NB_VXD_SERVICES (sizeof(vxd_services)/sizeof(vxd_services[0]))
|
|
|
|
#define W32S_APP2WINE(addr) ((addr)? (DWORD)(addr) + W32S_offset : 0)
|
|
#define W32S_WINE2APP(addr) ((addr)? (DWORD)(addr) - W32S_offset : 0)
|
|
|
|
#define VXD_BARF(context,name) \
|
|
TRACE( "vxd %s: unknown/not implemented parameters:\n" \
|
|
"vxd %s: AX %04x, BX %04x, CX %04x, DX %04x, " \
|
|
"SI %04x, DI %04x, DS %04x, ES %04x\n", \
|
|
(name), (name), AX_reg(context), BX_reg(context), \
|
|
CX_reg(context), DX_reg(context), SI_reg(context), \
|
|
DI_reg(context), (WORD)context->SegDs, (WORD)context->SegEs )
|
|
|
|
static CRITICAL_SECTION vxd_section;
|
|
static CRITICAL_SECTION_DEBUG critsect_debug =
|
|
{
|
|
0, 0, &vxd_section,
|
|
{ &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
|
|
0, 0, { (DWORD_PTR)(__FILE__ ": vxd_section") }
|
|
};
|
|
static CRITICAL_SECTION vxd_section = { &critsect_debug, -1, 0, 0, 0, 0 };
|
|
|
|
static UINT W32S_offset;
|
|
|
|
static WORD VXD_WinVersion(void)
|
|
{
|
|
WORD version = LOWORD(GetVersion16());
|
|
return (version >> 8) | (version << 8);
|
|
}
|
|
|
|
/* create a file handle to represent a VxD, by opening a dummy file in the wineserver directory */
|
|
static HANDLE open_vxd_handle( LPCWSTR name )
|
|
{
|
|
static const WCHAR prefixW[] = {'\\','?','?','\\','u','n','i','x'};
|
|
const char *dir = wine_get_server_dir();
|
|
int len;
|
|
HANDLE ret;
|
|
NTSTATUS status;
|
|
OBJECT_ATTRIBUTES attr;
|
|
UNICODE_STRING nameW;
|
|
IO_STATUS_BLOCK io;
|
|
|
|
len = MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, NULL, 0 );
|
|
nameW.Length = sizeof(prefixW) + (len + strlenW( name )) * sizeof(WCHAR);
|
|
nameW.MaximumLength = nameW.Length + sizeof(WCHAR);
|
|
if (!(nameW.Buffer = HeapAlloc( GetProcessHeap(), 0, nameW.MaximumLength )))
|
|
{
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
return 0;
|
|
}
|
|
memcpy( nameW.Buffer, prefixW, sizeof(prefixW) );
|
|
MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, nameW.Buffer + sizeof(prefixW)/sizeof(WCHAR), len );
|
|
len += sizeof(prefixW) / sizeof(WCHAR);
|
|
nameW.Buffer[len-1] = '/';
|
|
strcpyW( nameW.Buffer + len, name );
|
|
|
|
attr.Length = sizeof(attr);
|
|
attr.RootDirectory = 0;
|
|
attr.Attributes = 0;
|
|
attr.ObjectName = &nameW;
|
|
attr.SecurityDescriptor = NULL;
|
|
attr.SecurityQualityOfService = NULL;
|
|
|
|
status = NtCreateFile( &ret, SYNCHRONIZE, &attr, &io, NULL, 0,
|
|
FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF,
|
|
FILE_SYNCHRONOUS_IO_ALERT, NULL, 0 );
|
|
if (status)
|
|
{
|
|
ret = 0;
|
|
SetLastError( RtlNtStatusToDosError(status) );
|
|
}
|
|
RtlFreeUnicodeString( &nameW );
|
|
return ret;
|
|
}
|
|
|
|
/* retrieve the DeviceIoControl function for a Vxd given a file handle */
|
|
DeviceIoProc __wine_vxd_get_proc( HANDLE handle )
|
|
{
|
|
DeviceIoProc ret = NULL;
|
|
int status, i;
|
|
IO_STATUS_BLOCK io;
|
|
FILE_INTERNAL_INFORMATION info;
|
|
|
|
status = NtQueryInformationFile( handle, &io, &info, sizeof(info), FileInternalInformation );
|
|
if (status)
|
|
{
|
|
SetLastError( RtlNtStatusToDosError(status) );
|
|
return NULL;
|
|
}
|
|
|
|
RtlEnterCriticalSection( &vxd_section );
|
|
|
|
for (i = 0; i < MAX_VXD_MODULES; i++)
|
|
{
|
|
if (!vxd_modules[i].module) break;
|
|
if (vxd_modules[i].index.QuadPart == info.IndexNumber.QuadPart)
|
|
{
|
|
if (!(ret = vxd_modules[i].proc)) SetLastError( ERROR_INVALID_FUNCTION );
|
|
goto done;
|
|
}
|
|
}
|
|
/* FIXME: Here we could go through the directory to find the VxD name and load it. */
|
|
/* Let's wait to find out if there are actually apps out there that try to share */
|
|
/* VxD handles between processes, before we go to the trouble of implementing it. */
|
|
ERR( "handle %p not found in module list, inherited from another process?\n", handle );
|
|
|
|
done:
|
|
RtlLeaveCriticalSection( &vxd_section );
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* load a VxD and return a file handle to it */
|
|
HANDLE __wine_vxd_open( LPCWSTR filenameW, DWORD access, SECURITY_ATTRIBUTES *sa )
|
|
{
|
|
static const WCHAR dotVxDW[] = {'.','v','x','d',0};
|
|
int i;
|
|
HANDLE handle;
|
|
HMODULE module;
|
|
WCHAR *p, name[16];
|
|
|
|
/* normalize the filename */
|
|
|
|
if (strlenW( filenameW ) >= sizeof(name)/sizeof(WCHAR) - 4 ||
|
|
strchrW( filenameW, '/' ) || strchrW( filenameW, '\\' ))
|
|
{
|
|
SetLastError( ERROR_FILE_NOT_FOUND );
|
|
return 0;
|
|
}
|
|
strcpyW( name, filenameW );
|
|
strlwrW( name );
|
|
p = strchrW( name, '.' );
|
|
if (!p) strcatW( name, dotVxDW );
|
|
else if (strcmpiW( p, dotVxDW )) /* existing extension has to be .vxd */
|
|
{
|
|
SetLastError( ERROR_FILE_NOT_FOUND );
|
|
return 0;
|
|
}
|
|
|
|
/* try to load the module first */
|
|
|
|
if (!(module = LoadLibraryW( name )))
|
|
{
|
|
FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
|
|
debugstr_w(name) );
|
|
SetLastError( ERROR_FILE_NOT_FOUND );
|
|
return 0;
|
|
}
|
|
|
|
/* register the module in the global list if necessary */
|
|
|
|
RtlEnterCriticalSection( &vxd_section );
|
|
|
|
for (i = 0; i < MAX_VXD_MODULES; i++)
|
|
{
|
|
if (vxd_modules[i].module == module)
|
|
{
|
|
handle = vxd_modules[i].handle;
|
|
goto done; /* already registered */
|
|
}
|
|
if (!vxd_modules[i].module) /* new one, register it */
|
|
{
|
|
IO_STATUS_BLOCK io;
|
|
FILE_INTERNAL_INFORMATION info;
|
|
|
|
/* get a file handle to the dummy file */
|
|
if (!(handle = open_vxd_handle( name )))
|
|
{
|
|
FreeLibrary( module );
|
|
goto done;
|
|
}
|
|
if (!NtQueryInformationFile( handle, &io, &info, sizeof(info), FileInternalInformation ))
|
|
vxd_modules[i].index = info.IndexNumber;
|
|
|
|
vxd_modules[i].module = module;
|
|
vxd_modules[i].handle = handle;
|
|
vxd_modules[i].proc = (DeviceIoProc)GetProcAddress( module, "DeviceIoControl" );
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
ERR("too many open VxD modules, please report\n" );
|
|
FreeLibrary( module );
|
|
handle = 0;
|
|
|
|
done:
|
|
RtlLeaveCriticalSection( &vxd_section );
|
|
if (!DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(), &handle, 0,
|
|
(sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle),
|
|
DUP_HANDLE_SAME_ACCESS ))
|
|
handle = 0;
|
|
return handle;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* VxDCall0 (KERNEL32.1)
|
|
* VxDCall1 (KERNEL32.2)
|
|
* VxDCall2 (KERNEL32.3)
|
|
* VxDCall3 (KERNEL32.4)
|
|
* VxDCall4 (KERNEL32.5)
|
|
* VxDCall5 (KERNEL32.6)
|
|
* VxDCall6 (KERNEL32.7)
|
|
* VxDCall7 (KERNEL32.8)
|
|
* VxDCall8 (KERNEL32.9)
|
|
*/
|
|
void WINAPI __regs_VxDCall( DWORD service, CONTEXT *context )
|
|
{
|
|
unsigned int i;
|
|
VxDCallProc proc = NULL;
|
|
|
|
RtlEnterCriticalSection( &vxd_section );
|
|
for (i = 0; i < NB_VXD_SERVICES; i++)
|
|
{
|
|
if (HIWORD(service) != vxd_services[i].service) continue;
|
|
if (!vxd_services[i].module) /* need to load it */
|
|
{
|
|
if ((vxd_services[i].module = LoadLibraryW( vxd_services[i].name )))
|
|
vxd_services[i].proc = (VxDCallProc)GetProcAddress( vxd_services[i].module, "VxDCall" );
|
|
}
|
|
proc = vxd_services[i].proc;
|
|
break;
|
|
}
|
|
RtlLeaveCriticalSection( &vxd_section );
|
|
|
|
if (proc) context->Eax = proc( service, context );
|
|
else
|
|
{
|
|
FIXME( "Unknown/unimplemented VxD (%08x)\n", service);
|
|
context->Eax = 0xffffffff; /* FIXME */
|
|
}
|
|
}
|
|
#ifdef DEFINE_REGS_ENTRYPOINT
|
|
DEFINE_REGS_ENTRYPOINT( VxDCall, 1 )
|
|
#endif
|
|
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_vmm (WPROCS.401)
|
|
*/
|
|
void WINAPI __wine_vxd_vmm ( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] VMM\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x026d: /* Get_Debug_Flag '/m' */
|
|
case 0x026e: /* Get_Debug_Flag '/n' */
|
|
SET_AL( context, 0 );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "VMM" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_pagefile (WPROCS.433)
|
|
*/
|
|
void WINAPI __wine_vxd_pagefile( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
/* taken from Ralf Brown's Interrupt List */
|
|
|
|
TRACE("[%04x] PageFile\n", (UINT16)service );
|
|
|
|
switch(service)
|
|
{
|
|
case 0x00: /* get version, is this windows version? */
|
|
TRACE("returning version\n");
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x01: /* get swap file info */
|
|
TRACE("VxD PageFile: returning swap file info\n");
|
|
SET_AX( context, 0x00 ); /* paging disabled */
|
|
context->Ecx = 0; /* maximum size of paging file */
|
|
/* FIXME: do I touch DS:SI or DS:DI? */
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x02: /* delete permanent swap on exit */
|
|
TRACE("VxD PageFile: supposed to delete swap\n");
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x03: /* current temporary swap file size */
|
|
TRACE("VxD PageFile: what is current temp. swap size\n");
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x04: /* read or write?? INTERRUP.D */
|
|
case 0x05: /* cancel?? INTERRUP.D */
|
|
case 0x06: /* test I/O valid INTERRUP.D */
|
|
default:
|
|
VXD_BARF( context, "pagefile" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_reboot (WPROCS.409)
|
|
*/
|
|
void WINAPI __wine_vxd_reboot( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] Reboot\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "REBOOT" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_vdd (WPROCS.410)
|
|
*/
|
|
void WINAPI __wine_vxd_vdd( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] VDD\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "VDD" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_vmd (WPROCS.412)
|
|
*/
|
|
void WINAPI __wine_vxd_vmd( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] VMD\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "VMD" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_vxdloader (WPROCS.439)
|
|
*/
|
|
void WINAPI __wine_vxd_vxdloader( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] VXDLoader\n", (UINT16)service);
|
|
|
|
switch (service)
|
|
{
|
|
case 0x0000: /* get version */
|
|
TRACE("returning version\n");
|
|
SET_AX( context, 0x0000 );
|
|
SET_DX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x0001: /* load device */
|
|
FIXME("load device %04x:%04x (%s)\n",
|
|
context->SegDs, DX_reg(context),
|
|
debugstr_a(MapSL(MAKESEGPTR(context->SegDs, DX_reg(context)))));
|
|
SET_AX( context, 0x0000 );
|
|
context->SegEs = 0x0000;
|
|
SET_DI( context, 0x0000 );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x0002: /* unload device */
|
|
FIXME("unload device (%08x)\n", context->Ebx);
|
|
SET_AX( context, 0x0000 );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "VXDLDR" );
|
|
SET_AX( context, 0x000B ); /* invalid function number */
|
|
SET_CFLAG(context);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_shell (WPROCS.423)
|
|
*/
|
|
void WINAPI __wine_vxd_shell( CONTEXT *context )
|
|
{
|
|
unsigned service = DX_reg(context);
|
|
|
|
TRACE("[%04x] Shell\n", (UINT16)service);
|
|
|
|
switch (service) /* Ralf Brown says EDX, but I use DX instead */
|
|
{
|
|
case 0x0000:
|
|
TRACE("returning version\n");
|
|
SET_AX( context, VXD_WinVersion() );
|
|
context->Ebx = 1; /* system VM Handle */
|
|
break;
|
|
|
|
case 0x0001:
|
|
case 0x0002:
|
|
case 0x0003:
|
|
/* SHELL_SYSMODAL_Message
|
|
ebx virtual machine handle
|
|
eax message box flags
|
|
ecx address of message
|
|
edi address of caption
|
|
return response in eax
|
|
*/
|
|
case 0x0004:
|
|
/* SHELL_Message
|
|
ebx virtual machine handle
|
|
eax message box flags
|
|
ecx address of message
|
|
edi address of caption
|
|
esi address callback
|
|
edx reference data for callback
|
|
return response in eax
|
|
*/
|
|
case 0x0005:
|
|
VXD_BARF( context, "shell" );
|
|
break;
|
|
|
|
case 0x0006: /* SHELL_Get_VM_State */
|
|
TRACE("VxD Shell: returning VM state\n");
|
|
/* Actually we don't, not yet. We have to return a structure
|
|
* and I am not to sure how to set it up and return it yet,
|
|
* so for now let's do nothing. I can (hopefully) get this
|
|
* by the next release
|
|
*/
|
|
/* RESET_CFLAG(context); */
|
|
break;
|
|
|
|
case 0x0007:
|
|
case 0x0008:
|
|
case 0x0009:
|
|
case 0x000A:
|
|
case 0x000B:
|
|
case 0x000C:
|
|
case 0x000D:
|
|
case 0x000E:
|
|
case 0x000F:
|
|
case 0x0010:
|
|
case 0x0011:
|
|
case 0x0012:
|
|
case 0x0013:
|
|
case 0x0014:
|
|
case 0x0015:
|
|
case 0x0016:
|
|
VXD_BARF( context, "SHELL" );
|
|
break;
|
|
|
|
/* the new Win95 shell API */
|
|
case 0x0100: /* get version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
break;
|
|
|
|
case 0x0104: /* retrieve Hook_Properties list */
|
|
case 0x0105: /* call Hook_Properties callbacks */
|
|
VXD_BARF( context, "SHELL" );
|
|
break;
|
|
|
|
case 0x0106: /* install timeout callback */
|
|
TRACE("VxD Shell: ignoring shell callback (%d sec.)\n", context->Ebx);
|
|
SET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x0107: /* get version of any VxD */
|
|
default:
|
|
VXD_BARF( context, "SHELL" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_comm (WPROCS.414)
|
|
*/
|
|
void WINAPI __wine_vxd_comm( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] Comm\n", (UINT16)service);
|
|
|
|
switch (service)
|
|
{
|
|
case 0x0000: /* get version */
|
|
TRACE("returning version\n");
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x0001: /* set port global */
|
|
case 0x0002: /* get focus */
|
|
case 0x0003: /* virtualise port */
|
|
default:
|
|
VXD_BARF( context, "comm" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_timer (WPROCS.405)
|
|
*/
|
|
void WINAPI __wine_vxd_timer( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] Virtual Timer\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x0100: /* clock tick time, in 840nsecs */
|
|
context->Eax = GetTickCount();
|
|
|
|
context->Edx = context->Eax >> 22;
|
|
context->Eax <<= 10; /* not very precise */
|
|
break;
|
|
|
|
case 0x0101: /* current Windows time, msecs */
|
|
case 0x0102: /* current VM time, msecs */
|
|
context->Eax = GetTickCount();
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "VTD" );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* timer_thread
|
|
*/
|
|
static DWORD CALLBACK timer_thread( void *arg )
|
|
{
|
|
DWORD *system_time = arg;
|
|
|
|
for (;;)
|
|
{
|
|
*system_time = GetTickCount();
|
|
Sleep( 55 );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_timerapi (WPROCS.1490)
|
|
*/
|
|
void WINAPI __wine_vxd_timerapi( CONTEXT *context )
|
|
{
|
|
static WORD System_Time_Selector;
|
|
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] TimerAPI\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
case 0x0009: /* get system time selector */
|
|
if ( !System_Time_Selector )
|
|
{
|
|
HANDLE16 handle = GlobalAlloc16( GMEM_FIXED, sizeof(DWORD) );
|
|
System_Time_Selector = handle | 7;
|
|
CloseHandle( CreateThread( NULL, 0, timer_thread, GlobalLock16(handle), 0, NULL ) );
|
|
}
|
|
SET_AX( context, System_Time_Selector );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "VTDAPI" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_configmg (WPROCS.451)
|
|
*/
|
|
void WINAPI __wine_vxd_configmg( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] ConfigMG\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "CONFIGMG" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_enable (WPROCS.455)
|
|
*/
|
|
void WINAPI __wine_vxd_enable( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] Enable\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "ENABLE" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_apm (WPROCS.438)
|
|
*/
|
|
void WINAPI __wine_vxd_apm( CONTEXT *context )
|
|
{
|
|
unsigned service = AX_reg(context);
|
|
|
|
TRACE("[%04x] APM\n", (UINT16)service);
|
|
|
|
switch(service)
|
|
{
|
|
case 0x0000: /* version */
|
|
SET_AX( context, VXD_WinVersion() );
|
|
RESET_CFLAG(context);
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "APM" );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* __wine_vxd_win32s (WPROCS.445)
|
|
*
|
|
* This is an implementation of the services of the Win32s VxD.
|
|
* Since official documentation of these does not seem to be available,
|
|
* certain arguments of some of the services remain unclear.
|
|
*
|
|
* FIXME: The following services are currently unimplemented:
|
|
* Exception handling (0x01, 0x1C)
|
|
* Debugger support (0x0C, 0x14, 0x17)
|
|
* Low-level memory access (0x02, 0x03, 0x0A, 0x0B)
|
|
* Memory Statistics (0x1B)
|
|
*
|
|
*
|
|
* We have a specific problem running Win32s on Linux (and probably also
|
|
* the other x86 unixes), since Win32s tries to allocate its main 'flat
|
|
* code/data segment' selectors with a base of 0xffff0000 (and limit 4GB).
|
|
* The rationale for this seems to be that they want one the one hand to
|
|
* be able to leave the Win 3.1 memory (starting with the main DOS memory)
|
|
* at linear address 0, but want at other hand to have offset 0 of the
|
|
* flat data/code segment point to an unmapped page (to catch NULL pointer
|
|
* accesses). Hence they allocate the flat segments with a base of 0xffff0000
|
|
* so that the Win 3.1 memory area at linear address zero shows up in the
|
|
* flat segments at offset 0x10000 (since linear addresses wrap around at
|
|
* 4GB). To compensate for that discrepancy between flat segment offsets
|
|
* and plain linear addresses, all flat pointers passed between the 32-bit
|
|
* and the 16-bit parts of Win32s are shifted by 0x10000 in the appropriate
|
|
* direction by the glue code (mainly) in W32SKRNL and WIN32S16.
|
|
*
|
|
* The problem for us is now that Linux does not allow a LDT selector with
|
|
* base 0xffff0000 to be created, since it would 'see' a part of the kernel
|
|
* address space. To address this problem we introduce *another* offset:
|
|
* We add 0x10000 to every linear address we get as an argument from Win32s.
|
|
* This means especially that the flat code/data selectors get actually
|
|
* allocated with base 0x0, so that flat offsets and (real) linear addresses
|
|
* do again agree! In fact, every call e.g. of a Win32s VxD service now
|
|
* has all pointer arguments (which are offsets in the flat data segment)
|
|
* first reduced by 0x10000 by the W32SKRNL glue code, and then again
|
|
* increased by 0x10000 by *our* code.
|
|
*
|
|
* Note that to keep everything consistent, this offset has to be applied by
|
|
* every Wine function that operates on 'linear addresses' passed to it by
|
|
* Win32s. Fortunately, since Win32s does not directly call any Wine 32-bit
|
|
* API routines, this affects only two locations: this VxD and the DPMI
|
|
* handler. (NOTE: Should any Win32s application pass a linear address to
|
|
* any routine apart from those, e.g. some other VxD handler, that code
|
|
* would have to take the offset into account as well!)
|
|
*
|
|
* The offset is set the first time any application calls the GetVersion()
|
|
* service of the Win32s VxD. (Note that the offset is never reset.)
|
|
*
|
|
*/
|
|
void WINAPI __wine_vxd_win32s( CONTEXT *context )
|
|
{
|
|
switch (AX_reg(context))
|
|
{
|
|
case 0x0000: /* Get Version */
|
|
/*
|
|
* Input: None
|
|
*
|
|
* Output: EAX: LoWord: Win32s Version (1.30)
|
|
* HiWord: VxD Version (200)
|
|
*
|
|
* EBX: Build (172)
|
|
*
|
|
* ECX: ??? (1)
|
|
*
|
|
* EDX: Debugging Flags
|
|
*
|
|
* EDI: Error Flag
|
|
* 0 if OK,
|
|
* 1 if VMCPD VxD not found
|
|
*/
|
|
|
|
TRACE("GetVersion()\n");
|
|
|
|
context->Eax = VXD_WinVersion() | (200 << 16);
|
|
context->Ebx = 0;
|
|
context->Ecx = 0;
|
|
context->Edx = 0;
|
|
context->Edi = 0;
|
|
|
|
/*
|
|
* If this is the first time we are called for this process,
|
|
* hack the memory image of WIN32S16 so that it doesn't try
|
|
* to access the GDT directly ...
|
|
*
|
|
* The first code segment of WIN32S16 (version 1.30) contains
|
|
* an unexported function somewhere between the exported functions
|
|
* SetFS and StackLinearToSegmented that tries to find a selector
|
|
* in the LDT that maps to the memory image of the LDT itself.
|
|
* If it succeeds, it stores this selector into a global variable
|
|
* which will be used to speed up execution by using this selector
|
|
* to modify the LDT directly instead of using the DPMI calls.
|
|
*
|
|
* To perform this search of the LDT, this function uses the
|
|
* sgdt and sldt instructions to find the linear address of
|
|
* the (GDT and then) LDT. While those instructions themselves
|
|
* execute without problem, the linear address that sgdt returns
|
|
* points (at least under Linux) to the kernel address space, so
|
|
* that any subsequent access leads to a segfault.
|
|
*
|
|
* Fortunately, WIN32S16 still contains as a fallback option the
|
|
* mechanism of using DPMI calls to modify LDT selectors instead
|
|
* of direct writes to the LDT. Thus we can circumvent the problem
|
|
* by simply replacing the first byte of the offending function
|
|
* with an 'retf' instruction. This means that the global variable
|
|
* supposed to contain the LDT alias selector will remain zero,
|
|
* and hence WIN32S16 will fall back to using DPMI calls.
|
|
*
|
|
* The heuristic we employ to _find_ that function is as follows:
|
|
* We search between the addresses of the exported symbols SetFS
|
|
* and StackLinearToSegmented for the byte sequence '0F 01 04'
|
|
* (this is the opcode of 'sgdt [si]'). We then search backwards
|
|
* from this address for the last occurrence of 'CB' (retf) that marks
|
|
* the end of the preceding function. The following byte (which
|
|
* should now be the first byte of the function we are looking for)
|
|
* will be replaced by 'CB' (retf).
|
|
*
|
|
* This heuristic works for the retail as well as the debug version
|
|
* of Win32s version 1.30. For versions earlier than that this
|
|
* hack should not be necessary at all, since the whole mechanism
|
|
* ('PERF130') was introduced only in 1.30 to improve the overall
|
|
* performance of Win32s.
|
|
*/
|
|
|
|
if (!W32S_offset)
|
|
{
|
|
HMODULE16 hModule = GetModuleHandle16("win32s16");
|
|
SEGPTR func1 = (SEGPTR)GetProcAddress16(hModule, "SetFS");
|
|
SEGPTR func2 = (SEGPTR)GetProcAddress16(hModule, "StackLinearToSegmented");
|
|
|
|
if ( hModule && func1 && func2
|
|
&& SELECTOROF(func1) == SELECTOROF(func2))
|
|
{
|
|
BYTE *start = MapSL(func1);
|
|
BYTE *end = MapSL(func2);
|
|
BYTE *p, *retv = NULL;
|
|
int found = 0;
|
|
|
|
for (p = start; p < end; p++)
|
|
if (*p == 0xCB) found = 0, retv = p;
|
|
else if (*p == 0x0F) found = 1;
|
|
else if (*p == 0x01 && found == 1) found = 2;
|
|
else if (*p == 0x04 && found == 2) { found = 3; break; }
|
|
else found = 0;
|
|
|
|
if (found == 3 && retv)
|
|
{
|
|
TRACE("PERF130 hack: "
|
|
"Replacing byte %02X at offset %04X:%04X\n",
|
|
*(retv+1), SELECTOROF(func1),
|
|
OFFSETOF(func1) + retv+1-start);
|
|
|
|
*(retv+1) = (BYTE)0xCB;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Mark process as Win32s, so that subsequent DPMI calls
|
|
* will perform the W32S_APP2WINE/W32S_WINE2APP address shift.
|
|
*/
|
|
W32S_offset = 0x10000;
|
|
break;
|
|
|
|
|
|
case 0x0001: /* Install Exception Handling */
|
|
/*
|
|
* Input: EBX: Flat address of W32SKRNL Exception Data
|
|
*
|
|
* ECX: LoWord: Flat Code Selector
|
|
* HiWord: Flat Data Selector
|
|
*
|
|
* EDX: Flat address of W32SKRNL Exception Handler
|
|
* (this is equal to W32S_BackTo32 + 0x40)
|
|
*
|
|
* ESI: SEGPTR KERNEL.HASGPHANDLER
|
|
*
|
|
* EDI: SEGPTR phCurrentTask (KERNEL.THHOOK + 0x10)
|
|
*
|
|
* Output: EAX: 0 if OK
|
|
*/
|
|
|
|
TRACE("[0001] EBX=%x ECX=%x EDX=%x ESI=%x EDI=%x\n",
|
|
context->Ebx, context->Ecx, context->Edx,
|
|
context->Esi, context->Edi);
|
|
|
|
/* FIXME */
|
|
|
|
context->Eax = 0;
|
|
break;
|
|
|
|
|
|
case 0x0002: /* Set Page Access Flags */
|
|
/*
|
|
* Input: EBX: New access flags
|
|
* Bit 2: User Page if set, Supervisor Page if clear
|
|
* Bit 1: Read-Write if set, Read-Only if clear
|
|
*
|
|
* ECX: Size of memory area to change
|
|
*
|
|
* EDX: Flat start address of memory area
|
|
*
|
|
* Output: EAX: Size of area changed
|
|
*/
|
|
|
|
TRACE("[0002] EBX=%x ECX=%x EDX=%x\n",
|
|
context->Ebx, context->Ecx, context->Edx);
|
|
|
|
/* FIXME */
|
|
|
|
context->Eax = context->Ecx;
|
|
break;
|
|
|
|
|
|
case 0x0003: /* Get Page Access Flags */
|
|
/*
|
|
* Input: EDX: Flat address of page to query
|
|
*
|
|
* Output: EAX: Page access flags
|
|
* Bit 2: User Page if set, Supervisor Page if clear
|
|
* Bit 1: Read-Write if set, Read-Only if clear
|
|
*/
|
|
|
|
TRACE("[0003] EDX=%x\n", context->Edx);
|
|
|
|
/* FIXME */
|
|
|
|
context->Eax = 6;
|
|
break;
|
|
|
|
|
|
case 0x0004: /* Map Module */
|
|
/*
|
|
* Input: ECX: IMTE (offset in Module Table) of new module
|
|
*
|
|
* EDX: Flat address of Win32s Module Table
|
|
*
|
|
* Output: EAX: 0 if OK
|
|
*/
|
|
|
|
if (!context->Edx || CX_reg(context) == 0xFFFF)
|
|
{
|
|
TRACE("MapModule: Initialization call\n");
|
|
context->Eax = 0;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Structure of a Win32s Module Table Entry:
|
|
*/
|
|
struct Win32sModule
|
|
{
|
|
DWORD flags;
|
|
DWORD flatBaseAddr;
|
|
LPCSTR moduleName;
|
|
LPCSTR pathName;
|
|
LPCSTR unknown;
|
|
LPBYTE baseAddr;
|
|
DWORD hModule;
|
|
DWORD relocDelta;
|
|
};
|
|
|
|
/*
|
|
* Note: This function should set up a demand-paged memory image
|
|
* of the given module. Since mmap does not allow file offsets
|
|
* not aligned at 1024 bytes, we simply load the image fully
|
|
* into memory.
|
|
*/
|
|
|
|
struct Win32sModule *moduleTable =
|
|
(struct Win32sModule *)W32S_APP2WINE(context->Edx);
|
|
struct Win32sModule *module = moduleTable + context->Ecx;
|
|
|
|
IMAGE_NT_HEADERS *nt_header = RtlImageNtHeader( (HMODULE)module->baseAddr );
|
|
IMAGE_SECTION_HEADER *pe_seg = (IMAGE_SECTION_HEADER*)((char *)&nt_header->OptionalHeader +
|
|
nt_header->FileHeader.SizeOfOptionalHeader);
|
|
|
|
|
|
HFILE image = _lopen(module->pathName, OF_READ);
|
|
BOOL error = (image == HFILE_ERROR);
|
|
UINT i;
|
|
|
|
TRACE("MapModule: Loading %s\n", module->pathName);
|
|
|
|
for (i = 0;
|
|
!error && i < nt_header->FileHeader.NumberOfSections;
|
|
i++, pe_seg++)
|
|
if(!(pe_seg->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA))
|
|
{
|
|
DWORD off = pe_seg->PointerToRawData;
|
|
DWORD len = pe_seg->SizeOfRawData;
|
|
LPBYTE addr = module->baseAddr + pe_seg->VirtualAddress;
|
|
|
|
TRACE("MapModule: "
|
|
"Section %d at %08x from %08x len %08x\n",
|
|
i, (DWORD)addr, off, len);
|
|
|
|
if ( _llseek(image, off, SEEK_SET) != off
|
|
|| _lread(image, addr, len) != len)
|
|
error = TRUE;
|
|
}
|
|
|
|
_lclose(image);
|
|
|
|
if (error)
|
|
ERR("MapModule: Unable to load %s\n", module->pathName);
|
|
|
|
else if (module->relocDelta != 0)
|
|
{
|
|
IMAGE_DATA_DIRECTORY *dir = nt_header->OptionalHeader.DataDirectory
|
|
+ IMAGE_DIRECTORY_ENTRY_BASERELOC;
|
|
IMAGE_BASE_RELOCATION *r = (IMAGE_BASE_RELOCATION *)
|
|
(dir->Size? module->baseAddr + dir->VirtualAddress : 0);
|
|
|
|
TRACE("MapModule: Reloc delta %08x\n", module->relocDelta);
|
|
|
|
while (r && r->VirtualAddress)
|
|
{
|
|
LPBYTE page = module->baseAddr + r->VirtualAddress;
|
|
WORD *TypeOffset = (WORD *)(r + 1);
|
|
unsigned int count = (r->SizeOfBlock - sizeof(*r)) / sizeof(*TypeOffset);
|
|
|
|
TRACE("MapModule: %d relocations for page %08x\n",
|
|
count, (DWORD)page);
|
|
|
|
for(i = 0; i < count; i++)
|
|
{
|
|
int offset = TypeOffset[i] & 0xFFF;
|
|
int type = TypeOffset[i] >> 12;
|
|
switch(type)
|
|
{
|
|
case IMAGE_REL_BASED_ABSOLUTE:
|
|
break;
|
|
case IMAGE_REL_BASED_HIGH:
|
|
*(WORD *)(page+offset) += HIWORD(module->relocDelta);
|
|
break;
|
|
case IMAGE_REL_BASED_LOW:
|
|
*(WORD *)(page+offset) += LOWORD(module->relocDelta);
|
|
break;
|
|
case IMAGE_REL_BASED_HIGHLOW:
|
|
*(DWORD*)(page+offset) += module->relocDelta;
|
|
break;
|
|
default:
|
|
WARN("MapModule: Unsupported fixup type\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
r = (IMAGE_BASE_RELOCATION *)((LPBYTE)r + r->SizeOfBlock);
|
|
}
|
|
}
|
|
|
|
context->Eax = 0;
|
|
RESET_CFLAG(context);
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0005: /* UnMap Module */
|
|
/*
|
|
* Input: EDX: Flat address of module image
|
|
*
|
|
* Output: EAX: 1 if OK
|
|
*/
|
|
|
|
TRACE("UnMapModule: %x\n", W32S_APP2WINE(context->Edx));
|
|
|
|
/* As we didn't map anything, there's nothing to unmap ... */
|
|
|
|
context->Eax = 1;
|
|
break;
|
|
|
|
|
|
case 0x0006: /* VirtualAlloc */
|
|
/*
|
|
* Input: ECX: Current Process
|
|
*
|
|
* EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD *retv [out] Flat base address of allocated region
|
|
* LPVOID base [in] Flat address of region to reserve/commit
|
|
* DWORD size [in] Size of region
|
|
* DWORD type [in] Type of allocation
|
|
* DWORD prot [in] Type of access protection
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
|
|
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
|
|
DWORD size = stack[2];
|
|
DWORD type = stack[3];
|
|
DWORD prot = stack[4];
|
|
DWORD result;
|
|
|
|
TRACE("VirtualAlloc(%x, %x, %x, %x, %x)\n",
|
|
(DWORD)retv, (DWORD)base, size, type, prot);
|
|
|
|
if (type & 0x80000000)
|
|
{
|
|
WARN("VirtualAlloc: strange type %x\n", type);
|
|
type &= 0x7fffffff;
|
|
}
|
|
|
|
if (!base && (type & MEM_COMMIT) && prot == PAGE_READONLY)
|
|
{
|
|
WARN("VirtualAlloc: NLS hack, allowing write access!\n");
|
|
prot = PAGE_READWRITE;
|
|
}
|
|
|
|
result = (DWORD)VirtualAlloc(base, size, type, prot);
|
|
|
|
if (W32S_WINE2APP(result))
|
|
*retv = W32S_WINE2APP(result),
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
*retv = 0,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0007: /* VirtualFree */
|
|
/*
|
|
* Input: ECX: Current Process
|
|
*
|
|
* EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD *retv [out] TRUE if success, FALSE if failure
|
|
* LPVOID base [in] Flat address of region
|
|
* DWORD size [in] Size of region
|
|
* DWORD type [in] Type of operation
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
|
|
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
|
|
DWORD size = stack[2];
|
|
DWORD type = stack[3];
|
|
DWORD result;
|
|
|
|
TRACE("VirtualFree(%x, %x, %x, %x)\n",
|
|
(DWORD)retv, (DWORD)base, size, type);
|
|
|
|
result = VirtualFree(base, size, type);
|
|
|
|
if (result)
|
|
*retv = TRUE,
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
*retv = FALSE,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0008: /* VirtualProtect */
|
|
/*
|
|
* Input: ECX: Current Process
|
|
*
|
|
* EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD *retv [out] TRUE if success, FALSE if failure
|
|
* LPVOID base [in] Flat address of region
|
|
* DWORD size [in] Size of region
|
|
* DWORD new_prot [in] Desired access protection
|
|
* DWORD *old_prot [out] Previous access protection
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
|
|
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
|
|
DWORD size = stack[2];
|
|
DWORD new_prot = stack[3];
|
|
DWORD *old_prot = (DWORD *)W32S_APP2WINE(stack[4]);
|
|
DWORD result;
|
|
|
|
TRACE("VirtualProtect(%x, %x, %x, %x, %x)\n",
|
|
(DWORD)retv, (DWORD)base, size, new_prot, (DWORD)old_prot);
|
|
|
|
result = VirtualProtect(base, size, new_prot, old_prot);
|
|
|
|
if (result)
|
|
*retv = TRUE,
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
*retv = FALSE,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0009: /* VirtualQuery */
|
|
/*
|
|
* Input: ECX: Current Process
|
|
*
|
|
* EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD *retv [out] Nr. bytes returned
|
|
* LPVOID base [in] Flat address of region
|
|
* LPMEMORY_BASIC_INFORMATION info [out] Info buffer
|
|
* DWORD len [in] Size of buffer
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
|
|
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
|
|
PMEMORY_BASIC_INFORMATION info =
|
|
(PMEMORY_BASIC_INFORMATION)W32S_APP2WINE(stack[2]);
|
|
DWORD len = stack[3];
|
|
DWORD result;
|
|
|
|
TRACE("VirtualQuery(%x, %x, %x, %x)\n",
|
|
(DWORD)retv, (DWORD)base, (DWORD)info, len);
|
|
|
|
result = VirtualQuery(base, info, len);
|
|
|
|
*retv = result;
|
|
context->Eax = STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x000A: /* SetVirtMemProcess */
|
|
/*
|
|
* Input: ECX: Process Handle
|
|
*
|
|
* EDX: Flat address of region
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
|
|
TRACE("[000a] ECX=%x EDX=%x\n",
|
|
context->Ecx, context->Edx);
|
|
|
|
/* FIXME */
|
|
|
|
context->Eax = STATUS_SUCCESS;
|
|
break;
|
|
|
|
|
|
case 0x000B: /* ??? some kind of cleanup */
|
|
/*
|
|
* Input: ECX: Process Handle
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
|
|
TRACE("[000b] ECX=%x\n", context->Ecx);
|
|
|
|
/* FIXME */
|
|
|
|
context->Eax = STATUS_SUCCESS;
|
|
break;
|
|
|
|
|
|
case 0x000C: /* Set Debug Flags */
|
|
/*
|
|
* Input: EDX: Debug Flags
|
|
*
|
|
* Output: EDX: Previous Debug Flags
|
|
*/
|
|
|
|
FIXME("[000c] EDX=%x\n", context->Edx);
|
|
|
|
/* FIXME */
|
|
|
|
context->Edx = 0;
|
|
break;
|
|
|
|
|
|
case 0x000D: /* NtCreateSection */
|
|
/*
|
|
* Input: EDX: Flat address of arguments on stack
|
|
*
|
|
* HANDLE32 *retv [out] Handle of Section created
|
|
* DWORD flags1 [in] (?? unknown ??)
|
|
* DWORD atom [in] Name of Section to create
|
|
* LARGE_INTEGER *size [in] Size of Section
|
|
* DWORD protect [in] Access protection
|
|
* DWORD flags2 [in] (?? unknown ??)
|
|
* HFILE32 hFile [in] Handle of file to map
|
|
* DWORD psp [in] (Win32s: PSP that hFile belongs to)
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *) W32S_APP2WINE(context->Edx);
|
|
HANDLE *retv = (HANDLE *)W32S_APP2WINE(stack[0]);
|
|
DWORD flags1 = stack[1];
|
|
DWORD atom = stack[2];
|
|
LARGE_INTEGER *size = (LARGE_INTEGER *)W32S_APP2WINE(stack[3]);
|
|
DWORD protect = stack[4];
|
|
DWORD flags2 = stack[5];
|
|
HANDLE hFile = DosFileHandleToWin32Handle(stack[6]);
|
|
DWORD psp = stack[7];
|
|
|
|
HANDLE result = INVALID_HANDLE_VALUE;
|
|
char name[128];
|
|
|
|
TRACE("NtCreateSection(%x, %x, %x, %x, %x, %x, %x, %x)\n",
|
|
(DWORD)retv, flags1, atom, (DWORD)size, protect, flags2,
|
|
(DWORD)hFile, psp);
|
|
|
|
if (!atom || GlobalGetAtomNameA(atom, name, sizeof(name)))
|
|
{
|
|
TRACE("NtCreateSection: name=%s\n", atom? name : NULL);
|
|
|
|
result = CreateFileMappingA(hFile, NULL, protect,
|
|
size? size->u.HighPart : 0,
|
|
size? size->u.LowPart : 0,
|
|
atom? name : NULL);
|
|
}
|
|
|
|
if (result == INVALID_HANDLE_VALUE)
|
|
WARN("NtCreateSection: failed!\n");
|
|
else
|
|
TRACE("NtCreateSection: returned %x\n", (DWORD)result);
|
|
|
|
if (result != INVALID_HANDLE_VALUE)
|
|
*retv = result,
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
*retv = result,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x000E: /* NtOpenSection */
|
|
/*
|
|
* Input: EDX: Flat address of arguments on stack
|
|
*
|
|
* HANDLE32 *retv [out] Handle of Section opened
|
|
* DWORD protect [in] Access protection
|
|
* DWORD atom [in] Name of Section to create
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
HANDLE *retv = (HANDLE *)W32S_APP2WINE(stack[0]);
|
|
DWORD protect = stack[1];
|
|
DWORD atom = stack[2];
|
|
|
|
HANDLE result = INVALID_HANDLE_VALUE;
|
|
char name[128];
|
|
|
|
TRACE("NtOpenSection(%x, %x, %x)\n",
|
|
(DWORD)retv, protect, atom);
|
|
|
|
if (atom && GlobalGetAtomNameA(atom, name, sizeof(name)))
|
|
{
|
|
TRACE("NtOpenSection: name=%s\n", name);
|
|
|
|
result = OpenFileMappingA(protect, FALSE, name);
|
|
}
|
|
|
|
if (result == INVALID_HANDLE_VALUE)
|
|
WARN("NtOpenSection: failed!\n");
|
|
else
|
|
TRACE("NtOpenSection: returned %x\n", (DWORD)result);
|
|
|
|
if (result != INVALID_HANDLE_VALUE)
|
|
*retv = result,
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
*retv = result,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x000F: /* NtCloseSection */
|
|
/*
|
|
* Input: EDX: Flat address of arguments on stack
|
|
*
|
|
* HANDLE32 handle [in] Handle of Section to close
|
|
* DWORD *id [out] Unique ID (?? unclear ??)
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
HANDLE handle = (HANDLE)stack[0];
|
|
DWORD *id = (DWORD *)W32S_APP2WINE(stack[1]);
|
|
|
|
TRACE("NtCloseSection(%x, %x)\n", (DWORD)handle, (DWORD)id);
|
|
|
|
CloseHandle(handle);
|
|
if (id) *id = 0; /* FIXME */
|
|
|
|
context->Eax = STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0010: /* NtDupSection */
|
|
/*
|
|
* Input: EDX: Flat address of arguments on stack
|
|
*
|
|
* HANDLE32 handle [in] Handle of Section to duplicate
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
HANDLE handle = (HANDLE)stack[0];
|
|
HANDLE new_handle;
|
|
|
|
TRACE("NtDupSection(%x)\n", (DWORD)handle);
|
|
|
|
DuplicateHandle( GetCurrentProcess(), handle,
|
|
GetCurrentProcess(), &new_handle,
|
|
0, FALSE, DUPLICATE_SAME_ACCESS );
|
|
context->Eax = STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0011: /* NtMapViewOfSection */
|
|
/*
|
|
* Input: EDX: Flat address of arguments on stack
|
|
*
|
|
* HANDLE32 SectionHandle [in] Section to be mapped
|
|
* DWORD ProcessHandle [in] Process to be mapped into
|
|
* DWORD * BaseAddress [in/out] Address to be mapped at
|
|
* DWORD ZeroBits [in] (?? unclear ??)
|
|
* DWORD CommitSize [in] (?? unclear ??)
|
|
* LARGE_INTEGER *SectionOffset [in] Offset within section
|
|
* DWORD * ViewSize [in] Size of view
|
|
* DWORD InheritDisposition [in] (?? unclear ??)
|
|
* DWORD AllocationType [in] (?? unclear ??)
|
|
* DWORD Protect [in] Access protection
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD * stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
HANDLE SectionHandle = (HANDLE)stack[0];
|
|
DWORD ProcessHandle = stack[1]; /* ignored */
|
|
DWORD * BaseAddress = (DWORD *)W32S_APP2WINE(stack[2]);
|
|
DWORD ZeroBits = stack[3];
|
|
DWORD CommitSize = stack[4];
|
|
LARGE_INTEGER *SectionOffset = (LARGE_INTEGER *)W32S_APP2WINE(stack[5]);
|
|
DWORD * ViewSize = (DWORD *)W32S_APP2WINE(stack[6]);
|
|
DWORD InheritDisposition = stack[7];
|
|
DWORD AllocationType = stack[8];
|
|
DWORD Protect = stack[9];
|
|
|
|
LPBYTE address = (LPBYTE)(BaseAddress?
|
|
W32S_APP2WINE(*BaseAddress) : 0);
|
|
DWORD access = 0, result;
|
|
|
|
switch (Protect & ~(PAGE_GUARD|PAGE_NOCACHE))
|
|
{
|
|
case PAGE_READONLY: access = FILE_MAP_READ; break;
|
|
case PAGE_READWRITE: access = FILE_MAP_WRITE; break;
|
|
case PAGE_WRITECOPY: access = FILE_MAP_COPY; break;
|
|
|
|
case PAGE_EXECUTE_READ: access = FILE_MAP_READ; break;
|
|
case PAGE_EXECUTE_READWRITE: access = FILE_MAP_WRITE; break;
|
|
case PAGE_EXECUTE_WRITECOPY: access = FILE_MAP_COPY; break;
|
|
}
|
|
|
|
TRACE("NtMapViewOfSection"
|
|
"(%x, %x, %x, %x, %x, %x, %x, %x, %x, %x)\n",
|
|
(DWORD)SectionHandle, ProcessHandle, (DWORD)BaseAddress,
|
|
ZeroBits, CommitSize, (DWORD)SectionOffset, (DWORD)ViewSize,
|
|
InheritDisposition, AllocationType, Protect);
|
|
TRACE("NtMapViewOfSection: "
|
|
"base=%x, offset=%x, size=%x, access=%x\n",
|
|
(DWORD)address, SectionOffset? SectionOffset->u.LowPart : 0,
|
|
ViewSize? *ViewSize : 0, access);
|
|
|
|
result = (DWORD)MapViewOfFileEx(SectionHandle, access,
|
|
SectionOffset? SectionOffset->u.HighPart : 0,
|
|
SectionOffset? SectionOffset->u.LowPart : 0,
|
|
ViewSize? *ViewSize : 0, address);
|
|
|
|
TRACE("NtMapViewOfSection: result=%x\n", result);
|
|
|
|
if (W32S_WINE2APP(result))
|
|
{
|
|
if (BaseAddress) *BaseAddress = W32S_WINE2APP(result);
|
|
context->Eax = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0012: /* NtUnmapViewOfSection */
|
|
/*
|
|
* Input: EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD ProcessHandle [in] Process (defining address space)
|
|
* LPBYTE BaseAddress [in] Base address of view to be unmapped
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD ProcessHandle = stack[0]; /* ignored */
|
|
LPBYTE BaseAddress = (LPBYTE)W32S_APP2WINE(stack[1]);
|
|
|
|
TRACE("NtUnmapViewOfSection(%x, %x)\n",
|
|
ProcessHandle, (DWORD)BaseAddress);
|
|
|
|
UnmapViewOfFile(BaseAddress);
|
|
|
|
context->Eax = STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0013: /* NtFlushVirtualMemory */
|
|
/*
|
|
* Input: EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD ProcessHandle [in] Process (defining address space)
|
|
* LPBYTE *BaseAddress [in?] Base address of range to be flushed
|
|
* DWORD *ViewSize [in?] Number of bytes to be flushed
|
|
* DWORD *unknown [???] (?? unknown ??)
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD ProcessHandle = stack[0]; /* ignored */
|
|
DWORD *BaseAddress = (DWORD *)W32S_APP2WINE(stack[1]);
|
|
DWORD *ViewSize = (DWORD *)W32S_APP2WINE(stack[2]);
|
|
DWORD *unknown = (DWORD *)W32S_APP2WINE(stack[3]);
|
|
|
|
LPBYTE address = (LPBYTE)(BaseAddress? W32S_APP2WINE(*BaseAddress) : 0);
|
|
DWORD size = ViewSize? *ViewSize : 0;
|
|
|
|
TRACE("NtFlushVirtualMemory(%x, %x, %x, %x)\n",
|
|
ProcessHandle, (DWORD)BaseAddress, (DWORD)ViewSize,
|
|
(DWORD)unknown);
|
|
TRACE("NtFlushVirtualMemory: base=%x, size=%x\n",
|
|
(DWORD)address, size);
|
|
|
|
FlushViewOfFile(address, size);
|
|
|
|
context->Eax = STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0014: /* Get/Set Debug Registers */
|
|
/*
|
|
* Input: ECX: 0 if Get, 1 if Set
|
|
*
|
|
* EDX: Get: Flat address of buffer to receive values of
|
|
* debug registers DR0 .. DR7
|
|
* Set: Flat address of buffer containing values of
|
|
* debug registers DR0 .. DR7 to be set
|
|
* Output: None
|
|
*/
|
|
|
|
FIXME("[0014] ECX=%x EDX=%x\n",
|
|
context->Ecx, context->Edx);
|
|
|
|
/* FIXME */
|
|
break;
|
|
|
|
|
|
case 0x0015: /* Set Coprocessor Emulation Flag */
|
|
/*
|
|
* Input: EDX: 0 to deactivate, 1 to activate coprocessor emulation
|
|
*
|
|
* Output: None
|
|
*/
|
|
|
|
TRACE("[0015] EDX=%x\n", context->Edx);
|
|
|
|
/* We don't care, as we always have a coprocessor anyway */
|
|
break;
|
|
|
|
|
|
case 0x0016: /* Init Win32S VxD PSP */
|
|
/*
|
|
* If called to query required PSP size:
|
|
*
|
|
* Input: EBX: 0
|
|
* Output: EDX: Required size of Win32s VxD PSP
|
|
*
|
|
* If called to initialize allocated PSP:
|
|
*
|
|
* Input: EBX: LoWord: Selector of Win32s VxD PSP
|
|
* HiWord: Paragraph of Win32s VxD PSP (DOSMEM)
|
|
* Output: None
|
|
*/
|
|
|
|
if (context->Ebx == 0)
|
|
context->Edx = 0x80;
|
|
else
|
|
{
|
|
PDB16 *psp = MapSL( MAKESEGPTR( BX_reg(context), 0 ));
|
|
psp->nbFiles = 32;
|
|
psp->fileHandlesPtr = MAKELONG(HIWORD(context->Ebx), 0x5c);
|
|
memset((LPBYTE)psp + 0x5c, '\xFF', 32);
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0017: /* Set Break Point */
|
|
/*
|
|
* Input: EBX: Offset of Break Point
|
|
* CX: Selector of Break Point
|
|
*
|
|
* Output: None
|
|
*/
|
|
|
|
FIXME("[0017] EBX=%x CX=%x\n",
|
|
context->Ebx, CX_reg(context));
|
|
|
|
/* FIXME */
|
|
break;
|
|
|
|
|
|
case 0x0018: /* VirtualLock */
|
|
/*
|
|
* Input: ECX: Current Process
|
|
*
|
|
* EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD *retv [out] TRUE if success, FALSE if failure
|
|
* LPVOID base [in] Flat address of range to lock
|
|
* DWORD size [in] Size of range
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
|
|
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
|
|
DWORD size = stack[2];
|
|
DWORD result;
|
|
|
|
TRACE("VirtualLock(%x, %x, %x)\n",
|
|
(DWORD)retv, (DWORD)base, size);
|
|
|
|
result = VirtualLock(base, size);
|
|
|
|
if (result)
|
|
*retv = TRUE,
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
*retv = FALSE,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x0019: /* VirtualUnlock */
|
|
/*
|
|
* Input: ECX: Current Process
|
|
*
|
|
* EDX: Flat address of arguments on stack
|
|
*
|
|
* DWORD *retv [out] TRUE if success, FALSE if failure
|
|
* LPVOID base [in] Flat address of range to unlock
|
|
* DWORD size [in] Size of range
|
|
*
|
|
* Output: EAX: NtStatus
|
|
*/
|
|
{
|
|
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
|
|
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
|
|
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
|
|
DWORD size = stack[2];
|
|
DWORD result;
|
|
|
|
TRACE("VirtualUnlock(%x, %x, %x)\n",
|
|
(DWORD)retv, (DWORD)base, size);
|
|
|
|
result = VirtualUnlock(base, size);
|
|
|
|
if (result)
|
|
*retv = TRUE,
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
*retv = FALSE,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x001A: /* KGetSystemInfo */
|
|
/*
|
|
* Input: None
|
|
*
|
|
* Output: ECX: Start of sparse memory arena
|
|
* EDX: End of sparse memory arena
|
|
*/
|
|
|
|
TRACE("KGetSystemInfo()\n");
|
|
|
|
/*
|
|
* Note: Win32s reserves 0GB - 2GB for Win 3.1 and uses 2GB - 4GB as
|
|
* sparse memory arena. We do it the other way around, since
|
|
* we have to reserve 3GB - 4GB for Linux, and thus use
|
|
* 0GB - 3GB as sparse memory arena.
|
|
*
|
|
* FIXME: What about other OSes ?
|
|
*/
|
|
|
|
context->Ecx = W32S_WINE2APP(0x00000000);
|
|
context->Edx = W32S_WINE2APP(0xbfffffff);
|
|
break;
|
|
|
|
|
|
case 0x001B: /* KGlobalMemStat */
|
|
/*
|
|
* Input: ESI: Flat address of buffer to receive memory info
|
|
*
|
|
* Output: None
|
|
*/
|
|
{
|
|
struct Win32sMemoryInfo
|
|
{
|
|
DWORD DIPhys_Count; /* Total physical pages */
|
|
DWORD DIFree_Count; /* Free physical pages */
|
|
DWORD DILin_Total_Count; /* Total virtual pages (private arena) */
|
|
DWORD DILin_Total_Free; /* Free virtual pages (private arena) */
|
|
|
|
DWORD SparseTotal; /* Total size of sparse arena (bytes ?) */
|
|
DWORD SparseFree; /* Free size of sparse arena (bytes ?) */
|
|
};
|
|
|
|
struct Win32sMemoryInfo *info =
|
|
(struct Win32sMemoryInfo *)W32S_APP2WINE(context->Esi);
|
|
|
|
FIXME("KGlobalMemStat(%x)\n", (DWORD)info);
|
|
|
|
/* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x001C: /* Enable/Disable Exceptions */
|
|
/*
|
|
* Input: ECX: 0 to disable, 1 to enable exception handling
|
|
*
|
|
* Output: None
|
|
*/
|
|
|
|
TRACE("[001c] ECX=%x\n", context->Ecx);
|
|
|
|
/* FIXME */
|
|
break;
|
|
|
|
|
|
case 0x001D: /* VirtualAlloc called from 16-bit code */
|
|
/*
|
|
* Input: EDX: Segmented address of arguments on stack
|
|
*
|
|
* LPVOID base [in] Flat address of region to reserve/commit
|
|
* DWORD size [in] Size of region
|
|
* DWORD type [in] Type of allocation
|
|
* DWORD prot [in] Type of access protection
|
|
*
|
|
* Output: EAX: NtStatus
|
|
* EDX: Flat base address of allocated region
|
|
*/
|
|
{
|
|
DWORD *stack = MapSL( MAKESEGPTR( LOWORD(context->Edx), HIWORD(context->Edx) ));
|
|
LPVOID base = (LPVOID)W32S_APP2WINE(stack[0]);
|
|
DWORD size = stack[1];
|
|
DWORD type = stack[2];
|
|
DWORD prot = stack[3];
|
|
DWORD result;
|
|
|
|
TRACE("VirtualAlloc16(%x, %x, %x, %x)\n",
|
|
(DWORD)base, size, type, prot);
|
|
|
|
if (type & 0x80000000)
|
|
{
|
|
WARN("VirtualAlloc16: strange type %x\n", type);
|
|
type &= 0x7fffffff;
|
|
}
|
|
|
|
result = (DWORD)VirtualAlloc(base, size, type, prot);
|
|
|
|
if (W32S_WINE2APP(result))
|
|
context->Edx = W32S_WINE2APP(result),
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
context->Edx = 0,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
TRACE("VirtualAlloc16: returning base %x\n", context->Edx);
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x001E: /* VirtualFree called from 16-bit code */
|
|
/*
|
|
* Input: EDX: Segmented address of arguments on stack
|
|
*
|
|
* LPVOID base [in] Flat address of region
|
|
* DWORD size [in] Size of region
|
|
* DWORD type [in] Type of operation
|
|
*
|
|
* Output: EAX: NtStatus
|
|
* EDX: TRUE if success, FALSE if failure
|
|
*/
|
|
{
|
|
DWORD *stack = MapSL( MAKESEGPTR( LOWORD(context->Edx), HIWORD(context->Edx) ));
|
|
LPVOID base = (LPVOID)W32S_APP2WINE(stack[0]);
|
|
DWORD size = stack[1];
|
|
DWORD type = stack[2];
|
|
DWORD result;
|
|
|
|
TRACE("VirtualFree16(%x, %x, %x)\n",
|
|
(DWORD)base, size, type);
|
|
|
|
result = VirtualFree(base, size, type);
|
|
|
|
if (result)
|
|
context->Edx = TRUE,
|
|
context->Eax = STATUS_SUCCESS;
|
|
else
|
|
context->Edx = FALSE,
|
|
context->Eax = STATUS_NO_MEMORY; /* FIXME */
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x001F: /* FWorkingSetSize */
|
|
/*
|
|
* Input: EDX: 0 if Get, 1 if Set
|
|
*
|
|
* ECX: Get: Buffer to receive Working Set Size
|
|
* Set: Buffer containing Working Set Size
|
|
*
|
|
* Output: NtStatus
|
|
*/
|
|
{
|
|
DWORD *ptr = (DWORD *)W32S_APP2WINE(context->Ecx);
|
|
BOOL set = context->Edx;
|
|
|
|
TRACE("FWorkingSetSize(%x, %x)\n", (DWORD)ptr, (DWORD)set);
|
|
|
|
if (set)
|
|
/* We do it differently ... */;
|
|
else
|
|
*ptr = 0x100;
|
|
|
|
context->Eax = STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
VXD_BARF( context, "W32S" );
|
|
}
|
|
}
|