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

   1 /*
   2  * DOS Virtual Machine
   3  *
   4  * Copyright 1998 Ove Kåven
   5  *
   6  * This code hasn't been completely cleaned up yet.
   7  */
   8
   9 #include "config.h"
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <errno.h>
  15 #include <fcntl.h>
  16 #include <signal.h>
  17 #include <unistd.h>
  18 #include <sys/time.h>
  19 #include <sys/types.h>
  20
  21 #include "wine/winbase16.h"
  22 #include "wine/exception.h"
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "winuser.h"
  27 #include "winnt.h"
  28 #include "wincon.h"
  29
  30 #include "msdos.h"
  31 #include "file.h"
  32 #include "miscemu.h"
  33 #include "dosexe.h"
  34 #include "../../loader/dos/dosmod.h"
  35 #include "stackframe.h"
  36 #include "debugtools.h"
  37
  38 DECLARE_DEBUG_CHANNEL(int);
  39 DECLARE_DEBUG_CHANNEL(module);
  40 DECLARE_DEBUG_CHANNEL(relay);
  41
  42 #ifdef MZ_SUPPORTED
  43
  44 #ifdef HAVE_SYS_VM86_H
  45 # include <sys/vm86.h>
  46 #endif
  47 #ifdef HAVE_SYS_MMAN_H
  48 # include <sys/mman.h>
  49 #endif
  50
  51 #define IF_CLR(ctx)     ((ctx)->EFlags &= ~VIF_MASK)
  52 #define IF_SET(ctx)     ((ctx)->EFlags |= VIF_MASK)
  53 #define IF_ENABLED(ctx) ((ctx)->EFlags & VIF_MASK)
  54 #define SET_PEND(ctx)   ((ctx)->EFlags |= VIP_MASK)
  55 #define CLR_PEND(ctx)   ((ctx)->EFlags &= ~VIP_MASK)
  56 #define IS_PEND(ctx)    ((ctx)->EFlags & VIP_MASK)
  57
  58 #undef TRY_PICRETURN
  59
  60 typedef struct _DOSEVENT {
  61   int irq,priority;
  62   DOSRELAY relay;
  63   void *data;
  64   struct _DOSEVENT *next;
  65 } DOSEVENT, *LPDOSEVENT;
  66
  67 static struct _DOSEVENT *pending_event, *current_event;
  68 static int sig_sent, entered;
  69 static CONTEXT86 *current_context;
  70
  71 /* from module.c */
  72 extern int read_pipe, write_pipe;
  73 extern HANDLE hReadPipe;
  74 extern pid_t dosmod_pid;
  75
  76 static void do_exception( int signal, CONTEXT86 *context )
  77 {
  78     EXCEPTION_RECORD rec;
  79     if ((signal == SIGTRAP) || (signal == SIGHUP))
  80     {
  81         rec.ExceptionCode  = EXCEPTION_BREAKPOINT;
  82         rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
  83     }
  84     else
  85     {
  86         rec.ExceptionCode  = EXCEPTION_ILLEGAL_INSTRUCTION;  /* generic error */
  87         rec.ExceptionFlags = EH_NONCONTINUABLE;
  88     }
  89     rec.ExceptionRecord  = NULL;
  90     rec.ExceptionAddress = (LPVOID)context->Eip;
  91     rec.NumberParameters = 0;
  92     EXC_RtlRaiseException( &rec, context );
  93 }
  94
  95 static void DOSVM_Dump( int fn, int sig, struct vm86plus_struct*VM86 )
  96 {
  97  BYTE*inst;
  98  int x;
  99
 100  switch (VM86_TYPE(fn)) {
 101   case VM86_SIGNAL:
 102    printf("Trapped signal %d\n",sig); break;
 103   case VM86_UNKNOWN:
 104    printf("Trapped unhandled GPF\n"); break;
 105   case VM86_INTx:
 106    printf("Trapped INT %02x\n",VM86_ARG(fn)); break;
 107   case VM86_STI:
 108    printf("Trapped STI\n"); break;
 109   case VM86_PICRETURN:
 110    printf("Trapped due to pending PIC request\n"); break;
 111   case VM86_TRAP:
 112    printf("Trapped debug request\n"); break;
 113   default:
 114    printf("Trapped unknown VM86 type %d arg %d\n",VM86_TYPE(fn),VM86_ARG(fn)); break;
 115  }
 116 #define REGS VM86->regs
 117  fprintf(stderr,"AX=%04lX CX=%04lX DX=%04lX BX=%04lX\n",REGS.eax,REGS.ecx,REGS.edx,REGS.ebx);
 118  fprintf(stderr,"SI=%04lX DI=%04lX SP=%04lX BP=%04lX\n",REGS.esi,REGS.edi,REGS.esp,REGS.ebp);
 119  fprintf(stderr,"CS=%04X DS=%04X ES=%04X SS=%04X\n",REGS.cs,REGS.ds,REGS.es,REGS.ss);
 120  fprintf(stderr,"IP=%04lX EFLAGS=%08lX\n",REGS.eip,REGS.eflags);
 121
 122  inst = PTR_REAL_TO_LIN( REGS.cs, REGS.eip );
 123 #undef REGS
 124  printf("Opcodes:");
 125  for (x=0; x<8; x++) printf(" %02x",inst[x]);
 126  printf("\n");
 127 }
 128
 129 static int DOSVM_SimulateInt( int vect, CONTEXT86 *context, BOOL inwine )
 130 {
 131   FARPROC16 handler=INT_GetRMHandler(vect);
 132
 133   /* check for our real-mode hooks */
 134   if (vect==0x31) {
 135     if (context->SegCs==DOSMEM_wrap_seg) {
 136       /* exit from real-mode wrapper */
 137       return -1;
 138     }
 139     /* we could probably move some other dodgy stuff here too from dpmi.c */
 140   }
 141   /* check if the call is from our fake BIOS interrupt stubs */
 142   if ((context->SegCs==0xf000) && !inwine) {
 143     if (vect != (context->Eip/4)) {
 144       TRACE_(int)("something fishy going on here (interrupt stub is %02lx)\n", context->Eip/4);
 145     }
 146     TRACE_(int)("builtin interrupt %02x has been branched to\n", vect);
 147     INT_RealModeInterrupt(vect, context);
 148   }
 149   /* check if the call goes to an unhooked interrupt */
 150   else if (SELECTOROF(handler)==0xf000) {
 151     /* if so, call it directly */
 152     TRACE_(int)("builtin interrupt %02x has been invoked (through vector %02x)\n", OFFSETOF(handler)/4, vect);
 153     INT_RealModeInterrupt(OFFSETOF(handler)/4, context);
 154   }
 155   /* the interrupt is hooked, simulate interrupt in DOS space */
 156   else {
 157     WORD*stack= PTR_REAL_TO_LIN( context->SegSs, context->Esp );
 158     WORD flag=LOWORD(context->EFlags);
 159
 160     if (IF_ENABLED(context)) flag|=IF_MASK;
 161     else flag&=~IF_MASK;
 162
 163     *(--stack)=flag;
 164     *(--stack)=context->SegCs;
 165     *(--stack)=LOWORD(context->Eip);
 166     context->Esp-=6;
 167     context->SegCs=SELECTOROF(handler);
 168     context->Eip=OFFSETOF(handler);
 169     IF_CLR(context);
 170   }
 171   return 0;
 172 }
 173
 174 #define SHOULD_PEND(x) \
 175   (x && ((!current_event) || (x->priority < current_event->priority)))
 176
 177 static void DOSVM_SendQueuedEvent(CONTEXT86 *context)
 178 {
 179   LPDOSEVENT event = pending_event;
 180
 181   if (SHOULD_PEND(event)) {
 182     /* remove from "pending" list */
 183     pending_event = event->next;
 184     /* process event */
 185     if (event->irq>=0) {
 186       /* it's an IRQ, move it to "current" list */
 187       event->next = current_event;
 188       current_event = event;
 189       TRACE_(int)("dispatching IRQ %d\n",event->irq);
 190       /* note that if DOSVM_SimulateInt calls an internal interrupt directly,
 191        * current_event might be cleared (and event freed) in this very call! */
 192       DOSVM_SimulateInt((event->irq<8)?(event->irq+8):(event->irq-8+0x70),context,TRUE);
 193     } else {
 194       /* callback event */
 195       TRACE_(int)("dispatching callback event\n");
 196       (*event->relay)(context,event->data);
 197       free(event);
 198     }
 199   }
 200   if (!SHOULD_PEND(pending_event)) {
 201     TRACE_(int)("clearing Pending flag\n");
 202     CLR_PEND(context);
 203   }
 204 }
 205
 206 static void DOSVM_SendQueuedEvents(CONTEXT86 *context)
 207 {
 208   /* we will send all queued events as long as interrupts are enabled,
 209    * but IRQ events will disable interrupts again */
 210   while (IS_PEND(context) && IF_ENABLED(context))
 211     DOSVM_SendQueuedEvent(context);
 212 }
 213
 214 /***********************************************************************
 215  *              QueueEvent (WINEDOS.@)
 216  */
 217 void WINAPI DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
 218 {
 219   LPDOSEVENT event, cur, prev;
 220
 221   if (entered) {
 222     event = malloc(sizeof(DOSEVENT));
 223     if (!event) {
 224       ERR_(int)("out of memory allocating event entry\n");
 225       return;
 226     }
 227     event->irq = irq; event->priority = priority;
 228     event->relay = relay; event->data = data;
 229
 230     /* insert event into linked list, in order *after*
 231      * all earlier events of higher or equal priority */
 232     cur = pending_event; prev = NULL;
 233     while (cur && cur->priority<=priority) {
 234       prev = cur;
 235       cur = cur->next;
 236     }
 237     event->next = cur;
 238     if (prev) prev->next = event;
 239     else pending_event = event;
 240
 241     /* get dosmod's attention to the new event, if necessary */
 242     if (!sig_sent) {
 243       TRACE_(int)("new event queued, signalling dosmod\n");
 244       kill(dosmod_pid,SIGUSR2);
 245       sig_sent++;
 246     } else {
 247       TRACE_(int)("new event queued\n");
 248     }
 249   } else {
 250     /* DOS subsystem not running */
 251     /* (this probably means that we're running a win16 app
 252      *  which uses DPMI to thunk down to DOS services) */
 253     if (irq<0) {
 254       /* callback event, perform it with dummy context */
 255       CONTEXT86 context;
 256       memset(&context,0,sizeof(context));
 257       (*relay)(&context,data);
 258     } else {
 259       ERR_(int)("IRQ without DOS task: should not happen");
 260     }
 261   }
 262 }
 263
 264 #define CV do { CP(eax,Eax); CP(ecx,Ecx); CP(edx,Edx); CP(ebx,Ebx); \
 265            CP(esi,Esi); CP(edi,Edi); CP(esp,Esp); CP(ebp,Ebp); \
 266            CP(cs,SegCs); CP(ds,SegDs); CP(es,SegEs); \
 267            CP(ss,SegSs); CP(fs,SegFs); CP(gs,SegGs); \
 268            CP(eip,Eip); CP(eflags,EFlags); } while(0)
 269
 270 static int DOSVM_Process( int fn, int sig, struct vm86plus_struct*VM86 )
 271 {
 272  CONTEXT86 context, *old_context;
 273  int ret=0;
 274
 275 #define CP(x,y) context.y = VM86->regs.x
 276   CV;
 277 #undef CP
 278  if (VM86_TYPE(fn)==VM86_UNKNOWN) {
 279   ret=INSTR_EmulateInstruction(&context);
 280 #define CP(x,y) VM86->regs.x = context.y
 281   CV;
 282 #undef CP
 283   if (ret) return 0;
 284   ret=0;
 285  }
 286 #ifdef TRY_PICRETURN
 287  if (VM86->vm86plus.force_return_for_pic) {
 288    SET_PEND(&context);
 289  }
 290 #else
 291  /* linux doesn't preserve pending flag on return */
 292  if (SHOULD_PEND(pending_event)) {
 293    SET_PEND(&context);
 294  }
 295 #endif
 296
 297  old_context = current_context;
 298  current_context = &context;
 299
 300  switch (VM86_TYPE(fn)) {
 301   case VM86_SIGNAL:
 302    TRACE_(int)("DOS module caught signal %d\n",sig);
 303    if ((sig==SIGALRM) || (sig==SIGUSR2)) {
 304      if (sig==SIGALRM) {
 305        sig_sent++;
 306        DOSVM_QueueEvent(0,DOS_PRIORITY_REALTIME,NULL,NULL);
 307      }
 308      if (pending_event) {
 309        TRACE_(int)("setting Pending flag, interrupts are currently %s\n",
 310                  IF_ENABLED(&context) ? "enabled" : "disabled");
 311        SET_PEND(&context);
 312        DOSVM_SendQueuedEvents(&context);
 313      } else {
 314        TRACE_(int)("no events are pending, clearing Pending flag\n");
 315        CLR_PEND(&context);
 316      }
 317      sig_sent--;
 318    }
 319    else if ((sig==SIGHUP) || (sig==SIGILL) || (sig==SIGSEGV)) {
 320        do_exception( sig, &context );
 321    } else {
 322     DOSVM_Dump(fn,sig,VM86);
 323     ret=-1;
 324    }
 325    break;
 326   case VM86_UNKNOWN: /* unhandled GPF */
 327    DOSVM_Dump(fn,sig,VM86);
 328    do_exception( SIGSEGV, &context );
 329    break;
 330   case VM86_INTx:
 331    if (TRACE_ON(relay))
 332     DPRINTF("Call DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip);
 333    ret=DOSVM_SimulateInt(VM86_ARG(fn),&context,FALSE);
 334    if (TRACE_ON(relay))
 335     DPRINTF("Ret  DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip);
 336    break;
 337   case VM86_STI:
 338     IF_SET(&context);
 339   /* case VM86_PICRETURN: */
 340     TRACE_(int)("DOS task enabled interrupts %s events pending, sending events\n", IS_PEND(&context)?"with":"without");
 341     DOSVM_SendQueuedEvents(&context);
 342     break;
 343   case VM86_TRAP:
 344    do_exception( SIGTRAP, &context );
 345    break;
 346   default:
 347    DOSVM_Dump(fn,sig,VM86);
 348    ret=-1;
 349  }
 350
 351  current_context = old_context;
 352
 353 #define CP(x,y) VM86->regs.x = context.y
 354  CV;
 355 #undef CP
 356 #ifdef TRY_PICRETURN
 357  VM86->vm86plus.force_return_for_pic = IS_PEND(&context) ? 1 : 0;
 358  CLR_PEND(&context);
 359 #endif
 360  return ret;
 361 }
 362
 363 static void DOSVM_ProcessConsole(void)
 364 {
 365   INPUT_RECORD msg;
 366   DWORD res;
 367   BYTE scan;
 368
 369   if (ReadConsoleInputA(GetStdHandle(STD_INPUT_HANDLE),&msg,1,&res)) {
 370     switch (msg.EventType) {
 371     case KEY_EVENT:
 372       scan = msg.Event.KeyEvent.wVirtualScanCode;
 373       if (!msg.Event.KeyEvent.bKeyDown) scan |= 0x80;
 374
 375       /* check whether extended bit is set,
 376        * and if so, queue the extension prefix */
 377       if (msg.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY) {
 378         INT_Int09SendScan(0xE0,0);
 379       }
 380       INT_Int09SendScan(scan,msg.Event.KeyEvent.uChar.AsciiChar);
 381       break;
 382     default:
 383       FIXME_(int)("unhandled console event: %d\n", msg.EventType);
 384     }
 385   }
 386 }
 387
 388 static void DOSVM_ProcessMessage(MSG *msg)
 389 {
 390   BYTE scan = 0;
 391
 392   TRACE_(int)("got message %04x, wparam=%08x, lparam=%08lx\n",msg->message,msg->wParam,msg->lParam);
 393   if ((msg->message>=WM_MOUSEFIRST)&&
 394       (msg->message<=WM_MOUSELAST)) {
 395     INT_Int33Message(msg->message,msg->wParam,msg->lParam);
 396   } else {
 397     switch (msg->message) {
 398     case WM_KEYUP:
 399       scan = 0x80;
 400     case WM_KEYDOWN:
 401       scan |= (msg->lParam >> 16) & 0x7f;
 402
 403       /* check whether extended bit is set,
 404        * and if so, queue the extension prefix */
 405       if (msg->lParam & 0x1000000) {
 406         /* FIXME: some keys (function keys) have
 407          * extended bit set even when they shouldn't,
 408          * should check for them */
 409         INT_Int09SendScan(0xE0,0);
 410       }
 411       INT_Int09SendScan(scan,0);
 412       break;
 413     }
 414   }
 415 }
 416
 417 /***********************************************************************
 418  *              Wait (WINEDOS.@)
 419  */
 420 void WINAPI DOSVM_Wait( INT read_pipe, HANDLE hObject )
 421 {
 422   MSG msg;
 423   DWORD waitret;
 424   HANDLE objs[2];
 425   int objc;
 426   BOOL got_msg = FALSE;
 427
 428   objs[0]=GetStdHandle(STD_INPUT_HANDLE);
 429   objs[1]=hObject;
 430   objc=hObject?2:1;
 431   do {
 432     /* check for messages (waste time before the response check below) */
 433     if (PeekMessageA)
 434     {
 435         while (PeekMessageA(&msg,0,0,0,PM_REMOVE|PM_NOYIELD)) {
 436             /* got a message */
 437             DOSVM_ProcessMessage(&msg);
 438             /* we don't need a TranslateMessage here */
 439             DispatchMessageA(&msg);
 440             got_msg = TRUE;
 441         }
 442     }
 443 chk_console_input:
 444     if (!got_msg) {
 445       /* check for console input */
 446       INPUT_RECORD msg;
 447       DWORD num;
 448       if (PeekConsoleInputA(objs[0],&msg,1,&num) && num) {
 449         DOSVM_ProcessConsole();
 450         got_msg = TRUE;
 451       }
 452     }
 453     if (read_pipe == -1) {
 454       /* dispatch pending events */
 455       if (SHOULD_PEND(pending_event)) {
 456         CONTEXT86 context = *current_context;
 457         IF_SET(&context);
 458         SET_PEND(&context);
 459         DOSVM_SendQueuedEvents(&context);
 460       }
 461       if (got_msg) break;
 462     } else {
 463       fd_set readfds;
 464       struct timeval timeout={0,0};
 465       /* quick check for response from dosmod
 466        * (faster than doing the full blocking wait, if data already available) */
 467       FD_ZERO(&readfds); FD_SET(read_pipe,&readfds);
 468       if (select(read_pipe+1,&readfds,NULL,NULL,&timeout)>0)
 469         break;
 470     }
 471     /* nothing yet, block while waiting for something to do */
 472     if (MsgWaitForMultipleObjects)
 473         waitret = MsgWaitForMultipleObjects(objc,objs,FALSE,INFINITE,QS_ALLINPUT);
 474     else
 475         waitret = WaitForMultipleObjects(objc,objs,FALSE,INFINITE);
 476
 477     if (waitret==(DWORD)-1) {
 478       ERR_(module)("dosvm wait error=%ld\n",GetLastError());
 479     }
 480     if ((read_pipe != -1) && hObject) {
 481       if (waitret==(WAIT_OBJECT_0+1)) break;
 482     }
 483     if (waitret==WAIT_OBJECT_0)
 484       goto chk_console_input;
 485   } while (TRUE);
 486 }
 487
 488 /***********************************************************************
 489  *              Enter (WINEDOS.@)
 490  */
 491 INT WINAPI DOSVM_Enter( CONTEXT86 *context )
 492 {
 493  struct vm86plus_struct VM86;
 494  int stat,len,sig;
 495
 496  memset(&VM86, 0, sizeof(VM86));
 497 #define CP(x,y) VM86.regs.x = context->y
 498   CV;
 499 #undef CP
 500   if (VM86.regs.eflags & IF_MASK)
 501     VM86.regs.eflags |= VIF_MASK;
 502
 503  /* main exchange loop */
 504  entered++;
 505  do {
 506   TRACE_(module)("thread is: %lx\n",GetCurrentThreadId());
 507   stat = VM86_ENTER;
 508   errno = 0;
 509   /* transmit VM86 structure to dosmod task */
 510   if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
 511    ERR_(module)("dosmod sync lost, errno=%d, fd=%d, pid=%d\n",errno,write_pipe,getpid());
 512    return -1;
 513   }
 514   if (write(write_pipe,&VM86,sizeof(VM86))!=sizeof(VM86)) {
 515    ERR_(module)("dosmod sync lost, errno=%d\n",errno);
 516    return -1;
 517   }
 518   /* wait for response, doing other things in the meantime */
 519   DOSVM_Wait(read_pipe, hReadPipe);
 520   /* read response */
 521   while (1) {
 522     if ((len=read(read_pipe,&stat,sizeof(stat)))==sizeof(stat)) break;
 523     if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
 524      WARN_(module)("rereading dosmod return code due to errno=%d, result=%d\n",errno,len);
 525      continue;
 526     }
 527     ERR_(module)("dosmod sync lost reading return code, errno=%d, result=%d\n",errno,len);
 528     return -1;
 529   }
 530   TRACE_(module)("dosmod return code=%d\n",stat);
 531   if (stat==DOSMOD_LEFTIDLE) {
 532     continue;
 533   }
 534   while (1) {
 535     if ((len=read(read_pipe,&VM86,sizeof(VM86)))==sizeof(VM86)) break;
 536     if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
 537      WARN_(module)("rereading dosmod VM86 structure due to errno=%d, result=%d\n",errno,len);
 538      continue;
 539     }
 540     ERR_(module)("dosmod sync lost reading VM86 structure, errno=%d, result=%d\n",errno,len);
 541     return -1;
 542   }
 543   if ((stat&0xff)==DOSMOD_SIGNAL) {
 544     while (1) {
 545       if ((len=read(read_pipe,&sig,sizeof(sig)))==sizeof(sig)) break;
 546       if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
 547         WARN_(module)("rereading dosmod signal due to errno=%d, result=%d\n",errno,len);
 548         continue;
 549       }
 550       ERR_(module)("dosmod sync lost reading signal, errno=%d, result=%d\n",errno,len);
 551       return -1;
 552     } while (0);
 553   } else sig=0;
 554   /* got response */
 555  } while (DOSVM_Process(stat,sig,&VM86)>=0);
 556  entered--;
 557
 558 #define CP(x,y) context->y = VM86.regs.x
 559   CV;
 560 #undef CP
 561  return 0;
 562 }
 563
 564 /***********************************************************************
 565  *              OutPIC (WINEDOS.@)
 566  */
 567 void WINAPI DOSVM_PIC_ioport_out( WORD port, BYTE val)
 568 {
 569     LPDOSEVENT event;
 570
 571     if ((port==0x20) && (val==0x20)) {
 572       if (current_event) {
 573         /* EOI (End Of Interrupt) */
 574         TRACE_(int)("received EOI for current IRQ, clearing\n");
 575         event = current_event;
 576         current_event = event->next;
 577         if (event->relay)
 578         (*event->relay)(NULL,event->data);
 579         free(event);
 580
 581         if (pending_event &&
 582             !sig_sent) {
 583           /* another event is pending, which we should probably
 584            * be able to process now, so tell dosmod about it */
 585           TRACE_(int)("another event pending, signalling dosmod\n");
 586           kill(dosmod_pid,SIGUSR2);
 587           sig_sent++;
 588         }
 589       } else {
 590         WARN_(int)("EOI without active IRQ\n");
 591       }
 592     } else {
 593       FIXME_(int)("unrecognized PIC command %02x\n",val);
 594     }
 595 }
 596
 597 /***********************************************************************
 598  *              SetTimer (WINEDOS.@)
 599  */
 600 void WINAPI DOSVM_SetTimer( UINT ticks )
 601 {
 602   int stat=DOSMOD_SET_TIMER;
 603   struct timeval tim;
 604
 605   if (MZ_Current()) {
 606     /* the PC clocks ticks at 1193180 Hz */
 607     tim.tv_sec=0;
 608     tim.tv_usec=MulDiv(ticks,1000000,1193180);
 609     /* sanity check */
 610     if (!tim.tv_usec) tim.tv_usec=1;
 611
 612     if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
 613       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
 614       return;
 615     }
 616     if (write(write_pipe,&tim,sizeof(tim))!=sizeof(tim)) {
 617       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
 618       return;
 619     }
 620     /* there's no return */
 621   }
 622 }
 623
 624 /***********************************************************************
 625  *              GetTimer (WINEDOS.@)
 626  */
 627 UINT WINAPI DOSVM_GetTimer( void )
 628 {
 629   int stat=DOSMOD_GET_TIMER;
 630   struct timeval tim;
 631
 632   if (MZ_Current()) {
 633     if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
 634       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
 635       return 0;
 636     }
 637     /* read response */
 638     while (1) {
 639       if (read(read_pipe,&tim,sizeof(tim))==sizeof(tim)) break;
 640       if ((errno==EINTR)||(errno==EAGAIN)) continue;
 641       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
 642       return 0;
 643     }
 644     return MulDiv(tim.tv_usec,1193180,1000000);
 645   }
 646   return 0;
 647 }
 648
 649 #else /* !MZ_SUPPORTED */
 650
 651 /***********************************************************************
 652  *              Enter (WINEDOS.@)
 653  */
 654 INT WINAPI DOSVM_Enter( CONTEXT86 *context )
 655 {
 656  ERR_(module)("DOS realmode not supported on this architecture!\n");
 657  return -1;
 658 }
 659
 660 /***********************************************************************
 661  *              Wait (WINEDOS.@)
 662  */
 663 void WINAPI DOSVM_Wait( INT read_pipe, HANDLE hObject) {}
 664
 665 /***********************************************************************
 666  *              OutPIC (WINEDOS.@)
 667  */
 668 void WINAPI DOSVM_PIC_ioport_out( WORD port, BYTE val) {}
 669
 670 /***********************************************************************
 671  *              SetTimer (WINEDOS.@)
 672  */
 673 void WINAPI DOSVM_SetTimer( UINT ticks ) {}
 674
 675 /***********************************************************************
 676  *              GetTimer (WINEDOS.@)
 677  */
 678 UINT WINAPI DOSVM_GetTimer( void ) { return 0; }
 679
 680 /***********************************************************************
 681  *              QueueEvent (WINEDOS.@)
 682  */
 683 void WINAPI DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
 684 {
 685   if (irq<0) {
 686     /* callback event, perform it with dummy context */
 687     CONTEXT86 context;
 688     memset(&context,0,sizeof(context));
 689     (*relay)(&context,data);
 690   } else {
 691     ERR_(int)("IRQ without DOS task: should not happen");
 692   }
 693 }
 694
 695 #endif