mirror of
https://github.com/reactos/wine.git
synced 2024-11-26 05:00:30 +00:00
4ef7ba7247
Entering protected mode uses simpler and more robust virtual interrupt flag check. Mouse events are now received in graphics modes. Improved tracing output of int33 handler.
271 lines
8.3 KiB
C
271 lines
8.3 KiB
C
/*
|
|
* DOS upper memory management.
|
|
*
|
|
* 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 "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(dosmem);
|
|
|
|
/*
|
|
* Wine DOS memory layout above 640k:
|
|
*
|
|
* a0000 - affff : VGA graphics (vga.c)
|
|
* b0000 - bffff : Monochrome text (unused)
|
|
* b8000 - bffff : VGA text (vga.c)
|
|
* c0000 - cffff : EMS frame (int67.c)
|
|
* d0000 - effff : Free memory for UMBs (himem.c)
|
|
* f0000 - fffff : BIOS stuff (msdos/dosmem.c)
|
|
* 100000 -10ffff : High memory area (unused)
|
|
*/
|
|
|
|
/*
|
|
* Table of real mode segments and protected mode selectors
|
|
* for code stubs and other miscellaneous storage.
|
|
*/
|
|
struct DPMI_segments *DOSVM_dpmi_segments = NULL;
|
|
|
|
/*
|
|
* First and last address available for upper memory blocks.
|
|
*/
|
|
#define DOSVM_UMB_BOTTOM 0xd0000
|
|
#define DOSVM_UMB_TOP 0xeffff
|
|
|
|
/*
|
|
* First free address for upper memory blocks.
|
|
*/
|
|
static DWORD DOSVM_umb_free = DOSVM_UMB_BOTTOM;
|
|
|
|
|
|
/***********************************************************************
|
|
* DOSVM_AllocUMB
|
|
*
|
|
* Allocate upper memory block (UMB) from upper memory.
|
|
* Returned pointer is aligned to 16-byte (paragraph) boundary.
|
|
*
|
|
* This routine is only for allocating static storage for
|
|
* Wine internal uses. Allocated memory can be accessed from
|
|
* real mode, memory is taken from area already mapped and reserved
|
|
* by Wine and the allocation has very little memory and speed
|
|
* overhead. Use of this routine also preserves precious DOS
|
|
* conventional memory.
|
|
*/
|
|
LPVOID DOSVM_AllocUMB( DWORD size )
|
|
{
|
|
LPVOID ptr = (LPVOID)DOSVM_umb_free;
|
|
|
|
size = ((size + 15) >> 4) << 4;
|
|
|
|
if(DOSVM_umb_free + size - 1 > DOSVM_UMB_TOP) {
|
|
ERR("Out of upper memory area.\n");
|
|
return 0;
|
|
}
|
|
|
|
DOSVM_umb_free += size;
|
|
return ptr;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DOSVM_AllocCodeUMB
|
|
*
|
|
* Allocate upper memory block for storing code stubs.
|
|
* Initializes real mode segment and 16-bit protected mode selector
|
|
* for the allocated code block.
|
|
*/
|
|
LPVOID DOSVM_AllocCodeUMB( DWORD size, WORD *segment, WORD *selector )
|
|
{
|
|
LPVOID ptr = DOSVM_AllocUMB( size );
|
|
|
|
if (segment)
|
|
*segment = (DWORD)ptr >> 4;
|
|
|
|
if (selector)
|
|
*selector = SELECTOR_AllocBlock( ptr, size, WINE_LDT_FLAGS_CODE );
|
|
|
|
return ptr;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DOSVM_AllocDataUMB
|
|
*
|
|
* Allocate upper memory block for storing data.
|
|
* Initializes real mode segment and 16-bit protected mode selector
|
|
* for the allocated data block.
|
|
*/
|
|
LPVOID DOSVM_AllocDataUMB( DWORD size, WORD *segment, WORD *selector )
|
|
{
|
|
LPVOID ptr = DOSVM_AllocUMB( size );
|
|
|
|
if (segment)
|
|
*segment = (DWORD)ptr >> 4;
|
|
|
|
if (selector)
|
|
*selector = SELECTOR_AllocBlock( ptr, size, WINE_LDT_FLAGS_DATA );
|
|
|
|
return ptr;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DOSVM_InitSegments
|
|
*
|
|
* Initializes DOSVM_dpmi_segments. Allocates required memory and
|
|
* sets up segments and selectors for accessing the memory.
|
|
*/
|
|
void DOSVM_InitSegments( void )
|
|
{
|
|
LPSTR ptr;
|
|
int i;
|
|
|
|
static const char wrap_code[]={
|
|
0xCD,0x31, /* int $0x31 */
|
|
0xCB /* lret */
|
|
};
|
|
|
|
static const char enter_xms[]=
|
|
{
|
|
/* XMS hookable entry point */
|
|
0xEB,0x03, /* jmp entry */
|
|
0x90,0x90,0x90, /* nop;nop;nop */
|
|
/* entry: */
|
|
/* real entry point */
|
|
/* for simplicity, we'll just use the same hook as DPMI below */
|
|
0xCD,0x31, /* int $0x31 */
|
|
0xCB /* lret */
|
|
};
|
|
|
|
static const char enter_pm[]=
|
|
{
|
|
0x50, /* pushw %ax */
|
|
0x52, /* pushw %dx */
|
|
0x55, /* pushw %bp */
|
|
0x89,0xE5, /* movw %sp,%bp */
|
|
/* get return CS */
|
|
0x8B,0x56,0x08, /* movw 8(%bp),%dx */
|
|
/* just call int 31 here to get into protected mode... */
|
|
/* it'll check whether it was called from dpmi_seg... */
|
|
0xCD,0x31, /* int $0x31 */
|
|
/* we are now in the context of a 16-bit relay call */
|
|
/* need to fixup our stack;
|
|
* 16-bit relay return address will be lost,
|
|
* but we won't worry quite yet
|
|
*/
|
|
0x8E,0xD0, /* movw %ax,%ss */
|
|
0x66,0x0F,0xB7,0xE5, /* movzwl %bp,%esp */
|
|
/* set return CS */
|
|
0x89,0x56,0x08, /* movw %dx,8(%bp) */
|
|
0x5D, /* popw %bp */
|
|
0x5A, /* popw %dx */
|
|
0x58, /* popw %ax */
|
|
0xfb, /* sti, enable and check virtual interrupts */
|
|
0xCB /* lret */
|
|
};
|
|
|
|
static const char relay[]=
|
|
{
|
|
0xca, 0x04, 0x00, /* 16-bit far return and pop 4 bytes (relay void* arg) */
|
|
0xcd, 0x31, /* int 31 */
|
|
0xfb, 0x66, 0xcb /* sti and 32-bit far return */
|
|
};
|
|
|
|
/*
|
|
* Allocate pointer array.
|
|
*/
|
|
DOSVM_dpmi_segments = DOSVM_AllocUMB( sizeof(struct DPMI_segments) );
|
|
|
|
/*
|
|
* RM / offset 0: Exit from real mode.
|
|
* RM / offset 2: Points to lret opcode.
|
|
*/
|
|
ptr = DOSVM_AllocCodeUMB( sizeof(wrap_code),
|
|
&DOSVM_dpmi_segments->wrap_seg, 0 );
|
|
memcpy( ptr, wrap_code, sizeof(wrap_code) );
|
|
|
|
/*
|
|
* RM / offset 0: XMS driver entry.
|
|
*/
|
|
ptr = DOSVM_AllocCodeUMB( sizeof(enter_xms),
|
|
&DOSVM_dpmi_segments->xms_seg, 0 );
|
|
memcpy( ptr, enter_xms, sizeof(enter_xms) );
|
|
|
|
/*
|
|
* RM / offset 0: Switch to DPMI.
|
|
* PM / offset 8: DPMI raw mode switch.
|
|
*/
|
|
ptr = DOSVM_AllocCodeUMB( sizeof(enter_pm),
|
|
&DOSVM_dpmi_segments->dpmi_seg,
|
|
&DOSVM_dpmi_segments->dpmi_sel );
|
|
memcpy( ptr, enter_pm, sizeof(enter_pm) );
|
|
|
|
/*
|
|
* PM / offset N*6: Interrupt N in DPMI32.
|
|
*/
|
|
ptr = DOSVM_AllocCodeUMB( 6 * 256,
|
|
0, &DOSVM_dpmi_segments->int48_sel );
|
|
for(i=0; i<256; i++) {
|
|
/*
|
|
* Each 32-bit interrupt handler is 6 bytes:
|
|
* 0xCD,<i> = int <i> (nested 16-bit interrupt)
|
|
* 0x66,0xCA,0x04,0x00 = ret 4 (32-bit far return and pop 4 bytes / eflags)
|
|
*/
|
|
ptr[i * 6 + 0] = 0xCD;
|
|
ptr[i * 6 + 1] = i;
|
|
ptr[i * 6 + 2] = 0x66;
|
|
ptr[i * 6 + 3] = 0xCA;
|
|
ptr[i * 6 + 4] = 0x04;
|
|
ptr[i * 6 + 5] = 0x00;
|
|
}
|
|
|
|
/*
|
|
* PM / offset N*5: Interrupt N in 16-bit protected mode.
|
|
*/
|
|
ptr = DOSVM_AllocCodeUMB( 5 * 256,
|
|
0, &DOSVM_dpmi_segments->int16_sel );
|
|
for(i=0; i<256; i++) {
|
|
/*
|
|
* Each 16-bit interrupt handler is 5 bytes:
|
|
* 0xCD,<i> = int <i> (interrupt)
|
|
* 0xCA,0x02,0x00 = ret 2 (16-bit far return and pop 2 bytes / eflags)
|
|
*/
|
|
ptr[i * 5 + 0] = 0xCD;
|
|
ptr[i * 5 + 1] = i;
|
|
ptr[i * 5 + 2] = 0xCA;
|
|
ptr[i * 5 + 3] = 0x02;
|
|
ptr[i * 5 + 4] = 0x00;
|
|
}
|
|
|
|
/*
|
|
* PM / offset 0: Stub where __wine_call_from_16_regs returns.
|
|
* PM / offset 3: Stub which swaps back to 32-bit application code/stack.
|
|
* PM / offset 5: Stub which enables interrupts
|
|
*/
|
|
ptr = DOSVM_AllocCodeUMB( sizeof(relay),
|
|
0, &DOSVM_dpmi_segments->relay_code_sel);
|
|
memcpy( ptr, relay, sizeof(relay) );
|
|
|
|
/*
|
|
* Space for 16-bit stack used by relay code.
|
|
*/
|
|
ptr = DOSVM_AllocDataUMB( DOSVM_RELAY_DATA_SIZE,
|
|
0, &DOSVM_dpmi_segments->relay_data_sel);
|
|
memset( ptr, 0, DOSVM_RELAY_DATA_SIZE );
|
|
}
|