common.h File Reference

#include <pshpack1.h>
#include <poppack.h>
#include "common.inl"

Include dependency graph for common.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_FAST486_MOD_REG_RM
union	_FAST486_PAGE_DIR
union	_FAST486_PAGE_TABLE

Macros
#define	SIGN_FLAG_BYTE   0x80
#define	SIGN_FLAG_WORD   0x8000
#define	SIGN_FLAG_LONG   0x80000000
#define	REAL_MODE_FLAGS_MASK   0x57FD5
#define	PROT_MODE_FLAGS_MASK   0x50DD5
#define	STRING_BLOCK_SIZE   4096
#define	GET_SEGMENT_RPL(s)   ((s) & 3u)
#define	GET_SEGMENT_INDEX(s)   ((s) & 0xFFF8u)
#define	SEGMENT_TABLE_INDICATOR   (1 << 2)
#define	EXCEPTION_HAS_ERROR_CODE(x)   (((x) == 8) || ((x) >= 10 && (x) <= 14))
#define	NO_LOCK_PREFIX()
#define	TOGGLE_OPSIZE(x)    if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) x = !x;
#define	TOGGLE_ADSIZE(x)    if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) x = !x;
#define	SWAP(x, y)   { (x) ^= (y); (y) ^= (x); (x) ^= (y); }
#define	ALIGNMENT_CHECK(x, a)
#define	PAGE_ALIGN(x)   ((x) & 0xFFFFF000)
#define	PAGE_OFFSET(x)   ((x) & 0x00000FFF)
#define	GET_ADDR_PDE(x)   ((x) >> 22)
#define	GET_ADDR_PTE(x)   (((x) >> 12) & 0x3FF)
#define	INVALID_TLB_FIELD   0xFFFFFFFF
#define	NUM_TLB_ENTRIES   0x100000

Typedefs
typedef struct _FAST486_MOD_REG_RM	FAST486_MOD_REG_RM
typedef struct _FAST486_MOD_REG_RM *	PFAST486_MOD_REG_RM
typedef enum _FAST486_TASK_SWITCH_TYPE	FAST486_TASK_SWITCH_TYPE
typedef enum _FAST486_TASK_SWITCH_TYPE *	PFAST486_TASK_SWITCH_TYPE
typedef union _FAST486_PAGE_DIR	FAST486_PAGE_DIR
typedef union _FAST486_PAGE_DIR *	PFAST486_PAGE_DIR
typedef union _FAST486_PAGE_TABLE	FAST486_PAGE_TABLE
typedef union _FAST486_PAGE_TABLE *	PFAST486_PAGE_TABLE

Enumerations
enum	_FAST486_TASK_SWITCH_TYPE { FAST486_TASK_JUMP , FAST486_TASK_CALL , FAST486_TASK_RETURN }

Functions
	C_ASSERT (sizeof(FAST486_PAGE_DIR)==sizeof(ULONG))
BOOLEAN FASTCALL	Fast486ReadMemory (PFAST486_STATE State, FAST486_SEG_REGS SegmentReg, ULONG Offset, BOOLEAN InstFetch, PVOID Buffer, ULONG Size)
BOOLEAN FASTCALL	Fast486WriteMemory (PFAST486_STATE State, FAST486_SEG_REGS SegmentReg, ULONG Offset, PVOID Buffer, ULONG Size)
BOOLEAN FASTCALL	Fast486PerformInterrupt (PFAST486_STATE State, UCHAR Number)
VOID FASTCALL	Fast486ExceptionWithErrorCode (PFAST486_STATE State, FAST486_EXCEPTIONS ExceptionCode, ULONG ErrorCode)
BOOLEAN FASTCALL	Fast486TaskSwitch (PFAST486_STATE State, FAST486_TASK_SWITCH_TYPE Type, USHORT Selector)
BOOLEAN FASTCALL	Fast486CallGate (PFAST486_STATE State, PFAST486_CALL_GATE Gate, BOOLEAN Call)

Macro Definition Documentation

ALIGNMENT_CHECK

#define ALIGNMENT_CHECK	(		x,
			a
	)

Value:

                                  if (State->Flags.Ac \
                                  && (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_AM)\
                                  && (State->Cpl == 3)\
                                  && (((x) % (a)) != 0))\
{\
    Fast486Exception(State, FAST486_EXCEPTION_AC);\
    return FALSE;\
}

Definition at line 58 of file common.h.

EXCEPTION_HAS_ERROR_CODE

#define EXCEPTION_HAS_ERROR_CODE

(

x

)

(((x) == 8) || ((x) >= 10 && (x) <= 14))

Definition at line 41 of file common.h.

GET_ADDR_PDE

#define GET_ADDR_PDE

(

x

)

((x) >> 22)

Definition at line 69 of file common.h.

GET_ADDR_PTE

#define GET_ADDR_PTE

(

x

)

(((x) >> 12) & 0x3FF)

Definition at line 70 of file common.h.

GET_SEGMENT_INDEX

#define GET_SEGMENT_INDEX

(

s

)

((s) & 0xFFF8u)

Definition at line 39 of file common.h.

GET_SEGMENT_RPL

#define GET_SEGMENT_RPL

(

s

)

((s) & 3u)

Definition at line 38 of file common.h.

INVALID_TLB_FIELD

#define INVALID_TLB_FIELD   0xFFFFFFFF

Definition at line 71 of file common.h.

NO_LOCK_PREFIX

#define NO_LOCK_PREFIX

(

)

Value:

