Implemented DPMI RMCBs using the DOS subsystem, and a few other

improvements. Also, some special-cased shortcut paths will allow some
common real-mode call/RMCB combinations to work even without calling the
DOS subsystem, thus letting APIs like DOSASPI work without any dirty hacks
even on platforms that cannot use dosmod.
This commit is contained in:
Ove Kaaven 1998-12-09 13:14:19 +00:00 committed by Alexandre Julliard
parent d5e7c7927c
commit 2866809ce4
2 changed files with 276 additions and 133 deletions

View File

@ -82,7 +82,10 @@ extern void WINAPI INT_Int29Handler(CONTEXT*);
extern void WINAPI INT_Int2fHandler(CONTEXT*);
/* msdos/dpmi.c */
typedef void WINAPI (*RMCBPROC)(CONTEXT*);
extern void WINAPI INT_Int31Handler(CONTEXT*);
extern FARPROC16 WINAPI DPMI_AllocInternalRMCB(RMCBPROC);
extern void WINAPI DPMI_FreeInternalRMCB(FARPROC16);
/* msdos/xms.c */
extern void WINAPI XMS_Handler(CONTEXT*);

View File

@ -56,8 +56,9 @@ typedef struct
typedef struct tagRMCB {
DWORD address;
DWORD proc_ofs,proc_sel;
DWORD regs_ofs,regs_sel;
struct tagRMCB *next;
} RMCB;
static RMCB *FirstRMCB = NULL;
@ -180,6 +181,73 @@ static void INT_SetRealModeContext( REALMODECALL *call, CONTEXT *context )
}
/**********************************************************************
* DPMI_CallRMCBProc
*
* This routine does the hard work of calling a callback procedure.
*/
static void DPMI_CallRMCBProc( CONTEXT *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 edi;
INT_SetRealModeContext((REALMODECALL *)PTR_SEG_OFF_TO_LIN( rmcb->regs_sel, rmcb->regs_ofs ), context);
ss = SELECTOR_AllocBlock( DOSMEM_MemoryBase(0) + (DWORD)(SS_reg(context)<<4), 0x10000, SEGMENT_DATA, FALSE, FALSE );
FIXME(int31,"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 */
__asm__ __volatile__("
pushl %%es
pushl %%ds
pushfl
movl %4,%%es
movl %3,%%ds
lcall %2
popl %%ds
movl %%es,%0
popl %%es
"
: "=g" (es), "=D" (edi)
: "m" (rmcb->proc_ofs),
"g" (ss), "g" (rmcb->regs_sel),
"S" (ESP_reg(context)), "D" (rmcb->regs_ofs)
: "eax", "ecx", "edx", "esi", "ebp" );
} else {
/* 16-bit DPMI client */
CONTEXT ctx = *context;
CS_reg(&ctx) = rmcb->proc_sel;
EIP_reg(&ctx) = rmcb->proc_ofs;
DS_reg(&ctx) = ss;
ESI_reg(&ctx) = ESP_reg(context);
ES_reg(&ctx) = rmcb->regs_sel;
EDI_reg(&ctx) = rmcb->regs_ofs;
Callbacks->CallRegisterShortProc(&ctx, 2);
es = ES_reg(&ctx);
edi = EDI_reg(&ctx);
}
UnMapLS(PTR_SEG_OFF_TO_SEGPTR(ss,0));
INT_GetRealModeContext((REALMODECALL*)PTR_SEG_OFF_TO_LIN( es, edi ), context);
#else
ERR(int31,"RMCBs only implemented for i386\n");
#endif
}
}
/**********************************************************************
* DPMI_CallRMProc
*
@ -189,10 +257,11 @@ int DPMI_CallRMProc( CONTEXT *context, LPWORD stack, int args, int iret )
{
LPWORD stack16;
THDB *thdb = THREAD_Current();
LPVOID addr;
LPVOID addr = NULL; /* avoid gcc warning */
TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
NE_MODULE *pModule = pTask ? NE_GetPtr( pTask->hModule ) : NULL;
int alloc = 0;
RMCB *CurrRMCB;
int alloc = 0, already = 0;
WORD sel;
SEGPTR seg_addr;
@ -200,19 +269,33 @@ int DPMI_CallRMProc( CONTEXT *context, LPWORD stack, int args, int iret )
TRACE(int31, "EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n",
EAX_reg(context), EBX_reg(context), ECX_reg(context), EDX_reg(context) );
TRACE(int31, "ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x, %d WORD arguments\n",
TRACE(int31, "ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x, %d WORD arguments, %s\n",
ESI_reg(context), EDI_reg(context), ES_reg(context), DS_reg(context),
CS_reg(context), IP_reg(context), args );
CS_reg(context), IP_reg(context), args, iret?"IRET":"FAR" );
callrmproc_again:
/* shortcut for chaining to internal interrupt handlers */
if ((CS_reg(context) == 0xF000) && iret) {
return INT_RealModeInterrupt( IP_reg(context)/4, context);
}
/* shortcut for RMCBs */
CurrRMCB = FirstRMCB;
while (CurrRMCB && (HIWORD(CurrRMCB->address) != CS_reg(context)))
CurrRMCB = CurrRMCB->next;
#ifdef MZ_SUPPORTED
FIXME(int31,"DPMI real-mode call using DOS VM task system, not fully tested\n");
if (!pModule->lpDosTask) {
FIXME(int31,"DPMI real-mode call using DOS VM task system, not fully tested!\n");
if (!(CurrRMCB || pModule->lpDosTask)) {
TRACE(int31,"creating VM86 task\n");
if (MZ_InitTask( MZ_AllocDPMITask( pModule->self ) ) < 32) {
ERR(int31,"could not setup VM86 task\n");
return 1;
}
}
if (!already) {
if (!SS_reg(context)) {
alloc = 1; /* allocate default stack */
stack16 = addr = DOSMEM_GetBlock( pModule->self, 64, &(SS_reg(context)) );
@ -224,10 +307,10 @@ int DPMI_CallRMProc( CONTEXT *context, LPWORD stack, int args, int iret )
}
} else {
stack16 = CTX_SEG_OFF_TO_LIN(context, SS_reg(context), ESP_reg(context));
addr = NULL; /* avoid gcc warning */
}
SP_reg(context) -= (args + (iret?1:0)) * sizeof(WORD);
#else
if (!already) {
stack16 = THREAD_STACK16(thdb);
#endif
stack16 -= args;
@ -241,18 +324,37 @@ int DPMI_CallRMProc( CONTEXT *context, LPWORD stack, int args, int iret )
/* push return address (return to interrupt wrapper) */
*(--stack16) = pModule->lpDosTask->dpmi_seg;
*(--stack16) = pModule->lpDosTask->wrap_ofs;
/* adjust stack */
SP_reg(context) -= 2*sizeof(WORD);
#endif
already = 1;
}
if (CurrRMCB) {
/* RMCB call, invoke protected-mode handler directly */
DPMI_CallRMCBProc(context, CurrRMCB, pModule->lpDosTask?pModule->lpDosTask->dpmi_flag:0);
/* check if we returned to where we thought we would */
if ((CS_reg(context) != pModule->lpDosTask->dpmi_seg) ||
(IP_reg(context) != pModule->lpDosTask->wrap_ofs)) {
/* 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 {
#ifdef MZ_SUPPORTED
#if 0 /* this was probably unnecessary */
/* push call address */
*(--stack16) = CS_reg(context);
*(--stack16) = IP_reg(context);
/* adjust stack */
SP_reg(context) -= 4*sizeof(WORD);
SP_reg(context) -= 2*sizeof(WORD);
/* set initial CS:IP to the wrapper's "lret" */
CS_reg(context) = pModule->lpDosTask->dpmi_seg;
IP_reg(context) = pModule->lpDosTask->call_ofs;
#endif
TRACE(int31,"entering real mode...\n");
DOSVM_Enter( context );
TRACE(int31,"returned from real-mode call\n");
if (alloc) DOSMEM_FreeBlock( pModule->self, addr );
#else
addr = CTX_SEG_OFF_TO_LIN(context, CS_reg(context), EIP_reg(context));
sel = SELECTOR_AllocBlock( addr, 0x10000, SEGMENT_CODE, FALSE, FALSE );
@ -265,14 +367,16 @@ int DPMI_CallRMProc( CONTEXT *context, LPWORD stack, int args, int iret )
Callbacks->CallRegisterShortProc(context, args*sizeof(WORD));
UnMapLS(seg_addr);
#endif
}
if (alloc) DOSMEM_FreeBlock( pModule->self, addr );
return 0;
}
/**********************************************************************
* INT_DoRealModeInt
* CallRMInt
*/
static void INT_DoRealModeInt( CONTEXT *context )
static void CallRMInt( CONTEXT *context )
{
CONTEXT realmode_ctx;
FARPROC16 rm_int = INT_GetRMHandler( BL_reg(context) );
@ -280,7 +384,6 @@ static void INT_DoRealModeInt( CONTEXT *context )
DI_reg(context) );
INT_GetRealModeContext( call, &realmode_ctx );
#ifdef MZ_SUPPORTED
/* 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... */
@ -288,11 +391,11 @@ static void INT_DoRealModeInt( CONTEXT *context )
EIP_reg(&realmode_ctx) = LOWORD(rm_int);
if (DPMI_CallRMProc( &realmode_ctx, NULL, 0, TRUE))
SET_CFLAG(context);
} else
#endif
{
} else {
RESET_CFLAG(context);
if (INT_RealModeInterrupt( BL_reg(context), &realmode_ctx ))
/* use the IP we have instead of BL_reg, in case some apps
decide to move interrupts around for whatever reason... */
if (INT_RealModeInterrupt( LOWORD(rm_int)/4, &realmode_ctx ))
SET_CFLAG(context);
if (EFL_reg(context)&1) {
FIXME(int31,"%02x: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n",
@ -307,7 +410,7 @@ static void INT_DoRealModeInt( CONTEXT *context )
}
static void CallRMProcFar( CONTEXT *context )
static void CallRMProc( CONTEXT *context, int iret )
{
REALMODECALL *p = (REALMODECALL *)PTR_SEG_OFF_TO_LIN( ES_reg(context), DI_reg(context) );
CONTEXT context16;
@ -318,8 +421,8 @@ static void CallRMProcFar( CONTEXT *context )
TRACE(int31, "RealModeCall: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n",
p->eax, p->ebx, p->ecx, p->edx);
TRACE(int31, " ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x, %d WORD arguments\n",
p->esi, p->edi, p->es, p->ds, p->cs, p->ip, CX_reg(context) );
TRACE(int31, " 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
@ -328,75 +431,76 @@ static void CallRMProcFar( CONTEXT *context )
return;
}
INT_GetRealModeContext(p, &context16);
#if 0
addr = DOSMEM_MapRealToLinear(MAKELONG(p->ip, p->cs));
sel = SELECTOR_AllocBlock( addr, 0x10000, SEGMENT_CODE, FALSE, FALSE );
seg_addr = PTR_SEG_OFF_TO_SEGPTR( sel, 0 );
CS_reg(&context16) = HIWORD(seg_addr);
IP_reg(&context16) = LOWORD(seg_addr);
EBP_reg(&context16) = OFFSETOF( thdb->cur_stack )
+ (WORD)&((STACK16FRAME*)0)->bp;
argsize = CX_reg(context)*sizeof(WORD);
memcpy( ((LPBYTE)THREAD_STACK16(thdb))-argsize,
(LPBYTE)PTR_SEG_OFF_TO_LIN(SS_reg(context), SP_reg(context))+6, argsize );
Callbacks->CallRegisterShortProc(&context16, argsize);
UnMapLS(seg_addr);
#else
DPMI_CallRMProc( &context16, ((LPWORD)PTR_SEG_OFF_TO_LIN(SS_reg(context), SP_reg(context)))+3,
CX_reg(context), 0 );
#endif
CX_reg(context), iret );
INT_SetRealModeContext(p, &context16);
}
void WINAPI RMCallbackProc( FARPROC16 pmProc, REALMODECALL *rmc )
static void WINAPI RMCallbackProc( RMCB *rmcb )
{
CONTEXT ctx;
INT_GetRealModeContext(rmc, &ctx);
Callbacks->CallRegisterShortProc(&ctx, 0);
/* This routine should call DPMI_CallRMCBProc, but we don't have the
register structure available - this is easily fixed by going through
a Win16 register relay instead of calling RMCallbackProc "directly",
but I won't bother at this time. */
FIXME(int31,"not properly supported on your architecture!\n");
}
static RMCB *DPMI_AllocRMCB( void )
{
RMCB *NewRMCB = HeapAlloc(GetProcessHeap(), 0, sizeof(RMCB));
UINT16 uParagraph;
if (NewRMCB)
{
#ifdef MZ_SUPPORTED
LPVOID RMCBmem = DOSMEM_GetBlock(0, 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 */
#else
LPVOID RMCBmem = DOSMEM_GetBlock(0, 15, &uParagraph);
LPBYTE p = RMCBmem;
*p++ = 0x68; /* pushl */
*(LPVOID *)p = NewRMCB;
p+=4;
*p++ = 0x9a; /* lcall */
*(FARPROC16 *)p = (FARPROC16)RMCallbackProc; /* FIXME: register relay */
p+=4;
GET_CS(*(WORD *)p);
p+=2;
*p++=0xc3; /* lret (FIXME?) */
#endif
NewRMCB->address = MAKELONG(0, uParagraph);
NewRMCB->next = FirstRMCB;
FirstRMCB = NewRMCB;
}
return NewRMCB;
}
static void AllocRMCB( CONTEXT *context )
{
RMCB *NewRMCB = HeapAlloc(GetProcessHeap(), 0, sizeof(RMCB));
RMCB *NewRMCB = DPMI_AllocRMCB();
REALMODECALL *p = (REALMODECALL *)PTR_SEG_OFF_TO_LIN( ES_reg(context), DI_reg(context) );
UINT16 uParagraph;
FIXME(int31, "EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n", p->eax, p->ebx, p->ecx, p->edx);
FIXME(int31, " ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x\n", p->esi, p->edi, p->es, p->ds, p->cs, p->ip);
FIXME(int31, " Function to call: %04x:%04x\n",
(WORD)DS_reg(context), SI_reg(context) );
TRACE(int31, "Function to call: %04x:%04x\n", (WORD)DS_reg(context), SI_reg(context) );
if (NewRMCB)
{
LPVOID RMCBmem = DOSMEM_GetBlock(0, 20, &uParagraph);
LPBYTE p = RMCBmem;
*p++ = 0x68; /* pushl */
*(FARPROC16 *)p =
PTR_SEG_OFF_TO_LIN(ES_reg(context), SI_reg(context)); /* pmode proc to call */
p+=4;
*p++ = 0x68; /* pushl */
*(LPVOID *)p =
PTR_SEG_OFF_TO_LIN(ES_reg(context), DI_reg(context));
p+=4;
*p++ = 0x9a; /* lcall */
*(FARPROC16 *)p = (FARPROC16)RMCallbackProc; /* FIXME ? */
p+=4;
GET_CS(*(WORD *)p);
p+=2;
*p++=0xc3; /* retf */
NewRMCB->address = MAKELONG(0, uParagraph);
NewRMCB->next = FirstRMCB;
FirstRMCB = NewRMCB;
CX_reg(context) = uParagraph;
DX_reg(context) = 0;
/* FIXME: if 32-bit DPMI client, use ESI and EDI */
NewRMCB->proc_ofs = SI_reg(context);
NewRMCB->proc_sel = DS_reg(context);
NewRMCB->regs_ofs = DI_reg(context);
NewRMCB->regs_sel = ES_reg(context);
CX_reg(context) = HIWORD(NewRMCB->address);
DX_reg(context) = LOWORD(NewRMCB->address);
}
else
{
@ -406,15 +510,27 @@ static void AllocRMCB( CONTEXT *context )
}
static void FreeRMCB( CONTEXT *context )
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;
FIXME(int31, "callback address: %04x:%04x\n",
CX_reg(context), DX_reg(context));
while (CurrRMCB && (CurrRMCB->address != MAKELONG(DX_reg(context), CX_reg(context))))
while (CurrRMCB && (CurrRMCB->address != address))
{
PrevRMCB = CurrRMCB;
CurrRMCB = CurrRMCB->next;
@ -427,14 +543,30 @@ static void FreeRMCB( CONTEXT *context )
FirstRMCB = CurrRMCB->next;
DOSMEM_FreeBlock(0, DOSMEM_MapRealToLinear(CurrRMCB->address));
HeapFree(GetProcessHeap(), 0, CurrRMCB);
return 0;
}
else
return 1;
}
static void FreeRMCB( CONTEXT *context )
{
FIXME(int31, "callback address: %04x:%04x\n",
CX_reg(context), DX_reg(context));
if (DPMI_FreeRMCB(MAKELONG(DX_reg(context), CX_reg(context)))) {
AX_reg(context) = 0x8024; /* invalid callback address */
SET_CFLAG(context);
}
}
void WINAPI DPMI_FreeInternalRMCB( FARPROC16 proc )
{
DPMI_FreeRMCB( (DWORD)proc );
}
#ifdef MZ_SUPPORTED
/* (see loader/dos/module.c, function MZ_InitDPMI) */
@ -510,6 +642,19 @@ void WINAPI INT_Int31Handler( CONTEXT *context )
/* This is the XMS driver entry point */
XMS_Handler(context);
return;
} else
{
/* Check for RMCB */
RMCB *CurrRMCB = FirstRMCB;
while (CurrRMCB && (HIWORD(CurrRMCB->address) != CS_reg(context)))
CurrRMCB = CurrRMCB->next;
if (CurrRMCB) {
/* RMCB call, propagate to protected-mode handler */
DPMI_CallRMCBProc(context, CurrRMCB, pModule->lpDosTask->dpmi_flag);
return;
}
}
}
#endif
@ -726,20 +871,15 @@ void WINAPI INT_Int31Handler( CONTEXT *context )
break;
case 0x0300: /* Simulate real mode interrupt */
INT_DoRealModeInt( context );
CallRMInt( context );
break;
case 0x0301: /* Call real mode procedure with far return */
CallRMProcFar( context );
CallRMProc( context, FALSE );
break;
case 0x0302: /* Call real mode procedure with interrupt return */
{
REALMODECALL *p = (REALMODECALL *)PTR_SEG_OFF_TO_LIN( ES_reg(context), DI_reg(context) );
FIXME(int31, "RealModeCallIret: EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n", p->eax, p->ebx, p->ecx, p->edx);
FIXME(int31, " ESI=%08lx EDI=%08lx ES=%04x DS=%04x CS:IP=%04x:%04x\n", p->esi, p->edi, p->es, p->ds, p->cs, p->ip );
SET_CFLAG(context);
}
CallRMProc( context, TRUE );
break;
case 0x0303: /* Allocate Real Mode Callback Address */