dlls/winedos/int31.c - wine - Git at Google

 /*
  * DPMI 0.9 emulation
  *
  * Copyright 1995 Alexandre Julliard
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

 #include "config.h"

 #include "windef.h"
 #include "wine/winbase16.h"
 #include "miscemu.h"
 #include "task.h"
 #include "msdos.h"
 #include "dosexe.h"

 #include "wine/debug.h"

 WINE_DEFAULT_DEBUG_CHANNEL(int31);

 /* Structure for real-mode callbacks */
 typedef struct
 {
     DWORD edi;
     DWORD esi;
     DWORD ebp;
     DWORD reserved;
     DWORD ebx;
     DWORD edx;
     DWORD ecx;
     DWORD eax;
     WORD  fl;
     WORD  es;
     WORD  ds;
     WORD  fs;
     WORD  gs;
     WORD  ip;
     WORD  cs;
     WORD  sp;
     WORD  ss;
 } REALMODECALL;

 typedef struct tagRMCB {
     DWORD address;
     DWORD proc_ofs,proc_sel;
     DWORD regs_ofs,regs_sel;
     struct tagRMCB *next;
 } RMCB;

 static RMCB *FirstRMCB = NULL;
 static WORD dpmi_flag;

 /**********************************************************************
  *	    INT_GetRealModeContext
  */
 static void INT_GetRealModeContext( REALMODECALL *call, CONTEXT86 *context )
 {
     context->Eax    = call->eax;
     context->Ebx    = call->ebx;
     context->Ecx    = call->ecx;
     context->Edx    = call->edx;
     context->Esi    = call->esi;
     context->Edi    = call->edi;
     context->Ebp    = call->ebp;
     context->EFlags = call->fl | V86_FLAG;
     context->Eip    = call->ip;
     context->Esp    = call->sp;
     context->SegCs  = call->cs;
     context->SegDs  = call->ds;
     context->SegEs  = call->es;
     context->SegFs  = call->fs;
     context->SegGs  = call->gs;
     context->SegSs  = call->ss;
 }


 /**********************************************************************
  *	    INT_SetRealModeContext
  */
 static void INT_SetRealModeContext( REALMODECALL *call, CONTEXT86 *context )
 {
     call->eax = context->Eax;
     call->ebx = context->Ebx;
     call->ecx = context->Ecx;
     call->edx = context->Edx;
     call->esi = context->Esi;
     call->edi = context->Edi;
     call->ebp = context->Ebp;
     call->fl  = LOWORD(context->EFlags);
     call->ip  = LOWORD(context->Eip);
     call->sp  = LOWORD(context->Esp);
     call->cs  = context->SegCs;
     call->ds  = context->SegDs;
     call->es  = context->SegEs;
     call->fs  = context->SegFs;
     call->gs  = context->SegGs;
     call->ss  = context->SegSs;
 }


 #ifdef __i386__

 void DPMI_CallRMCB32(RMCB *rmcb, UINT16 ss, DWORD esp, UINT16*es, DWORD*edi)
 #if 0 /* original code, which early gccs puke on */
 {
     int _clobber;
     __asm__ __volatile__(
         "pushl %%ebp\n"
         "pushl %%ebx\n"
         "pushl %%es\n"
         "pushl %%ds\n"
         "pushfl\n"
         "mov %7,%%es\n"
         "mov %5,%%ds\n"
         ".byte 0x36, 0xff, 0x18\n" /* lcall *%ss:(%eax) */
         "popl %%ds\n"
         "mov %%es,%0\n"
         "popl %%es\n"
         "popl %%ebx\n"
         "popl %%ebp\n"
     : "=d" (*es), "=D" (*edi), "=S" (_clobber), "=a" (_clobber), "=c" (_clobber)
     : "0" (ss), "2" (esp),
       "4" (rmcb->regs_sel), "1" (rmcb->regs_ofs),
       "3" (&rmcb->proc_ofs) );
 }
 #else /* code generated by a gcc new enough */
 ;
 __ASM_GLOBAL_FUNC(DPMI_CallRMCB32,
     "pushl %ebp\n\t"
     "movl %esp,%ebp\n\t"
     "pushl %edi\n\t"
     "pushl %esi\n\t"
     "movl 0x8(%ebp),%eax\n\t"
     "movl 0x10(%ebp),%esi\n\t"
     "movl 0xc(%ebp),%edx\n\t"
     "movl 0x10(%eax),%ecx\n\t"
     "movl 0xc(%eax),%edi\n\t"
     "addl $0x4,%eax\n\t"
     "pushl %ebp\n\t"
     "pushl %ebx\n\t"
     "pushl %es\n\t"
     "pushl %ds\n\t"
     "pushfl\n\t"
     "mov %cx,%es\n\t"
     "mov %dx,%ds\n\t"
     ".byte 0x36, 0xff, 0x18\n\t" /* lcall *%ss:(%eax) */
     "popl %ds\n\t"
     "mov %es,%dx\n\t"
     "popl %es\n\t"
     "popl %ebx\n\t"
     "popl %ebp\n\t"
     "movl 0x14(%ebp),%eax\n\t"
     "movw %dx,(%eax)\n\t"
     "movl 0x18(%ebp),%edx\n\t"
     "movl %edi,(%edx)\n\t"
     "popl %esi\n\t"
     "popl %edi\n\t"
     "leave\n\t"
     "ret")
 #endif

 #endif /* __i386__ */

 /**********************************************************************
  *	    DPMI_CallRMCBProc
  *
  * This routine does the hard work of calling a callback procedure.
  */
 static void DPMI_CallRMCBProc( CONTEXT86 *context, RMCB *rmcb, WORD flag )
 {
     if (IS_SELECTOR_SYSTEM( rmcb->proc_sel )) {
         /* Wine-internal RMCB, call directly */
         ((RMCBPROC)rmcb->proc_ofs)(context);
     } else {
 #ifdef __i386__
         UINT16 ss,es;
         DWORD esp,edi;

         INT_SetRealModeContext(MapSL(MAKESEGPTR( rmcb->regs_sel, rmcb->regs_ofs )), context);
         ss = SELECTOR_AllocBlock( (void *)(context->SegSs<<4), 0x10000, WINE_LDT_FLAGS_DATA );
         esp = context->Esp;

         FIXME("untested!\n");

         /* The called proc ends with an IRET, and takes these parameters:
          * DS:ESI = pointer to real-mode SS:SP
          * ES:EDI = pointer to real-mode call structure
          * It returns:
          * ES:EDI = pointer to real-mode call structure (may be a copy)
          * It is the proc's responsibility to change the return CS:IP in the
          * real-mode call structure. */
         if (flag & 1) {
             /* 32-bit DPMI client */
             DPMI_CallRMCB32(rmcb, ss, esp, &es, &edi);
         } else {
             /* 16-bit DPMI client */
             CONTEXT86 ctx = *context;
             ctx.SegCs = rmcb->proc_sel;
             ctx.Eip   = rmcb->proc_ofs;
             ctx.SegDs = ss;
             ctx.Esi   = esp;
             ctx.SegEs = rmcb->regs_sel;
             ctx.Edi   = rmcb->regs_ofs;
             /* FIXME: I'm pretty sure this isn't right - should push flags first */
             wine_call_to_16_regs_short(&ctx, 0);
             es = ctx.SegEs;
             edi = ctx.Edi;
         }
 	FreeSelector16(ss);
         INT_GetRealModeContext( MapSL( MAKESEGPTR( es, edi )), context);
 #else
         ERR("RMCBs only implemented for i386\n");
 #endif
     }
 }


 /**********************************************************************
  *	    DPMI_CallRMProc
  *
  * This routine does the hard work of calling a real mode procedure.
  */
 int DPMI_CallRMProc( CONTEXT86 *context, LPWORD stack, int args, int iret )
 {
     LPWORD stack16;
     LPVOID addr = NULL; /* avoid gcc warning */
     RMCB *CurrRMCB;
     int alloc = 0, already = 0;
     BYTE *code;

     TRACE("EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n",
                  context->Eax, context->Ebx, context->Ecx, context->Edx );
     TRACE("ESI=%08lx EDI=%08lx ES=%04lx DS=%04lx CS:IP=%04lx:%04x, %d WORD arguments, %s\n",
                  context->Esi, context->Edi, context->SegEs, context->SegDs,
                  context->SegCs, LOWORD(context->Eip), args, iret?"IRET":"FAR" );

 callrmproc_again:

 /* there might be some code that just jumps to RMCBs or the like,
    in which case following the jumps here might get us to a shortcut */
     code = CTX_SEG_OFF_TO_LIN(context, context->SegCs, context->Eip);
     switch (*code) {
     case 0xe9: /* JMP NEAR */
       context->Eip += 3 + *(WORD *)(code+1);
       /* yeah, I know these gotos don't look good... */
       goto callrmproc_again;
     case 0xea: /* JMP FAR */
       context->Eip = *(WORD *)(code+1);
       context->SegCs = *(WORD *)(code+3);
       /* ...but since the label is there anyway... */
       goto callrmproc_again;
     case 0xeb: /* JMP SHORT */
       context->Eip += 2 + *(signed char *)(code+1);
       /* ...because of other gotos below, so... */
       goto callrmproc_again;
     }

 /* shortcut for chaining to internal interrupt handlers */
     if ((context->SegCs == 0xF000) && iret)
     {
         DOSVM_RealModeInterrupt( LOWORD(context->Eip)/4, context);
         return 0;
     }

 /* shortcut for RMCBs */
     CurrRMCB = FirstRMCB;

     while (CurrRMCB && (HIWORD(CurrRMCB->address) != context->SegCs))
         CurrRMCB = CurrRMCB->next;

     if (!CurrRMCB && !MZ_Current())
     {
         FIXME("DPMI real-mode call using DOS VM task system, not fully tested!\n");
         TRACE("creating VM86 task\n");
         MZ_AllocDPMITask();
     }
     if (!already) {
         if (!context->SegSs) {
             alloc = 1; /* allocate default stack */
             stack16 = addr = DOSMEM_GetBlock( 64, (UINT16 *)&(context->SegSs) );
             context->Esp = 64-2;
             stack16 += 32-1;
             if (!addr) {
                 ERR("could not allocate default stack\n");
                 return 1;
             }
         } else {
             stack16 = CTX_SEG_OFF_TO_LIN(context, context->SegSs, context->Esp);
         }
         context->Esp -= (args + (iret?1:0)) * sizeof(WORD);
         stack16 -= args;
         if (args) memcpy(stack16, stack, args*sizeof(WORD) );
         /* push flags if iret */
         if (iret) {
             stack16--; args++;
             *stack16 = LOWORD(context->EFlags);
         }
         /* push return address (return to interrupt wrapper) */
         *(--stack16) = DOSMEM_wrap_seg;
         *(--stack16) = 0;
         /* adjust stack */
         context->Esp -= 2*sizeof(WORD);
         already = 1;
     }

     if (CurrRMCB) {
         /* RMCB call, invoke protected-mode handler directly */
         DPMI_CallRMCBProc(context, CurrRMCB, dpmi_flag);
         /* check if we returned to where we thought we would */
         if ((context->SegCs != DOSMEM_wrap_seg) ||
             (LOWORD(context->Eip) != 0)) {
             /* we need to continue at different address in real-mode space,
                so we need to set it all up for real mode again */
             goto callrmproc_again;
         }
     } else {
         TRACE("entering real mode...\n");
         DOSVM_Enter( context );
         TRACE("returned from real-mode call\n");
     }
     if (alloc) DOSMEM_FreeBlock( addr );
     return 0;
 }


 /**********************************************************************
  *	    CallRMInt   (WINEDOS.@)
  */
 void WINAPI DOSVM_CallRMInt( CONTEXT86 *context )
 {
     CONTEXT86 realmode_ctx;
     FARPROC16 rm_int = DOSVM_GetRMHandler( BL_reg(context) );
     REALMODECALL *call = MapSL( MAKESEGPTR( context->SegEs, DI_reg(context) ));
     INT_GetRealModeContext( call, &realmode_ctx );

     /* we need to check if a real-mode program has hooked the interrupt */
     if (HIWORD(rm_int)!=0xF000) {
         /* yup, which means we need to switch to real mode... */
         realmode_ctx.SegCs = HIWORD(rm_int);
         realmode_ctx.Eip   = LOWORD(rm_int);
         if (DPMI_CallRMProc( &realmode_ctx, NULL, 0, TRUE))
           SET_CFLAG(context);
     } else {
         RESET_CFLAG(context);
         /* use the IP we have instead of BL_reg, in case some apps
            decide to move interrupts around for whatever reason... */
         DOSVM_RealModeInterrupt( LOWORD(rm_int)/4, &realmode_ctx );
     }
     INT_SetRealModeContext( call, &realmode_ctx );
 }


 /**********************************************************************
  *	    CallRMProc   (WINEDOS.@)
  */
 void WINAPI DOSVM_CallRMProc( CONTEXT86 *context, int iret )
 {
     REALMODECALL *p = MapSL( MAKESEGPTR( context->SegEs, DI_reg(context) ));
     CONTEXT86 context16;

     TRACE("RealModeCall: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n",
           p->eax, p->ebx, p->ecx, p->edx);
     TRACE("              ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x, %d WORD arguments, %s\n",
           p->esi, p->edi, p->es, p->ds, p->cs, p->ip, CX_reg(context), iret?"IRET":"FAR" );

     if (!(p->cs) && !(p->ip)) { /* remove this check
                                    if Int21/6501 case map function
                                    has been implemented */
         SET_CFLAG(context);
         return;
      }
     INT_GetRealModeContext(p, &context16);
     DPMI_CallRMProc( &context16, ((LPWORD)MapSL(MAKESEGPTR(context->SegSs, LOWORD(context->Esp))))+3,
                      CX_reg(context), iret );
     INT_SetRealModeContext(p, &context16);
 }


 /* (see dosmem.c, function DOSMEM_InitDPMI) */
 static void StartPM( CONTEXT86 *context )
 {
     UINT16 cs, ss, ds, es;
     CONTEXT86 pm_ctx;
     DWORD psp_ofs = (DWORD)(DOSVM_psp<<4);
     PDB16 *psp = (PDB16 *)psp_ofs;
     HANDLE16 env_seg = psp->environment;
     unsigned char selflags = WINE_LDT_FLAGS_DATA;

     RESET_CFLAG(context);
     dpmi_flag = AX_reg(context);
 /* our mode switch wrapper have placed the desired CS into DX */
     cs = SELECTOR_AllocBlock( (void *)(DX_reg(context)<<4), 0x10000, WINE_LDT_FLAGS_CODE );
 /* due to a flaw in some CPUs (at least mine), it is best to mark stack segments as 32-bit if they
    can be used in 32-bit code. Otherwise, these CPUs may not set the high word of esp during a
    ring transition (from kernel code) to the 16-bit stack, and this causes trouble if executing
    32-bit code using this stack. */
     if (dpmi_flag & 1) selflags |= WINE_LDT_FLAGS_32BIT;
     ss = SELECTOR_AllocBlock( (void *)(context->SegSs<<4), 0x10000, selflags );
 /* do the same for the data segments, just in case */
     if (context->SegDs == context->SegSs) ds = ss;
     else ds = SELECTOR_AllocBlock( (void *)(context->SegDs<<4), 0x10000, selflags );
     es = SELECTOR_AllocBlock( psp, 0x100, selflags );
 /* convert environment pointer, as the spec says, but we're a bit lazy about the size here... */
     psp->environment = SELECTOR_AllocBlock( (void *)(env_seg<<4), 0x10000, WINE_LDT_FLAGS_DATA );

     pm_ctx = *context;
     pm_ctx.SegCs = DOSMEM_dpmi_sel;
 /* our mode switch wrapper expects the new CS in DX, and the new SS in AX */
     pm_ctx.Eax   = ss;
     pm_ctx.Edx   = cs;
     pm_ctx.SegDs = ds;
     pm_ctx.SegEs = es;
     pm_ctx.SegFs = 0;
     pm_ctx.SegGs = 0;

     TRACE("DOS program is now entering protected mode\n");
     wine_call_to_16_regs_short(&pm_ctx, 0);

     /* in the current state of affairs, we won't ever actually return here... */
     /* we should have int21/ah=4c do it someday, though... */

     FreeSelector16(psp->environment);
     psp->environment = env_seg;
     FreeSelector16(es);
     if (ds != ss) FreeSelector16(ds);
     FreeSelector16(ss);
     FreeSelector16(cs);
 }

 static RMCB *DPMI_AllocRMCB( void )
 {
     RMCB *NewRMCB = HeapAlloc(GetProcessHeap(), 0, sizeof(RMCB));
     UINT16 uParagraph;

     if (NewRMCB)
     {
 	LPVOID RMCBmem = DOSMEM_GetBlock(4, &uParagraph);
 	LPBYTE p = RMCBmem;

 	*p++ = 0xcd; /* RMCB: */
 	*p++ = 0x31; /* int $0x31 */
 /* it is the called procedure's task to change the return CS:EIP
    the DPMI 0.9 spec states that if it doesn't, it will be called again */
 	*p++ = 0xeb;
 	*p++ = 0xfc; /* jmp RMCB */
 	NewRMCB->address = MAKELONG(0, uParagraph);
 	NewRMCB->next = FirstRMCB;
 	FirstRMCB = NewRMCB;
     }
     return NewRMCB;
 }


 FARPROC16 WINAPI DPMI_AllocInternalRMCB( RMCBPROC proc )
 {
     RMCB *NewRMCB = DPMI_AllocRMCB();

     if (NewRMCB) {
         NewRMCB->proc_ofs = (DWORD)proc;
         NewRMCB->proc_sel = 0;
         NewRMCB->regs_ofs = 0;
         NewRMCB->regs_sel = 0;
         return (FARPROC16)(NewRMCB->address);
     }
     return NULL;
 }


 static int DPMI_FreeRMCB( DWORD address )
 {
     RMCB *CurrRMCB = FirstRMCB;
     RMCB *PrevRMCB = NULL;

     while (CurrRMCB && (CurrRMCB->address != address))
     {
 	PrevRMCB = CurrRMCB;
 	CurrRMCB = CurrRMCB->next;
     }
     if (CurrRMCB)
     {
 	if (PrevRMCB)
 	PrevRMCB->next = CurrRMCB->next;
 	    else
 	FirstRMCB = CurrRMCB->next;
 	DOSMEM_FreeBlock(DOSMEM_MapRealToLinear(CurrRMCB->address));
 	HeapFree(GetProcessHeap(), 0, CurrRMCB);
 	return 0;
     }
     return 1;
 }


 void WINAPI DPMI_FreeInternalRMCB( FARPROC16 proc )
 {
     DPMI_FreeRMCB( (DWORD)proc );
 }


 /* DPMI Raw Mode Switch handler */

 #if 0
 void WINAPI DPMI_RawModeSwitch( SIGCONTEXT *context )
 {
   LPDOSTASK lpDosTask = MZ_Current();
   CONTEXT86 rm_ctx;
   int ret;

   if (!lpDosTask) {
     /* we could probably start a DPMI-only dosmod task here, but I doubt
        anything other than real DOS apps want to call raw mode switch */
     ERR("attempting raw mode switch without DOS task!\n");
     ExitProcess(1);
   }
   /* initialize real-mode context as per spec */
   memset(&rm_ctx, 0, sizeof(rm_ctx));
   rm_ctx.SegDs  = AX_sig(context);
   rm_ctx.SegEs  = CX_sig(context);
   rm_ctx.SegSs  = DX_sig(context);
   rm_ctx.Esp    = EBX_sig(context);
   rm_ctx.SegCs  = SI_sig(context);
   rm_ctx.Eip    = EDI_sig(context);
   rm_ctx.Ebp    = EBP_sig(context);
   rm_ctx.SegFs  = 0;
   rm_ctx.SegGs  = 0;
   rm_ctx.EFlags = EFL_sig(context); /* at least we need the IF flag */

   /* enter real mode again */
   TRACE("re-entering real mode at %04lx:%04lx\n",rm_ctx.SegCs,rm_ctx.Eip);
   ret = DOSVM_Enter( &rm_ctx );
   /* when the real-mode stuff call its mode switch address,
      DOSVM_Enter will return and we will continue here */

   if (ret<0) {
     /* if the sync was lost, there's no way to recover */
     ExitProcess(1);
   }

   /* alter protected-mode context as per spec */
   DS_sig(context)  = LOWORD(rm_ctx.Eax);
   ES_sig(context)  = LOWORD(rm_ctx.Ecx);
   SS_sig(context)  = LOWORD(rm_ctx.Edx);
   ESP_sig(context) = rm_ctx.Ebx;
   CS_sig(context)  = LOWORD(rm_ctx.Esi);
   EIP_sig(context) = rm_ctx.Edi;
   EBP_sig(context) = rm_ctx.Ebp;
   FS_sig(context) = 0;
   GS_sig(context) = 0;

   /* Return to new address and hope that we didn't mess up */
   TRACE("re-entering protected mode at %04x:%08lx\n",
 	CS_sig(context), EIP_sig(context));
 }
 #endif


 /**********************************************************************
  *	    AllocRMCB   (WINEDOS.@)
  */
 void WINAPI DOSVM_AllocRMCB( CONTEXT86 *context )
 {
     RMCB *NewRMCB = DPMI_AllocRMCB();

     TRACE("Function to call: %04x:%04x\n", (WORD)context->SegDs, SI_reg(context) );

     if (NewRMCB)
     {
 	/* FIXME: if 32-bit DPMI client, use ESI and EDI */
 	NewRMCB->proc_ofs = LOWORD(context->Esi);
 	NewRMCB->proc_sel = context->SegDs;
 	NewRMCB->regs_ofs = LOWORD(context->Edi);
 	NewRMCB->regs_sel = context->SegEs;
 	SET_LOWORD( context->Ecx, HIWORD(NewRMCB->address) );
 	SET_LOWORD( context->Edx, LOWORD(NewRMCB->address) );
     }
     else
     {
 	SET_LOWORD( context->Eax, 0x8015 ); /* callback unavailable */
 	SET_CFLAG(context);
     }
 }


 /**********************************************************************
  *	    FreeRMCB   (WINEDOS.@)
  */
 void WINAPI DOSVM_FreeRMCB( CONTEXT86 *context )
 {
     FIXME("callback address: %04x:%04x\n",
           CX_reg(context), DX_reg(context));

     if (DPMI_FreeRMCB(MAKELONG(DX_reg(context), CX_reg(context)))) {
 	SET_LOWORD( context->Eax, 0x8024 ); /* invalid callback address */
 	SET_CFLAG(context);
     }
 }


 /**********************************************************************
  *	    DOSVM_Int31Handler
  *
  * Handler for real-mode int 31h (DPMI).
  */
 void WINAPI DOSVM_Int31Handler( CONTEXT86 *context )
 {
     /* check if it's our wrapper */
     TRACE("called from real mode\n");
     if (context->SegCs==DOSMEM_dpmi_seg) {
         /* This is the protected mode switch */
         StartPM(context);
         return;
     }
     else if (context->SegCs==DOSMEM_xms_seg)
     {
         /* This is the XMS driver entry point */
         XMS_Handler(context);
         return;
     }
     else
     {
         /* Check for RMCB */
         RMCB *CurrRMCB = FirstRMCB;

         while (CurrRMCB && (HIWORD(CurrRMCB->address) != context->SegCs))
             CurrRMCB = CurrRMCB->next;

         if (CurrRMCB) {
             /* RMCB call, propagate to protected-mode handler */
             DPMI_CallRMCBProc(context, CurrRMCB, dpmi_flag);
             return;
         }
     }

     /* chain to protected mode handler */
     INT_Int31Handler( context );
 }
	/*
	* DPMI 0.9 emulation
	*
	* Copyright 1995 Alexandre Julliard
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include "config.h"

	#include "windef.h"
	#include "wine/winbase16.h"
	#include "miscemu.h"
	#include "task.h"
	#include "msdos.h"
	#include "dosexe.h"

	#include "wine/debug.h"

	WINE_DEFAULT_DEBUG_CHANNEL(int31);

	/* Structure for real-mode callbacks */
	typedef struct
	{
	DWORD edi;
	DWORD esi;
	DWORD ebp;
	DWORD reserved;
	DWORD ebx;
	DWORD edx;
	DWORD ecx;
	DWORD eax;
	WORD fl;
	WORD es;
	WORD ds;
	WORD fs;
	WORD gs;
	WORD ip;
	WORD cs;
	WORD sp;
	WORD ss;
	} REALMODECALL;

	typedef struct tagRMCB {
	DWORD address;
	DWORD proc_ofs,proc_sel;
	DWORD regs_ofs,regs_sel;
	struct tagRMCB *next;
	} RMCB;

	static RMCB *FirstRMCB = NULL;
	static WORD dpmi_flag;

	/**********************************************************************
	* INT_GetRealModeContext
	*/
	static void INT_GetRealModeContext( REALMODECALL call, CONTEXT86 context )
	{
	context->Eax = call->eax;
	context->Ebx = call->ebx;
	context->Ecx = call->ecx;
	context->Edx = call->edx;
	context->Esi = call->esi;
	context->Edi = call->edi;
	context->Ebp = call->ebp;
	context->EFlags = call->fl \| V86_FLAG;
	context->Eip = call->ip;
	context->Esp = call->sp;
	context->SegCs = call->cs;
	context->SegDs = call->ds;
	context->SegEs = call->es;
	context->SegFs = call->fs;
	context->SegGs = call->gs;
	context->SegSs = call->ss;
	}


	/**********************************************************************
	* INT_SetRealModeContext
	*/
	static void INT_SetRealModeContext( REALMODECALL call, CONTEXT86 context )
	{
	call->eax = context->Eax;
	call->ebx = context->Ebx;
	call->ecx = context->Ecx;
	call->edx = context->Edx;
	call->esi = context->Esi;
	call->edi = context->Edi;
	call->ebp = context->Ebp;
	call->fl = LOWORD(context->EFlags);
	call->ip = LOWORD(context->Eip);
	call->sp = LOWORD(context->Esp);
	call->cs = context->SegCs;
	call->ds = context->SegDs;
	call->es = context->SegEs;
	call->fs = context->SegFs;
	call->gs = context->SegGs;
	call->ss = context->SegSs;
	}


	#ifdef __i386__

	void DPMI_CallRMCB32(RMCB rmcb, UINT16 ss, DWORD esp, UINT16es, DWORD*edi)
	#if 0 /* original code, which early gccs puke on */
	{
	int _clobber;
	__asm__ __volatile__(
	"pushl %%ebp\n"
	"pushl %%ebx\n"
	"pushl %%es\n"
	"pushl %%ds\n"
	"pushfl\n"
	"mov %7,%%es\n"
	"mov %5,%%ds\n"
	".byte 0x36, 0xff, 0x18\n" /* lcall %ss:(%eax) /
	"popl %%ds\n"
	"mov %%es,%0\n"
	"popl %%es\n"
	"popl %%ebx\n"
	"popl %%ebp\n"
	: "=d" (es), "=D" (edi), "=S" (_clobber), "=a" (_clobber), "=c" (_clobber)
	: "0" (ss), "2" (esp),
	"4" (rmcb->regs_sel), "1" (rmcb->regs_ofs),
	"3" (&rmcb->proc_ofs) );
	}
	#else /* code generated by a gcc new enough */
	;
	__ASM_GLOBAL_FUNC(DPMI_CallRMCB32,
	"pushl %ebp\n\t"
	"movl %esp,%ebp\n\t"
	"pushl %edi\n\t"
	"pushl %esi\n\t"
	"movl 0x8(%ebp),%eax\n\t"
	"movl 0x10(%ebp),%esi\n\t"
	"movl 0xc(%ebp),%edx\n\t"
	"movl 0x10(%eax),%ecx\n\t"
	"movl 0xc(%eax),%edi\n\t"
	"addl $0x4,%eax\n\t"
	"pushl %ebp\n\t"
	"pushl %ebx\n\t"
	"pushl %es\n\t"
	"pushl %ds\n\t"
	"pushfl\n\t"
	"mov %cx,%es\n\t"
	"mov %dx,%ds\n\t"
	".byte 0x36, 0xff, 0x18\n\t" /* lcall %ss:(%eax) /
	"popl %ds\n\t"
	"mov %es,%dx\n\t"
	"popl %es\n\t"
	"popl %ebx\n\t"
	"popl %ebp\n\t"
	"movl 0x14(%ebp),%eax\n\t"
	"movw %dx,(%eax)\n\t"
	"movl 0x18(%ebp),%edx\n\t"
	"movl %edi,(%edx)\n\t"
	"popl %esi\n\t"
	"popl %edi\n\t"
	"leave\n\t"
	"ret")
	#endif

	#endif /* __i386__ */

	/**********************************************************************
	* DPMI_CallRMCBProc
	*
	* This routine does the hard work of calling a callback procedure.
	*/
	static void DPMI_CallRMCBProc( CONTEXT86 context, RMCB rmcb, WORD flag )
	{
	if (IS_SELECTOR_SYSTEM( rmcb->proc_sel )) {
	/* Wine-internal RMCB, call directly */
	((RMCBPROC)rmcb->proc_ofs)(context);
	} else {
	#ifdef __i386__
	UINT16 ss,es;
	DWORD esp,edi;

	INT_SetRealModeContext(MapSL(MAKESEGPTR( rmcb->regs_sel, rmcb->regs_ofs )), context);
	ss = SELECTOR_AllocBlock( (void *)(context->SegSs<<4), 0x10000, WINE_LDT_FLAGS_DATA );
	esp = context->Esp;

	FIXME("untested!\n");

	/* The called proc ends with an IRET, and takes these parameters:
	* DS:ESI = pointer to real-mode SS:SP
	* ES:EDI = pointer to real-mode call structure
	* It returns:
	* ES:EDI = pointer to real-mode call structure (may be a copy)
	* It is the proc's responsibility to change the return CS:IP in the
	* real-mode call structure. */
	if (flag & 1) {
	/* 32-bit DPMI client */
	DPMI_CallRMCB32(rmcb, ss, esp, &es, &edi);
	} else {
	/* 16-bit DPMI client */
	CONTEXT86 ctx = *context;
	ctx.SegCs = rmcb->proc_sel;
	ctx.Eip = rmcb->proc_ofs;
	ctx.SegDs = ss;
	ctx.Esi = esp;
	ctx.SegEs = rmcb->regs_sel;
	ctx.Edi = rmcb->regs_ofs;
	/* FIXME: I'm pretty sure this isn't right - should push flags first */
	wine_call_to_16_regs_short(&ctx, 0);
	es = ctx.SegEs;
	edi = ctx.Edi;
	}
	FreeSelector16(ss);
	INT_GetRealModeContext( MapSL( MAKESEGPTR( es, edi )), context);
	#else
	ERR("RMCBs only implemented for i386\n");
	#endif
	}
	}


	/**********************************************************************
	* DPMI_CallRMProc
	*
	* This routine does the hard work of calling a real mode procedure.
	*/
	int DPMI_CallRMProc( CONTEXT86 *context, LPWORD stack, int args, int iret )
	{
	LPWORD stack16;
	LPVOID addr = NULL; /* avoid gcc warning */
	RMCB *CurrRMCB;
	int alloc = 0, already = 0;
	BYTE *code;

	TRACE("EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n",
	context->Eax, context->Ebx, context->Ecx, context->Edx );
	TRACE("ESI=%08lx EDI=%08lx ES=%04lx DS=%04lx CS:IP=%04lx:%04x, %d WORD arguments, %s\n",
	context->Esi, context->Edi, context->SegEs, context->SegDs,
	context->SegCs, LOWORD(context->Eip), args, iret?"IRET":"FAR" );

	callrmproc_again:

	/* there might be some code that just jumps to RMCBs or the like,
	in which case following the jumps here might get us to a shortcut */
	code = CTX_SEG_OFF_TO_LIN(context, context->SegCs, context->Eip);
	switch (*code) {
	case 0xe9: /* JMP NEAR */
	context->Eip += 3 + (WORD )(code+1);
	/* yeah, I know these gotos don't look good... */
	goto callrmproc_again;
	case 0xea: /* JMP FAR */
	context->Eip = (WORD )(code+1);
	context->SegCs = (WORD )(code+3);
	/* ...but since the label is there anyway... */
	goto callrmproc_again;
	case 0xeb: /* JMP SHORT */
	context->Eip += 2 + (signed char )(code+1);
	/* ...because of other gotos below, so... */
	goto callrmproc_again;
	}

	/* shortcut for chaining to internal interrupt handlers */
	if ((context->SegCs == 0xF000) && iret)
	{
	DOSVM_RealModeInterrupt( LOWORD(context->Eip)/4, context);
	return 0;
	}

	/* shortcut for RMCBs */
	CurrRMCB = FirstRMCB;

	while (CurrRMCB && (HIWORD(CurrRMCB->address) != context->SegCs))
	CurrRMCB = CurrRMCB->next;

	if (!CurrRMCB && !MZ_Current())
	{
	FIXME("DPMI real-mode call using DOS VM task system, not fully tested!\n");
	TRACE("creating VM86 task\n");
	MZ_AllocDPMITask();
	}
	if (!already) {
	if (!context->SegSs) {
	alloc = 1; /* allocate default stack */
	stack16 = addr = DOSMEM_GetBlock( 64, (UINT16 *)&(context->SegSs) );
	context->Esp = 64-2;
	stack16 += 32-1;
	if (!addr) {
	ERR("could not allocate default stack\n");
	return 1;
	}
	} else {
	stack16 = CTX_SEG_OFF_TO_LIN(context, context->SegSs, context->Esp);
	}
	context->Esp -= (args + (iret?1:0)) * sizeof(WORD);
	stack16 -= args;
	if (args) memcpy(stack16, stack, args*sizeof(WORD) );
	/* push flags if iret */
	if (iret) {
	stack16--; args++;
	*stack16 = LOWORD(context->EFlags);
	}
	/* push return address (return to interrupt wrapper) */
	*(--stack16) = DOSMEM_wrap_seg;
	*(--stack16) = 0;
	/* adjust stack */
	context->Esp -= 2*sizeof(WORD);
	already = 1;
	}

	if (CurrRMCB) {
	/* RMCB call, invoke protected-mode handler directly */
	DPMI_CallRMCBProc(context, CurrRMCB, dpmi_flag);
	/* check if we returned to where we thought we would */
	if ((context->SegCs != DOSMEM_wrap_seg) \|\|
	(LOWORD(context->Eip) != 0)) {
	/* we need to continue at different address in real-mode space,
	so we need to set it all up for real mode again */
	goto callrmproc_again;
	}
	} else {
	TRACE("entering real mode...\n");
	DOSVM_Enter( context );
	TRACE("returned from real-mode call\n");
	}
	if (alloc) DOSMEM_FreeBlock( addr );
	return 0;
	}


	/**********************************************************************
	* CallRMInt (WINEDOS.@)
	*/
	void WINAPI DOSVM_CallRMInt( CONTEXT86 *context )
	{
	CONTEXT86 realmode_ctx;
	FARPROC16 rm_int = DOSVM_GetRMHandler( BL_reg(context) );
	REALMODECALL *call = MapSL( MAKESEGPTR( context->SegEs, DI_reg(context) ));
	INT_GetRealModeContext( call, &realmode_ctx );

	/* we need to check if a real-mode program has hooked the interrupt */
	if (HIWORD(rm_int)!=0xF000) {
	/* yup, which means we need to switch to real mode... */
	realmode_ctx.SegCs = HIWORD(rm_int);
	realmode_ctx.Eip = LOWORD(rm_int);
	if (DPMI_CallRMProc( &realmode_ctx, NULL, 0, TRUE))
	SET_CFLAG(context);
	} else {
	RESET_CFLAG(context);
	/* use the IP we have instead of BL_reg, in case some apps
	decide to move interrupts around for whatever reason... */
	DOSVM_RealModeInterrupt( LOWORD(rm_int)/4, &realmode_ctx );
	}
	INT_SetRealModeContext( call, &realmode_ctx );
	}


	/**********************************************************************
	* CallRMProc (WINEDOS.@)
	*/
	void WINAPI DOSVM_CallRMProc( CONTEXT86 *context, int iret )
	{
	REALMODECALL *p = MapSL( MAKESEGPTR( context->SegEs, DI_reg(context) ));
	CONTEXT86 context16;

	TRACE("RealModeCall: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n",
	p->eax, p->ebx, p->ecx, p->edx);
	TRACE(" ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x, %d WORD arguments, %s\n",
	p->esi, p->edi, p->es, p->ds, p->cs, p->ip, CX_reg(context), iret?"IRET":"FAR" );

	if (!(p->cs) && !(p->ip)) { /* remove this check
	if Int21/6501 case map function
	has been implemented */
	SET_CFLAG(context);
	return;
	}
	INT_GetRealModeContext(p, &context16);
	DPMI_CallRMProc( &context16, ((LPWORD)MapSL(MAKESEGPTR(context->SegSs, LOWORD(context->Esp))))+3,
	CX_reg(context), iret );
	INT_SetRealModeContext(p, &context16);
	}


	/* (see dosmem.c, function DOSMEM_InitDPMI) */
	static void StartPM( CONTEXT86 *context )
	{
	UINT16 cs, ss, ds, es;
	CONTEXT86 pm_ctx;
	DWORD psp_ofs = (DWORD)(DOSVM_psp<<4);
	PDB16 psp = (PDB16 )psp_ofs;
	HANDLE16 env_seg = psp->environment;
	unsigned char selflags = WINE_LDT_FLAGS_DATA;

	RESET_CFLAG(context);
	dpmi_flag = AX_reg(context);
	/* our mode switch wrapper have placed the desired CS into DX */
	cs = SELECTOR_AllocBlock( (void *)(DX_reg(context)<<4), 0x10000, WINE_LDT_FLAGS_CODE );
	/* due to a flaw in some CPUs (at least mine), it is best to mark stack segments as 32-bit if they
	can be used in 32-bit code. Otherwise, these CPUs may not set the high word of esp during a
	ring transition (from kernel code) to the 16-bit stack, and this causes trouble if executing
	32-bit code using this stack. */
	if (dpmi_flag & 1) selflags \|= WINE_LDT_FLAGS_32BIT;
	ss = SELECTOR_AllocBlock( (void *)(context->SegSs<<4), 0x10000, selflags );
	/* do the same for the data segments, just in case */
	if (context->SegDs == context->SegSs) ds = ss;
	else ds = SELECTOR_AllocBlock( (void *)(context->SegDs<<4), 0x10000, selflags );
	es = SELECTOR_AllocBlock( psp, 0x100, selflags );
	/* convert environment pointer, as the spec says, but we're a bit lazy about the size here... */
	psp->environment = SELECTOR_AllocBlock( (void *)(env_seg<<4), 0x10000, WINE_LDT_FLAGS_DATA );

	pm_ctx = *context;
	pm_ctx.SegCs = DOSMEM_dpmi_sel;
	/* our mode switch wrapper expects the new CS in DX, and the new SS in AX */
	pm_ctx.Eax = ss;
	pm_ctx.Edx = cs;
	pm_ctx.SegDs = ds;
	pm_ctx.SegEs = es;
	pm_ctx.SegFs = 0;
	pm_ctx.SegGs = 0;

	TRACE("DOS program is now entering protected mode\n");
	wine_call_to_16_regs_short(&pm_ctx, 0);

	/* in the current state of affairs, we won't ever actually return here... */
	/* we should have int21/ah=4c do it someday, though... */

	FreeSelector16(psp->environment);
	psp->environment = env_seg;
	FreeSelector16(es);
	if (ds != ss) FreeSelector16(ds);
	FreeSelector16(ss);
	FreeSelector16(cs);
	}

	static RMCB *DPMI_AllocRMCB( void )
	{
	RMCB *NewRMCB = HeapAlloc(GetProcessHeap(), 0, sizeof(RMCB));
	UINT16 uParagraph;

	if (NewRMCB)
	{
	LPVOID RMCBmem = DOSMEM_GetBlock(4, &uParagraph);
	LPBYTE p = RMCBmem;

	p++ = 0xcd; / RMCB: */
	p++ = 0x31; / int $0x31 */
	/* it is the called procedure's task to change the return CS:EIP
	the DPMI 0.9 spec states that if it doesn't, it will be called again */
	*p++ = 0xeb;
	p++ = 0xfc; / jmp RMCB */
	NewRMCB->address = MAKELONG(0, uParagraph);
	NewRMCB->next = FirstRMCB;
	FirstRMCB = NewRMCB;
	}
	return NewRMCB;
	}


	FARPROC16 WINAPI DPMI_AllocInternalRMCB( RMCBPROC proc )
	{
	RMCB *NewRMCB = DPMI_AllocRMCB();

	if (NewRMCB) {
	NewRMCB->proc_ofs = (DWORD)proc;
	NewRMCB->proc_sel = 0;
	NewRMCB->regs_ofs = 0;
	NewRMCB->regs_sel = 0;
	return (FARPROC16)(NewRMCB->address);
	}
	return NULL;
	}


	static int DPMI_FreeRMCB( DWORD address )
	{
	RMCB *CurrRMCB = FirstRMCB;
	RMCB *PrevRMCB = NULL;

	while (CurrRMCB && (CurrRMCB->address != address))
	{
	PrevRMCB = CurrRMCB;
	CurrRMCB = CurrRMCB->next;
	}
	if (CurrRMCB)
	{
	if (PrevRMCB)
	PrevRMCB->next = CurrRMCB->next;
	else
	FirstRMCB = CurrRMCB->next;
	DOSMEM_FreeBlock(DOSMEM_MapRealToLinear(CurrRMCB->address));
	HeapFree(GetProcessHeap(), 0, CurrRMCB);
	return 0;
	}
	return 1;
	}


	void WINAPI DPMI_FreeInternalRMCB( FARPROC16 proc )
	{
	DPMI_FreeRMCB( (DWORD)proc );
	}


	/* DPMI Raw Mode Switch handler */

	#if 0
	void WINAPI DPMI_RawModeSwitch( SIGCONTEXT *context )
	{
	LPDOSTASK lpDosTask = MZ_Current();
	CONTEXT86 rm_ctx;
	int ret;

	if (!lpDosTask) {
	/* we could probably start a DPMI-only dosmod task here, but I doubt
	anything other than real DOS apps want to call raw mode switch */
	ERR("attempting raw mode switch without DOS task!\n");
	ExitProcess(1);
	}
	/* initialize real-mode context as per spec */
	memset(&rm_ctx, 0, sizeof(rm_ctx));
	rm_ctx.SegDs = AX_sig(context);
	rm_ctx.SegEs = CX_sig(context);
	rm_ctx.SegSs = DX_sig(context);
	rm_ctx.Esp = EBX_sig(context);
	rm_ctx.SegCs = SI_sig(context);
	rm_ctx.Eip = EDI_sig(context);
	rm_ctx.Ebp = EBP_sig(context);
	rm_ctx.SegFs = 0;
	rm_ctx.SegGs = 0;
	rm_ctx.EFlags = EFL_sig(context); /* at least we need the IF flag */

	/* enter real mode again */
	TRACE("re-entering real mode at %04lx:%04lx\n",rm_ctx.SegCs,rm_ctx.Eip);
	ret = DOSVM_Enter( &rm_ctx );
	/* when the real-mode stuff call its mode switch address,
	DOSVM_Enter will return and we will continue here */

	if (ret<0) {
	/* if the sync was lost, there's no way to recover */
	ExitProcess(1);
	}

	/* alter protected-mode context as per spec */
	DS_sig(context) = LOWORD(rm_ctx.Eax);
	ES_sig(context) = LOWORD(rm_ctx.Ecx);
	SS_sig(context) = LOWORD(rm_ctx.Edx);
	ESP_sig(context) = rm_ctx.Ebx;
	CS_sig(context) = LOWORD(rm_ctx.Esi);
	EIP_sig(context) = rm_ctx.Edi;
	EBP_sig(context) = rm_ctx.Ebp;
	FS_sig(context) = 0;
	GS_sig(context) = 0;

	/* Return to new address and hope that we didn't mess up */
	TRACE("re-entering protected mode at %04x:%08lx\n",
	CS_sig(context), EIP_sig(context));
	}
	#endif


	/**********************************************************************
	* AllocRMCB (WINEDOS.@)
	*/
	void WINAPI DOSVM_AllocRMCB( CONTEXT86 *context )
	{
	RMCB *NewRMCB = DPMI_AllocRMCB();

	TRACE("Function to call: %04x:%04x\n", (WORD)context->SegDs, SI_reg(context) );

	if (NewRMCB)
	{
	/* FIXME: if 32-bit DPMI client, use ESI and EDI */
	NewRMCB->proc_ofs = LOWORD(context->Esi);
	NewRMCB->proc_sel = context->SegDs;
	NewRMCB->regs_ofs = LOWORD(context->Edi);
	NewRMCB->regs_sel = context->SegEs;
	SET_LOWORD( context->Ecx, HIWORD(NewRMCB->address) );
	SET_LOWORD( context->Edx, LOWORD(NewRMCB->address) );
	}
	else
	{
	SET_LOWORD( context->Eax, 0x8015 ); /* callback unavailable */
	SET_CFLAG(context);
	}
	}


	/**********************************************************************
	* FreeRMCB (WINEDOS.@)
	*/
	void WINAPI DOSVM_FreeRMCB( CONTEXT86 *context )
	{
	FIXME("callback address: %04x:%04x\n",
	CX_reg(context), DX_reg(context));

	if (DPMI_FreeRMCB(MAKELONG(DX_reg(context), CX_reg(context)))) {
	SET_LOWORD( context->Eax, 0x8024 ); /* invalid callback address */
	SET_CFLAG(context);
	}
	}


	/**********************************************************************
	* DOSVM_Int31Handler
	*
	* Handler for real-mode int 31h (DPMI).
	*/
	void WINAPI DOSVM_Int31Handler( CONTEXT86 *context )
	{
	/* check if it's our wrapper */
	TRACE("called from real mode\n");
	if (context->SegCs==DOSMEM_dpmi_seg) {
	/* This is the protected mode switch */
	StartPM(context);
	return;
	}
	else if (context->SegCs==DOSMEM_xms_seg)
	{
	/* This is the XMS driver entry point */
	XMS_Handler(context);
	return;
	}
	else
	{
	/* Check for RMCB */
	RMCB *CurrRMCB = FirstRMCB;

	while (CurrRMCB && (HIWORD(CurrRMCB->address) != context->SegCs))
	CurrRMCB = CurrRMCB->next;

	if (CurrRMCB) {
	/* RMCB call, propagate to protected-mode handler */
	DPMI_CallRMCBProc(context, CurrRMCB, dpmi_flag);
	return;
	}
	}

	/* chain to protected mode handler */
	INT_Int31Handler( context );
	}