if (State->PrefixFlags & FAST486_PREFIX_LOCK)\
{\
    Fast486Exception(State, FAST486_EXCEPTION_UD);\
    return;\
}

Definition at line 43 of file common.h.

NUM_TLB_ENTRIES

#define NUM_TLB_ENTRIES   0x100000

Definition at line 72 of file common.h.

PAGE_ALIGN

#define PAGE_ALIGN

(

x

)

((x) & 0xFFFFF000)

Definition at line 67 of file common.h.

PAGE_OFFSET

#define PAGE_OFFSET

(

x

)

((x) & 0x00000FFF)

Definition at line 68 of file common.h.

PROT_MODE_FLAGS_MASK

#define PROT_MODE_FLAGS_MASK   0x50DD5

Definition at line 33 of file common.h.

REAL_MODE_FLAGS_MASK

#define REAL_MODE_FLAGS_MASK   0x57FD5

Definition at line 32 of file common.h.

SEGMENT_TABLE_INDICATOR

#define SEGMENT_TABLE_INDICATOR   (1 << 2)

Definition at line 40 of file common.h.

SIGN_FLAG_BYTE

#define SIGN_FLAG_BYTE   0x80

Definition at line 29 of file common.h.

SIGN_FLAG_LONG

#define SIGN_FLAG_LONG   0x80000000

Definition at line 31 of file common.h.

SIGN_FLAG_WORD

#define SIGN_FLAG_WORD   0x8000

Definition at line 30 of file common.h.

STRING_BLOCK_SIZE

#define STRING_BLOCK_SIZE   4096

Definition at line 36 of file common.h.

SWAP

#define SWAP	(		x,
			y
	)		{ (x) ^= (y); (y) ^= (x); (x) ^= (y); }

Definition at line 56 of file common.h.

TOGGLE_ADSIZE

#define TOGGLE_ADSIZE

(

x

)

if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) x = !x;

Definition at line 53 of file common.h.

TOGGLE_OPSIZE

#define TOGGLE_OPSIZE

(

x

)

if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) x = !x;

Definition at line 50 of file common.h.

Typedef Documentation

FAST486_MOD_REG_RM

typedef struct _FAST486_MOD_REG_RM FAST486_MOD_REG_RM

FAST486_PAGE_DIR

typedef union _FAST486_PAGE_DIR FAST486_PAGE_DIR

FAST486_PAGE_TABLE

typedef union _FAST486_PAGE_TABLE FAST486_PAGE_TABLE

FAST486_TASK_SWITCH_TYPE

typedef enum _FAST486_TASK_SWITCH_TYPE FAST486_TASK_SWITCH_TYPE

PFAST486_MOD_REG_RM

typedef struct _FAST486_MOD_REG_RM * PFAST486_MOD_REG_RM

PFAST486_PAGE_DIR

typedef union _FAST486_PAGE_DIR * PFAST486_PAGE_DIR

PFAST486_PAGE_TABLE

typedef union _FAST486_PAGE_TABLE * PFAST486_PAGE_TABLE

PFAST486_TASK_SWITCH_TYPE

typedef enum _FAST486_TASK_SWITCH_TYPE * PFAST486_TASK_SWITCH_TYPE

Enumeration Type Documentation

_FAST486_TASK_SWITCH_TYPE

enum _FAST486_TASK_SWITCH_TYPE

Enumerator
FAST486_TASK_JUMP
FAST486_TASK_CALL
FAST486_TASK_RETURN

Definition at line 85 of file common.h.

{
    FAST486_TASK_JUMP,
    FAST486_TASK_CALL,
    FAST486_TASK_RETURN
} FAST486_TASK_SWITCH_TYPE, *PFAST486_TASK_SWITCH_TYPE;

Function Documentation

C_ASSERT()

C_ASSERT

(

sizeof(FAST486_PAGE_DIR)

= =sizeof(ULONG)

)

Fast486CallGate()

BOOLEAN FASTCALL Fast486CallGate	(	PFAST486_STATE	State,
		PFAST486_CALL_GATE	Gate,
		BOOLEAN	Call
	)

Definition at line 1116 of file common.c.

