reactos/subsystems/ntvdm/callback.c

   1 /*
   2  * COPYRIGHT:       GPL - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            callback.c
   5  * PURPOSE:         16 and 32-bit Callbacks Support
   6  * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   7  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   8  */
   9
  10 /* INCLUDES *******************************************************************/
  11
  12 #define NDEBUG
  13
  14 #include "emulator.h"
  15 #include "callback.h"
  16
  17 #include "bop.h"
  18 #include <isvbop.h>
  19
  20 /* PRIVATE VARIABLES **********************************************************/
  21
  22 /*
  23  * This is the list of registered 32-bit Interrupt handlers.
  24  */
  25 static EMULATOR_INT32_PROC Int32Proc[EMULATOR_MAX_INT32_NUM] = { NULL };
  26
  27 /* BOP Identifiers */
  28 #define BOP_CONTROL             0xFF    // Control BOP Handler
  29     #define BOP_CONTROL_DEFFUNC 0x00    // Default Control BOP Function
  30     #define BOP_CONTROL_INT32   0xFF    // 32-bit Interrupt dispatcher
  31                                         // function code for the Control BOP Handler
  32
  33 #define BOP(num)            LOBYTE(EMULATOR_BOP), HIBYTE(EMULATOR_BOP), (num)
  34 #define UnSimulate16(trap)           \
  35 do {                                 \
  36     *(PUSHORT)(trap) = EMULATOR_BOP; \
  37     (trap) += sizeof(USHORT);        \
  38     *(trap) = BOP_UNSIMULATE;        \
  39 } while(0)
  40 // #define UnSimulate16        MAKELONG(EMULATOR_BOP, BOP_UNSIMULATE) // BOP(BOP_UNSIMULATE)
  41
  42 #define CALL16_TRAMPOLINE_SIZE  (1 * sizeof(ULONGLONG))
  43 #define  INT16_TRAMPOLINE_SIZE  (1 * sizeof(ULONGLONG))
  44
  45 //
  46 // WARNING WARNING!!
  47 //
  48 // If you modify the code stubs here, think also
  49 // about updating them in int32.c too!!
  50 //
  51
  52 /* 16-bit generic interrupt code for calling a 32-bit interrupt handler */
  53 static BYTE Int16To32[] =
  54 {
  55     0xFA,               // cli
  56
  57     /* Push the value of the interrupt to be called */
  58     0x6A, 0xFF,         // push i (patchable to 0x6A, 0xIntNum)
  59
  60     /* The BOP Sequence */
  61 // BOP_SEQ:
  62     0xF8,               // clc
  63     BOP(BOP_CONTROL),   // Control BOP
  64     BOP_CONTROL_INT32,  // 32-bit Interrupt dispatcher
  65
  66     0x73, 0x04,         // jnc EXIT (offset +4)
  67
  68     0xFB,               // sti
  69
  70     // HACK: The following instruction should be HLT!
  71     0x90,               // nop
  72
  73     0xEB, 0xF5,         // jmp BOP_SEQ (offset -11)
  74
  75 // EXIT:
  76     0x44, 0x44,         // inc sp, inc sp
  77     0xCF,               // iret
  78 };
  79 const ULONG Int16To32StubSize = sizeof(Int16To32);
  80
  81 /* PUBLIC FUNCTIONS ***********************************************************/
  82
  83 VOID
  84 InitializeContext(IN PCALLBACK16 Context,
  85                   IN USHORT      Segment,
  86                   IN USHORT      Offset)
  87 {
  88     Context->TrampolineFarPtr = MAKELONG(Offset, Segment);
  89     Context->TrampolineSize   = max(CALL16_TRAMPOLINE_SIZE,
  90                                      INT16_TRAMPOLINE_SIZE);
  91     Context->Segment          = Segment;
  92     Context->NextOffset       = Offset + Context->TrampolineSize;
  93 }
  94
  95 VOID
  96 Call16(IN USHORT Segment,
  97        IN USHORT Offset)
  98 {
  99     /* Save CS:IP */
 100     USHORT OrgCS = getCS();
 101     USHORT OrgIP = getIP();
 102
 103     /* Set the new CS:IP */
 104     setCS(Segment);
 105     setIP(Offset);
 106
 107     DPRINT("Call16(%04X:%04X)\n", Segment, Offset);
 108
 109     /* Start CPU simulation */
 110     EmulatorSimulate();
 111
 112     /* Restore CS:IP */
 113     setCS(OrgCS);
 114     setIP(OrgIP);
 115 }
 116
 117
 118
 119 ULONG
 120 RegisterCallback16(IN  ULONG   FarPtr,
 121                    IN  LPBYTE  CallbackCode,
 122                    IN  SIZE_T  CallbackSize,
 123                    OUT PSIZE_T CodeSize OPTIONAL)
 124 {
 125     LPBYTE CodeStart = (LPBYTE)FAR_POINTER(FarPtr);
 126     LPBYTE Code      = CodeStart;
 127
 128     SIZE_T OurCodeSize = CallbackSize;
 129
 130     if (CallbackCode == NULL) CallbackSize = 0;
 131
 132     if (CallbackCode)
 133     {
 134         /* 16-bit interrupt code */
 135         RtlCopyMemory(Code, CallbackCode, CallbackSize);
 136         Code += CallbackSize;
 137     }
 138
 139     /* Return the real size of the code if needed */
 140     if (CodeSize) *CodeSize = OurCodeSize; // == (ULONG_PTR)Code - (ULONG_PTR)CodeStart;
 141
 142     // /* Return the entry-point address for 32-bit calls */
 143     // return (ULONG_PTR)(CodeStart + CallbackSize);
 144     return OurCodeSize;
 145 }
 146
 147 VOID
 148 RunCallback16(IN PCALLBACK16 Context,
 149               IN ULONG       FarPtr)
 150 {
 151     PUCHAR TrampolineBase = (PUCHAR)FAR_POINTER(Context->TrampolineFarPtr);
 152     PUCHAR Trampoline     = TrampolineBase;
 153     UCHAR  OldTrampoline[CALL16_TRAMPOLINE_SIZE];
 154
 155     /* Save the old trampoline */
 156     ((PULONGLONG)&OldTrampoline)[0] = ((PULONGLONG)TrampolineBase)[0];
 157
 158     DPRINT1("RunCallback16(0x%p)\n", FarPtr);
 159
 160     /* Build the generic entry-point for 16-bit far calls */
 161     *Trampoline++ = 0x9A; // Call far seg:off
 162     *(PULONG)Trampoline = FarPtr;
 163     Trampoline += sizeof(ULONG);
 164     UnSimulate16(Trampoline);
 165
 166     /* Perform the call */
 167     Call16(HIWORD(Context->TrampolineFarPtr),
 168            LOWORD(Context->TrampolineFarPtr));
 169
 170     /* Restore the old trampoline */
 171     ((PULONGLONG)TrampolineBase)[0] = ((PULONGLONG)&OldTrampoline)[0];
 172 }
 173
 174
 175
 176 ULONG
 177 RegisterInt16(IN  ULONG   FarPtr,
 178               IN  BYTE    IntNumber,
 179               IN  LPBYTE  CallbackCode,
 180               IN  SIZE_T  CallbackSize,
 181               OUT PSIZE_T CodeSize OPTIONAL)
 182 {
 183     /* Get a pointer to the IVT and set the corresponding entry (far pointer) */
 184     LPDWORD IntVecTable = (LPDWORD)SEG_OFF_TO_PTR(0x0000, 0x0000);
 185     IntVecTable[IntNumber] = FarPtr;
 186
 187     /* Register the 16-bit callback */
 188     return RegisterCallback16(FarPtr,
 189                               CallbackCode,
 190                               CallbackSize,
 191                               CodeSize);
 192 }
 193
 194 ULONG
 195 RegisterInt32(IN  ULONG   FarPtr,
 196               IN  BYTE    IntNumber,
 197               IN  EMULATOR_INT32_PROC IntHandler,
 198               OUT PSIZE_T CodeSize OPTIONAL)
 199 {
 200     /* Array for holding our copy of the 16-bit interrupt callback */
 201     BYTE IntCallback[sizeof(Int16To32)/sizeof(BYTE)];
 202
 203     /* Check whether the 32-bit interrupt was already registered */
 204 #if 0
 205     if (Int32Proc[IntNumber] != NULL)
 206     {
 207         DPRINT1("RegisterInt32: Interrupt 0x%X already registered!\n", IntNumber);
 208         return 0;
 209     }
 210 #endif
 211
 212     /* Register the 32-bit interrupt handler */
 213     Int32Proc[IntNumber] = IntHandler;
 214
 215     /* Copy the generic 16-bit interrupt callback and patch it */
 216     RtlCopyMemory(IntCallback, Int16To32, sizeof(Int16To32));
 217     IntCallback[2] = IntNumber;
 218
 219     /* Register the 16-bit interrupt callback */
 220     return RegisterInt16(FarPtr,
 221                          IntNumber,
 222                          IntCallback,
 223                          sizeof(IntCallback),
 224                          CodeSize);
 225 }
 226
 227 VOID
 228 Int32Call(IN PCALLBACK16 Context,
 229           IN BYTE IntNumber)
 230 {
 231     PUCHAR TrampolineBase = (PUCHAR)FAR_POINTER(Context->TrampolineFarPtr);
 232     PUCHAR Trampoline     = TrampolineBase;
 233     UCHAR  OldTrampoline[INT16_TRAMPOLINE_SIZE];
 234
 235     DPRINT("Int32Call(0x%X)\n", IntNumber);
 236
 237     /* Save the old trampoline */
 238     ((PULONGLONG)&OldTrampoline)[0] = ((PULONGLONG)TrampolineBase)[0];
 239
 240     /* Build the generic entry-point for 16-bit calls */
 241     if (IntNumber == 0x03)
 242     {
 243         /* We are redefining for INT 03h */
 244         *Trampoline++ = 0xCC; // Call INT 03h
 245         /** *Trampoline++ = 0x90; // nop **/
 246     }
 247     else
 248     {
 249         /* Normal interrupt */
 250         *Trampoline++ = 0xCD; // Call INT XXh
 251         *Trampoline++ = IntNumber;
 252     }
 253     UnSimulate16(Trampoline);
 254
 255     /* Perform the call */
 256     Call16(HIWORD(Context->TrampolineFarPtr),
 257            LOWORD(Context->TrampolineFarPtr));
 258
 259     /* Restore the old trampoline */
 260     ((PULONGLONG)TrampolineBase)[0] = ((PULONGLONG)&OldTrampoline)[0];
 261 }
 262
 263
 264
 265 VOID WINAPI Int32Dispatch(LPWORD Stack)
 266 {
 267     /* Get the interrupt number */
 268     BYTE IntNum = LOBYTE(Stack[STACK_INT_NUM]);
 269
 270     /* Call the 32-bit Interrupt handler */
 271     if (Int32Proc[IntNum] != NULL)
 272         Int32Proc[IntNum](Stack);
 273     else
 274         DPRINT1("Unhandled 32-bit interrupt: 0x%02X, AX = 0x%04X\n", IntNum, getAX());
 275 }
 276
 277 static VOID WINAPI ControlBop(LPWORD Stack)
 278 {
 279     /* Get the Function Number and skip it */
 280     BYTE FuncNum = *(PBYTE)SEG_OFF_TO_PTR(getCS(), getIP());
 281     setIP(getIP() + 1);
 282
 283     switch (FuncNum)
 284     {
 285         case BOP_CONTROL_INT32:
 286             Int32Dispatch(Stack);
 287             break;
 288
 289         default:
 290             // DPRINT1("Unassigned Control BOP Function: 0x%02X\n", FuncNum);
 291             DisplayMessage(L"Unassigned Control BOP Function: 0x%02X", FuncNum);
 292             break;
 293     }
 294 }
 295
 296 VOID InitializeCallbacks(VOID)
 297 {
 298     /* Register the Control BOP */
 299     RegisterBop(BOP_CONTROL, ControlBop);
 300 }
 301
 302 /* EOF */