| /* |
| * Routines for dynamically building calls to Wine from |
| * protected mode applications. |
| * |
| * Copyright 2002 Jukka Heinonen |
| * |
| * 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 "dosexe.h" |
| #include "stackframe.h" |
| #include "wine/debug.h" |
| #include "builtin16.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(int); |
| |
| /* |
| * Magic DWORD used to check stack integrity. |
| */ |
| #define RELAY_MAGIC 0xabcdef00 |
| |
| /* |
| * Memory block for temporary 16-bit stacks used with relay calls. |
| */ |
| typedef struct { |
| DWORD inuse; /* non-zero if stack block is in use */ |
| DWORD eip; /* saved ip */ |
| DWORD seg_cs; /* saved cs */ |
| DWORD esp; /* saved sp */ |
| DWORD seg_ss; /* saved ss */ |
| DWORD stack_bottom; /* guard dword */ |
| BYTE stack[256-7*4]; /* 16-bit stack */ |
| DWORD stack_top; /* guard dword */ |
| } RELAY_Stack16; |
| |
| |
| /********************************************************************** |
| * RELAY_GetPointer |
| * |
| * Get pointer to stack block when given esp pointing to 16-bit stack |
| * inside relay data segment. |
| */ |
| static RELAY_Stack16 *RELAY_GetPointer( DWORD offset ) |
| { |
| offset = offset / sizeof(RELAY_Stack16) * sizeof(RELAY_Stack16); |
| return MapSL(MAKESEGPTR(DOSVM_dpmi_segments->relay_data_sel, offset)); |
| } |
| |
| |
| /********************************************************************** |
| * RELAY_MakeShortContext |
| * |
| * Allocate separate 16-bit stack, make stack pointer point to this |
| * stack and make code pointer point to stub that restores everything. |
| * So, after this routine, SS and CS are guaranteed to be 16-bit. |
| * |
| * Note: This might be called from signal handler, so the stack |
| * allocation algorithm must be signal safe. |
| */ |
| static void RELAY_MakeShortContext( CONTEXT86 *context ) |
| { |
| DWORD offset = offsetof(RELAY_Stack16, stack_top); |
| RELAY_Stack16 *stack = RELAY_GetPointer( 0 ); |
| |
| while (stack->inuse && offset < DOSVM_RELAY_DATA_SIZE) { |
| stack++; |
| offset += sizeof(RELAY_Stack16); |
| } |
| |
| if (offset >= DOSVM_RELAY_DATA_SIZE) |
| ERR( "Too many nested interrupts!\n" ); |
| |
| stack->inuse = 1; |
| stack->eip = context->Eip; |
| stack->seg_cs = context->SegCs; |
| stack->esp = context->Esp; |
| stack->seg_ss = context->SegSs; |
| |
| stack->stack_bottom = RELAY_MAGIC; |
| stack->stack_top = RELAY_MAGIC; |
| |
| context->SegSs = DOSVM_dpmi_segments->relay_data_sel; |
| context->Esp = offset; |
| context->SegCs = DOSVM_dpmi_segments->relay_code_sel; |
| context->Eip = 3; |
| } |
| |
| |
| /********************************************************************** |
| * RELAY_RelayStub |
| * |
| * This stub is called by __wine_call_from_16_regs in order to marshall |
| * relay parameters. |
| */ |
| static void __stdcall RELAY_RelayStub( DOSRELAY proc, |
| unsigned char *args, |
| void *context ) |
| { |
| if (proc) |
| proc( (CONTEXT86*)context, *(LPVOID *)args ); |
| } |
| |
| |
| /********************************************************************** |
| * DOSVM_RelayHandler |
| * |
| * Restore saved code and stack pointers and release stack block. |
| */ |
| void DOSVM_RelayHandler( CONTEXT86 *context ) |
| { |
| RELAY_Stack16 *stack = RELAY_GetPointer( context->Esp ); |
| |
| context->SegSs = stack->seg_ss; |
| context->Esp = stack->esp; |
| context->SegCs = stack->seg_cs; |
| context->Eip = stack->eip; |
| |
| if (!stack->inuse || |
| stack->stack_bottom != RELAY_MAGIC || |
| stack->stack_top != RELAY_MAGIC) |
| ERR( "Stack corrupted!\n" ); |
| |
| stack->inuse = 0; |
| |
| /* |
| * We have now restored original stack and instruction pointers. |
| * Because signals are blocked here, this is a safe place to |
| * check for pending events before we return to application context. |
| */ |
| if (NtCurrentTeb()->vm86_pending && NtCurrentTeb()->dpmi_vif) |
| { |
| NtCurrentTeb()->vm86_pending = 0; |
| DOSVM_SendQueuedEvents( context ); |
| } |
| } |
| |
| |
| /********************************************************************** |
| * DOSVM_SaveCallFrame |
| * |
| * Save current call frame. This routine must be called from DOSRELAY |
| * called using DOSVM_BuildCallFrame before the relay modifies stack |
| * pointer. This routine makes sure that the relay can return safely |
| * to application context and that no memory is leaked. |
| * |
| * Note: If DOSVM_BuildCallFrame was called using 32-bit CS or SS, |
| * old values of CS and SS will be lost. This does not matter |
| * since this routine is only used by Raw Mode Switch. |
| */ |
| void DOSVM_SaveCallFrame( CONTEXT86 *context, STACK16FRAME *frame ) |
| { |
| *frame = *CURRENT_STACK16; |
| |
| /* |
| * If context is using allocated stack, release it. |
| */ |
| if (context->SegSs == DOSVM_dpmi_segments->relay_data_sel) |
| { |
| RELAY_Stack16 *stack = RELAY_GetPointer( context->Esp ); |
| |
| if (!stack->inuse || |
| stack->stack_bottom != RELAY_MAGIC || |
| stack->stack_top != RELAY_MAGIC) |
| ERR( "Stack corrupted!\n" ); |
| |
| stack->inuse = 0; |
| } |
| } |
| |
| |
| /********************************************************************** |
| * DOSVM_RestoreCallFrame |
| * |
| * Restore saved call frame to currect stack. This routine must always |
| * be called after DOSVM_SaveCallFrame has been called and before returning |
| * from DOSRELAY. |
| */ |
| void DOSVM_RestoreCallFrame( CONTEXT86 *context, STACK16FRAME *frame ) |
| { |
| /* |
| * Allocate separate stack for relay call. |
| */ |
| RELAY_MakeShortContext( context ); |
| |
| /* |
| * After this function returns to relay code, protected mode |
| * 16 bit stack will contain STACK16FRAME and single WORD |
| * (EFlags, see next comment). |
| */ |
| NtCurrentTeb()->cur_stack = |
| MAKESEGPTR( context->SegSs, |
| context->Esp - sizeof(STACK16FRAME) - sizeof(WORD) ); |
| |
| /* |
| * After relay code returns to glue function, protected |
| * mode 16 bit stack will contain interrupt return record: |
| * IP, CS and EFlags. Since EFlags is ignored, it won't |
| * need to be initialized. |
| */ |
| context->Esp -= 3 * sizeof(WORD); |
| |
| /* |
| * Restore stack frame so that relay code won't be confused. |
| * It should be noted that relay code overwrites IP and CS |
| * in STACK16FRAME with values taken from current CONTEXT86. |
| * These values are what is returned to glue function |
| * (see previous comment). |
| */ |
| *CURRENT_STACK16 = *frame; |
| } |
| |
| |
| /********************************************************************** |
| * DOSVM_BuildCallFrame |
| * |
| * Modifies the context so that return to context calls DOSRELAY and |
| * only after return from DOSRELAY the original context will be returned to. |
| */ |
| void DOSVM_BuildCallFrame( CONTEXT86 *context, DOSRELAY relay, LPVOID data ) |
| { |
| WORD *stack; |
| WORD code_sel = DOSVM_dpmi_segments->relay_code_sel; |
| |
| /* |
| * Allocate separate stack for relay call. |
| */ |
| RELAY_MakeShortContext( context ); |
| |
| /* |
| * Get stack pointer after RELAY_MakeShortContext. |
| */ |
| stack = CTX_SEG_OFF_TO_LIN(context, context->SegSs, context->Esp); |
| |
| /* |
| * Build call frame. |
| */ |
| *(--stack) = HIWORD(data); /* argument.hiword */ |
| *(--stack) = LOWORD(data); /* argument.loword */ |
| *(--stack) = context->SegCs; /* STACK16FRAME.cs */ |
| *(--stack) = LOWORD(context->Eip); /* STACK16FRAME.ip */ |
| *(--stack) = LOWORD(context->Ebp); /* STACK16FRAME.bp */ |
| *(--stack) = HIWORD(relay); /* STACK16FRAME.entry_point.hiword */ |
| *(--stack) = LOWORD(relay); /* STACK16FRAME.entry_point.loword */ |
| *(--stack) = 0; /* STACK16FRAME.entry_ip */ |
| *(--stack) = HIWORD(RELAY_RelayStub); /* STACK16FRAME.relay.hiword */ |
| *(--stack) = LOWORD(RELAY_RelayStub); /* STACK16FRAME.relay.loword */ |
| *(--stack) = 0; /* STACK16FRAME.module_cs.hiword */ |
| *(--stack) = code_sel; /* STACK16FRAME.module_cs.loword */ |
| *(--stack) = 0; /* STACK16FRAME.callfrom_ip.hiword */ |
| *(--stack) = 0; /* STACK16FRAME.callfrom_ip.loword */ |
| |
| /* |
| * Adjust stack and code pointers. |
| */ |
| ADD_LOWORD( context->Esp, -28 ); |
| context->SegCs = wine_get_cs(); |
| context->Eip = (DWORD)__wine_call_from_16_regs; |
| } |
