msdos/vxd.c

   1 /*
   2  * VxD emulation
   3  *
   4  * Copyright 1995 Anand Kumria
   5  */
   6
   7 #include <fcntl.h>
   8 #include <memory.h>
   9 #include <sys/types.h>
  10 #include <unistd.h>
  11 #include "winbase.h"
  12 #include "windef.h"
  13 #include "wingdi.h"
  14 #include "winuser.h"
  15 #include "wine/winbase16.h"
  16 #include "wine/winuser16.h"
  17 #include "msdos.h"
  18 #include "miscemu.h"
  19 #include "selectors.h"
  20 #include "neexe.h"
  21 #include "task.h"
  22 #include "process.h"
  23 #include "file.h"
  24 #include "debugtools.h"
  25
  26 DEFAULT_DEBUG_CHANNEL(vxd);
  27
  28
  29 #define VXD_BARF(context,name) \
  30     DPRINTF( "vxd %s: unknown/not implemented parameters:\n" \
  31                      "vxd %s: AX %04x, BX %04x, CX %04x, DX %04x, " \
  32                      "SI %04x, DI %04x, DS %04x, ES %04x\n", \
  33              (name), (name), AX_reg(context), BX_reg(context), \
  34              CX_reg(context), DX_reg(context), SI_reg(context), \
  35              DI_reg(context), (WORD)context->SegDs, (WORD)context->SegEs )
  36
  37
  38 static WORD VXD_WinVersion(void)
  39 {
  40     WORD version = LOWORD(GetVersion16());
  41     return (version >> 8) | (version << 8);
  42 }
  43
  44 /***********************************************************************
  45  *           VXD_VMM
  46  */
  47 void WINAPI VXD_VMM ( CONTEXT86 *context )
  48 {
  49     unsigned service = AX_reg(context);
  50
  51     TRACE("[%04x] VMM\n", (UINT16)service);
  52
  53     switch(service)
  54     {
  55     case 0x0000: /* version */
  56         AX_reg(context) = VXD_WinVersion();
  57         RESET_CFLAG(context);
  58         break;
  59
  60     case 0x026d: /* Get_Debug_Flag '/m' */
  61     case 0x026e: /* Get_Debug_Flag '/n' */
  62         AL_reg(context) = 0;
  63         RESET_CFLAG(context);
  64         break;
  65
  66     default:
  67         VXD_BARF( context, "VMM" );
  68     }
  69 }
  70
  71 /***********************************************************************
  72  *           VXD_PageFile
  73  */
  74 void WINAPI VXD_PageFile( CONTEXT86 *context )
  75 {
  76     unsigned    service = AX_reg(context);
  77
  78     /* taken from Ralf Brown's Interrupt List */
  79
  80     TRACE("[%04x] PageFile\n", (UINT16)service );
  81
  82     switch(service)
  83     {
  84     case 0x00: /* get version, is this windows version? */
  85         TRACE("returning version\n");
  86         AX_reg(context) = VXD_WinVersion();
  87         RESET_CFLAG(context);
  88         break;
  89
  90     case 0x01: /* get swap file info */
  91         TRACE("VxD PageFile: returning swap file info\n");
  92         AX_reg(context) = 0x00; /* paging disabled */
  93         context->Ecx = 0;   /* maximum size of paging file */
  94         /* FIXME: do I touch DS:SI or DS:DI? */
  95         RESET_CFLAG(context);
  96         break;
  97
  98     case 0x02: /* delete permanent swap on exit */
  99         TRACE("VxD PageFile: supposed to delete swap\n");
 100         RESET_CFLAG(context);
 101         break;
 102
 103     case 0x03: /* current temporary swap file size */
 104         TRACE("VxD PageFile: what is current temp. swap size\n");
 105         RESET_CFLAG(context);
 106         break;
 107
 108     case 0x04: /* read or write?? INTERRUP.D */
 109     case 0x05: /* cancel?? INTERRUP.D */
 110     case 0x06: /* test I/O valid INTERRUP.D */
 111     default:
 112         VXD_BARF( context, "pagefile" );
 113         break;
 114     }
 115 }
 116
 117 /***********************************************************************
 118  *           VXD_Reboot
 119  */
 120 void WINAPI VXD_Reboot ( CONTEXT86 *context )
 121 {
 122     unsigned service = AX_reg(context);
 123
 124     TRACE("[%04x] Reboot\n", (UINT16)service);
 125
 126     switch(service)
 127     {
 128     case 0x0000: /* version */
 129         AX_reg(context) = VXD_WinVersion();
 130         RESET_CFLAG(context);
 131         break;
 132
 133     default:
 134         VXD_BARF( context, "REBOOT" );
 135     }
 136 }
 137
 138 /***********************************************************************
 139  *           VXD_VDD
 140  */
 141 void WINAPI VXD_VDD ( CONTEXT86 *context )
 142 {
 143     unsigned service = AX_reg(context);
 144
 145     TRACE("[%04x] VDD\n", (UINT16)service);
 146
 147     switch(service)
 148     {
 149     case 0x0000: /* version */
 150         AX_reg(context) = VXD_WinVersion();
 151         RESET_CFLAG(context);
 152         break;
 153
 154     default:
 155         VXD_BARF( context, "VDD" );
 156     }
 157 }
 158
 159 /***********************************************************************
 160  *           VXD_VMD
 161  */
 162 void WINAPI VXD_VMD ( CONTEXT86 *context )
 163 {
 164     unsigned service = AX_reg(context);
 165
 166     TRACE("[%04x] VMD\n", (UINT16)service);
 167
 168     switch(service)
 169     {
 170     case 0x0000: /* version */
 171         AX_reg(context) = VXD_WinVersion();
 172         RESET_CFLAG(context);
 173         break;
 174
 175     default:
 176         VXD_BARF( context, "VMD" );
 177     }
 178 }
 179
 180 /***********************************************************************
 181  *           VXD_VXDLoader
 182  */
 183 void WINAPI VXD_VXDLoader( CONTEXT86 *context )
 184 {
 185     unsigned service = AX_reg(context);
 186
 187     TRACE("[%04x] VXDLoader\n", (UINT16)service);
 188
 189     switch (service)
 190     {
 191     case 0x0000: /* get version */
 192         TRACE("returning version\n");
 193         AX_reg(context) = 0x0000;
 194         DX_reg(context) = VXD_WinVersion();
 195         RESET_CFLAG(context);
 196         break;
 197
 198     case 0x0001: /* load device */
 199         FIXME("load device %04lx:%04x (%s)\n",
 200               context->SegDs, DX_reg(context),
 201               debugstr_a(PTR_SEG_OFF_TO_LIN(context->SegDs, DX_reg(context))));
 202         AX_reg(context) = 0x0000;
 203         context->SegEs = 0x0000;
 204         DI_reg(context) = 0x0000;
 205         RESET_CFLAG(context);
 206         break;
 207
 208     case 0x0002: /* unload device */
 209         FIXME("unload device (%08lx)\n", context->Ebx);
 210         AX_reg(context) = 0x0000;
 211         RESET_CFLAG(context);
 212         break;
 213
 214     default:
 215         VXD_BARF( context, "VXDLDR" );
 216         AX_reg(context) = 0x000B; /* invalid function number */
 217         SET_CFLAG(context);
 218         break;
 219     }
 220 }
 221
 222 /***********************************************************************
 223  *           VXD_Shell
 224  */
 225 void WINAPI VXD_Shell( CONTEXT86 *context )
 226 {
 227     unsigned    service = DX_reg(context);
 228
 229     TRACE("[%04x] Shell\n", (UINT16)service);
 230
 231     switch (service) /* Ralf Brown says EDX, but I use DX instead */
 232     {
 233     case 0x0000:
 234         TRACE("returning version\n");
 235         AX_reg(context) = VXD_WinVersion();
 236         context->Ebx = 1; /* system VM Handle */
 237         break;
 238
 239     case 0x0001:
 240     case 0x0002:
 241     case 0x0003:
 242         /* SHELL_SYSMODAL_Message
 243         ebx virtual maschine handle
 244         eax message box flags
 245         ecx address of message
 246         edi address of caption
 247         return response in eax
 248         */
 249     case 0x0004:
 250         /* SHELL_Message
 251         ebx virtual maschine handle
 252         eax message box flags
 253         ecx address of message
 254         edi address of caption
 255         esi address callback
 256         edx reference data for callback
 257         return response in eax
 258         */
 259     case 0x0005:
 260         VXD_BARF( context, "shell" );
 261         break;
 262
 263     case 0x0006: /* SHELL_Get_VM_State */
 264         TRACE("VxD Shell: returning VM state\n");
 265         /* Actually we don't, not yet. We have to return a structure
 266          * and I am not to sure how to set it up and return it yet,
 267          * so for now let's do nothing. I can (hopefully) get this
 268          * by the next release
 269          */
 270         /* RESET_CFLAG(context); */
 271         break;
 272
 273     case 0x0007:
 274     case 0x0008:
 275     case 0x0009:
 276     case 0x000A:
 277     case 0x000B:
 278     case 0x000C:
 279     case 0x000D:
 280     case 0x000E:
 281     case 0x000F:
 282     case 0x0010:
 283     case 0x0011:
 284     case 0x0012:
 285     case 0x0013:
 286     case 0x0014:
 287     case 0x0015:
 288     case 0x0016:
 289         VXD_BARF( context, "SHELL" );
 290         break;
 291
 292     /* the new Win95 shell API */
 293     case 0x0100:     /* get version */
 294         AX_reg(context) = VXD_WinVersion();
 295         break;
 296
 297     case 0x0104:   /* retrieve Hook_Properties list */
 298     case 0x0105:   /* call Hook_Properties callbacks */
 299         VXD_BARF( context, "SHELL" );
 300         break;
 301
 302     case 0x0106:   /* install timeout callback */
 303         TRACE("VxD Shell: ignoring shell callback (%ld sec.)\n", context->Ebx);
 304         SET_CFLAG(context);
 305         break;
 306
 307     case 0x0107:   /* get version of any VxD */
 308     default:
 309         VXD_BARF( context, "SHELL" );
 310         break;
 311     }
 312 }
 313
 314
 315 /***********************************************************************
 316  *           VXD_Comm
 317  */
 318 void WINAPI VXD_Comm( CONTEXT86 *context )
 319 {
 320     unsigned    service = AX_reg(context);
 321
 322     TRACE("[%04x] Comm\n", (UINT16)service);
 323
 324     switch (service)
 325     {
 326     case 0x0000: /* get version */
 327         TRACE("returning version\n");
 328         AX_reg(context) = VXD_WinVersion();
 329         RESET_CFLAG(context);
 330         break;
 331
 332     case 0x0001: /* set port global */
 333     case 0x0002: /* get focus */
 334     case 0x0003: /* virtualise port */
 335     default:
 336         VXD_BARF( context, "comm" );
 337     }
 338 }
 339
 340 /***********************************************************************
 341  *           VXD_Timer
 342  */
 343 void WINAPI VXD_Timer( CONTEXT86 *context )
 344 {
 345     unsigned service = AX_reg(context);
 346
 347     TRACE("[%04x] Virtual Timer\n", (UINT16)service);
 348
 349     switch(service)
 350     {
 351     case 0x0000: /* version */
 352         AX_reg(context) = VXD_WinVersion();
 353         RESET_CFLAG(context);
 354         break;
 355
 356     case 0x0100: /* clock tick time, in 840nsecs */
 357         context->Eax = GetTickCount();
 358
 359         context->Edx = context->Eax >> 22;
 360         context->Eax <<= 10; /* not very precise */
 361         break;
 362
 363     case 0x0101: /* current Windows time, msecs */
 364     case 0x0102: /* current VM time, msecs */
 365         context->Eax = GetTickCount();
 366         break;
 367
 368     default:
 369         VXD_BARF( context, "VTD" );
 370     }
 371 }
 372
 373 /***********************************************************************
 374  *           VXD_TimerAPI
 375  */
 376 static DWORD System_Time = 0;
 377 static WORD  System_Time_Selector = 0;
 378 static void  System_Time_Tick( WORD timer ) { System_Time += 55; }
 379 void WINAPI VXD_TimerAPI ( CONTEXT86 *context )
 380 {
 381     unsigned service = AX_reg(context);
 382
 383     TRACE("[%04x] TimerAPI\n", (UINT16)service);
 384
 385     switch(service)
 386     {
 387     case 0x0000: /* version */
 388         AX_reg(context) = VXD_WinVersion();
 389         RESET_CFLAG(context);
 390         break;
 391
 392     case 0x0009: /* get system time selector */
 393         if ( !System_Time_Selector )
 394         {
 395             System_Time_Selector = SELECTOR_AllocBlock( &System_Time, sizeof(DWORD), WINE_LDT_FLAGS_DATA );
 396             CreateSystemTimer( 55, System_Time_Tick );
 397         }
 398
 399         AX_reg(context) = System_Time_Selector;
 400         RESET_CFLAG(context);
 401         break;
 402
 403     default:
 404         VXD_BARF( context, "VTDAPI" );
 405     }
 406 }
 407
 408 /***********************************************************************
 409  *           VXD_ConfigMG
 410  */
 411 void WINAPI VXD_ConfigMG ( CONTEXT86 *context )
 412 {
 413     unsigned service = AX_reg(context);
 414
 415     TRACE("[%04x] ConfigMG\n", (UINT16)service);
 416
 417     switch(service)
 418     {
 419     case 0x0000: /* version */
 420         AX_reg(context) = VXD_WinVersion();
 421         RESET_CFLAG(context);
 422         break;
 423
 424     default:
 425         VXD_BARF( context, "CONFIGMG" );
 426     }
 427 }
 428
 429 /***********************************************************************
 430  *           VXD_Enable
 431  */
 432 void WINAPI VXD_Enable ( CONTEXT86 *context )
 433 {
 434     unsigned service = AX_reg(context);
 435
 436     TRACE("[%04x] Enable\n", (UINT16)service);
 437
 438     switch(service)
 439     {
 440     case 0x0000: /* version */
 441         AX_reg(context) = VXD_WinVersion();
 442         RESET_CFLAG(context);
 443         break;
 444
 445     default:
 446         VXD_BARF( context, "ENABLE" );
 447     }
 448 }
 449
 450 /***********************************************************************
 451  *           VXD_APM
 452  */
 453 void WINAPI VXD_APM ( CONTEXT86 *context )
 454 {
 455     unsigned service = AX_reg(context);
 456
 457     TRACE("[%04x] APM\n", (UINT16)service);
 458
 459     switch(service)
 460     {
 461     case 0x0000: /* version */
 462         AX_reg(context) = VXD_WinVersion();
 463         RESET_CFLAG(context);
 464         break;
 465
 466     default:
 467         VXD_BARF( context, "APM" );
 468     }
 469 }
 470
 471 /***********************************************************************
 472  *           VXD_Win32s
 473  *
 474  * This is an implementation of the services of the Win32s VxD.
 475  * Since official documentation of these does not seem to be available,
 476  * certain arguments of some of the services remain unclear.
 477  *
 478  * FIXME: The following services are currently unimplemented:
 479  *        Exception handling      (0x01, 0x1C)
 480  *        Debugger support        (0x0C, 0x14, 0x17)
 481  *        Low-level memory access (0x02, 0x03, 0x0A, 0x0B)
 482  *        Memory Statistics       (0x1B)
 483  *
 484  *
 485  * We have a specific problem running Win32s on Linux (and probably also
 486  * the other x86 unixes), since Win32s tries to allocate its main 'flat
 487  * code/data segment' selectors with a base of 0xffff0000 (and limit 4GB).
 488  * The rationale for this seems to be that they want one the one hand to
 489  * be able to leave the Win 3.1 memory (starting with the main DOS memory)
 490  * at linear address 0, but want at other hand to have offset 0 of the
 491  * flat data/code segment point to an unmapped page (to catch NULL pointer
 492  * accesses). Hence they allocate the flat segments with a base of 0xffff0000
 493  * so that the Win 3.1 memory area at linear address zero shows up in the
 494  * flat segments at offset 0x10000 (since linear addresses wrap around at
 495  * 4GB). To compensate for that discrepancy between flat segment offsets
 496  * and plain linear addresses, all flat pointers passed between the 32-bit
 497  * and the 16-bit parts of Win32s are shifted by 0x10000 in the appropriate
 498  * direction by the glue code (mainly) in W32SKRNL and WIN32S16.
 499  *
 500  * The problem for us is now that Linux does not allow a LDT selector with
 501  * base 0xffff0000 to be created, since it would 'see' a part of the kernel
 502  * address space. To address this problem we introduce *another* offset:
 503  * We add 0x10000 to every linear address we get as an argument from Win32s.
 504  * This means especially that the flat code/data selectors get actually
 505  * allocated with base 0x0, so that flat offsets and (real) linear addresses
 506  * do again agree!  In fact, every call e.g. of a Win32s VxD service now
 507  * has all pointer arguments (which are offsets in the flat data segement)
 508  * first reduced by 0x10000 by the W32SKRNL glue code, and then again
 509  * increased by 0x10000 by *our* code.
 510  *
 511  * Note that to keep everything consistent, this offset has to be applied by
 512  * every Wine function that operates on 'linear addresses' passed to it by
 513  * Win32s. Fortunately, since Win32s does not directly call any Wine 32-bit
 514  * API routines, this affects only two locations: this VxD and the DPMI
 515  * handler. (NOTE: Should any Win32s application pass a linear address to
 516  * any routine apart from those, e.g. some other VxD handler, that code
 517  * would have to take the offset into account as well!)
 518  *
 519  * The application of the offset is triggered by marking the current process
 520  * as a Win32s process by setting the PDB32_WIN32S_PROC flag in the process
 521  * database. This is done the first time any application calls the GetVersion()
 522  * service of the Win32s VxD. (Note that the flag is never removed.)
 523  *
 524  */
 525
 526 void WINAPI VXD_Win32s( CONTEXT86 *context )
 527 {
 528     switch (AX_reg(context))
 529     {
 530     case 0x0000: /* Get Version */
 531         /*
 532          * Input:   None
 533          *
 534          * Output:  EAX: LoWord: Win32s Version (1.30)
 535          *               HiWord: VxD Version (200)
 536          *
 537          *          EBX: Build (172)
 538          *
 539          *          ECX: ???   (1)
 540          *
 541          *          EDX: Debugging Flags
 542          *
 543          *          EDI: Error Flag
 544          *               0 if OK,
 545          *               1 if VMCPD VxD not found
 546          */
 547
 548         TRACE("GetVersion()\n");
 549
 550         context->Eax = VXD_WinVersion() | (200 << 16);
 551         context->Ebx = 0;
 552         context->Ecx = 0;
 553         context->Edx = 0;
 554         context->Edi = 0;
 555
 556         /*
 557          * If this is the first time we are called for this process,
 558          * hack the memory image of WIN32S16 so that it doesn't try
 559          * to access the GDT directly ...
 560          *
 561          * The first code segment of WIN32S16 (version 1.30) contains
 562          * an unexported function somewhere between the exported functions
 563          * SetFS and StackLinearToSegmented that tries to find a selector
 564          * in the LDT that maps to the memory image of the LDT itself.
 565          * If it succeeds, it stores this selector into a global variable
 566          * which will be used to speed up execution by using this selector
 567          * to modify the LDT directly instead of using the DPMI calls.
 568          *
 569          * To perform this search of the LDT, this function uses the
 570          * sgdt and sldt instructions to find the linear address of
 571          * the (GDT and then) LDT. While those instructions themselves
 572          * execute without problem, the linear address that sgdt returns
 573          * points (at least under Linux) to the kernel address space, so
 574          * that any subsequent access leads to a segfault.
 575          *
 576          * Fortunately, WIN32S16 still contains as a fallback option the
 577          * mechanism of using DPMI calls to modify LDT selectors instead
 578          * of direct writes to the LDT. Thus we can circumvent the problem
 579          * by simply replacing the first byte of the offending function
 580          * with an 'retf' instruction. This means that the global variable
 581          * supposed to contain the LDT alias selector will remain zero,
 582          * and hence WIN32S16 will fall back to using DPMI calls.
 583          *
 584          * The heuristic we employ to _find_ that function is as follows:
 585          * We search between the addresses of the exported symbols SetFS
 586          * and StackLinearToSegmented for the byte sequence '0F 01 04'
 587          * (this is the opcode of 'sgdt [si]'). We then search backwards
 588          * from this address for the last occurrance of 'CB' (retf) that marks
 589          * the end of the preceeding function. The following byte (which
 590          * should now be the first byte of the function we are looking for)
 591          * will be replaced by 'CB' (retf).
 592          *
 593          * This heuristic works for the retail as well as the debug version
 594          * of Win32s version 1.30. For versions earlier than that this
 595          * hack should not be necessary at all, since the whole mechanism
 596          * ('PERF130') was introduced only in 1.30 to improve the overall
 597          * performance of Win32s.
 598          */
 599
 600         if (!(PROCESS_Current()->flags & PDB32_WIN32S_PROC))
 601         {
 602             HMODULE16 hModule = GetModuleHandle16("win32s16");
 603             SEGPTR func1 = (SEGPTR)GetProcAddress16(hModule, "SetFS");
 604             SEGPTR func2 = (SEGPTR)GetProcAddress16(hModule, "StackLinearToSegmented");
 605
 606             if (   hModule && func1 && func2
 607                 && SELECTOROF(func1) == SELECTOROF(func2))
 608             {
 609                 BYTE *start = PTR_SEG_TO_LIN(func1);
 610                 BYTE *end   = PTR_SEG_TO_LIN(func2);
 611                 BYTE *p, *retv = NULL;
 612                 int found = 0;
 613
 614                 for (p = start; p < end; p++)
 615                     if (*p == 0xCB) found = 0, retv = p;
 616                     else if (*p == 0x0F) found = 1;
 617                     else if (*p == 0x01 && found == 1) found = 2;
 618                     else if (*p == 0x04 && found == 2) { found = 3; break; }
 619                     else found = 0;
 620
 621                 if (found == 3 && retv)
 622                 {
 623                     TRACE("PERF130 hack: "
 624                                "Replacing byte %02X at offset %04X:%04X\n",
 625                                *(retv+1), SELECTOROF(func1),
 626                                           OFFSETOF(func1) + retv+1-start);
 627
 628                     *(retv+1) = (BYTE)0xCB;
 629                 }
 630             }
 631         }
 632
 633         /*
 634          * Mark process as Win32s, so that subsequent DPMI calls
 635          * will perform the W32S_APP2WINE/W32S_WINE2APP address shift.
 636          */
 637
 638         PROCESS_Current()->flags |= PDB32_WIN32S_PROC;
 639         break;
 640
 641
 642     case 0x0001: /* Install Exception Handling */
 643         /*
 644          * Input:   EBX: Flat address of W32SKRNL Exception Data
 645          *
 646          *          ECX: LoWord: Flat Code Selector
 647          *               HiWord: Flat Data Selector
 648          *
 649          *          EDX: Flat address of W32SKRNL Exception Handler
 650          *               (this is equal to W32S_BackTo32 + 0x40)
 651          *
 652          *          ESI: SEGPTR KERNEL.HASGPHANDLER
 653          *
 654          *          EDI: SEGPTR phCurrentTask (KERNEL.THHOOK + 0x10)
 655          *
 656          * Output:  EAX: 0 if OK
 657          */
 658
 659         TRACE("[0001] EBX=%lx ECX=%lx EDX=%lx ESI=%lx EDI=%lx\n",
 660                    context->Ebx, context->Ecx, context->Edx,
 661                    context->Esi, context->Edi);
 662
 663         /* FIXME */
 664
 665         context->Eax = 0;
 666         break;
 667
 668
 669     case 0x0002: /* Set Page Access Flags */
 670         /*
 671          * Input:   EBX: New access flags
 672          *               Bit 2: User Page if set, Supervisor Page if clear
 673          *               Bit 1: Read-Write if set, Read-Only if clear
 674          *
 675          *          ECX: Size of memory area to change
 676          *
 677          *          EDX: Flat start address of memory area
 678          *
 679          * Output:  EAX: Size of area changed
 680          */
 681
 682         TRACE("[0002] EBX=%lx ECX=%lx EDX=%lx\n",
 683                    context->Ebx, context->Ecx, context->Edx);
 684
 685         /* FIXME */
 686
 687         context->Eax = context->Ecx;
 688         break;
 689
 690
 691     case 0x0003: /* Get Page Access Flags */
 692         /*
 693          * Input:   EDX: Flat address of page to query
 694          *
 695          * Output:  EAX: Page access flags
 696          *               Bit 2: User Page if set, Supervisor Page if clear
 697          *               Bit 1: Read-Write if set, Read-Only if clear
 698          */
 699
 700         TRACE("[0003] EDX=%lx\n", context->Edx);
 701
 702         /* FIXME */
 703
 704         context->Eax = 6;
 705         break;
 706
 707
 708     case 0x0004: /* Map Module */
 709         /*
 710          * Input:   ECX: IMTE (offset in Module Table) of new module
 711          *
 712          *          EDX: Flat address of Win32s Module Table
 713          *
 714          * Output:  EAX: 0 if OK
 715          */
 716
 717     if (!context->Edx || CX_reg(context) == 0xFFFF)
 718     {
 719         TRACE("MapModule: Initialization call\n");
 720         context->Eax = 0;
 721     }
 722     else
 723     {
 724         /*
 725          * Structure of a Win32s Module Table Entry:
 726          */
 727         struct Win32sModule
 728         {
 729             DWORD  flags;
 730             DWORD  flatBaseAddr;
 731             LPCSTR moduleName;
 732             LPCSTR pathName;
 733             LPCSTR unknown;
 734             LPBYTE baseAddr;
 735             DWORD  hModule;
 736             DWORD  relocDelta;
 737         };
 738
 739         /*
 740          * Note: This function should set up a demand-paged memory image
 741          *       of the given module. Since mmap does not allow file offsets
 742          *       not aligned at 1024 bytes, we simply load the image fully
 743          *       into memory.
 744          */
 745
 746         struct Win32sModule *moduleTable =
 747                             (struct Win32sModule *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
 748         struct Win32sModule *module = moduleTable + context->Ecx;
 749
 750         IMAGE_NT_HEADERS *nt_header = PE_HEADER(module->baseAddr);
 751         IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(module->baseAddr);
 752
 753         HFILE image = _lopen(module->pathName, OF_READ);
 754         BOOL error = (image == HFILE_ERROR);
 755         UINT i;
 756
 757         TRACE("MapModule: Loading %s\n", module->pathName);
 758
 759         for (i = 0;
 760              !error && i < nt_header->FileHeader.NumberOfSections;
 761              i++, pe_seg++)
 762             if(!(pe_seg->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA))
 763             {
 764                 DWORD  off  = pe_seg->PointerToRawData;
 765                 DWORD  len  = pe_seg->SizeOfRawData;
 766                 LPBYTE addr = module->baseAddr + pe_seg->VirtualAddress;
 767
 768                 TRACE("MapModule: "
 769                            "Section %d at %08lx from %08lx len %08lx\n",
 770                            i, (DWORD)addr, off, len);
 771
 772                 if (   _llseek(image, off, SEEK_SET) != off
 773                     || _lread(image, addr, len) != len)
 774                     error = TRUE;
 775             }
 776
 777         _lclose(image);
 778
 779         if (error)
 780             ERR("MapModule: Unable to load %s\n", module->pathName);
 781
 782         else if (module->relocDelta != 0)
 783         {
 784             IMAGE_DATA_DIRECTORY *dir = nt_header->OptionalHeader.DataDirectory
 785                                       + IMAGE_DIRECTORY_ENTRY_BASERELOC;
 786             IMAGE_BASE_RELOCATION *r = (IMAGE_BASE_RELOCATION *)
 787                 (dir->Size? module->baseAddr + dir->VirtualAddress : 0);
 788
 789             TRACE("MapModule: Reloc delta %08lx\n", module->relocDelta);
 790
 791             while (r && r->VirtualAddress)
 792             {
 793                 LPBYTE page  = module->baseAddr + r->VirtualAddress;
 794                 int    count = (r->SizeOfBlock - 8) / 2;
 795
 796                 TRACE("MapModule: %d relocations for page %08lx\n",
 797                            count, (DWORD)page);
 798
 799                 for(i = 0; i < count; i++)
 800                 {
 801                     int offset = r->TypeOffset[i] & 0xFFF;
 802                     int type   = r->TypeOffset[i] >> 12;
 803                     switch(type)
 804                     {
 805                     case IMAGE_REL_BASED_ABSOLUTE:
 806                         break;
 807                     case IMAGE_REL_BASED_HIGH:
 808                         *(WORD *)(page+offset) += HIWORD(module->relocDelta);
 809                         break;
 810                     case IMAGE_REL_BASED_LOW:
 811                         *(WORD *)(page+offset) += LOWORD(module->relocDelta);
 812                         break;
 813                     case IMAGE_REL_BASED_HIGHLOW:
 814                         *(DWORD*)(page+offset) += module->relocDelta;
 815                         break;
 816                     default:
 817                         WARN("MapModule: Unsupported fixup type\n");
 818                         break;
 819                     }
 820                 }
 821
 822                 r = (IMAGE_BASE_RELOCATION *)((LPBYTE)r + r->SizeOfBlock);
 823             }
 824         }
 825
 826         context->Eax = 0;
 827         RESET_CFLAG(context);
 828     }
 829     break;
 830
 831
 832     case 0x0005: /* UnMap Module */
 833         /*
 834          * Input:   EDX: Flat address of module image
 835          *
 836          * Output:  EAX: 1 if OK
 837          */
 838
 839         TRACE("UnMapModule: %lx\n", (DWORD)W32S_APP2WINE(context->Edx, W32S_OFFSET));
 840
 841         /* As we didn't map anything, there's nothing to unmap ... */
 842
 843         context->Eax = 1;
 844         break;
 845
 846
 847     case 0x0006: /* VirtualAlloc */
 848         /*
 849          * Input:   ECX: Current Process
 850          *
 851          *          EDX: Flat address of arguments on stack
 852          *
 853          *   DWORD *retv     [out] Flat base address of allocated region
 854          *   LPVOID base     [in]  Flat address of region to reserve/commit
 855          *   DWORD  size     [in]  Size of region
 856          *   DWORD  type     [in]  Type of allocation
 857          *   DWORD  prot     [in]  Type of access protection
 858          *
 859          * Output:  EAX: NtStatus
 860          */
 861     {
 862         DWORD *stack  = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
 863         DWORD *retv   = (DWORD *)W32S_APP2WINE(stack[0], W32S_OFFSET);
 864         LPVOID base   = (LPVOID) W32S_APP2WINE(stack[1], W32S_OFFSET);
 865         DWORD  size   = stack[2];
 866         DWORD  type   = stack[3];
 867         DWORD  prot   = stack[4];
 868         DWORD  result;
 869
 870         TRACE("VirtualAlloc(%lx, %lx, %lx, %lx, %lx)\n",
 871                    (DWORD)retv, (DWORD)base, size, type, prot);
 872
 873         if (type & 0x80000000)
 874         {
 875             WARN("VirtualAlloc: strange type %lx\n", type);
 876             type &= 0x7fffffff;
 877         }
 878
 879         if (!base && (type & MEM_COMMIT) && prot == PAGE_READONLY)
 880         {
 881             WARN("VirtualAlloc: NLS hack, allowing write access!\n");
 882             prot = PAGE_READWRITE;
 883         }
 884
 885         result = (DWORD)VirtualAlloc(base, size, type, prot);
 886
 887         if (W32S_WINE2APP(result, W32S_OFFSET))
 888             *retv            = W32S_WINE2APP(result, W32S_OFFSET),
 889             context->Eax = STATUS_SUCCESS;
 890         else
 891             *retv            = 0,
 892             context->Eax = STATUS_NO_MEMORY;  /* FIXME */
 893     }
 894     break;
 895
 896
 897     case 0x0007: /* VirtualFree */
 898         /*
 899          * Input:   ECX: Current Process
 900          *
 901          *          EDX: Flat address of arguments on stack
 902          *
 903          *   DWORD *retv     [out] TRUE if success, FALSE if failure
 904          *   LPVOID base     [in]  Flat address of region
 905          *   DWORD  size     [in]  Size of region
 906          *   DWORD  type     [in]  Type of operation
 907          *
 908          * Output:  EAX: NtStatus
 909          */
 910     {
 911         DWORD *stack  = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
 912         DWORD *retv   = (DWORD *)W32S_APP2WINE(stack[0], W32S_OFFSET);
 913         LPVOID base   = (LPVOID) W32S_APP2WINE(stack[1], W32S_OFFSET);
 914         DWORD  size   = stack[2];
 915         DWORD  type   = stack[3];
 916         DWORD  result;
 917
 918         TRACE("VirtualFree(%lx, %lx, %lx, %lx)\n",
 919                    (DWORD)retv, (DWORD)base, size, type);
 920
 921         result = VirtualFree(base, size, type);
 922
 923         if (result)
 924             *retv            = TRUE,
 925             context->Eax = STATUS_SUCCESS;
 926         else
 927             *retv            = FALSE,
 928             context->Eax = STATUS_NO_MEMORY;  /* FIXME */
 929     }
 930     break;
 931
 932
 933     case 0x0008: /* VirtualProtect */
 934         /*
 935          * Input:   ECX: Current Process
 936          *
 937          *          EDX: Flat address of arguments on stack
 938          *
 939          *   DWORD *retv     [out] TRUE if success, FALSE if failure
 940          *   LPVOID base     [in]  Flat address of region
 941          *   DWORD  size     [in]  Size of region
 942          *   DWORD  new_prot [in]  Desired access protection
 943          *   DWORD *old_prot [out] Previous access protection
 944          *
 945          * Output:  EAX: NtStatus
 946          */
 947     {
 948         DWORD *stack    = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
 949         DWORD *retv     = (DWORD *)W32S_APP2WINE(stack[0], W32S_OFFSET);
 950         LPVOID base     = (LPVOID) W32S_APP2WINE(stack[1], W32S_OFFSET);
 951         DWORD  size     = stack[2];
 952         DWORD  new_prot = stack[3];
 953         DWORD *old_prot = (DWORD *)W32S_APP2WINE(stack[4], W32S_OFFSET);
 954         DWORD  result;
 955
 956         TRACE("VirtualProtect(%lx, %lx, %lx, %lx, %lx)\n",
 957                    (DWORD)retv, (DWORD)base, size, new_prot, (DWORD)old_prot);
 958
 959         result = VirtualProtect(base, size, new_prot, old_prot);
 960
 961         if (result)
 962             *retv            = TRUE,
 963             context->Eax = STATUS_SUCCESS;
 964         else
 965             *retv            = FALSE,
 966             context->Eax = STATUS_NO_MEMORY;  /* FIXME */
 967     }
 968     break;
 969
 970
 971     case 0x0009: /* VirtualQuery */
 972         /*
 973          * Input:   ECX: Current Process
 974          *
 975          *          EDX: Flat address of arguments on stack
 976          *
 977          *   DWORD *retv                     [out] Nr. bytes returned
 978          *   LPVOID base                     [in]  Flat address of region
 979          *   LPMEMORY_BASIC_INFORMATION info [out] Info buffer
 980          *   DWORD  len                      [in]  Size of buffer
 981          *
 982          * Output:  EAX: NtStatus
 983          */
 984     {
 985         DWORD *stack  = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
 986         DWORD *retv   = (DWORD *)W32S_APP2WINE(stack[0], W32S_OFFSET);
 987         LPVOID base   = (LPVOID) W32S_APP2WINE(stack[1], W32S_OFFSET);
 988         LPMEMORY_BASIC_INFORMATION info =
 989                         (LPMEMORY_BASIC_INFORMATION)W32S_APP2WINE(stack[2], W32S_OFFSET);
 990         DWORD  len    = stack[3];
 991         DWORD  result;
 992
 993         TRACE("VirtualQuery(%lx, %lx, %lx, %lx)\n",
 994                    (DWORD)retv, (DWORD)base, (DWORD)info, len);
 995
 996         result = VirtualQuery(base, info, len);
 997
 998         *retv            = result;
 999         context->Eax = STATUS_SUCCESS;
1000     }
1001     break;
1002
1003
1004     case 0x000A: /* SetVirtMemProcess */
1005         /*
1006          * Input:   ECX: Process Handle
1007          *
1008          *          EDX: Flat address of region
1009          *
1010          * Output:  EAX: NtStatus
1011          */
1012
1013         TRACE("[000a] ECX=%lx EDX=%lx\n",
1014                    context->Ecx, context->Edx);
1015
1016         /* FIXME */
1017
1018         context->Eax = STATUS_SUCCESS;
1019         break;
1020
1021
1022     case 0x000B: /* ??? some kind of cleanup */
1023         /*
1024          * Input:   ECX: Process Handle
1025          *
1026          * Output:  EAX: NtStatus
1027          */
1028
1029         TRACE("[000b] ECX=%lx\n", context->Ecx);
1030
1031         /* FIXME */
1032
1033         context->Eax = STATUS_SUCCESS;
1034         break;
1035
1036
1037     case 0x000C: /* Set Debug Flags */
1038         /*
1039          * Input:   EDX: Debug Flags
1040          *
1041          * Output:  EDX: Previous Debug Flags
1042          */
1043
1044         FIXME("[000c] EDX=%lx\n", context->Edx);
1045
1046         /* FIXME */
1047
1048         context->Edx = 0;
1049         break;
1050
1051
1052     case 0x000D: /* NtCreateSection */
1053         /*
1054          * Input:   EDX: Flat address of arguments on stack
1055          *
1056          *   HANDLE32 *retv      [out] Handle of Section created
1057          *   DWORD  flags1       [in]  (?? unknown ??)
1058          *   DWORD  atom         [in]  Name of Section to create
1059          *   LARGE_INTEGER *size [in]  Size of Section
1060          *   DWORD  protect      [in]  Access protection
1061          *   DWORD  flags2       [in]  (?? unknown ??)
1062          *   HFILE32 hFile       [in]  Handle of file to map
1063          *   DWORD  psp          [in]  (Win32s: PSP that hFile belongs to)
1064          *
1065          * Output:  EAX: NtStatus
1066          */
1067     {
1068         DWORD *stack    = (DWORD *)   W32S_APP2WINE(context->Edx, W32S_OFFSET);
1069         HANDLE *retv  = (HANDLE *)W32S_APP2WINE(stack[0], W32S_OFFSET);
1070         DWORD  flags1   = stack[1];
1071         DWORD  atom     = stack[2];
1072         LARGE_INTEGER *size = (LARGE_INTEGER *)W32S_APP2WINE(stack[3], W32S_OFFSET);
1073         DWORD  protect  = stack[4];
1074         DWORD  flags2   = stack[5];
1075         HANDLE hFile    = DosFileHandleToWin32Handle(stack[6]);
1076         DWORD  psp      = stack[7];
1077
1078         HANDLE result = INVALID_HANDLE_VALUE;
1079         char name[128];
1080
1081         TRACE("NtCreateSection(%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx)\n",
1082                    (DWORD)retv, flags1, atom, (DWORD)size, protect, flags2,
1083                    (DWORD)hFile, psp);
1084
1085         if (!atom || GlobalGetAtomNameA(atom, name, sizeof(name)))
1086         {
1087             TRACE("NtCreateSection: name=%s\n", atom? name : NULL);
1088
1089             result = CreateFileMappingA(hFile, NULL, protect,
1090                                           size? size->s.HighPart : 0,
1091                                           size? size->s.LowPart  : 0,
1092                                           atom? name : NULL);
1093         }
1094
1095         if (result == INVALID_HANDLE_VALUE)
1096             WARN("NtCreateSection: failed!\n");
1097         else
1098             TRACE("NtCreateSection: returned %lx\n", (DWORD)result);
1099
1100         if (result != INVALID_HANDLE_VALUE)
1101             *retv            = result,
1102             context->Eax = STATUS_SUCCESS;
1103         else
1104             *retv            = result,
1105             context->Eax = STATUS_NO_MEMORY;   /* FIXME */
1106     }
1107     break;
1108
1109
1110     case 0x000E: /* NtOpenSection */
1111         /*
1112          * Input:   EDX: Flat address of arguments on stack
1113          *
1114          *   HANDLE32 *retv  [out] Handle of Section opened
1115          *   DWORD  protect  [in]  Access protection
1116          *   DWORD  atom     [in]  Name of Section to create
1117          *
1118          * Output:  EAX: NtStatus
1119          */
1120     {
1121         DWORD *stack    = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1122         HANDLE *retv  = (HANDLE *)W32S_APP2WINE(stack[0], W32S_OFFSET);
1123         DWORD  protect  = stack[1];
1124         DWORD  atom     = stack[2];
1125
1126         HANDLE result = INVALID_HANDLE_VALUE;
1127         char name[128];
1128
1129         TRACE("NtOpenSection(%lx, %lx, %lx)\n",
1130                    (DWORD)retv, protect, atom);
1131
1132         if (atom && GlobalGetAtomNameA(atom, name, sizeof(name)))
1133         {
1134             TRACE("NtOpenSection: name=%s\n", name);
1135
1136             result = OpenFileMappingA(protect, FALSE, name);
1137         }
1138
1139         if (result == INVALID_HANDLE_VALUE)
1140             WARN("NtOpenSection: failed!\n");
1141         else
1142             TRACE("NtOpenSection: returned %lx\n", (DWORD)result);
1143
1144         if (result != INVALID_HANDLE_VALUE)
1145             *retv            = result,
1146             context->Eax = STATUS_SUCCESS;
1147         else
1148             *retv            = result,
1149             context->Eax = STATUS_NO_MEMORY;   /* FIXME */
1150     }
1151     break;
1152
1153
1154     case 0x000F: /* NtCloseSection */
1155         /*
1156          * Input:   EDX: Flat address of arguments on stack
1157          *
1158          *   HANDLE32 handle  [in]  Handle of Section to close
1159          *   DWORD *id        [out] Unique ID  (?? unclear ??)
1160          *
1161          * Output:  EAX: NtStatus
1162          */
1163     {
1164         DWORD *stack    = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1165         HANDLE handle = stack[0];
1166         DWORD *id       = (DWORD *)W32S_APP2WINE(stack[1], W32S_OFFSET);
1167
1168         TRACE("NtCloseSection(%lx, %lx)\n", (DWORD)handle, (DWORD)id);
1169
1170         CloseHandle(handle);
1171         if (id) *id = 0; /* FIXME */
1172
1173         context->Eax = STATUS_SUCCESS;
1174     }
1175     break;
1176
1177
1178     case 0x0010: /* NtDupSection */
1179         /*
1180          * Input:   EDX: Flat address of arguments on stack
1181          *
1182          *   HANDLE32 handle  [in]  Handle of Section to duplicate
1183          *
1184          * Output:  EAX: NtStatus
1185          */
1186     {
1187         DWORD *stack    = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1188         HANDLE handle = stack[0];
1189         HANDLE new_handle;
1190
1191         TRACE("NtDupSection(%lx)\n", (DWORD)handle);
1192
1193         DuplicateHandle( GetCurrentProcess(), handle,
1194                          GetCurrentProcess(), &new_handle,
1195                          0, FALSE, DUPLICATE_SAME_ACCESS );
1196         context->Eax = STATUS_SUCCESS;
1197     }
1198     break;
1199
1200
1201     case 0x0011: /* NtMapViewOfSection */
1202         /*
1203          * Input:   EDX: Flat address of arguments on stack
1204          *
1205          *   HANDLE32 SectionHandle       [in]     Section to be mapped
1206          *   DWORD    ProcessHandle       [in]     Process to be mapped into
1207          *   DWORD *  BaseAddress         [in/out] Address to be mapped at
1208          *   DWORD    ZeroBits            [in]     (?? unclear ??)
1209          *   DWORD    CommitSize          [in]     (?? unclear ??)
1210          *   LARGE_INTEGER *SectionOffset [in]     Offset within section
1211          *   DWORD *  ViewSize            [in]     Size of view
1212          *   DWORD    InheritDisposition  [in]     (?? unclear ??)
1213          *   DWORD    AllocationType      [in]     (?? unclear ??)
1214          *   DWORD    Protect             [in]     Access protection
1215          *
1216          * Output:  EAX: NtStatus
1217          */
1218     {
1219         DWORD *  stack          = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1220         HANDLE SectionHandle  = stack[0];
1221         DWORD    ProcessHandle  = stack[1]; /* ignored */
1222         DWORD *  BaseAddress    = (DWORD *)W32S_APP2WINE(stack[2], W32S_OFFSET);
1223         DWORD    ZeroBits       = stack[3];
1224         DWORD    CommitSize     = stack[4];
1225         LARGE_INTEGER *SectionOffset = (LARGE_INTEGER *)W32S_APP2WINE(stack[5], W32S_OFFSET);
1226         DWORD *  ViewSize       = (DWORD *)W32S_APP2WINE(stack[6], W32S_OFFSET);
1227         DWORD    InheritDisposition = stack[7];
1228         DWORD    AllocationType = stack[8];
1229         DWORD    Protect        = stack[9];
1230
1231         LPBYTE address = (LPBYTE)(BaseAddress?
1232                         W32S_APP2WINE(*BaseAddress, W32S_OFFSET) : 0);
1233         DWORD  access = 0, result;
1234
1235         switch (Protect & ~(PAGE_GUARD|PAGE_NOCACHE))
1236         {
1237             case PAGE_READONLY:           access = FILE_MAP_READ;  break;
1238             case PAGE_READWRITE:          access = FILE_MAP_WRITE; break;
1239             case PAGE_WRITECOPY:          access = FILE_MAP_COPY;  break;
1240
1241             case PAGE_EXECUTE_READ:       access = FILE_MAP_READ;  break;
1242             case PAGE_EXECUTE_READWRITE:  access = FILE_MAP_WRITE; break;
1243             case PAGE_EXECUTE_WRITECOPY:  access = FILE_MAP_COPY;  break;
1244         }
1245
1246         TRACE("NtMapViewOfSection"
1247                    "(%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx)\n",
1248                    (DWORD)SectionHandle, ProcessHandle, (DWORD)BaseAddress,
1249                    ZeroBits, CommitSize, (DWORD)SectionOffset, (DWORD)ViewSize,
1250                    InheritDisposition, AllocationType, Protect);
1251         TRACE("NtMapViewOfSection: "
1252                    "base=%lx, offset=%lx, size=%lx, access=%lx\n",
1253                    (DWORD)address, SectionOffset? SectionOffset->s.LowPart : 0,
1254                    ViewSize? *ViewSize : 0, access);
1255
1256         result = (DWORD)MapViewOfFileEx(SectionHandle, access,
1257                             SectionOffset? SectionOffset->s.HighPart : 0,
1258                             SectionOffset? SectionOffset->s.LowPart  : 0,
1259                             ViewSize? *ViewSize : 0, address);
1260
1261         TRACE("NtMapViewOfSection: result=%lx\n", result);
1262
1263         if (W32S_WINE2APP(result, W32S_OFFSET))
1264         {
1265             if (BaseAddress) *BaseAddress = W32S_WINE2APP(result, W32S_OFFSET);
1266             context->Eax = STATUS_SUCCESS;
1267         }
1268         else
1269             context->Eax = STATUS_NO_MEMORY; /* FIXME */
1270     }
1271     break;
1272
1273
1274     case 0x0012: /* NtUnmapViewOfSection */
1275         /*
1276          * Input:   EDX: Flat address of arguments on stack
1277          *
1278          *   DWORD  ProcessHandle  [in]  Process (defining address space)
1279          *   LPBYTE BaseAddress    [in]  Base address of view to be unmapped
1280          *
1281          * Output:  EAX: NtStatus
1282          */
1283     {
1284         DWORD *stack          = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1285         DWORD  ProcessHandle  = stack[0]; /* ignored */
1286         LPBYTE BaseAddress    = (LPBYTE)W32S_APP2WINE(stack[1], W32S_OFFSET);
1287
1288         TRACE("NtUnmapViewOfSection(%lx, %lx)\n",
1289                    ProcessHandle, (DWORD)BaseAddress);
1290
1291         UnmapViewOfFile(BaseAddress);
1292
1293         context->Eax = STATUS_SUCCESS;
1294     }
1295     break;
1296
1297
1298     case 0x0013: /* NtFlushVirtualMemory */
1299         /*
1300          * Input:   EDX: Flat address of arguments on stack
1301          *
1302          *   DWORD   ProcessHandle  [in]  Process (defining address space)
1303          *   LPBYTE *BaseAddress    [in?] Base address of range to be flushed
1304          *   DWORD  *ViewSize       [in?] Number of bytes to be flushed
1305          *   DWORD  *unknown        [???] (?? unknown ??)
1306          *
1307          * Output:  EAX: NtStatus
1308          */
1309     {
1310         DWORD *stack          = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1311         DWORD  ProcessHandle  = stack[0]; /* ignored */
1312         DWORD *BaseAddress    = (DWORD *)W32S_APP2WINE(stack[1], W32S_OFFSET);
1313         DWORD *ViewSize       = (DWORD *)W32S_APP2WINE(stack[2], W32S_OFFSET);
1314         DWORD *unknown        = (DWORD *)W32S_APP2WINE(stack[3], W32S_OFFSET);
1315
1316         LPBYTE address = (LPBYTE)(BaseAddress? W32S_APP2WINE(*BaseAddress, W32S_OFFSET) : 0);
1317         DWORD  size    = ViewSize? *ViewSize : 0;
1318
1319         TRACE("NtFlushVirtualMemory(%lx, %lx, %lx, %lx)\n",
1320                    ProcessHandle, (DWORD)BaseAddress, (DWORD)ViewSize,
1321                    (DWORD)unknown);
1322         TRACE("NtFlushVirtualMemory: base=%lx, size=%lx\n",
1323                    (DWORD)address, size);
1324
1325         FlushViewOfFile(address, size);
1326
1327         context->Eax = STATUS_SUCCESS;
1328     }
1329     break;
1330
1331
1332     case 0x0014: /* Get/Set Debug Registers */
1333         /*
1334          * Input:   ECX: 0 if Get, 1 if Set
1335          *
1336          *          EDX: Get: Flat address of buffer to receive values of
1337          *                    debug registers DR0 .. DR7
1338          *               Set: Flat address of buffer containing values of
1339          *                    debug registers DR0 .. DR7 to be set
1340          * Output:  None
1341          */
1342
1343         FIXME("[0014] ECX=%lx EDX=%lx\n",
1344                    context->Ecx, context->Edx);
1345
1346         /* FIXME */
1347         break;
1348
1349
1350     case 0x0015: /* Set Coprocessor Emulation Flag */
1351         /*
1352          * Input:   EDX: 0 to deactivate, 1 to activate coprocessor emulation
1353          *
1354          * Output:  None
1355          */
1356
1357         TRACE("[0015] EDX=%lx\n", context->Edx);
1358
1359         /* We don't care, as we always have a coprocessor anyway */
1360         break;
1361
1362
1363     case 0x0016: /* Init Win32S VxD PSP */
1364         /*
1365          * If called to query required PSP size:
1366          *
1367          *     Input:  EBX: 0
1368          *     Output: EDX: Required size of Win32s VxD PSP
1369          *
1370          * If called to initialize allocated PSP:
1371          *
1372          *     Input:  EBX: LoWord: Selector of Win32s VxD PSP
1373          *                  HiWord: Paragraph of Win32s VxD PSP (DOSMEM)
1374          *     Output: None
1375          */
1376
1377         if (context->Ebx == 0)
1378             context->Edx = 0x80;
1379         else
1380         {
1381             PDB16 *psp = PTR_SEG_OFF_TO_LIN(BX_reg(context), 0);
1382             psp->nbFiles = 32;
1383             psp->fileHandlesPtr = MAKELONG(HIWORD(context->Ebx), 0x5c);
1384             memset((LPBYTE)psp + 0x5c, '\xFF', 32);
1385         }
1386         break;
1387
1388
1389     case 0x0017: /* Set Break Point */
1390         /*
1391          * Input:   EBX: Offset of Break Point
1392          *          CX:  Selector of Break Point
1393          *
1394          * Output:  None
1395          */
1396
1397         FIXME("[0017] EBX=%lx CX=%x\n",
1398                    context->Ebx, CX_reg(context));
1399
1400         /* FIXME */
1401         break;
1402
1403
1404     case 0x0018: /* VirtualLock */
1405         /*
1406          * Input:   ECX: Current Process
1407          *
1408          *          EDX: Flat address of arguments on stack
1409          *
1410          *   DWORD *retv     [out] TRUE if success, FALSE if failure
1411          *   LPVOID base     [in]  Flat address of range to lock
1412          *   DWORD  size     [in]  Size of range
1413          *
1414          * Output:  EAX: NtStatus
1415          */
1416     {
1417         DWORD *stack  = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1418         DWORD *retv   = (DWORD *)W32S_APP2WINE(stack[0], W32S_OFFSET);
1419         LPVOID base   = (LPVOID) W32S_APP2WINE(stack[1], W32S_OFFSET);
1420         DWORD  size   = stack[2];
1421         DWORD  result;
1422
1423         TRACE("VirtualLock(%lx, %lx, %lx)\n",
1424                    (DWORD)retv, (DWORD)base, size);
1425
1426         result = VirtualLock(base, size);
1427
1428         if (result)
1429             *retv            = TRUE,
1430             context->Eax = STATUS_SUCCESS;
1431         else
1432             *retv            = FALSE,
1433             context->Eax = STATUS_NO_MEMORY;  /* FIXME */
1434     }
1435     break;
1436
1437
1438     case 0x0019: /* VirtualUnlock */
1439         /*
1440          * Input:   ECX: Current Process
1441          *
1442          *          EDX: Flat address of arguments on stack
1443          *
1444          *   DWORD *retv     [out] TRUE if success, FALSE if failure
1445          *   LPVOID base     [in]  Flat address of range to unlock
1446          *   DWORD  size     [in]  Size of range
1447          *
1448          * Output:  EAX: NtStatus
1449          */
1450     {
1451         DWORD *stack  = (DWORD *)W32S_APP2WINE(context->Edx, W32S_OFFSET);
1452         DWORD *retv   = (DWORD *)W32S_APP2WINE(stack[0], W32S_OFFSET);
1453         LPVOID base   = (LPVOID) W32S_APP2WINE(stack[1], W32S_OFFSET);
1454         DWORD  size   = stack[2];
1455         DWORD  result;
1456
1457         TRACE("VirtualUnlock(%lx, %lx, %lx)\n",
1458                    (DWORD)retv, (DWORD)base, size);
1459
1460         result = VirtualUnlock(base, size);
1461
1462         if (result)
1463             *retv            = TRUE,
1464             context->Eax = STATUS_SUCCESS;
1465         else
1466             *retv            = FALSE,
1467             context->Eax = STATUS_NO_MEMORY;  /* FIXME */
1468     }
1469     break;
1470
1471
1472     case 0x001A: /* KGetSystemInfo */
1473         /*
1474          * Input:   None
1475          *
1476          * Output:  ECX:  Start of sparse memory arena
1477          *          EDX:  End of sparse memory arena
1478          */
1479
1480         TRACE("KGetSystemInfo()\n");
1481
1482         /*
1483          * Note: Win32s reserves 0GB - 2GB for Win 3.1 and uses 2GB - 4GB as
1484          *       sparse memory arena. We do it the other way around, since
1485          *       we have to reserve 3GB - 4GB for Linux, and thus use
1486          *       0GB - 3GB as sparse memory arena.
1487          *
1488          *       FIXME: What about other OSes ?
1489          */
1490
1491         context->Ecx = W32S_WINE2APP(0x00000000, W32S_OFFSET);
1492         context->Edx = W32S_WINE2APP(0xbfffffff, W32S_OFFSET);
1493         break;
1494
1495
1496     case 0x001B: /* KGlobalMemStat */
1497         /*
1498          * Input:   ESI: Flat address of buffer to receive memory info
1499          *
1500          * Output:  None
1501          */
1502     {
1503         struct Win32sMemoryInfo
1504         {
1505             DWORD DIPhys_Count;       /* Total physical pages */
1506             DWORD DIFree_Count;       /* Free physical pages */
1507             DWORD DILin_Total_Count;  /* Total virtual pages (private arena) */
1508             DWORD DILin_Total_Free;   /* Free virtual pages (private arena) */
1509
1510             DWORD SparseTotal;        /* Total size of sparse arena (bytes ?) */
1511             DWORD SparseFree;         /* Free size of sparse arena (bytes ?) */
1512         };
1513
1514         struct Win32sMemoryInfo *info =
1515                        (struct Win32sMemoryInfo *)W32S_APP2WINE(context->Esi, W32S_OFFSET);
1516
1517         FIXME("KGlobalMemStat(%lx)\n", (DWORD)info);
1518
1519         /* FIXME */
1520     }
1521     break;
1522
1523
1524     case 0x001C: /* Enable/Disable Exceptions */
1525         /*
1526          * Input:   ECX: 0 to disable, 1 to enable exception handling
1527          *
1528          * Output:  None
1529          */
1530
1531         TRACE("[001c] ECX=%lx\n", context->Ecx);
1532
1533         /* FIXME */
1534         break;
1535
1536
1537     case 0x001D: /* VirtualAlloc called from 16-bit code */
1538         /*
1539          * Input:   EDX: Segmented address of arguments on stack
1540          *
1541          *   LPVOID base     [in]  Flat address of region to reserve/commit
1542          *   DWORD  size     [in]  Size of region
1543          *   DWORD  type     [in]  Type of allocation
1544          *   DWORD  prot     [in]  Type of access protection
1545          *
1546          * Output:  EAX: NtStatus
1547          *          EDX: Flat base address of allocated region
1548          */
1549     {
1550         DWORD *stack  = PTR_SEG_OFF_TO_LIN(LOWORD(context->Edx),
1551                                            HIWORD(context->Edx));
1552         LPVOID base   = (LPVOID)W32S_APP2WINE(stack[0], W32S_OFFSET);
1553         DWORD  size   = stack[1];
1554         DWORD  type   = stack[2];
1555         DWORD  prot   = stack[3];
1556         DWORD  result;
1557
1558         TRACE("VirtualAlloc16(%lx, %lx, %lx, %lx)\n",
1559                    (DWORD)base, size, type, prot);
1560
1561         if (type & 0x80000000)
1562         {
1563             WARN("VirtualAlloc16: strange type %lx\n", type);
1564             type &= 0x7fffffff;
1565         }
1566
1567         result = (DWORD)VirtualAlloc(base, size, type, prot);
1568
1569         if (W32S_WINE2APP(result, W32S_OFFSET))
1570             context->Edx = W32S_WINE2APP(result, W32S_OFFSET),
1571             context->Eax = STATUS_SUCCESS;
1572         else
1573             context->Edx = 0,
1574             context->Eax = STATUS_NO_MEMORY;  /* FIXME */
1575         TRACE("VirtualAlloc16: returning base %lx\n", context->Edx);
1576     }
1577     break;
1578
1579
1580     case 0x001E: /* VirtualFree called from 16-bit code */
1581         /*
1582          * Input:   EDX: Segmented address of arguments on stack
1583          *
1584          *   LPVOID base     [in]  Flat address of region
1585          *   DWORD  size     [in]  Size of region
1586          *   DWORD  type     [in]  Type of operation
1587          *
1588          * Output:  EAX: NtStatus
1589          *          EDX: TRUE if success, FALSE if failure
1590          */
1591     {
1592         DWORD *stack  = PTR_SEG_OFF_TO_LIN(LOWORD(context->Edx),
1593                                            HIWORD(context->Edx));
1594         LPVOID base   = (LPVOID)W32S_APP2WINE(stack[0], W32S_OFFSET);
1595         DWORD  size   = stack[1];
1596         DWORD  type   = stack[2];
1597         DWORD  result;
1598
1599         TRACE("VirtualFree16(%lx, %lx, %lx)\n",
1600                    (DWORD)base, size, type);
1601
1602         result = VirtualFree(base, size, type);
1603
1604         if (result)
1605             context->Edx = TRUE,
1606             context->Eax = STATUS_SUCCESS;
1607         else
1608             context->Edx = FALSE,
1609             context->Eax = STATUS_NO_MEMORY;  /* FIXME */
1610     }
1611     break;
1612
1613
1614     case 0x001F: /* FWorkingSetSize */
1615         /*
1616          * Input:   EDX: 0 if Get, 1 if Set
1617          *
1618          *          ECX: Get: Buffer to receive Working Set Size
1619          *               Set: Buffer containing Working Set Size
1620          *
1621          * Output:  NtStatus
1622          */
1623     {
1624         DWORD *ptr = (DWORD *)W32S_APP2WINE(context->Ecx, W32S_OFFSET);
1625         BOOL set = context->Edx;
1626
1627         TRACE("FWorkingSetSize(%lx, %lx)\n", (DWORD)ptr, (DWORD)set);
1628
1629         if (set)
1630             /* We do it differently ... */;
1631         else
1632             *ptr = 0x100;
1633
1634         context->Eax = STATUS_SUCCESS;
1635     }
1636     break;
1637
1638
1639     default:
1640         VXD_BARF( context, "W32S" );
1641     }
1642
1643 }
1644