{
    BOOLEAN Valid;
    FAST486_GDT_ENTRY NewCodeSegment;
    BOOLEAN GateSize = (Gate->Type == FAST486_CALL_GATE_SIGNATURE);
    FAST486_TSS Tss;
    PFAST486_LEGACY_TSS LegacyTss = (PFAST486_LEGACY_TSS)&Tss;
    USHORT OldCs = State->SegmentRegs[FAST486_REG_CS].Selector;
    ULONG OldEip = State->InstPtr.Long;
    USHORT OldCpl = State->Cpl;
    USHORT OldSs = State->SegmentRegs[FAST486_REG_SS].Selector;
    ULONG OldEsp = State->GeneralRegs[FAST486_REG_ESP].Long;
    ULONG ParamBuffer[32]; /* Maximum possible size - 32 DWORDs */
    PULONG LongParams = (PULONG)ParamBuffer;
    PUSHORT ShortParams = (PUSHORT)ParamBuffer;
 
    if (!Gate->Selector)
    {
        /* The code segment is NULL */
        Fast486Exception(State, FAST486_EXCEPTION_GP);
        return FALSE;
    }
 
    if (!Fast486ReadDescriptorEntry(State, Gate->Selector, &Valid, &NewCodeSegment))
    {
        /* Exception occurred */
        return FALSE;
    }
 
    if (!Valid || (NewCodeSegment.Dpl > Fast486GetCurrentPrivLevel(State)))
    {
        /* Code segment invalid */
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, Gate->Selector);
        return FALSE;
    }
 
    if (Call && Gate->ParamCount)
    {
        /* Read the parameters */
        if (!Fast486ReadMemory(State,
                               FAST486_REG_SS,
                               OldEsp,
                               FALSE,
                               ParamBuffer,
                               Gate->ParamCount * (GateSize ? sizeof(ULONG) : sizeof(USHORT))))
        {
            /* Exception occurred */
            return FALSE;
        }
    }
 
    /* Check if the new code segment is more privileged */
    if (NewCodeSegment.Dpl < OldCpl)
    {
        if (Call)
        {
            USHORT NewSs;
            ULONG NewEsp;
 
            /* Read the TSS */
            if (!Fast486ReadLinearMemory(State,
                                         State->TaskReg.Base,
                                         &Tss,
                                         State->TaskReg.Modern
                                         ? sizeof(FAST486_TSS) : sizeof(FAST486_LEGACY_TSS),
                                         FALSE))
            {
                /* Exception occurred */
                return FALSE;
            }
 
            /* Switch to the new privilege level */
            State->Cpl = NewCodeSegment.Dpl;
 
            /* Check the new (higher) privilege level */
            switch (State->Cpl)
            {
                case 0:
                {
                    if (State->TaskReg.Modern)
                    {
                        NewSs = Tss.Ss0;
                        NewEsp = Tss.Esp0;
                    }
                    else
                    {
                        NewSs = LegacyTss->Ss0;
                        NewEsp = LegacyTss->Sp0;
                    }
 
                    break;
                }
 
                case 1:
                {
                    if (State->TaskReg.Modern)
                    {
                        NewSs = Tss.Ss1;
                        NewEsp = Tss.Esp1;
                    }
                    else
                    {
                        NewSs = LegacyTss->Ss1;
                        NewEsp = LegacyTss->Sp1;
                    }
 
                    break;
                }
 
                case 2:
                {
                    if (State->TaskReg.Modern)
                    {
                        NewSs = Tss.Ss2;
                        NewEsp = Tss.Esp2;
                    }
                    else
                    {
                        NewSs = LegacyTss->Ss2;
                        NewEsp = LegacyTss->Sp2;
                    }
 
                    break;
                }
 
                default:
                {
                    /* Should never reach here! */
                    ASSERT(FALSE);
                }
            }
 
            if (!Fast486LoadSegment(State, FAST486_REG_SS, NewSs))
            {
                /* Exception occurred */
                return FALSE;
            }
 
            State->GeneralRegs[FAST486_REG_ESP].Long = NewEsp;
        }
        else if (!NewCodeSegment.DirConf)
        {
            /* This is not allowed for jumps */
            Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, Gate->Selector);
            return FALSE;
        }
    }
 
    /* Load new CS */
    if (!Fast486LoadSegment(State, FAST486_REG_CS, Gate->Selector))
    {
        /* An exception occurred during the jump */
        return FALSE;
    }
 
    /* Set the instruction pointer */
    if (GateSize) State->InstPtr.Long = MAKELONG(Gate->Offset, Gate->OffsetHigh);
    else State->InstPtr.Long = Gate->Offset;
 
    if (Call)
    {
        INT i;
 
        /* Check if the new code segment is more privileged (again) */
        if (NewCodeSegment.Dpl < OldCpl)
        {
            /* Push SS selector */
            if (!Fast486StackPushInternal(State, GateSize, OldSs)) return FALSE;
 
            /* Push stack pointer */
            if (!Fast486StackPushInternal(State, GateSize, OldEsp)) return FALSE;
        }
 
        /* Push the parameters in reverse order */
        for (i = Gate->ParamCount - 1; i >= 0; i--)
        {
            if (!Fast486StackPushInternal(State,
                                          GateSize,
                                          GateSize ? LongParams[i] : ShortParams[i]))
            {
                /* Exception occurred */
                return FALSE;
            }
        }
 
        /* Push CS selector */
        if (!Fast486StackPushInternal(State, GateSize, OldCs)) return FALSE;
 
        /* Push the instruction pointer */
        if (!Fast486StackPushInternal(State, GateSize, OldEip)) return FALSE;
    }
 
    return TRUE;
}

Fast486ExceptionWithErrorCode()

VOID FASTCALL Fast486ExceptionWithErrorCode	(	PFAST486_STATE	State,
		FAST486_EXCEPTIONS	ExceptionCode,
		ULONG	ErrorCode
	)

Definition at line 557 of file common.c.

{
    FAST486_IDT_ENTRY IdtEntry;
 
    /* Increment the exception count */
    State->ExceptionCount++;
 
    /* Check if the exception occurred more than once */
    if (State->ExceptionCount > 1)
    {
        /* Then this is a double fault */
        ExceptionCode = FAST486_EXCEPTION_DF;
    }
 
    /* Check if this is a triple fault */
    if (State->ExceptionCount == 3)
    {
        DPRINT("Fast486ExceptionWithErrorCode(%04X:%08X) -- Triple fault\n",
               State->SegmentRegs[FAST486_REG_CS].Selector,
               State->InstPtr.Long);
 
        /* Reset the CPU */
        Fast486Reset(State);
        return;
    }
 
    /* Clear the prefix flags */
    State->PrefixFlags = 0;
 
    /* Restore the IP to the saved IP */
    State->InstPtr = State->SavedInstPtr;
 
    /* Restore the SP to the saved SP */
    State->GeneralRegs[FAST486_REG_ESP] = State->SavedStackPtr;
 
    /* Get the interrupt vector */
    if (!Fast486GetIntVector(State, ExceptionCode, &IdtEntry))
    {
        /*
         * If this function failed, that means Fast486Exception
         * was called again, so just return in this case.
         */
        return;
    }
 
    /* Perform the interrupt */
    if (!Fast486InterruptInternal(State,
                                  &IdtEntry,
                                  EXCEPTION_HAS_ERROR_CODE(ExceptionCode)
                                  && (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE),
                                  ErrorCode))
    {
        /*
         * If this function failed, that means Fast486Exception
         * was called again, so just return in this case.
         */
        return;
    }
 
    /* Reset the exception count */
    State->ExceptionCount = 0;
}

