MdePkg/Library/BaseLib/x86Thunk.c

   1 /** @file
   2   Real Mode Thunk Functions for IA32 and X64.
   3
   4   Copyright (c) 2006, Intel Corporation<BR>
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13   Module Name:  x86Thunk.c
  14
  15 **/
  16
  17 //
  18 // Include common header file for this module.
  19 //
  20 #include "CommonHeader.h"
  21
  22 //
  23 // Byte packed structure for a segment descriptor in a GDT/LDT
  24 //
  25 typedef union {
  26   struct {
  27     UINT32  LimitLow:16;
  28     UINT32  BaseLow:16;
  29     UINT32  BaseMid:8;
  30     UINT32  Type:4;
  31     UINT32  S:1;
  32     UINT32  DPL:2;
  33     UINT32  P:1;
  34     UINT32  LimitHigh:4;
  35     UINT32  AVL:1;
  36     UINT32  L:1;
  37     UINT32  DB:1;
  38     UINT32  G:1;
  39     UINT32  BaseHigh:8;
  40   } Bits;
  41   UINT64  Uint64;
  42 } IA32_SEGMENT_DESCRIPTOR;
  43
  44 extern CONST UINT8                  m16Start;
  45 extern CONST UINT16                 m16Size;
  46 extern CONST UINT16                 mThunk16Attr;
  47 extern CONST UINT16                 m16Gdt;
  48 extern CONST UINT16                 m16GdtrBase;
  49 extern CONST UINT16                 mTransition;
  50
  51 /**
  52   Invokes 16-bit code in big real mode and returns the updated register set.
  53
  54   This function transfers control to the 16-bit code specified by CS:EIP using
  55   the stack specified by SS:ESP in RegisterSet. The updated registers are saved
  56   on the real mode stack and the starting address of the save area is returned.
  57
  58   @param  RegisterSet Values of registers before invocation of 16-bit code.
  59   @param  Transition  Pointer to the transition code under 1MB.
  60
  61   @return The pointer to a IA32_REGISTER_SET structure containing the updated
  62           register values.
  63
  64 **/
  65 IA32_REGISTER_SET *
  66 EFIAPI
  67 InternalAsmThunk16 (
  68   IN      IA32_REGISTER_SET         *RegisterSet,
  69   IN OUT  VOID                      *Transition
  70   );
  71
  72 /**
  73   Retrieves the properties for 16-bit thunk functions.
  74
  75   Computes the size of the buffer and stack below 1MB required to use the
  76   AsmPrepareThunk16(), AsmThunk16() and AsmPrepareAndThunk16() functions. This
  77   buffer size is returned in RealModeBufferSize, and the stack size is returned
  78   in ExtraStackSize. If parameters are passed to the 16-bit real mode code,
  79   then the actual minimum stack size is ExtraStackSize plus the maximum number
  80   of bytes that need to be passed to the 16-bit real mode code.
  81
  82   If RealModeBufferSize is NULL, then ASSERT().
  83   If ExtraStackSize is NULL, then ASSERT().
  84
  85   @param  RealModeBufferSize  A pointer to the size of the buffer below 1MB
  86                               required to use the 16-bit thunk functions.
  87   @param  ExtraStackSize      A pointer to the extra size of stack below 1MB
  88                               that the 16-bit thunk functions require for
  89                               temporary storage in the transition to and from
  90                               16-bit real mode.
  91
  92 **/
  93 VOID
  94 EFIAPI
  95 AsmGetThunk16Properties (
  96   OUT     UINT32                    *RealModeBufferSize,
  97   OUT     UINT32                    *ExtraStackSize
  98   )
  99 {
 100   ASSERT (RealModeBufferSize != NULL);
 101   ASSERT (ExtraStackSize != NULL);
 102
 103   *RealModeBufferSize = m16Size;
 104
 105   //
 106   // Extra 4 bytes for return address, and another 4 bytes for mode transition
 107   //
 108   *ExtraStackSize = sizeof (IA32_DWORD_REGS) + 8;
 109 }
 110
 111 /**
 112   Prepares all structures a code required to use AsmThunk16().
 113
 114   Prepares all structures and code required to use AsmThunk16().
 115
 116   If ThunkContext is NULL, then ASSERT().
 117
 118   @param  ThunkContext  A pointer to the context structure that describes the
 119                         16-bit real mode code to call.
 120
 121 **/
 122 VOID
 123 EFIAPI
 124 AsmPrepareThunk16 (
 125   OUT     THUNK_CONTEXT             *ThunkContext
 126   )
 127 {
 128   IA32_SEGMENT_DESCRIPTOR           *RealModeGdt;
 129
 130   ASSERT (ThunkContext != NULL);
 131   ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
 132   ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
 133   ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
 134
 135   CopyMem (ThunkContext->RealModeBuffer, &m16Start, m16Size);
 136
 137   //
 138   // Point RealModeGdt to the GDT to be used in transition
 139   //
 140   // RealModeGdt[0]: Reserved as NULL descriptor
 141   // RealModeGdt[1]: Code Segment
 142   // RealModeGdt[2]: Data Segment
 143   // RealModeGdt[3]: Call Gate
 144   //
 145   RealModeGdt = (IA32_SEGMENT_DESCRIPTOR*)(
 146                   (UINTN)ThunkContext->RealModeBuffer + m16Gdt);
 147
 148   //
 149   // Update Code & Data Segment Descriptor
 150   //
 151   RealModeGdt[1].Bits.BaseLow =
 152     (UINT32)(UINTN)ThunkContext->RealModeBuffer & ~0xf;
 153   RealModeGdt[1].Bits.BaseMid =
 154     (UINT32)(UINTN)ThunkContext->RealModeBuffer >> 16;
 155
 156   //
 157   // Update transition code entry point offset
 158   //
 159   *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mTransition) +=
 160     (UINT32)(UINTN)ThunkContext->RealModeBuffer & 0xf;
 161
 162   //
 163   // Update Segment Limits for both Code and Data Segment Descriptors
 164   //
 165   if ((ThunkContext->ThunkAttributes & THUNK_ATTRIBUTE_BIG_REAL_MODE) == 0) {
 166     //
 167     // Set segment limits to 64KB
 168     //
 169     RealModeGdt[1].Bits.LimitHigh = 0;
 170     RealModeGdt[1].Bits.G = 0;
 171     RealModeGdt[2].Bits.LimitHigh = 0;
 172     RealModeGdt[2].Bits.G = 0;
 173   }
 174
 175   //
 176   // Update GDTBASE for this thunk context
 177   //
 178   *(VOID**)((UINTN)ThunkContext->RealModeBuffer + m16GdtrBase) = RealModeGdt;
 179
 180   //
 181   // Update Thunk Attributes
 182   //
 183   *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mThunk16Attr) =
 184     ThunkContext->ThunkAttributes;
 185 }
 186
 187 /**
 188   Transfers control to a 16-bit real mode entry point and returns the results.
 189
 190   Transfers control to a 16-bit real mode entry point and returns the results.
 191   AsmPrepareThunk16() must be called with ThunkContext before this function is
 192   used. This function must be called with interrupts disabled.
 193
 194   If ThunkContext is NULL, then ASSERT().
 195   If AsmPrepareThunk16() was not previously called with ThunkContext, then ASSERT().
 196
 197   @param  ThunkContext  A pointer to the context structure that describes the
 198                         16-bit real mode code to call.
 199
 200 **/
 201 VOID
 202 EFIAPI
 203 AsmThunk16 (
 204   IN OUT  THUNK_CONTEXT             *ThunkContext
 205   )
 206 {
 207   IA32_REGISTER_SET                 *UpdatedRegs;
 208
 209   ASSERT (ThunkContext != NULL);
 210   ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
 211   ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
 212   ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
 213
 214   UpdatedRegs = InternalAsmThunk16 (
 215                   ThunkContext->RealModeState,
 216                   ThunkContext->RealModeBuffer
 217                   );
 218
 219   CopyMem (ThunkContext->RealModeState, UpdatedRegs, sizeof (*UpdatedRegs));
 220 }
 221
 222 /**
 223   Prepares all structures and code for a 16-bit real mode thunk, transfers
 224   control to a 16-bit real mode entry point, and returns the results.
 225
 226   Prepares all structures and code for a 16-bit real mode thunk, transfers
 227   control to a 16-bit real mode entry point, and returns the results. If the
 228   caller only need to perform a single 16-bit real mode thunk, then this
 229   service should be used. If the caller intends to make more than one 16-bit
 230   real mode thunk, then it is more efficient if AsmPrepareThunk16() is called
 231   once and AsmThunk16() can be called for each 16-bit real mode thunk. This
 232   function must be called with interrupts disabled.
 233
 234   If ThunkContext is NULL, then ASSERT().
 235
 236   @param  ThunkContext  A pointer to the context structure that describes the
 237                         16-bit real mode code to call.
 238
 239 **/
 240 VOID
 241 EFIAPI
 242 AsmPrepareAndThunk16 (
 243   IN OUT  THUNK_CONTEXT             *ThunkContext
 244   )
 245 {
 246   AsmPrepareThunk16 (ThunkContext);
 247   AsmThunk16 (ThunkContext);
 248 }