git.oblomov.eu Git - wine/blob - dlls/krnl386.exe16/dosvm.c

   1 /*
   2  * DOS Virtual Machine
   3  *
   4  * Copyright 1998 Ove Kåven
   5  * Copyright 2002 Jukka Heinonen
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * Note: This code hasn't been completely cleaned up yet.
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <signal.h>
  34 #ifdef HAVE_UNISTD_H
  35 # include <unistd.h>
  36 #endif
  37 #ifdef HAVE_SYS_TIME_H
  38 # include <sys/time.h>
  39 #endif
  40 #include <sys/types.h>
  41
  42 #include "wine/winbase16.h"
  43 #include "wine/exception.h"
  44 #include "windef.h"
  45 #include "winbase.h"
  46 #include "winternl.h"
  47 #include "wingdi.h"
  48 #include "winuser.h"
  49 #include "wownt32.h"
  50 #include "winnt.h"
  51 #include "wincon.h"
  52
  53 #include "dosexe.h"
  54 #include "wine/debug.h"
  55 #include "excpt.h"
  56
  57 WINE_DEFAULT_DEBUG_CHANNEL(int);
  58 #ifdef MZ_SUPPORTED
  59 WINE_DECLARE_DEBUG_CHANNEL(module);
  60 WINE_DECLARE_DEBUG_CHANNEL(relay);
  61 #endif
  62
  63 WORD DOSVM_psp = 0;
  64 WORD DOSVM_retval = 0;
  65
  66 /*
  67  * Wine DOS memory layout above 640k:
  68  *
  69  *   a0000 - affff : VGA graphics         (vga.c)
  70  *   b0000 - bffff : Monochrome text      (unused)
  71  *   b8000 - bffff : VGA text             (vga.c)
  72  *   c0000 - cffff : EMS frame            (int67.c)
  73  *   d0000 - effff : Free memory for UMBs (himem.c)
  74  *   f0000 - fffff : BIOS stuff           (msdos/dosmem.c)
  75  *  100000 -10ffff : High memory area     (unused)
  76  */
  77
  78 /*
  79  * Table of real mode segments and protected mode selectors
  80  * for code stubs and other miscellaneous storage.
  81  */
  82 struct DPMI_segments *DOSVM_dpmi_segments = NULL;
  83
  84 /*
  85  * First and last address available for upper memory blocks.
  86  */
  87 #define DOSVM_UMB_BOTTOM 0xd0000
  88 #define DOSVM_UMB_TOP    0xeffff
  89
  90 /*
  91  * First free address for upper memory blocks.
  92  */
  93 static DWORD DOSVM_umb_free = DOSVM_UMB_BOTTOM;
  94
  95
  96 typedef struct _DOSEVENT {
  97   int irq,priority;
  98   DOSRELAY relay;
  99   void *data;
 100   struct _DOSEVENT *next;
 101 } DOSEVENT, *LPDOSEVENT;
 102
 103 static struct _DOSEVENT *pending_event, *current_event;
 104 static HANDLE event_notifier;
 105
 106 static CRITICAL_SECTION qcrit;
 107 static CRITICAL_SECTION_DEBUG critsect_debug =
 108 {
 109     0, 0, &qcrit,
 110     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 111       0, 0, { (DWORD_PTR)(__FILE__ ": qcrit") }
 112 };
 113 static CRITICAL_SECTION qcrit = { &critsect_debug, -1, 0, 0, 0, 0 };
 114
 115
 116 /***********************************************************************
 117  *              DOSVM_HasPendingEvents
 118  *
 119  * Return true if there are pending events that are not
 120  * blocked by currently active event.
 121  */
 122 static BOOL DOSVM_HasPendingEvents( void )
 123 {
 124     if (!pending_event)
 125         return FALSE;
 126
 127     if (!current_event)
 128         return TRUE;
 129
 130     if (pending_event->priority < current_event->priority)
 131         return TRUE;
 132
 133     return FALSE;
 134 }
 135
 136
 137 /***********************************************************************
 138  *              DOSVM_SendOneEvent
 139  *
 140  * Process single pending event.
 141  *
 142  * This function should be called with queue critical section locked.
 143  * The function temporarily releases the critical section if it is
 144  * possible that internal interrupt handler or user procedure will
 145  * be called. This is because we may otherwise get a deadlock if
 146  * another thread is waiting for the same critical section.
 147  */
 148 static void DOSVM_SendOneEvent( CONTEXT *context )
 149 {
 150     LPDOSEVENT event = pending_event;
 151
 152     /* Remove from pending events list. */
 153     pending_event = event->next;
 154
 155     /* Process active event. */
 156     if (event->irq >= 0)
 157     {
 158         BYTE intnum = (event->irq < 8) ?
 159             (event->irq + 8) : (event->irq - 8 + 0x70);
 160
 161         /* Event is an IRQ, move it to current events list. */
 162         event->next = current_event;
 163         current_event = event;
 164
 165         TRACE( "Dispatching IRQ %d.\n", event->irq );
 166
 167         if (ISV86(context))
 168         {
 169             /*
 170              * Note that if DOSVM_HardwareInterruptRM calls an internal
 171              * interrupt directly, current_event might be cleared
 172              * (and event freed) in this call.
 173              */
 174             LeaveCriticalSection(&qcrit);
 175             DOSVM_HardwareInterruptRM( context, intnum );
 176             EnterCriticalSection(&qcrit);
 177         }
 178         else
 179         {
 180             /*
 181              * This routine only modifies current context so it is
 182              * not necessary to release critical section.
 183              */
 184             DOSVM_HardwareInterruptPM( context, intnum );
 185         }
 186     }
 187     else
 188     {
 189         /* Callback event. */
 190         TRACE( "Dispatching callback event.\n" );
 191
 192         if (ISV86(context))
 193         {
 194             /*
 195              * Call relay immediately in real mode.
 196              */
 197             LeaveCriticalSection(&qcrit);
 198             (*event->relay)( context, event->data );
 199             EnterCriticalSection(&qcrit);
 200         }
 201         else
 202         {
 203             /*
 204              * Force return to relay code. We do not want to
 205              * call relay directly because we may be inside a signal handler.
 206              */
 207             DOSVM_BuildCallFrame( context, event->relay, event->data );
 208         }
 209
 210         HeapFree(GetProcessHeap(), 0, event);
 211     }
 212 }
 213
 214
 215 /***********************************************************************
 216  *              DOSVM_SendQueuedEvents
 217  *
 218  * As long as context instruction pointer stays unmodified,
 219  * process all pending events that are not blocked by currently
 220  * active event.
 221  *
 222  * This routine assumes that caller has already cleared TEB.vm86_pending
 223  * and checked that interrupts are enabled.
 224  */
 225 void DOSVM_SendQueuedEvents( CONTEXT *context )
 226 {
 227     DWORD old_cs = context->SegCs;
 228     DWORD old_ip = context->Eip;
 229
 230     EnterCriticalSection(&qcrit);
 231
 232     TRACE( "Called in %s mode %s events pending (time=%d)\n",
 233            ISV86(context) ? "real" : "protected",
 234            DOSVM_HasPendingEvents() ? "with" : "without",
 235            GetTickCount() );
 236     TRACE( "cs:ip=%04x:%08x, ss:sp=%04x:%08x\n",
 237            context->SegCs, context->Eip, context->SegSs, context->Esp);
 238
 239     while (context->SegCs == old_cs &&
 240            context->Eip == old_ip &&
 241            DOSVM_HasPendingEvents())
 242     {
 243         DOSVM_SendOneEvent(context);
 244
 245         /*
 246          * Event handling may have turned pending events flag on.
 247          * We disable it here because this prevents some
 248          * unnecessary calls to this function.
 249          */
 250         get_vm86_teb_info()->vm86_pending = 0;
 251     }
 252
 253 #ifdef MZ_SUPPORTED
 254
 255     if (DOSVM_HasPendingEvents())
 256     {
 257         /*
 258          * Interrupts disabled, but there are still
 259          * pending events, make sure that pending flag is turned on.
 260          */
 261         TRACE( "Another event is pending, setting VIP flag.\n" );
 262         get_vm86_teb_info()->vm86_pending |= VIP_MASK;
 263     }
 264
 265 #else
 266
 267     FIXME("No DOS .exe file support on this platform (yet)\n");
 268
 269 #endif /* MZ_SUPPORTED */
 270
 271     LeaveCriticalSection(&qcrit);
 272 }
 273
 274
 275 #ifdef MZ_SUPPORTED
 276 /***********************************************************************
 277  *              DOSVM_QueueEvent
 278  */
 279 void DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
 280 {
 281   LPDOSEVENT event, cur, prev;
 282   BOOL       old_pending;
 283
 284   if (MZ_Current()) {
 285     event = HeapAlloc(GetProcessHeap(), 0, sizeof(DOSEVENT));
 286     if (!event) {
 287       ERR("out of memory allocating event entry\n");
 288       return;
 289     }
 290     event->irq = irq; event->priority = priority;
 291     event->relay = relay; event->data = data;
 292
 293     EnterCriticalSection(&qcrit);
 294     old_pending = DOSVM_HasPendingEvents();
 295
 296     /* insert event into linked list, in order *after*
 297      * all earlier events of higher or equal priority */
 298     cur = pending_event; prev = NULL;
 299     while (cur && cur->priority<=priority) {
 300       prev = cur;
 301       cur = cur->next;
 302     }
 303     event->next = cur;
 304     if (prev) prev->next = event;
 305     else pending_event = event;
 306
 307     if (!old_pending && DOSVM_HasPendingEvents()) {
 308       TRACE("new event queued, signalling (time=%d)\n", GetTickCount());
 309
 310       /* Alert VM86 thread about the new event. */
 311       kill(dosvm_pid,SIGUSR2);
 312
 313       /* Wake up DOSVM_Wait so that it can serve pending events. */
 314       SetEvent(event_notifier);
 315     } else {
 316       TRACE("new event queued (time=%d)\n", GetTickCount());
 317     }
 318
 319     LeaveCriticalSection(&qcrit);
 320   } else {
 321     /* DOS subsystem not running */
 322     /* (this probably means that we're running a win16 app
 323      *  which uses DPMI to thunk down to DOS services) */
 324     if (irq<0) {
 325       /* callback event, perform it with dummy context */
 326       CONTEXT context;
 327       memset(&context,0,sizeof(context));
 328       (*relay)(&context,data);
 329     } else {
 330       ERR("IRQ without DOS task: should not happen\n");
 331     }
 332   }
 333 }
 334
 335 static void DOSVM_ProcessConsole(void)
 336 {
 337   INPUT_RECORD msg;
 338   DWORD res;
 339   BYTE scan, ascii;
 340
 341   if (ReadConsoleInputA(GetStdHandle(STD_INPUT_HANDLE),&msg,1,&res)) {
 342     switch (msg.EventType) {
 343     case KEY_EVENT:
 344       scan = msg.Event.KeyEvent.wVirtualScanCode;
 345       ascii = msg.Event.KeyEvent.uChar.AsciiChar;
 346       TRACE("scan %02x, ascii %02x\n", scan, ascii);
 347
 348       /* set the "break" (release) flag if key released */
 349       if (!msg.Event.KeyEvent.bKeyDown) scan |= 0x80;
 350
 351       /* check whether extended bit is set,
 352        * and if so, queue the extension prefix */
 353       if (msg.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY) {
 354         DOSVM_Int09SendScan(0xE0,0);
 355       }
 356       DOSVM_Int09SendScan(scan, ascii);
 357       break;
 358     case MOUSE_EVENT:
 359       DOSVM_Int33Console(&msg.Event.MouseEvent);
 360       break;
 361     case WINDOW_BUFFER_SIZE_EVENT:
 362       FIXME("unhandled WINDOW_BUFFER_SIZE_EVENT.\n");
 363       break;
 364     case MENU_EVENT:
 365       FIXME("unhandled MENU_EVENT.\n");
 366       break;
 367     case FOCUS_EVENT:
 368       FIXME("unhandled FOCUS_EVENT.\n");
 369       break;
 370     default:
 371       FIXME("unknown console event: %d\n", msg.EventType);
 372     }
 373   }
 374 }
 375
 376 static void DOSVM_ProcessMessage(MSG *msg)
 377 {
 378   BYTE scan = 0;
 379
 380   TRACE("got message %04x, wparam=%08lx, lparam=%08lx\n",msg->message,msg->wParam,msg->lParam);
 381   if ((msg->message>=WM_MOUSEFIRST)&&
 382       (msg->message<=WM_MOUSELAST)) {
 383     DOSVM_Int33Message(msg->message,msg->wParam,msg->lParam);
 384   } else {
 385     switch (msg->message) {
 386     case WM_KEYUP:
 387       scan = 0x80;
 388     case WM_KEYDOWN:
 389       scan |= (msg->lParam >> 16) & 0x7f;
 390
 391       /* check whether extended bit is set,
 392        * and if so, queue the extension prefix */
 393       if (msg->lParam & 0x1000000) {
 394         /* FIXME: some keys (function keys) have
 395          * extended bit set even when they shouldn't,
 396          * should check for them */
 397         DOSVM_Int09SendScan(0xE0,0);
 398       }
 399       DOSVM_Int09SendScan(scan,0);
 400       break;
 401     }
 402   }
 403 }
 404
 405
 406 /***********************************************************************
 407  *              DOSVM_Wait
 408  *
 409  * Wait for asynchronous events. This routine temporarily enables
 410  * interrupts and waits until some asynchronous event has been
 411  * processed.
 412  */
 413 void DOSVM_Wait( CONTEXT *waitctx )
 414 {
 415     if (DOSVM_HasPendingEvents())
 416     {
 417         CONTEXT context = *waitctx;
 418
 419         /*
 420          * If DOSVM_Wait is called from protected mode we emulate
 421          * interrupt reflection and convert context into real mode context.
 422          * This is actually the correct thing to do as long as DOSVM_Wait
 423          * is only called from those interrupt functions that DPMI reflects
 424          * to real mode.
 425          *
 426          * FIXME: Need to think about where to place real mode stack.
 427          * FIXME: If DOSVM_Wait calls are nested stack gets corrupted.
 428          *        Can this really happen?
 429          */
 430         if (!ISV86(&context))
 431         {
 432             context.EFlags |= V86_FLAG;
 433             context.SegSs = 0xffff;
 434             context.Esp = 0;
 435         }
 436
 437         context.EFlags |= VIF_MASK;
 438         context.SegCs = 0;
 439         context.Eip = 0;
 440
 441         DOSVM_SendQueuedEvents(&context);
 442
 443         if(context.SegCs || context.Eip)
 444             DPMI_CallRMProc( &context, NULL, 0, TRUE );
 445     }
 446     else
 447     {
 448         HANDLE objs[2];
 449         int    objc = DOSVM_IsWin16() ? 2 : 1;
 450         DWORD  waitret;
 451
 452         objs[0] = event_notifier;
 453         objs[1] = GetStdHandle(STD_INPUT_HANDLE);
 454
 455         waitret = MsgWaitForMultipleObjects( objc, objs, FALSE,
 456                                              INFINITE, QS_ALLINPUT );
 457
 458         if (waitret == WAIT_OBJECT_0)
 459         {
 460             /*
 461              * New pending event has been queued, we ignore it
 462              * here because it will be processed on next call to
 463              * DOSVM_Wait.
 464              */
 465         }
 466         else if (objc == 2 && waitret == WAIT_OBJECT_0 + 1)
 467         {
 468             DOSVM_ProcessConsole();
 469         }
 470         else if (waitret == WAIT_OBJECT_0 + objc)
 471         {
 472             MSG msg;
 473             while (PeekMessageA(&msg,0,0,0,PM_REMOVE|PM_NOYIELD))
 474             {
 475                 /* got a message */
 476                 DOSVM_ProcessMessage(&msg);
 477                 /* we don't need a TranslateMessage here */
 478                 DispatchMessageA(&msg);
 479             }
 480         }
 481         else
 482         {
 483             ERR_(module)( "dosvm wait error=%d\n", GetLastError() );
 484         }
 485     }
 486 }
 487
 488
 489 DWORD DOSVM_Loop( HANDLE hThread )
 490 {
 491   HANDLE objs[2];
 492   int count = 0;
 493   MSG msg;
 494   DWORD waitret;
 495
 496   objs[count++] = hThread;
 497   if (GetConsoleMode( GetStdHandle(STD_INPUT_HANDLE), NULL ))
 498       objs[count++] = GetStdHandle(STD_INPUT_HANDLE);
 499
 500   for(;;) {
 501       TRACE_(int)("waiting for action\n");
 502       waitret = MsgWaitForMultipleObjects(count, objs, FALSE, INFINITE, QS_ALLINPUT);
 503       if (waitret == WAIT_OBJECT_0) {
 504          DWORD rv;
 505          if(!GetExitCodeThread(hThread, &rv)) {
 506              ERR("Failed to get thread exit code!\n");
 507              rv = 0;
 508          }
 509          return rv;
 510       }
 511       else if (waitret == WAIT_OBJECT_0 + count) {
 512           while (PeekMessageA(&msg,0,0,0,PM_REMOVE)) {
 513               if (msg.hwnd) {
 514                   /* it's a window message */
 515                   DOSVM_ProcessMessage(&msg);
 516                   DispatchMessageA(&msg);
 517               } else {
 518                   /* it's a thread message */
 519                   switch (msg.message) {
 520                   case WM_QUIT:
 521                       /* stop this madness!! */
 522                       return 0;
 523                   case WM_USER:
 524                       /* run passed procedure in this thread */
 525                       /* (sort of like APC, but we signal the completion) */
 526                       {
 527                           DOS_SPC *spc = (DOS_SPC *)msg.lParam;
 528                           TRACE_(int)("calling %p with arg %08lx\n", spc->proc, spc->arg);
 529                           (spc->proc)(spc->arg);
 530                           TRACE_(int)("done, signalling event %lx\n", msg.wParam);
 531                           SetEvent( (HANDLE)msg.wParam );
 532                       }
 533                       break;
 534                   default:
 535                       DispatchMessageA(&msg);
 536                   }
 537               }
 538           }
 539       }
 540       else if (waitret == WAIT_OBJECT_0 + 1)
 541       {
 542           DOSVM_ProcessConsole();
 543       }
 544       else
 545       {
 546           ERR_(int)("MsgWaitForMultipleObjects returned unexpected value.\n");
 547           return 0;
 548       }
 549   }
 550 }
 551
 552 static LONG WINAPI exception_handler(EXCEPTION_POINTERS *eptr)
 553 {
 554   EXCEPTION_RECORD *rec = eptr->ExceptionRecord;
 555   CONTEXT *context = eptr->ContextRecord;
 556   int arg = rec->ExceptionInformation[0];
 557   BOOL ret;
 558
 559   switch(rec->ExceptionCode) {
 560   case EXCEPTION_VM86_INTx:
 561     TRACE_(relay)("Call DOS int 0x%02x ret=%04x:%04x\n"
 562                   " eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n"
 563                   " ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
 564                   arg, context->SegCs, context->Eip,
 565                   context->Eax, context->Ebx, context->Ecx, context->Edx, context->Esi, context->Edi,
 566                   context->Ebp, context->Esp, context->SegDs, context->SegEs, context->SegFs, context->SegGs,
 567                   context->EFlags );
 568     ret = DOSVM_EmulateInterruptRM( context, arg );
 569     TRACE_(relay)("Ret  DOS int 0x%02x ret=%04x:%04x\n"
 570                   " eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n"
 571                   " ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
 572                   arg, context->SegCs, context->Eip,
 573                   context->Eax, context->Ebx, context->Ecx, context->Edx, context->Esi, context->Edi,
 574                   context->Ebp, context->Esp, context->SegDs, context->SegEs,
 575                   context->SegFs, context->SegGs, context->EFlags );
 576     return ret ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_EXECUTE_HANDLER;
 577
 578   case EXCEPTION_VM86_STI:
 579   /* case EXCEPTION_VM86_PICRETURN: */
 580     if (!ISV86(context))
 581       ERR( "Protected mode STI caught by real mode handler!\n" );
 582     DOSVM_SendQueuedEvents(context);
 583     return EXCEPTION_CONTINUE_EXECUTION;
 584
 585   case EXCEPTION_SINGLE_STEP:
 586     ret = DOSVM_EmulateInterruptRM( context, 1 );
 587     return ret ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_EXECUTE_HANDLER;
 588
 589   case EXCEPTION_BREAKPOINT:
 590     ret = DOSVM_EmulateInterruptRM( context, 3 );
 591     return ret ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_EXECUTE_HANDLER;
 592
 593   }
 594   return EXCEPTION_CONTINUE_SEARCH;
 595 }
 596
 597 INT DOSVM_Enter( CONTEXT *context )
 598 {
 599   INT ret = 0;
 600   if (!ISV86(context))
 601       ERR( "Called with protected mode context!\n" );
 602
 603   __TRY
 604   {
 605       if (!WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)context )) ret = -1;
 606       TRACE_(module)( "ret %d err %u\n", ret, GetLastError() );
 607   }
 608   __EXCEPT(exception_handler)
 609   {
 610     TRACE_(module)( "leaving vm86 mode\n" );
 611   }
 612   __ENDTRY
 613
 614   return ret;
 615 }
 616
 617 /***********************************************************************
 618  *              DOSVM_PIC_ioport_out
 619  */
 620 void DOSVM_PIC_ioport_out( WORD port, BYTE val)
 621 {
 622     if (port != 0x20)
 623     {
 624         FIXME( "Unsupported PIC port %04x\n", port );
 625     }
 626     else if (val == 0x20 || (val >= 0x60 && val <= 0x67))
 627     {
 628         EnterCriticalSection(&qcrit);
 629
 630         if (!current_event)
 631         {
 632             WARN( "%s without active IRQ\n",
 633                   val == 0x20 ? "EOI" : "Specific EOI" );
 634         }
 635         else if (val != 0x20 && val - 0x60 != current_event->irq)
 636         {
 637             WARN( "Specific EOI but current IRQ %d is not %d\n",
 638                   current_event->irq, val - 0x60 );
 639         }
 640         else
 641         {
 642             LPDOSEVENT event = current_event;
 643
 644             TRACE( "Received %s for current IRQ %d, clearing event\n",
 645                    val == 0x20 ? "EOI" : "Specific EOI", event->irq );
 646
 647             current_event = event->next;
 648             if (event->relay)
 649                 (*event->relay)(NULL,event->data);
 650             HeapFree(GetProcessHeap(), 0, event);
 651
 652             if (DOSVM_HasPendingEvents())
 653             {
 654                 TRACE( "Another event pending, setting pending flag\n" );
 655                 get_vm86_teb_info()->vm86_pending |= VIP_MASK;
 656             }
 657         }
 658
 659         LeaveCriticalSection(&qcrit);
 660     }
 661     else
 662     {
 663         FIXME( "Unrecognized PIC command %02x\n", val );
 664     }
 665 }
 666
 667 #else /* !MZ_SUPPORTED */
 668
 669 /***********************************************************************
 670  *              DOSVM_Enter
 671  */
 672 INT DOSVM_Enter( CONTEXT *context )
 673 {
 674     SetLastError( ERROR_NOT_SUPPORTED );
 675     return -1;
 676 }
 677
 678 /***********************************************************************
 679  *              DOSVM_Wait
 680  */
 681 void DOSVM_Wait( CONTEXT *waitctx ) { }
 682
 683 /***********************************************************************
 684  *              DOSVM_PIC_ioport_out
 685  */
 686 void DOSVM_PIC_ioport_out( WORD port, BYTE val) {}
 687
 688 /***********************************************************************
 689  *              DOSVM_QueueEvent
 690  */
 691 void DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
 692 {
 693   if (irq<0) {
 694     /* callback event, perform it with dummy context */
 695     CONTEXT context;
 696     memset(&context,0,sizeof(context));
 697     (*relay)(&context,data);
 698   } else {
 699     ERR("IRQ without DOS task: should not happen\n");
 700   }
 701 }
 702
 703 #endif /* MZ_SUPPORTED */
 704
 705
 706 /**********************************************************************
 707  *         DOSVM_AcknowledgeIRQ
 708  *
 709  * This routine should be called by all internal IRQ handlers.
 710  */
 711 void WINAPI DOSVM_AcknowledgeIRQ( CONTEXT *context )
 712 {
 713     /*
 714      * Send EOI to PIC.
 715      */
 716     DOSVM_PIC_ioport_out( 0x20, 0x20 );
 717
 718     /*
 719      * Protected mode IRQ handlers are supposed
 720      * to turn VIF flag on before they return.
 721      */
 722     if (!ISV86(context))
 723         get_vm86_teb_info()->dpmi_vif = 1;
 724 }
 725
 726
 727 /***********************************************************************
 728  *           DOSVM_AllocUMB
 729  *
 730  * Allocate upper memory block (UMB) from upper memory.
 731  * Returned pointer is aligned to 16-byte (paragraph) boundary.
 732  *
 733  * This routine is only for allocating static storage for
 734  * Wine internal uses. Allocated memory can be accessed from
 735  * real mode, memory is taken from area already mapped and reserved
 736  * by Wine and the allocation has very little memory and speed
 737  * overhead. Use of this routine also preserves precious DOS
 738  * conventional memory.
 739  */
 740 static LPVOID DOSVM_AllocUMB( DWORD size )
 741 {
 742   LPVOID ptr = (LPVOID)DOSVM_umb_free;
 743
 744   size = ((size + 15) >> 4) << 4;
 745
 746   if(DOSVM_umb_free + size - 1 > DOSVM_UMB_TOP) {
 747     ERR("Out of upper memory area.\n");
 748     return 0;
 749   }
 750
 751   DOSVM_umb_free += size;
 752   return ptr;
 753 }
 754
 755
 756 /**********************************************************************
 757  *          alloc_selector
 758  *
 759  * Allocate a selector corresponding to a real mode address.
 760  * size must be < 64k.
 761  */
 762 static WORD alloc_selector( void *base, DWORD size, unsigned char flags )
 763 {
 764     WORD sel = wine_ldt_alloc_entries( 1 );
 765
 766     if (sel)
 767     {
 768         LDT_ENTRY entry;
 769         wine_ldt_set_base( &entry, base );
 770         wine_ldt_set_limit( &entry, size - 1 );
 771         wine_ldt_set_flags( &entry, flags );
 772         wine_ldt_set_entry( sel, &entry );
 773     }
 774     return sel;
 775 }
 776
 777
 778 /***********************************************************************
 779  *           DOSVM_AllocCodeUMB
 780  *
 781  * Allocate upper memory block for storing code stubs.
 782  * Initializes real mode segment and 16-bit protected mode selector
 783  * for the allocated code block.
 784  *
 785  * FIXME: should allocate a single PM selector for the whole UMB range.
 786  */
 787 static LPVOID DOSVM_AllocCodeUMB( DWORD size, WORD *segment, WORD *selector )
 788 {
 789   LPVOID ptr = DOSVM_AllocUMB( size );
 790
 791   if (segment)
 792     *segment = (DWORD)ptr >> 4;
 793
 794   if (selector)
 795     *selector = alloc_selector( ptr, size, WINE_LDT_FLAGS_CODE );
 796
 797   return ptr;
 798 }
 799
 800
 801 /***********************************************************************
 802  *           DOSVM_AllocDataUMB
 803  *
 804  * Allocate upper memory block for storing data.
 805  * Initializes real mode segment and 16-bit protected mode selector
 806  * for the allocated data block.
 807  */
 808 LPVOID DOSVM_AllocDataUMB( DWORD size, WORD *segment, WORD *selector )
 809 {
 810   LPVOID ptr = DOSVM_AllocUMB( size );
 811
 812   if (segment)
 813     *segment = (DWORD)ptr >> 4;
 814
 815   if (selector)
 816     *selector = alloc_selector( ptr, size, WINE_LDT_FLAGS_DATA );
 817
 818   return ptr;
 819 }
 820
 821
 822 /***********************************************************************
 823  *           DOSVM_InitSegments
 824  *
 825  * Initializes DOSVM_dpmi_segments. Allocates required memory and
 826  * sets up segments and selectors for accessing the memory.
 827  */
 828 void DOSVM_InitSegments(void)
 829 {
 830     LPSTR ptr;
 831     int   i;
 832
 833     static const char wrap_code[]={
 834      0xCD,0x31, /* int $0x31 */
 835      0xCB       /* lret */
 836     };
 837
 838     static const char enter_xms[]=
 839     {
 840         /* XMS hookable entry point */
 841         0xEB,0x03,           /* jmp entry */
 842         0x90,0x90,0x90,      /* nop;nop;nop */
 843                              /* entry: */
 844         /* real entry point */
 845         /* for simplicity, we'll just use the same hook as DPMI below */
 846         0xCD,0x31,           /* int $0x31 */
 847         0xCB                 /* lret */
 848     };
 849
 850     static const char enter_pm[]=
 851     {
 852         0x50,                /* pushw %ax */
 853         0x52,                /* pushw %dx */
 854         0x55,                /* pushw %bp */
 855         0x89,0xE5,           /* movw %sp,%bp */
 856         /* get return CS */
 857         0x8B,0x56,0x08,      /* movw 8(%bp),%dx */
 858         /* just call int 31 here to get into protected mode... */
 859         /* it'll check whether it was called from dpmi_seg... */
 860         0xCD,0x31,           /* int $0x31 */
 861         /* we are now in the context of a 16-bit relay call */
 862         /* need to fixup our stack;
 863          * 16-bit relay return address will be lost,
 864          * but we won't worry quite yet
 865          */
 866         0x8E,0xD0,           /* movw %ax,%ss */
 867         0x66,0x0F,0xB7,0xE5, /* movzwl %bp,%esp */
 868         /* set return CS */
 869         0x89,0x56,0x08,      /* movw %dx,8(%bp) */
 870         0x5D,                /* popw %bp */
 871         0x5A,                /* popw %dx */
 872         0x58,                /* popw %ax */
 873         0xfb,                /* sti, enable and check virtual interrupts */
 874         0xCB                 /* lret */
 875     };
 876
 877     static const char relay[]=
 878     {
 879         0xca, 0x04, 0x00, /* 16-bit far return and pop 4 bytes (relay void* arg) */
 880         0xcd, 0x31,       /* int 31 */
 881         0xfb, 0x66, 0xcb  /* sti and 32-bit far return */
 882     };
 883
 884     /*
 885      * Allocate pointer array.
 886      */
 887     DOSVM_dpmi_segments = DOSVM_AllocUMB( sizeof(struct DPMI_segments) );
 888
 889     /*
 890      * RM / offset 0: Exit from real mode.
 891      * RM / offset 2: Points to lret opcode.
 892      */
 893     ptr = DOSVM_AllocCodeUMB( sizeof(wrap_code),
 894                               &DOSVM_dpmi_segments->wrap_seg, 0 );
 895     memcpy( ptr, wrap_code, sizeof(wrap_code) );
 896
 897     /*
 898      * RM / offset 0: XMS driver entry.
 899      */
 900     ptr = DOSVM_AllocCodeUMB( sizeof(enter_xms),
 901                               &DOSVM_dpmi_segments->xms_seg, 0 );
 902     memcpy( ptr, enter_xms, sizeof(enter_xms) );
 903
 904     /*
 905      * RM / offset 0: Switch to DPMI.
 906      * PM / offset 8: DPMI raw mode switch.
 907      */
 908     ptr = DOSVM_AllocCodeUMB( sizeof(enter_pm),
 909                               &DOSVM_dpmi_segments->dpmi_seg,
 910                               &DOSVM_dpmi_segments->dpmi_sel );
 911     memcpy( ptr, enter_pm, sizeof(enter_pm) );
 912
 913     /*
 914      * PM / offset N*6: Interrupt N in DPMI32.
 915      */
 916     ptr = DOSVM_AllocCodeUMB( 6 * 256,
 917                               0, &DOSVM_dpmi_segments->int48_sel );
 918     for(i=0; i<256; i++) {
 919         /*
 920          * Each 32-bit interrupt handler is 6 bytes:
 921          * 0xCD,<i>            = int <i> (nested 16-bit interrupt)
 922          * 0x66,0xCA,0x04,0x00 = ret 4   (32-bit far return and pop 4 bytes / eflags)
 923          */
 924         ptr[i * 6 + 0] = 0xCD;
 925         ptr[i * 6 + 1] = i;
 926         ptr[i * 6 + 2] = 0x66;
 927         ptr[i * 6 + 3] = 0xCA;
 928         ptr[i * 6 + 4] = 0x04;
 929         ptr[i * 6 + 5] = 0x00;
 930     }
 931
 932     /*
 933      * PM / offset N*5: Interrupt N in 16-bit protected mode.
 934      */
 935     ptr = DOSVM_AllocCodeUMB( 5 * 256,
 936                               0, &DOSVM_dpmi_segments->int16_sel );
 937     for(i=0; i<256; i++) {
 938         /*
 939          * Each 16-bit interrupt handler is 5 bytes:
 940          * 0xCD,<i>       = int <i> (interrupt)
 941          * 0xCA,0x02,0x00 = ret 2   (16-bit far return and pop 2 bytes / eflags)
 942          */
 943         ptr[i * 5 + 0] = 0xCD;
 944         ptr[i * 5 + 1] = i;
 945         ptr[i * 5 + 2] = 0xCA;
 946         ptr[i * 5 + 3] = 0x02;
 947         ptr[i * 5 + 4] = 0x00;
 948     }
 949
 950     /*
 951      * PM / offset 0: Stub where __wine_call_from_16_regs returns.
 952      * PM / offset 3: Stub which swaps back to 32-bit application code/stack.
 953      * PM / offset 5: Stub which enables interrupts
 954      */
 955     ptr = DOSVM_AllocCodeUMB( sizeof(relay),
 956                               0,  &DOSVM_dpmi_segments->relay_code_sel);
 957     memcpy( ptr, relay, sizeof(relay) );
 958
 959     /*
 960      * Space for 16-bit stack used by relay code.
 961      */
 962     ptr = DOSVM_AllocDataUMB( DOSVM_RELAY_DATA_SIZE,
 963                               0, &DOSVM_dpmi_segments->relay_data_sel);
 964     memset( ptr, 0, DOSVM_RELAY_DATA_SIZE );
 965
 966     /*
 967      * As we store code in UMB we should make sure it is executable
 968      */
 969     VirtualProtect((void *)DOSVM_UMB_BOTTOM, DOSVM_UMB_TOP - DOSVM_UMB_BOTTOM, PAGE_EXECUTE_READWRITE, NULL);
 970
 971     event_notifier = CreateEventW(NULL, FALSE, FALSE, NULL);
 972 }