reactos/lib/fast486/common.c

   1 /*
   2  * Fast486 386/486 CPU Emulation Library
   3  * common.c
   4  *
   5  * Copyright (C) 2014 Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  */
  21
  22 /* INCLUDES *******************************************************************/
  23
  24 #include <windef.h>
  25
  26 // #define NDEBUG
  27 #include <debug.h>
  28
  29 #include <fast486.h>
  30 #include "common.h"
  31
  32 /* PUBLIC FUNCTIONS ***********************************************************/
  33
  34 BOOLEAN
  35 Fast486ReadMemory(PFAST486_STATE State,
  36                   FAST486_SEG_REGS SegmentReg,
  37                   ULONG Offset,
  38                   BOOLEAN InstFetch,
  39                   PVOID Buffer,
  40                   ULONG Size)
  41 {
  42     ULONG LinearAddress;
  43     PFAST486_SEG_REG CachedDescriptor;
  44
  45     ASSERT(SegmentReg < FAST486_NUM_SEG_REGS);
  46
  47     /* Get the cached descriptor */
  48     CachedDescriptor = &State->SegmentRegs[SegmentReg];
  49
  50     if ((Offset + Size - 1) > CachedDescriptor->Limit)
  51     {
  52         /* Read beyond limit */
  53         Fast486Exception(State, FAST486_EXCEPTION_GP);
  54         return FALSE;
  55     }
  56
  57     /* Check for protected mode */
  58     if (State->ControlRegisters[0] & FAST486_CR0_PE)
  59     {
  60         /* Privilege checks */
  61
  62         if (!CachedDescriptor->Present)
  63         {
  64             Fast486Exception(State, FAST486_EXCEPTION_NP);
  65             return FALSE;
  66         }
  67
  68         if ((!InstFetch && (CachedDescriptor->Rpl > CachedDescriptor->Dpl))
  69             || (Fast486GetCurrentPrivLevel(State) > CachedDescriptor->Dpl))
  70         {
  71             Fast486Exception(State, FAST486_EXCEPTION_GP);
  72             return FALSE;
  73         }
  74
  75         if (InstFetch)
  76         {
  77             if (!CachedDescriptor->Executable)
  78             {
  79                 /* Data segment not executable */
  80                 Fast486Exception(State, FAST486_EXCEPTION_GP);
  81                 return FALSE;
  82             }
  83         }
  84         else
  85         {
  86             if (CachedDescriptor->Executable && (!CachedDescriptor->ReadWrite))
  87             {
  88                 /* Code segment not readable */
  89                 Fast486Exception(State, FAST486_EXCEPTION_GP);
  90                 return FALSE;
  91             }
  92         }
  93     }
  94
  95     /* Find the linear address */
  96     LinearAddress = CachedDescriptor->Base + Offset;
  97
  98     /* Read from the linear address */
  99     return Fast486ReadLinearMemory(State, LinearAddress, Buffer, Size);
 100 }
 101
 102 BOOLEAN
 103 Fast486WriteMemory(PFAST486_STATE State,
 104                    FAST486_SEG_REGS SegmentReg,
 105                    ULONG Offset,
 106                    PVOID Buffer,
 107                    ULONG Size)
 108 {
 109     ULONG LinearAddress;
 110     PFAST486_SEG_REG CachedDescriptor;
 111
 112     ASSERT(SegmentReg < FAST486_NUM_SEG_REGS);
 113
 114     /* Get the cached descriptor */
 115     CachedDescriptor = &State->SegmentRegs[SegmentReg];
 116
 117     if ((Offset + Size - 1) > CachedDescriptor->Limit)
 118     {
 119         /* Write beyond limit */
 120         Fast486Exception(State, FAST486_EXCEPTION_GP);
 121         return FALSE;
 122     }
 123
 124     /* Check for protected mode */
 125     if (State->ControlRegisters[0] & FAST486_CR0_PE)
 126     {
 127         /* Privilege checks */
 128
 129         if (!CachedDescriptor->Present)
 130         {
 131             Fast486Exception(State, FAST486_EXCEPTION_NP);
 132             return FALSE;
 133         }
 134
 135         if ((CachedDescriptor->Rpl > CachedDescriptor->Dpl)
 136             || (Fast486GetCurrentPrivLevel(State) > CachedDescriptor->Dpl))
 137         {
 138             Fast486Exception(State, FAST486_EXCEPTION_GP);
 139             return FALSE;
 140         }
 141
 142         if (CachedDescriptor->Executable)
 143         {
 144             /* Code segment not writable */
 145             Fast486Exception(State, FAST486_EXCEPTION_GP);
 146             return FALSE;
 147         }
 148         else if (!CachedDescriptor->ReadWrite)
 149         {
 150             /* Data segment not writeable */
 151             Fast486Exception(State, FAST486_EXCEPTION_GP);
 152             return FALSE;
 153         }
 154     }
 155
 156     /* Find the linear address */
 157     LinearAddress = CachedDescriptor->Base + Offset;
 158
 159     /* Write to the linear address */
 160     return Fast486WriteLinearMemory(State, LinearAddress, Buffer, Size);
 161 }
 162
 163 static
 164 inline
 165 BOOLEAN
 166 Fast486GetIntVector(PFAST486_STATE State,
 167                     UCHAR Number,
 168                     PFAST486_IDT_ENTRY IdtEntry)
 169 {
 170     ULONG FarPointer;
 171
 172     /* Check for protected mode */
 173     if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)
 174     {
 175         /* Read from the IDT */
 176         if (!Fast486ReadLinearMemory(State,
 177                                      State->Idtr.Address
 178                                      + Number * sizeof(*IdtEntry),
 179                                      IdtEntry,
 180                                      sizeof(*IdtEntry)))
 181         {
 182             /* Exception occurred */
 183             return FALSE;
 184         }
 185     }
 186     else
 187     {
 188         /* Read from the real-mode IVT */
 189
 190         /* Paging is always disabled in real mode */
 191         State->MemReadCallback(State,
 192                                State->Idtr.Address
 193                                + Number * sizeof(FarPointer),
 194                                &FarPointer,
 195                                sizeof(FarPointer));
 196
 197         /* Fill a fake IDT entry */
 198         IdtEntry->Offset = LOWORD(FarPointer);
 199         IdtEntry->Selector = HIWORD(FarPointer);
 200         IdtEntry->Zero = 0;
 201         IdtEntry->Type = FAST486_IDT_INT_GATE;
 202         IdtEntry->Storage = FALSE;
 203         IdtEntry->Dpl = 0;
 204         IdtEntry->Present = TRUE;
 205         IdtEntry->OffsetHigh = 0;
 206     }
 207
 208     return TRUE;
 209 }
 210
 211 static
 212 inline
 213 BOOLEAN
 214 Fast486InterruptInternal(PFAST486_STATE State,
 215                          USHORT SegmentSelector,
 216                          ULONG Offset,
 217                          ULONG GateType)
 218 {
 219     BOOLEAN GateSize = (GateType == FAST486_IDT_INT_GATE_32)
 220                        || (GateType == FAST486_IDT_TRAP_GATE_32);
 221     BOOLEAN Success = FALSE;
 222     ULONG OldPrefixFlags = State->PrefixFlags;
 223
 224     /* Check for protected mode */
 225     if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)
 226     {
 227         FAST486_TSS Tss;
 228         USHORT OldSs = State->SegmentRegs[FAST486_REG_SS].Selector;
 229         ULONG OldEsp = State->GeneralRegs[FAST486_REG_ESP].Long;
 230
 231         if (GateSize != (State->SegmentRegs[FAST486_REG_CS].Size))
 232         {
 233             /*
 234              * The gate size doesn't match the current operand size, so toggle
 235              * the OPSIZE flag.
 236              */
 237             State->PrefixFlags ^= FAST486_PREFIX_OPSIZE;
 238         }
 239
 240         /* Check if the interrupt handler is more privileged */
 241         if (Fast486GetCurrentPrivLevel(State) > GET_SEGMENT_RPL(SegmentSelector))
 242         {
 243             /* Read the TSS */
 244             if (!Fast486ReadLinearMemory(State,
 245                                          State->TaskReg.Base,
 246                                          &Tss,
 247                                          sizeof(Tss)))
 248             {
 249                 /* Exception occurred */
 250                 goto Cleanup;
 251             }
 252
 253             /* Check the new (higher) privilege level */
 254             switch (GET_SEGMENT_RPL(SegmentSelector))
 255             {
 256                 case 0:
 257                 {
 258                     if (!Fast486LoadSegment(State, FAST486_REG_SS, Tss.Ss0))
 259                     {
 260                         /* Exception occurred */
 261                         goto Cleanup;
 262                     }
 263                     State->GeneralRegs[FAST486_REG_ESP].Long = Tss.Esp0;
 264
 265                     break;
 266                 }
 267
 268                 case 1:
 269                 {
 270                     if (!Fast486LoadSegment(State, FAST486_REG_SS, Tss.Ss1))
 271                     {
 272                         /* Exception occurred */
 273                         goto Cleanup;
 274                     }
 275                     State->GeneralRegs[FAST486_REG_ESP].Long = Tss.Esp1;
 276
 277                     break;
 278                 }
 279
 280                 case 2:
 281                 {
 282                     if (!Fast486LoadSegment(State, FAST486_REG_SS, Tss.Ss2))
 283                     {
 284                         /* Exception occurred */
 285                         goto Cleanup;
 286                     }
 287                     State->GeneralRegs[FAST486_REG_ESP].Long = Tss.Esp2;
 288
 289                     break;
 290                 }
 291
 292                 default:
 293                 {
 294                     /* Should never reach here! */
 295                     ASSERT(FALSE);
 296                 }
 297             }
 298
 299             /* Push SS selector */
 300             if (!Fast486StackPush(State, OldSs)) goto Cleanup;
 301
 302             /* Push stack pointer */
 303             if (!Fast486StackPush(State, OldEsp)) goto Cleanup;
 304         }
 305     }
 306     else
 307     {
 308         if (State->SegmentRegs[FAST486_REG_CS].Size)
 309         {
 310             /* Set OPSIZE, because INT always pushes 16-bit values in real mode */
 311             State->PrefixFlags |= FAST486_PREFIX_OPSIZE;
 312         }
 313     }
 314
 315     /* Push EFLAGS */
 316     if (!Fast486StackPush(State, State->Flags.Long)) goto Cleanup;
 317
 318     /* Push CS selector */
 319     if (!Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector)) goto Cleanup;
 320
 321     /* Push the instruction pointer */
 322     if (!Fast486StackPush(State, State->InstPtr.Long)) goto Cleanup;
 323
 324     if ((GateType == FAST486_IDT_INT_GATE) || (GateType == FAST486_IDT_INT_GATE_32))
 325     {
 326         /* Disable interrupts after a jump to an interrupt gate handler */
 327         State->Flags.If = FALSE;
 328     }
 329
 330     /* Load new CS */
 331     if (!Fast486LoadSegment(State, FAST486_REG_CS, SegmentSelector))
 332     {
 333         /* An exception occurred during the jump */
 334         goto Cleanup;
 335     }
 336
 337     if (GateSize)
 338     {
 339         /* 32-bit code segment, use EIP */
 340         State->InstPtr.Long = Offset;
 341     }
 342     else
 343     {
 344         /* 16-bit code segment, use IP */
 345         State->InstPtr.LowWord = LOWORD(Offset);
 346     }
 347
 348     Success = TRUE;
 349
 350 Cleanup:
 351     /* Restore the prefix flags */
 352     State->PrefixFlags = OldPrefixFlags;
 353
 354     return Success;
 355 }
 356
 357 BOOLEAN
 358 Fast486PerformInterrupt(PFAST486_STATE State,
 359                         UCHAR Number)
 360 {
 361     FAST486_IDT_ENTRY IdtEntry;
 362
 363     /* Get the interrupt vector */
 364     if (!Fast486GetIntVector(State, Number, &IdtEntry))
 365     {
 366         /* Exception occurred */
 367         return FALSE;
 368     }
 369
 370     /* Perform the interrupt */
 371     if (!Fast486InterruptInternal(State,
 372                                   IdtEntry.Selector,
 373                                   MAKELONG(IdtEntry.Offset, IdtEntry.OffsetHigh),
 374                                   IdtEntry.Type))
 375     {
 376         /* Exception occurred */
 377         return FALSE;
 378     }
 379
 380     return TRUE;
 381 }
 382
 383 VOID
 384 FASTCALL
 385 Fast486ExceptionWithErrorCode(PFAST486_STATE State,
 386                               FAST486_EXCEPTIONS ExceptionCode,
 387                               ULONG ErrorCode)
 388 {
 389     /* Increment the exception count */
 390     State->ExceptionCount++;
 391
 392     /* Check if the exception occurred more than once */
 393     if (State->ExceptionCount > 1)
 394     {
 395         /* Then this is a double fault */
 396         ExceptionCode = FAST486_EXCEPTION_DF;
 397     }
 398
 399     /* Check if this is a triple fault */
 400     if (State->ExceptionCount == 3)
 401     {
 402         DPRINT("Fast486ExceptionWithErrorCode(%04X:%08X) -- Triple fault\n",
 403                State->SegmentRegs[FAST486_REG_CS].Selector,
 404                State->InstPtr.Long);
 405
 406         /* Reset the CPU */
 407         Fast486Reset(State);
 408         return;
 409     }
 410
 411     /* Restore the IP to the saved IP */
 412     State->InstPtr = State->SavedInstPtr;
 413
 414     /* Perform the interrupt */
 415     if (!Fast486PerformInterrupt(State, ExceptionCode))
 416     {
 417         /*
 418          * If this function failed, that means Fast486Exception
 419          * was called again, so just return in this case.
 420          */
 421         return;
 422     }
 423
 424     if (EXCEPTION_HAS_ERROR_CODE(ExceptionCode)
 425         && (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE))
 426     {
 427         /* Push the error code */
 428         if (!Fast486StackPush(State, ErrorCode))
 429         {
 430             /*
 431              * If this function failed, that means Fast486Exception
 432              * was called again, so just return in this case.
 433              */
 434             return;
 435         }
 436     }
 437
 438     /* Reset the exception count */
 439     State->ExceptionCount = 0;
 440 }
 441
 442 /* EOF */