Referenced by FAST486_OPCODE_HANDLER(), Fast486CallGate(), and Fast486TaskSwitch().

Fast486PerformInterrupt()

BOOLEAN FASTCALL Fast486PerformInterrupt	(	PFAST486_STATE	State,
		UCHAR	Number
	)

Definition at line 533 of file common.c.

{
    FAST486_IDT_ENTRY IdtEntry;
 
    /* Get the interrupt vector */
    if (!Fast486GetIntVector(State, Number, &IdtEntry))
    {
        /* Exception occurred */
        return FALSE;
    }
 
    /* Perform the interrupt */
    if (!Fast486InterruptInternal(State, &IdtEntry, FALSE, 0))
    {
        /* Exception occurred */
        return FALSE;
    }
 
    return TRUE;
}

Referenced by FAST486_OPCODE_HANDLER(), and Fast486ExecutionControl().

Fast486ReadMemory()

BOOLEAN FASTCALL Fast486ReadMemory	(	PFAST486_STATE	State,
		FAST486_SEG_REGS	SegmentReg,
		ULONG	Offset,
		BOOLEAN	InstFetch,
		PVOID	Buffer,
		ULONG	Size
	)

Definition at line 36 of file common.c.

{
    ULONG LinearAddress;
    PFAST486_SEG_REG CachedDescriptor;
    FAST486_EXCEPTIONS Exception = SegmentReg != FAST486_REG_SS
                                   ? FAST486_EXCEPTION_GP : FAST486_EXCEPTION_SS;
 
    ASSERT(SegmentReg < FAST486_NUM_SEG_REGS);
 
    /* Get the cached descriptor */
    CachedDescriptor = &State->SegmentRegs[SegmentReg];
 
    if (InstFetch || CachedDescriptor->Executable || !CachedDescriptor->DirConf)
    {
        if ((Offset + Size - 1) > CachedDescriptor->Limit)
        {
            /* Read beyond limit */
            Fast486Exception(State, Exception);
            return FALSE;
        }
    }
    else
    {
        if (Offset < CachedDescriptor->Limit)
        {
            /* Read beyond limit */
            Fast486Exception(State, Exception);
            return FALSE;
        }
    }
 
    /* Check for protected mode */
    if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) && !State->Flags.Vm)
    {
        /* Privilege checks */
 
        if (!CachedDescriptor->Present)
        {
            Fast486Exception(State, Exception);
            return FALSE;
        }
 
        if ((!InstFetch && (CachedDescriptor->Rpl > CachedDescriptor->Dpl))
            || (Fast486GetCurrentPrivLevel(State) > CachedDescriptor->Dpl))
        {
            Fast486Exception(State, Exception);
            return FALSE;
        }
 
        if (InstFetch)
        {
            if (!CachedDescriptor->Executable)
            {
                /* Data segment not executable */
                Fast486Exception(State, Exception);
                return FALSE;
            }
        }
        else
        {
            if (CachedDescriptor->Executable && (!CachedDescriptor->ReadWrite))
            {
                /* Code segment not readable */
                Fast486Exception(State, Exception);
                return FALSE;
            }
        }
    }
 
    /* Find the linear address */
    LinearAddress = CachedDescriptor->Base + Offset;
 
#ifndef FAST486_NO_PREFETCH
    if (InstFetch && ((Offset + FAST486_CACHE_SIZE - 1) <= CachedDescriptor->Limit))
    {
        State->PrefetchAddress = LinearAddress;
 
        if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PG)
            && (PAGE_OFFSET(State->PrefetchAddress) > (FAST486_PAGE_SIZE - FAST486_CACHE_SIZE)))
        {
            /* We mustn't prefetch across a page boundary */
            State->PrefetchAddress = PAGE_ALIGN(State->PrefetchAddress)
                                     | (FAST486_PAGE_SIZE - FAST486_CACHE_SIZE);
 
            if ((LinearAddress - State->PrefetchAddress + Size) >= FAST486_CACHE_SIZE)
            {
                /* We can't prefetch without possibly violating page permissions */
                State->PrefetchValid = FALSE;
                return Fast486ReadLinearMemory(State, LinearAddress, Buffer, Size, TRUE);
            }
        }
 
        /* Prefetch */
        if (Fast486ReadLinearMemory(State,
                                    State->PrefetchAddress,
                                    State->PrefetchCache,
                                    FAST486_CACHE_SIZE,
                                    TRUE))
        {
            State->PrefetchValid = TRUE;
 
            RtlMoveMemory(Buffer,
                          &State->PrefetchCache[LinearAddress - State->PrefetchAddress],
                          Size);
            return TRUE;
        }
        else
        {
            State->PrefetchValid = FALSE;
            return FALSE;
        }
    }
    else
