dlls/winedos/himem.c

   1 /*
   2  * DOS upper memory management.
   3  *
   4  * Copyright 2002 Jukka Heinonen
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "dosexe.h"
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(dosmem);
  25
  26 /*
  27  * Wine DOS memory layout above 640k:
  28  *
  29  *   a0000 - affff : VGA graphics         (vga.c)
  30  *   b0000 - bffff : Monochrome text      (unused)
  31  *   b8000 - bffff : VGA text             (vga.c)
  32  *   c0000 - cffff : EMS frame            (int67.c)
  33  *   d0000 - effff : Free memory for UMBs (himem.c)
  34  *   f0000 - fffff : BIOS stuff           (msdos/dosmem.c)
  35  *  100000 -10ffff : High memory area     (unused)
  36  */
  37
  38 /*
  39  * Table of real mode segments and protected mode selectors
  40  * for code stubs and other miscellaneous storage.
  41  */
  42 struct DPMI_segments *DOSVM_dpmi_segments = NULL;
  43
  44 /*
  45  * First and last address available for upper memory blocks.
  46  */
  47 #define DOSVM_UMB_BOTTOM 0xd0000
  48 #define DOSVM_UMB_TOP    0xeffff
  49
  50 /*
  51  * First free address for upper memory blocks.
  52  */
  53 static DWORD DOSVM_umb_free = DOSVM_UMB_BOTTOM;
  54
  55
  56 /***********************************************************************
  57  *           DOSVM_AllocUMB
  58  *
  59  * Allocate upper memory block (UMB) from upper memory.
  60  * Returned pointer is aligned to 16-byte (paragraph) boundary.
  61  *
  62  * This routine is only for allocating static storage for
  63  * Wine internal uses. Allocated memory can be accessed from
  64  * real mode, memory is taken from area already mapped and reserved
  65  * by Wine and the allocation has very little memory and speed
  66  * overhead. Use of this routine also preserves precious DOS
  67  * conventional memory.
  68  */
  69 LPVOID DOSVM_AllocUMB( DWORD size )
  70 {
  71   LPVOID ptr = (LPVOID)DOSVM_umb_free;
  72
  73   size = ((size + 15) >> 4) << 4;
  74
  75   if(DOSVM_umb_free + size - 1 > DOSVM_UMB_TOP) {
  76     ERR("Out of upper memory area.\n");
  77     return 0;
  78   }
  79
  80   DOSVM_umb_free += size;
  81   return ptr;
  82 }
  83
  84
  85 /***********************************************************************
  86  *           DOSVM_AllocCodeUMB
  87  *
  88  * Allocate upper memory block for storing code stubs.
  89  * Initializes real mode segment and 16-bit protected mode selector
  90  * for the allocated code block.
  91  */
  92 LPVOID DOSVM_AllocCodeUMB( DWORD size, WORD *segment, WORD *selector )
  93 {
  94   LPVOID ptr = DOSVM_AllocUMB( size );
  95
  96   if (segment)
  97     *segment = (DWORD)ptr >> 4;
  98
  99   if (selector)
 100     *selector = SELECTOR_AllocBlock( ptr, size, WINE_LDT_FLAGS_CODE );
 101
 102   return ptr;
 103 }
 104
 105
 106 /***********************************************************************
 107  *           DOSVM_AllocDataUMB
 108  *
 109  * Allocate upper memory block for storing data.
 110  * Initializes real mode segment and 16-bit protected mode selector
 111  * for the allocated data block.
 112  */
 113 LPVOID DOSVM_AllocDataUMB( DWORD size, WORD *segment, WORD *selector )
 114 {
 115   LPVOID ptr = DOSVM_AllocUMB( size );
 116
 117   if (segment)
 118     *segment = (DWORD)ptr >> 4;
 119
 120   if (selector)
 121     *selector = SELECTOR_AllocBlock( ptr, size, WINE_LDT_FLAGS_DATA );
 122
 123   return ptr;
 124 }
 125
 126
 127 /***********************************************************************
 128  *           DOSVM_InitSegments
 129  *
 130  * Initializes DOSVM_dpmi_segments. Allocates required memory and
 131  * sets up segments and selectors for accessing the memory.
 132  */
 133 void DOSVM_InitSegments( void )
 134 {
 135     LPSTR ptr;
 136     int   i;
 137
 138     static const char wrap_code[]={
 139      0xCD,0x31, /* int $0x31 */
 140      0xCB       /* lret */
 141     };
 142
 143     static const char enter_xms[]=
 144     {
 145         /* XMS hookable entry point */
 146         0xEB,0x03,           /* jmp entry */
 147         0x90,0x90,0x90,      /* nop;nop;nop */
 148                              /* entry: */
 149         /* real entry point */
 150         /* for simplicity, we'll just use the same hook as DPMI below */
 151         0xCD,0x31,           /* int $0x31 */
 152         0xCB                 /* lret */
 153     };
 154
 155     static const char enter_pm[]=
 156     {
 157         0x50,                /* pushw %ax */
 158         0x52,                /* pushw %dx */
 159         0x55,                /* pushw %bp */
 160         0x89,0xE5,           /* movw %sp,%bp */
 161         /* get return CS */
 162         0x8B,0x56,0x08,      /* movw 8(%bp),%dx */
 163         /* just call int 31 here to get into protected mode... */
 164         /* it'll check whether it was called from dpmi_seg... */
 165         0xCD,0x31,           /* int $0x31 */
 166         /* we are now in the context of a 16-bit relay call */
 167         /* need to fixup our stack;
 168          * 16-bit relay return address will be lost,
 169          * but we won't worry quite yet
 170          */
 171         0x8E,0xD0,           /* movw %ax,%ss */
 172         0x66,0x0F,0xB7,0xE5, /* movzwl %bp,%esp */
 173         /* set return CS */
 174         0x89,0x56,0x08,      /* movw %dx,8(%bp) */
 175         0x5D,                /* popw %bp */
 176         0x5A,                /* popw %dx */
 177         0x58,                /* popw %ax */
 178         0xfb,                /* sti, enable and check virtual interrupts */
 179         0xCB                 /* lret */
 180     };
 181
 182     static const char relay[]=
 183     {
 184         0xca, 0x04, 0x00, /* 16-bit far return and pop 4 bytes (relay void* arg) */
 185         0xcd, 0x31,       /* int 31 */
 186         0xfb, 0x66, 0xcb  /* sti and 32-bit far return */
 187     };
 188
 189     /*
 190      * Allocate pointer array.
 191      */
 192     DOSVM_dpmi_segments = DOSVM_AllocUMB( sizeof(struct DPMI_segments) );
 193
 194     /*
 195      * RM / offset 0: Exit from real mode.
 196      * RM / offset 2: Points to lret opcode.
 197      */
 198     ptr = DOSVM_AllocCodeUMB( sizeof(wrap_code),
 199                               &DOSVM_dpmi_segments->wrap_seg, 0 );
 200     memcpy( ptr, wrap_code, sizeof(wrap_code) );
 201
 202     /*
 203      * RM / offset 0: XMS driver entry.
 204      */
 205     ptr = DOSVM_AllocCodeUMB( sizeof(enter_xms),
 206                               &DOSVM_dpmi_segments->xms_seg, 0 );
 207     memcpy( ptr, enter_xms, sizeof(enter_xms) );
 208
 209     /*
 210      * RM / offset 0: Switch to DPMI.
 211      * PM / offset 8: DPMI raw mode switch.
 212      */
 213     ptr = DOSVM_AllocCodeUMB( sizeof(enter_pm),
 214                               &DOSVM_dpmi_segments->dpmi_seg,
 215                               &DOSVM_dpmi_segments->dpmi_sel );
 216     memcpy( ptr, enter_pm, sizeof(enter_pm) );
 217
 218     /*
 219      * PM / offset N*6: Interrupt N in DPMI32.
 220      */
 221     ptr = DOSVM_AllocCodeUMB( 6 * 256,
 222                               0, &DOSVM_dpmi_segments->int48_sel );
 223     for(i=0; i<256; i++) {
 224         /*
 225          * Each 32-bit interrupt handler is 6 bytes:
 226          * 0xCD,<i>            = int <i> (nested 16-bit interrupt)
 227          * 0x66,0xCA,0x04,0x00 = ret 4   (32-bit far return and pop 4 bytes / eflags)
 228          */
 229         ptr[i * 6 + 0] = 0xCD;
 230         ptr[i * 6 + 1] = i;
 231         ptr[i * 6 + 2] = 0x66;
 232         ptr[i * 6 + 3] = 0xCA;
 233         ptr[i * 6 + 4] = 0x04;
 234         ptr[i * 6 + 5] = 0x00;
 235     }
 236
 237     /*
 238      * PM / offset N*5: Interrupt N in 16-bit protected mode.
 239      */
 240     ptr = DOSVM_AllocCodeUMB( 5 * 256,
 241                               0, &DOSVM_dpmi_segments->int16_sel );
 242     for(i=0; i<256; i++) {
 243         /*
 244          * Each 16-bit interrupt handler is 5 bytes:
 245          * 0xCD,<i>       = int <i> (interrupt)
 246          * 0xCA,0x02,0x00 = ret 2   (16-bit far return and pop 2 bytes / eflags)
 247          */
 248         ptr[i * 5 + 0] = 0xCD;
 249         ptr[i * 5 + 1] = i;
 250         ptr[i * 5 + 2] = 0xCA;
 251         ptr[i * 5 + 3] = 0x02;
 252         ptr[i * 5 + 4] = 0x00;
 253     }
 254
 255     /*
 256      * PM / offset 0: Stub where __wine_call_from_16_regs returns.
 257      * PM / offset 3: Stub which swaps back to 32-bit application code/stack.
 258      * PM / offset 5: Stub which enables interrupts
 259      */
 260     ptr = DOSVM_AllocCodeUMB( sizeof(relay),
 261                               0,  &DOSVM_dpmi_segments->relay_code_sel);
 262     memcpy( ptr, relay, sizeof(relay) );
 263
 264     /*
 265      * Space for 16-bit stack used by relay code.
 266      */
 267     ptr = DOSVM_AllocDataUMB( DOSVM_RELAY_DATA_SIZE,
 268                               0, &DOSVM_dpmi_segments->relay_data_sel);
 269     memset( ptr, 0, DOSVM_RELAY_DATA_SIZE );
 270 }