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