#endif
    {
        /* Read from the linear address */
        return Fast486ReadLinearMemory(State, LinearAddress, Buffer, Size, TRUE);
    }
}

Referenced by FAST486_OPCODE_HANDLER(), Fast486CallGate(), and Fast486FpuLoadEnvironment().

Fast486TaskSwitch()

BOOLEAN FASTCALL Fast486TaskSwitch	(	PFAST486_STATE	State,
		FAST486_TASK_SWITCH_TYPE	Type,
		USHORT	Selector
	)

Definition at line 624 of file common.c.

{
    ULONG NewTssAddress;
    ULONG NewTssLimit;
    FAST486_SYSTEM_DESCRIPTOR NewTssDescriptor;
    FAST486_TSS OldTss;
    PFAST486_LEGACY_TSS OldLegacyTss = (PFAST486_LEGACY_TSS)&OldTss;
    FAST486_TSS NewTss;
    PFAST486_LEGACY_TSS NewLegacyTss = (PFAST486_LEGACY_TSS)&NewTss;
    USHORT NewLdtr, NewEs, NewCs, NewSs, NewDs;
 
    if ((State->TaskReg.Modern && State->TaskReg.Limit < (sizeof(FAST486_TSS) - 1))
        || (!State->TaskReg.Modern && State->TaskReg.Limit < (sizeof(FAST486_LEGACY_TSS) - 1)))
    {
        /* Invalid task register limit */
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_TS, State->TaskReg.Selector);
        return FALSE;
    }
 
    /* Read the old TSS */
    if (!Fast486ReadLinearMemory(State,
                                 State->TaskReg.Base,
                                 &OldTss,
                                 State->TaskReg.Modern
                                 ? sizeof(FAST486_TSS) : sizeof(FAST486_LEGACY_TSS),
                                 FALSE))
    {
        /* Exception occurred */
        return FALSE;
    }
 
 
    /* If this is a task return, use the linked previous selector */
    if (Type == FAST486_TASK_RETURN)
    {
        if (State->TaskReg.Modern) Selector = LOWORD(OldTss.Link);
        else Selector = OldLegacyTss->Link;
    }
 
    /* Make sure the entry exists in the GDT (not LDT!) */
    if ((GET_SEGMENT_INDEX(Selector) == 0)
        || (Selector & SEGMENT_TABLE_INDICATOR)
        || GET_SEGMENT_INDEX(Selector) >= (State->Gdtr.Size + 1u))
    {
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_TS, Selector);
        return FALSE;
    }
 
    /* Get the TSS descriptor from the GDT */
    if (!Fast486ReadLinearMemory(State,
                                 State->Gdtr.Address + GET_SEGMENT_INDEX(Selector),
                                 &NewTssDescriptor,
                                 sizeof(NewTssDescriptor),
                                 FALSE))
    {
        /* Exception occurred */
        return FALSE;
    }
 
    if (!NewTssDescriptor.Present)
    {
        /* Incoming task TSS not present */
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_NP, Selector);
        return FALSE;
    }
 
    /* Calculate the linear address of the new TSS */
    NewTssAddress = NewTssDescriptor.Base;
    NewTssAddress |= NewTssDescriptor.BaseMid << 16;
    NewTssAddress |= NewTssDescriptor.BaseHigh << 24;
 
    /* Calculate the limit of the new TSS */
    NewTssLimit = NewTssDescriptor.Limit | (NewTssDescriptor.LimitHigh << 16);
 
    if (NewTssDescriptor.Granularity)
    {
        NewTssLimit <<= 12;
        NewTssLimit |= 0x00000FFF;
    }
 
    if (NewTssLimit < (sizeof(FAST486_TSS) - 1)
        && NewTssLimit != (sizeof(FAST486_LEGACY_TSS) - 1))
    {
        /* TSS limit invalid */
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_TS, Selector);
        return FALSE;
    }
 
    /*
     * The incoming task shouldn't be busy if we're executing it as a
     * new task, and it should be busy if we're returning to it.
     */
    if ((((NewTssDescriptor.Signature != FAST486_TSS_SIGNATURE)
        && (NewTssDescriptor.Signature != FAST486_TSS_16_SIGNATURE))
        || (Type == FAST486_TASK_RETURN))
        && (((NewTssDescriptor.Signature != FAST486_BUSY_TSS_SIGNATURE)
        && (NewTssDescriptor.Signature != FAST486_BUSY_TSS_16_SIGNATURE))
        || (Type != FAST486_TASK_RETURN)))
    {
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, Selector);
        return FALSE;
    }
 
    /* Read the new TSS */
    if (!Fast486ReadLinearMemory(State,
                                 NewTssAddress,
                                 &NewTss,
                                 (NewTssDescriptor.Signature == FAST486_TSS_SIGNATURE)
                                 || (NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE)
                                 ? sizeof(FAST486_TSS) : sizeof(FAST486_LEGACY_TSS),
                                 FALSE))
    {
        /* Exception occurred */
        return FALSE;
    }
 
    if (Type != FAST486_TASK_CALL)
    {
        /* Clear the busy bit of the outgoing task */
        FAST486_SYSTEM_DESCRIPTOR OldTssDescriptor;
 
        if (!Fast486ReadLinearMemory(State,
                                     State->Gdtr.Address
                                     + GET_SEGMENT_INDEX(State->TaskReg.Selector),
                                     &OldTssDescriptor,
                                     sizeof(OldTssDescriptor),
                                     FALSE))
        {
            /* Exception occurred */
            return FALSE;
        }
 
        OldTssDescriptor.Signature = FAST486_TSS_SIGNATURE;
 
        if (!Fast486WriteLinearMemory(State,
                                      State->Gdtr.Address
                                      + GET_SEGMENT_INDEX(State->TaskReg.Selector),
                                      &OldTssDescriptor,
                                      sizeof(OldTssDescriptor),
                                      FALSE))
        {
            /* Exception occurred */
            return FALSE;
        }
    }
    else
    {
        /* Store the link */
        if ((NewTssDescriptor.Signature == FAST486_TSS_SIGNATURE)
            || (NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE))
        {
            NewTss.Link = State->TaskReg.Selector;
 
            /* Write back the new TSS link */
            if (!Fast486WriteLinearMemory(State,
                                          NewTssAddress,
                                          &NewTss.Link,
                                          sizeof(NewTss.Link),
                                          FALSE))
            {
                /* Exception occurred */
                return FALSE;
            }
        }
        else
        {
            NewLegacyTss->Link = State->TaskReg.Selector;
 
            /* Write back the new legacy TSS link */
            if (!Fast486WriteLinearMemory(State,
                                          NewTssAddress,
                                          &NewLegacyTss->Link,
                                          sizeof(NewLegacyTss->Link),
                                          FALSE))
            {
                /* Exception occurred */
                return FALSE;
            }
        }
    }
 
    /* Save the current task into the TSS */
    if (State->TaskReg.Modern)
    {
        OldTss.Cr3 = State->ControlRegisters[FAST486_REG_CR3];
        OldTss.Eip = State->InstPtr.Long;
        OldTss.Eflags = State->Flags.Long;
        OldTss.Eax = State->GeneralRegs[FAST486_REG_EAX].Long;
        OldTss.Ecx = State->GeneralRegs[FAST486_REG_ECX].Long;
        OldTss.Edx = State->GeneralRegs[FAST486_REG_EDX].Long;
        OldTss.Ebx = State->GeneralRegs[FAST486_REG_EBX].Long;
        OldTss.Esp = State->GeneralRegs[FAST486_REG_ESP].Long;
        OldTss.Ebp = State->GeneralRegs[FAST486_REG_EBP].Long;
        OldTss.Esi = State->GeneralRegs[FAST486_REG_ESI].Long;
        OldTss.Edi = State->GeneralRegs[FAST486_REG_EDI].Long;
        OldTss.Es = State->SegmentRegs[FAST486_REG_ES].Selector;
        OldTss.Cs = State->SegmentRegs[FAST486_REG_CS].Selector;
        OldTss.Ss = State->SegmentRegs[FAST486_REG_SS].Selector;
        OldTss.Ds = State->SegmentRegs[FAST486_REG_DS].Selector;
        OldTss.Fs = State->SegmentRegs[FAST486_REG_FS].Selector;
        OldTss.Gs = State->SegmentRegs[FAST486_REG_GS].Selector;
        OldTss.Ldtr = State->Ldtr.Selector;
    }
    else
    {
        OldLegacyTss->Ip = State->InstPtr.LowWord;
        OldLegacyTss->Flags = State->Flags.LowWord;
        OldLegacyTss->Ax = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        OldLegacyTss->Cx = State->GeneralRegs[FAST486_REG_ECX].LowWord;
        OldLegacyTss->Dx = State->GeneralRegs[FAST486_REG_EDX].LowWord;
        OldLegacyTss->Bx = State->GeneralRegs[FAST486_REG_EBX].LowWord;
        OldLegacyTss->Sp = State->GeneralRegs[FAST486_REG_ESP].LowWord;
        OldLegacyTss->Bp = State->GeneralRegs[FAST486_REG_EBP].LowWord;
        OldLegacyTss->Si = State->GeneralRegs[FAST486_REG_ESI].LowWord;
        OldLegacyTss->Di = State->GeneralRegs[FAST486_REG_EDI].LowWord;
        OldLegacyTss->Es = State->SegmentRegs[FAST486_REG_ES].Selector;
        OldLegacyTss->Cs = State->SegmentRegs[FAST486_REG_CS].Selector;
        OldLegacyTss->Ss = State->SegmentRegs[FAST486_REG_SS].Selector;
        OldLegacyTss->Ds = State->SegmentRegs[FAST486_REG_DS].Selector;
        OldLegacyTss->Ldtr = State->Ldtr.Selector;
    }
 
    /* Write back the old TSS */
    if (!Fast486WriteLinearMemory(State,
                                  State->TaskReg.Base,
                                  &OldTss,
                                  State->TaskReg.Modern
                                  ? sizeof(FAST486_TSS) : sizeof(FAST486_LEGACY_TSS),
                                  FALSE))
    {
        /* Exception occurred */
        return FALSE;
    }
 
    /* Mark the new task as busy */
    if (NewTssDescriptor.Signature == FAST486_TSS_SIGNATURE
        || NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE)
    {
        /* 32-bit TSS */
        NewTssDescriptor.Signature = FAST486_BUSY_TSS_SIGNATURE;
    }
    else
    {
        /* 16-bit TSS */
        NewTssDescriptor.Signature = FAST486_BUSY_TSS_16_SIGNATURE;
    }
 
    /* Write back the new TSS descriptor */
    if (!Fast486WriteLinearMemory(State,
                                  State->Gdtr.Address + GET_SEGMENT_INDEX(Selector),
                                  &NewTssDescriptor,
                                  sizeof(NewTssDescriptor),
                                  FALSE))
    {
        /* Exception occurred */
        return FALSE;
    }
 
    /* Set the task switch bit */
    State->ControlRegisters[FAST486_REG_CR0] |= FAST486_CR0_TS;
 
    /* Load the task register with the new values */
    State->TaskReg.Selector = Selector;
    State->TaskReg.Base = NewTssAddress;
    State->TaskReg.Limit = NewTssLimit;
    State->TaskReg.Modern = (NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE);
 
    if (NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE)
    {
        /* Change the page directory */
        State->ControlRegisters[FAST486_REG_CR3] = NewTss.Cr3;
    }
 
    /* Flush the TLB */
    Fast486FlushTlb(State);
 
    /* Update the CPL */
    if (NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE)
    {
        State->Cpl = GET_SEGMENT_RPL(NewTss.Cs);
    }
    else
    {
        State->Cpl = GET_SEGMENT_RPL(NewLegacyTss->Cs);
    }
 
