msdos/dpmi.c

   1 /*
   2  * DPMI 0.9 emulation
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <unistd.h>
   9 #include <string.h>
  10 #include "windows.h"
  11 #include "heap.h"
  12 #include "ldt.h"
  13 #include "module.h"
  14 #include "miscemu.h"
  15 #include "drive.h"
  16 #include "msdos.h"
  17 #include "toolhelp.h"
  18 #include "debug.h"
  19
  20 #define DOS_GET_DRIVE(reg) ((reg) ? (reg) - 1 : DRIVE_GetCurrentDrive())
  21
  22 void CreateBPB(int drive, BYTE *data);  /* defined in int21.c */
  23
  24
  25 /* Structure for real-mode callbacks */
  26 typedef struct
  27 {
  28     DWORD edi;
  29     DWORD esi;
  30     DWORD ebp;
  31     DWORD reserved;
  32     DWORD ebx;
  33     DWORD edx;
  34     DWORD ecx;
  35     DWORD eax;
  36     WORD  fl;
  37     WORD  es;
  38     WORD  ds;
  39     WORD  fs;
  40     WORD  gs;
  41     WORD  ip;
  42     WORD  cs;
  43     WORD  sp;
  44     WORD  ss;
  45 } REALMODECALL;
  46
  47
  48
  49 /**********************************************************************
  50  *          INT_GetRealModeContext
  51  */
  52 static void INT_GetRealModeContext( REALMODECALL *call, CONTEXT *context )
  53 {
  54     EAX_reg(context) = call->eax;
  55     EBX_reg(context) = call->ebx;
  56     ECX_reg(context) = call->ecx;
  57     EDX_reg(context) = call->edx;
  58     ESI_reg(context) = call->esi;
  59     EDI_reg(context) = call->edi;
  60     EBP_reg(context) = call->ebp;
  61     EFL_reg(context) = call->fl;
  62     EIP_reg(context) = call->ip;
  63     ESP_reg(context) = call->sp;
  64     CS_reg(context)  = call->cs;
  65     DS_reg(context)  = call->ds;
  66     ES_reg(context)  = call->es;
  67     FS_reg(context)  = call->fs;
  68     GS_reg(context)  = call->gs;
  69 }
  70
  71
  72 /**********************************************************************
  73  *          INT_SetRealModeContext
  74  */
  75 static void INT_SetRealModeContext( REALMODECALL *call, CONTEXT *context )
  76 {
  77     call->eax = EAX_reg(context);
  78     call->ebx = EBX_reg(context);
  79     call->ecx = ECX_reg(context);
  80     call->edx = EDX_reg(context);
  81     call->esi = ESI_reg(context);
  82     call->edi = EDI_reg(context);
  83     call->ebp = EBP_reg(context);
  84     call->fl  = FL_reg(context);
  85     call->ip  = IP_reg(context);
  86     call->sp  = SP_reg(context);
  87     call->cs  = CS_reg(context);
  88     call->ds  = DS_reg(context);
  89     call->es  = ES_reg(context);
  90     call->fs  = FS_reg(context);
  91     call->gs  = GS_reg(context);
  92 }
  93
  94
  95 /**********************************************************************
  96  *          INT_DoRealModeInt
  97  */
  98 static void INT_DoRealModeInt( CONTEXT *context )
  99 {
 100     CONTEXT realmode_ctx;
 101     REALMODECALL *call = (REALMODECALL *)PTR_SEG_OFF_TO_LIN( ES_reg(context),
 102                                                           DI_reg(context) );
 103     INT_GetRealModeContext( call, &realmode_ctx );
 104
 105     RESET_CFLAG(context);
 106     switch (BL_reg(context))
 107     {
 108     case 0x2f:  /* int2f */
 109         switch (AH_reg(&realmode_ctx))
 110         {
 111         case 0x15:
 112             /* MSCDEX hook */
 113             do_mscdex( &realmode_ctx );
 114             break;
 115         default:
 116             SET_CFLAG(context);
 117             break;
 118         }
 119         break;
 120     case 0x21:  /* int21 */
 121         switch (AH_reg(&realmode_ctx))
 122         {
 123         case 0x52:
 124             ES_reg(&realmode_ctx) = 0;
 125             EBX_reg(&realmode_ctx) = 0;
 126             break;
 127         case 0x65:
 128             switch (AL_reg(&realmode_ctx))
 129             {
 130             case 0x06:
 131                 {/* get collate table */
 132                     /* ES:DI is a REALMODE pointer to 5 byte dosmem
 133                      * we fill that with 0x6, realmode pointer to collateTB
 134                      */
 135                     char *table = DOSMEM_MapRealToLinear(
 136                        MAKELONG(EDI_reg(&realmode_ctx),ES_reg(&realmode_ctx)));
 137                     *(BYTE*)table      = 0x06;
 138                     *(DWORD*)(table+1) = DOSMEM_CollateTable;
 139                     CX_reg(&realmode_ctx) = 258;/*FIXME: size of table?*/
 140                     break;
 141                 }
 142             default:
 143                 SET_CFLAG(context);
 144                 break;
 145             }
 146             break;
 147         case 0x44:
 148             switch (AL_reg(&realmode_ctx))
 149             {
 150             case 0x0D:
 151                 {/* generic block device request */
 152                     BYTE *dataptr = DOSMEM_MapRealToLinear(
 153                        MAKELONG(EDX_reg(&realmode_ctx),DS_reg(&realmode_ctx)));
 154                     int drive = DOS_GET_DRIVE(BL_reg(&realmode_ctx));
 155                     if (CH_reg(&realmode_ctx) != 0x08)
 156                     {
 157                         SET_CFLAG(context);
 158                         break;
 159                     }
 160                     switch (CL_reg(&realmode_ctx))
 161                     {
 162                     case 0x66:
 163                         {
 164                             char    label[12],fsname[9],path[4];
 165                             DWORD   serial;
 166
 167                             strcpy(path,"x:\\");path[0]=drive+'A';
 168                             GetVolumeInformation32A(path,label,12,&serial,NULL,NULL,fsname,9);
 169                             *(WORD*)dataptr         = 0;
 170                             memcpy(dataptr+2,&serial,4);
 171                             memcpy(dataptr+6,label  ,11);
 172                             memcpy(dataptr+17,fsname,8);
 173                             break;
 174                         }
 175                     case 0x60:  /* get device parameters */
 176                                 /* used by defrag.exe of win95 */
 177                         memset(dataptr, 0, 0x26);
 178                         dataptr[0] = 0x04;
 179                         dataptr[6] = 0; /* media type */
 180                         if (drive > 1)
 181                         {
 182                             dataptr[1] = 0x05; /* fixed disk */
 183                             setword(&dataptr[2], 0x01); /* non removable */
 184                             setword(&dataptr[4], 0x300); /* # of cylinders */
 185                         }
 186                         else
 187                         {
 188                             dataptr[1] = 0x07; /* block dev, floppy */
 189                             setword(&dataptr[2], 0x02); /* removable */
 190                             setword(&dataptr[4], 80); /* # of cylinders */
 191                         }
 192                         CreateBPB(drive, &dataptr[7]);
 193                         break;
 194                     default:
 195                         SET_CFLAG(context);
 196                         break;
 197                     }
 198                 }
 199             break;
 200             default:
 201                 SET_CFLAG(context);
 202                 break;
 203             }
 204             break;
 205         default:
 206             SET_CFLAG(context);
 207             break;
 208         }
 209         break;
 210     default:
 211         SET_CFLAG(context);
 212         break;
 213     }
 214
 215     if (EFL_reg(context)&1)
 216         fprintf(stdnimp,
 217                 "RealModeInt %02x: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n"
 218                 "                ESI=%08lx EDI=%08lx DS=%04lx ES=%04lx\n",
 219                 BL_reg(context), EAX_reg(&realmode_ctx),
 220                 EBX_reg(&realmode_ctx), ECX_reg(&realmode_ctx),
 221                 EDX_reg(&realmode_ctx), ESI_reg(&realmode_ctx),
 222                 EDI_reg(&realmode_ctx), DS_reg(&realmode_ctx),
 223                 ES_reg(&realmode_ctx) );
 224     INT_SetRealModeContext( call, &realmode_ctx );
 225 }
 226
 227
 228 /**********************************************************************
 229  *          INT_Int31Handler
 230  *
 231  * Handler for int 31h (DPMI).
 232  */
 233 void WINAPI INT_Int31Handler( CONTEXT *context )
 234 {
 235     DWORD dw;
 236     BYTE *ptr;
 237
 238     RESET_CFLAG(context);
 239     switch(AX_reg(context))
 240     {
 241     case 0x0000:  /* Allocate LDT descriptors */
 242         if (!(AX_reg(context) = AllocSelectorArray( CX_reg(context) )))
 243         {
 244             AX_reg(context) = 0x8011;  /* descriptor unavailable */
 245             SET_CFLAG(context);
 246         }
 247         break;
 248
 249     case 0x0001:  /* Free LDT descriptor */
 250         if (FreeSelector( BX_reg(context) ))
 251         {
 252             AX_reg(context) = 0x8022;  /* invalid selector */
 253             SET_CFLAG(context);
 254         }
 255         else
 256         {
 257             /* If a segment register contains the selector being freed, */
 258             /* set it to zero. */
 259             if (!((DS_reg(context)^BX_reg(context)) & ~3)) DS_reg(context) = 0;
 260             if (!((ES_reg(context)^BX_reg(context)) & ~3)) ES_reg(context) = 0;
 261             if (!((FS_reg(context)^BX_reg(context)) & ~3)) FS_reg(context) = 0;
 262             if (!((GS_reg(context)^BX_reg(context)) & ~3)) GS_reg(context) = 0;
 263         }
 264         break;
 265
 266     case 0x0002:  /* Real mode segment to descriptor */
 267         {
 268             WORD entryPoint = 0;  /* KERNEL entry point for descriptor */
 269             switch(BX_reg(context))
 270             {
 271             case 0x0000: entryPoint = 183; break;  /* __0000H */
 272             case 0x0040: entryPoint = 193; break;  /* __0040H */
 273             case 0xa000: entryPoint = 174; break;  /* __A000H */
 274             case 0xb000: entryPoint = 181; break;  /* __B000H */
 275             case 0xb800: entryPoint = 182; break;  /* __B800H */
 276             case 0xc000: entryPoint = 195; break;  /* __C000H */
 277             case 0xd000: entryPoint = 179; break;  /* __D000H */
 278             case 0xe000: entryPoint = 190; break;  /* __E000H */
 279             case 0xf000: entryPoint = 194; break;  /* __F000H */
 280             default:
 281                 AX_reg(context) = DOSMEM_AllocSelector(BX_reg(context));
 282                 break;
 283             }
 284             if (entryPoint)
 285                 AX_reg(context) = LOWORD(MODULE_GetEntryPoint(
 286                                                  GetModuleHandle16( "KERNEL" ),
 287                                                  entryPoint ));
 288         }
 289         break;
 290
 291     case 0x0003:  /* Get next selector increment */
 292         AX_reg(context) = __AHINCR;
 293         break;
 294
 295     case 0x0004:  /* Lock selector (not supported) */
 296         AX_reg(context) = 0;  /* FIXME: is this a correct return value? */
 297         break;
 298
 299     case 0x0005:  /* Unlock selector (not supported) */
 300         AX_reg(context) = 0;  /* FIXME: is this a correct return value? */
 301         break;
 302
 303     case 0x0006:  /* Get selector base address */
 304         if (!(dw = GetSelectorBase( BX_reg(context) )))
 305         {
 306             AX_reg(context) = 0x8022;  /* invalid selector */
 307             SET_CFLAG(context);
 308         }
 309         else
 310         {
 311             CX_reg(context) = HIWORD(dw);
 312             DX_reg(context) = LOWORD(dw);
 313         }
 314         break;
 315
 316     case 0x0007:  /* Set selector base address */
 317         SetSelectorBase( BX_reg(context),
 318                          MAKELONG( DX_reg(context), CX_reg(context) ) );
 319         break;
 320
 321     case 0x0008:  /* Set selector limit */
 322         SetSelectorLimit( BX_reg(context),
 323                           MAKELONG( DX_reg(context), CX_reg(context) ) );
 324         break;
 325
 326     case 0x0009:  /* Set selector access rights */
 327         SelectorAccessRights( BX_reg(context), 1, CX_reg(context) );
 328         break;
 329
 330     case 0x000a:  /* Allocate selector alias */
 331         if (!(AX_reg(context) = AllocCStoDSAlias( BX_reg(context) )))
 332         {
 333             AX_reg(context) = 0x8011;  /* descriptor unavailable */
 334             SET_CFLAG(context);
 335         }
 336         break;
 337
 338     case 0x000b:  /* Get descriptor */
 339         {
 340             ldt_entry entry;
 341             LDT_GetEntry( SELECTOR_TO_ENTRY( BX_reg(context) ), &entry );
 342             /* FIXME: should use ES:EDI for 32-bit clients */
 343             LDT_EntryToBytes( PTR_SEG_OFF_TO_LIN( ES_reg(context),
 344                                                   DI_reg(context) ), &entry );
 345         }
 346         break;
 347
 348     case 0x000c:  /* Set descriptor */
 349         {
 350             ldt_entry entry;
 351             LDT_BytesToEntry( PTR_SEG_OFF_TO_LIN( ES_reg(context),
 352                                                   DI_reg(context) ), &entry );
 353             LDT_SetEntry( SELECTOR_TO_ENTRY( BX_reg(context) ), &entry );
 354         }
 355         break;
 356
 357     case 0x000d:  /* Allocate specific LDT descriptor */
 358         AX_reg(context) = 0x8011; /* descriptor unavailable */
 359         SET_CFLAG(context);
 360         break;
 361     case 0x0200: /* get real mode interrupt vector */
 362         fprintf(stdnimp,
 363                 "int31: get realmode interupt vector(0x%02x) unimplemented.\n",
 364                 BL_reg(context)
 365         );
 366         SET_CFLAG(context);
 367         break;
 368     case 0x0201: /* set real mode interrupt vector */
 369         fprintf(stdnimp,
 370                 "int31: set realmode interupt vector(0x%02x,0x%04x:0x%04x) unimplemented\n",
 371                 BL_reg(context),CX_reg(context),DX_reg(context)
 372         );
 373         SET_CFLAG(context);
 374         break;
 375     case 0x0204:  /* Get protected mode interrupt vector */
 376         dw = (DWORD)INT_GetHandler( BL_reg(context) );
 377         CX_reg(context) = HIWORD(dw);
 378         DX_reg(context) = LOWORD(dw);
 379         break;
 380
 381     case 0x0205:  /* Set protected mode interrupt vector */
 382         INT_SetHandler( BL_reg(context),
 383                         (FARPROC16)PTR_SEG_OFF_TO_SEGPTR( CX_reg(context),
 384                                                           DX_reg(context) ));
 385         break;
 386
 387     case 0x0300:  /* Simulate real mode interrupt */
 388         INT_DoRealModeInt( context );
 389         break;
 390
 391     case 0x0301:  /* Call real mode procedure with far return */
 392         {
 393             REALMODECALL *p = (REALMODECALL *)PTR_SEG_OFF_TO_LIN( ES_reg(context), DI_reg(context) );
 394             fprintf(stdnimp,
 395                     "RealModeCall: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n"
 396                     "              ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x\n",
 397                     p->eax, p->ebx, p->ecx, p->edx,
 398                     p->esi, p->edi, p->es, p->ds, p->cs, p->ip );
 399             SET_CFLAG(context);
 400         }
 401         break;
 402
 403     case 0x0302:  /* Call real mode procedure with interrupt return */
 404         {
 405             REALMODECALL *p = (REALMODECALL *)PTR_SEG_OFF_TO_LIN( ES_reg(context), DI_reg(context) );
 406             fprintf(stdnimp,
 407                     "RealModeCallIret: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n"
 408                     "                  ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x\n",
 409                     p->eax, p->ebx, p->ecx, p->edx,
 410                     p->esi, p->edi, p->es, p->ds, p->cs, p->ip );
 411             SET_CFLAG(context);
 412         }
 413         break;
 414
 415     case 0x0303:  /* Allocate Real Mode Callback Address */
 416         {
 417             REALMODECALL *p = (REALMODECALL *)PTR_SEG_OFF_TO_LIN( ES_reg(context), DI_reg(context) );
 418             fprintf(stdnimp,
 419                     "AllocRMCB: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n"
 420                     "           ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x\n"
 421                     "   Function to call: %04x:%04x\n",
 422                     p->eax, p->ebx, p->ecx, p->edx,
 423                     p->esi, p->edi, p->es, p->ds, p->cs, p->ip,
 424                     (WORD)DS_reg(context), SI_reg(context) );
 425             SET_CFLAG(context);
 426         }
 427         break;
 428
 429     case 0x0304:  /* Free Real Mode Callback Address */
 430         {
 431             fprintf(stdnimp,
 432                     "FreeRMCB: callback address: %04x:%04x\n",
 433                     CX_reg(context), DX_reg(context));
 434             SET_CFLAG(context);
 435         }
 436         break;
 437
 438     case 0x0400:  /* Get DPMI version */
 439         {
 440             SYSTEM_INFO si;
 441
 442             GetSystemInfo(&si);
 443             AX_reg(context) = 0x005a;  /* DPMI version 0.90 */
 444             BX_reg(context) = 0x0005;  /* Flags: 32-bit, virtual memory */
 445             CL_reg(context) = si.wProcessorLevel;
 446             DX_reg(context) = 0x0102;  /* Master/slave interrupt controller base*/
 447             break;
 448         }
 449     case 0x0500:  /* Get free memory information */
 450         {
 451             MEMMANINFO mmi;
 452
 453             mmi.dwSize = sizeof(mmi);
 454             MemManInfo(&mmi);
 455             ptr = (BYTE *)PTR_SEG_OFF_TO_LIN(ES_reg(context),DI_reg(context));
 456             /* the layout is just the same as MEMMANINFO, but without
 457              * the dwSize entry.
 458              */
 459             memcpy(ptr,((char*)&mmi)+4,sizeof(mmi)-4);
 460             break;
 461         }
 462     case 0x0501:  /* Allocate memory block */
 463         if (!(ptr = (BYTE *)VirtualAlloc(NULL, MAKELONG(CX_reg(context), BX_reg(context)), MEM_COMMIT, PAGE_EXECUTE_READWRITE)))
 464         {
 465             AX_reg(context) = 0x8012;  /* linear memory not available */
 466             SET_CFLAG(context);
 467         }
 468         else
 469         {
 470             BX_reg(context) = SI_reg(context) = HIWORD(ptr);
 471             CX_reg(context) = DI_reg(context) = LOWORD(ptr);
 472         }
 473         break;
 474
 475     case 0x0502:  /* Free memory block */
 476         VirtualFree((void *)MAKELONG(DI_reg(context), SI_reg(context)), 0, MEM_RELEASE);
 477         break;
 478
 479     case 0x0503:  /* Resize memory block */
 480         if (!(ptr = (BYTE *)HeapReAlloc( GetProcessHeap(), 0,
 481                            (void *)MAKELONG(DI_reg(context),SI_reg(context)),
 482                                    MAKELONG(CX_reg(context),BX_reg(context)))))
 483         {
 484             AX_reg(context) = 0x8012;  /* linear memory not available */
 485             SET_CFLAG(context);
 486         }
 487         else
 488         {
 489             BX_reg(context) = SI_reg(context) = HIWORD(ptr);
 490             CX_reg(context) = DI_reg(context) = LOWORD(ptr);
 491         }
 492         break;
 493
 494     case 0x0600:  /* Lock linear region */
 495         break;  /* Just ignore it */
 496
 497     case 0x0601:  /* Unlock linear region */
 498         break;  /* Just ignore it */
 499
 500     case 0x0602:  /* Unlock real-mode region */
 501         break;  /* Just ignore it */
 502
 503     case 0x0603:  /* Lock real-mode region */
 504         break;  /* Just ignore it */
 505
 506     case 0x0604:  /* Get page size */
 507         BX_reg(context) = 0;
 508         CX_reg(context) = 4096;
 509         break;
 510
 511     case 0x0702:  /* Mark page as demand-paging candidate */
 512         break;  /* Just ignore it */
 513
 514     case 0x0703:  /* Discard page contents */
 515         break;  /* Just ignore it */
 516
 517      case 0x0800:  /* Physical address mapping */
 518          if(!(ptr=DOSMEM_MapRealToLinear(MAKELONG(CX_reg(context),BX_reg(context)))))
 519          {
 520              AX_reg(context) = 0x8021;
 521              SET_CFLAG(context);
 522          }
 523          else
 524          {
 525              BX_reg(context) = HIWORD(ptr);
 526              CX_reg(context) = LOWORD(ptr);
 527              RESET_CFLAG(context);
 528          }
 529          break;
 530
 531     default:
 532         INT_BARF( context, 0x31 );
 533         AX_reg(context) = 0x8001;  /* unsupported function */
 534         SET_CFLAG(context);
 535         break;
 536     }
 537 }