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