#ifndef FAST486_NO_PREFETCH
    /* Context switching invalidates the prefetch */
    State->PrefetchValid = FALSE;
#endif
 
    /* Load the registers */
    if (NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE)
    {
        State->InstPtr.Long = State->SavedInstPtr.Long = NewTss.Eip;
        State->Flags.Long = NewTss.Eflags;
        State->GeneralRegs[FAST486_REG_EAX].Long = NewTss.Eax;
        State->GeneralRegs[FAST486_REG_ECX].Long = NewTss.Ecx;
        State->GeneralRegs[FAST486_REG_EDX].Long = NewTss.Edx;
        State->GeneralRegs[FAST486_REG_EBX].Long = NewTss.Ebx;
        State->GeneralRegs[FAST486_REG_EBP].Long = NewTss.Ebp;
        State->GeneralRegs[FAST486_REG_ESI].Long = NewTss.Esi;
        State->GeneralRegs[FAST486_REG_EDI].Long = NewTss.Edi;
        NewEs = NewTss.Es;
        NewCs = NewTss.Cs;
        NewDs = NewTss.Ds;
        NewLdtr = NewTss.Ldtr;
 
        if (Type == FAST486_TASK_CALL && State->Cpl < 3)
        {
            switch (State->Cpl)
            {
                case 0:
                {
                    State->GeneralRegs[FAST486_REG_ESP].Long = NewTss.Esp0;
                    NewSs = NewTss.Ss0;
                    break;
                }
 
                case 1:
                {
                    State->GeneralRegs[FAST486_REG_ESP].Long = NewTss.Esp1;
                    NewSs = NewTss.Ss1;
                    break;
                }
 
                case 2:
                {
                    State->GeneralRegs[FAST486_REG_ESP].Long = NewTss.Esp2;
                    NewSs = NewTss.Ss2;
                    break;
                }
            }
        }
        else
        {
            State->GeneralRegs[FAST486_REG_ESP].Long = NewTss.Esp;
            NewSs = NewTss.Ss;
        }
    }
    else
    {
        State->InstPtr.LowWord = State->SavedInstPtr.LowWord = NewLegacyTss->Ip;
        State->Flags.LowWord = NewLegacyTss->Flags;
        State->GeneralRegs[FAST486_REG_EAX].LowWord = NewLegacyTss->Ax;
        State->GeneralRegs[FAST486_REG_ECX].LowWord = NewLegacyTss->Cx;
        State->GeneralRegs[FAST486_REG_EDX].LowWord = NewLegacyTss->Dx;
        State->GeneralRegs[FAST486_REG_EBX].LowWord = NewLegacyTss->Bx;
        State->GeneralRegs[FAST486_REG_EBP].LowWord = NewLegacyTss->Bp;
        State->GeneralRegs[FAST486_REG_ESI].LowWord = NewLegacyTss->Si;
        State->GeneralRegs[FAST486_REG_EDI].LowWord = NewLegacyTss->Di;
        NewEs = NewLegacyTss->Es;
        NewCs = NewLegacyTss->Cs;
        NewDs = NewLegacyTss->Ds;
        NewLdtr = NewLegacyTss->Ldtr;
 
        if (Type == FAST486_TASK_CALL && State->Cpl < 3)
        {
            switch (State->Cpl)
            {
                case 0:
                {
                    State->GeneralRegs[FAST486_REG_ESP].Long = NewLegacyTss->Sp0;
                    NewSs = NewLegacyTss->Ss0;
                    break;
                }
 
                case 1:
                {
                    State->GeneralRegs[FAST486_REG_ESP].Long = NewLegacyTss->Sp1;
                    NewSs = NewLegacyTss->Ss1;
                    break;
                }
 
                case 2:
                {
                    State->GeneralRegs[FAST486_REG_ESP].Long = NewLegacyTss->Sp2;
                    NewSs = NewLegacyTss->Ss2;
                    break;
                }
            }
        }
        else
        {
            State->GeneralRegs[FAST486_REG_ESP].Long = NewLegacyTss->Sp;
            NewSs = NewLegacyTss->Ss;
        }
    }
 
    /* Set the NT flag if nesting */
    if (Type == FAST486_TASK_CALL) State->Flags.Nt = TRUE;
 
    if (GET_SEGMENT_INDEX(NewLdtr) != 0)
    {
        BOOLEAN Valid;
        FAST486_SYSTEM_DESCRIPTOR GdtEntry;
 
        if (NewLdtr & SEGMENT_TABLE_INDICATOR)
        {
            /* This selector doesn't point to the GDT */
            Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_TS, NewLdtr);
            return FALSE;
        }
 
        if (!Fast486ReadDescriptorEntry(State, NewLdtr, &Valid, (PFAST486_GDT_ENTRY)&GdtEntry))
        {
            /* Exception occurred */
            return FALSE;
        }
 
        if (!Valid)
        {
            /* Invalid selector */
            Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_TS, NewLdtr);
            return FALSE;
        }
 
        if (GdtEntry.Signature != FAST486_LDT_SIGNATURE)
        {
            /* This is not an LDT descriptor */
            Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_TS, NewLdtr);
            return FALSE;
        }
 
        if (!GdtEntry.Present)
        {
            Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_TS, NewLdtr);
            return FALSE;
        }
 
        /* Update the LDTR */
        State->Ldtr.Selector = NewLdtr;
        State->Ldtr.Base = GdtEntry.Base | (GdtEntry.BaseMid << 16) | (GdtEntry.BaseHigh << 24);
        State->Ldtr.Limit = GdtEntry.Limit | (GdtEntry.LimitHigh << 16);
 
        if (GdtEntry.Granularity)
        {
            State->Ldtr.Limit <<= 12;
            State->Ldtr.Limit |= 0x00000FFF;
        }
    }
    else
    {
        /* The LDT of this task is empty */
        RtlZeroMemory(&State->Ldtr, sizeof(State->Ldtr));
    }
 
    /* Load the new segments */
    if (!Fast486LoadSegmentInternal(State, FAST486_REG_CS, NewCs, FAST486_EXCEPTION_TS))
    {
        return FALSE;
    }
 
    if (!Fast486LoadSegmentInternal(State, FAST486_REG_SS, NewSs, FAST486_EXCEPTION_TS))
    {
        return FALSE;
    }
 
    if (!Fast486LoadSegmentInternal(State, FAST486_REG_ES, NewEs, FAST486_EXCEPTION_TS))
    {
        return FALSE;
    }
 
    if (!Fast486LoadSegmentInternal(State, FAST486_REG_DS, NewDs, FAST486_EXCEPTION_TS))
    {
        return FALSE;
    }
 
    if (NewTssDescriptor.Signature == FAST486_BUSY_TSS_SIGNATURE)
    {
        if (!Fast486LoadSegmentInternal(State,
                                        FAST486_REG_FS,
                                        NewTss.Fs,
                                        FAST486_EXCEPTION_TS))
        {
            return FALSE;
        }
 
        if (!Fast486LoadSegmentInternal(State,
                                        FAST486_REG_GS,
                                        NewTss.Gs,
                                        FAST486_EXCEPTION_TS))
        {
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by FAST486_OPCODE_HANDLER(), and Fast486InterruptInternal().

Fast486WriteMemory()

BOOLEAN FASTCALL Fast486WriteMemory	(	PFAST486_STATE	State,
		FAST486_SEG_REGS	SegmentReg,
		ULONG	Offset,
		PVOID	Buffer,
		ULONG	Size
	)

Definition at line 163 of file common.c.

{
    ULONG LinearAddress;
    PFAST486_SEG_REG CachedDescriptor;
    FAST486_EXCEPTIONS Exception = SegmentReg != FAST486_REG_SS
                                   ? FAST486_EXCEPTION_GP : FAST486_EXCEPTION_SS;
 
    ASSERT(SegmentReg < FAST486_NUM_SEG_REGS);
 
    /* Get the cached descriptor */
    CachedDescriptor = &State->SegmentRegs[SegmentReg];
 
    if (CachedDescriptor->Executable || !CachedDescriptor->DirConf)
    {
        if ((Offset + Size - 1) > CachedDescriptor->Limit)
        {
            /* Write beyond limit */
            Fast486Exception(State, Exception);
            return FALSE;
        }
    }
    else
    {
        if (Offset < CachedDescriptor->Limit)
        {
            /* Write beyond limit */
            Fast486Exception(State, Exception);
            return FALSE;
        }
    }
 
    /* Check for protected mode */
    if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) && !State->Flags.Vm)
    {
        /* Privilege checks */
 
        if (!CachedDescriptor->Present)
        {
            Fast486Exception(State, Exception);
            return FALSE;
        }
 
        if ((CachedDescriptor->Rpl > CachedDescriptor->Dpl)
            || (Fast486GetCurrentPrivLevel(State) > CachedDescriptor->Dpl))
        {
            Fast486Exception(State, Exception);
            return FALSE;
        }
 
        if (CachedDescriptor->Executable)
        {
            /* Code segment not writable */
            Fast486Exception(State, Exception);
            return FALSE;
        }
        else if (!CachedDescriptor->ReadWrite)
        {
            /* Data segment not writeable */
            Fast486Exception(State, Exception);
            return FALSE;
        }
    }
 
    /* Find the linear address */
    LinearAddress = CachedDescriptor->Base + Offset;
 
#ifndef FAST486_NO_PREFETCH
    if (State->PrefetchValid
        && (LinearAddress >= State->PrefetchAddress)
        && ((LinearAddress + Size) <= (State->PrefetchAddress + FAST486_CACHE_SIZE)))
    {
        /* Update the prefetch */
        RtlMoveMemory(&State->PrefetchCache[LinearAddress - State->PrefetchAddress],
                      Buffer,
                      min(Size, FAST486_CACHE_SIZE + State->PrefetchAddress - LinearAddress));
    }
#endif
 
    /* Write to the linear address */
    return Fast486WriteLinearMemory(State, LinearAddress, Buffer, Size, TRUE);
}

Referenced by FAST486_OPCODE_HANDLER(), and Fast486FpuSaveEnvironment().