thrdini.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for thrdini.c:

Go to the source code of this file.

Classes
struct	_KUINIT_FRAME
struct	_KKINIT_FRAME

Macros
#define	NDEBUG

Typedefs
typedef struct _KUINIT_FRAME	KUINIT_FRAME
typedef struct _KUINIT_FRAME *	PKUINIT_FRAME
typedef struct _KKINIT_FRAME	KKINIT_FRAME
typedef struct _KKINIT_FRAME *	PKKINIT_FRAME

Functions
void	KiInvalidSystemThreadStartupExit (void)
void	KiUserThreadStartupExit (void)
void	KiServiceExit3 (void)
VOID NTAPI	KiInitializeContextThread (IN PKTHREAD Thread, IN PKSYSTEM_ROUTINE SystemRoutine, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext, IN PCONTEXT Context)
BOOLEAN	KiSwapContextResume (_In_ BOOLEAN ApcBypass, _In_ PKTHREAD OldThread, _In_ PKTHREAD NewThread)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file thrdini.c.

Typedef Documentation

KKINIT_FRAME

typedef struct _KKINIT_FRAME KKINIT_FRAME

KUINIT_FRAME

typedef struct _KUINIT_FRAME KUINIT_FRAME

PKKINIT_FRAME

typedef struct _KKINIT_FRAME * PKKINIT_FRAME

PKUINIT_FRAME

typedef struct _KUINIT_FRAME * PKUINIT_FRAME

Function Documentation

KiInitializeContextThread()

VOID NTAPI KiInitializeContextThread	(	IN PKTHREAD	Thread,
		IN PKSYSTEM_ROUTINE	SystemRoutine,
		IN PKSTART_ROUTINE	StartRoutine,
		IN PVOID	StartContext,
		IN PCONTEXT	Context
	)

Definition at line 43 of file thrdini.c.

{
    PKSTART_FRAME StartFrame;
    PKSWITCH_FRAME CtxSwitchFrame;
    PKTRAP_FRAME TrapFrame;
    PKEXCEPTION_FRAME ExceptionFrame;
    ULONG ContextFlags;
    PVOID InitialStack;
 
    /* Allocate space on the stack for the XSAVE area */
    InitialStack = (PUCHAR)Thread->InitialStack - KeXStateLength;
    InitialStack = ALIGN_DOWN_POINTER_BY(InitialStack, 64);
    Thread->InitialStack = InitialStack;
 
    /* Initialize the state save area */
    Thread->StateSaveArea = InitialStack;
    RtlZeroMemory(Thread->StateSaveArea, KeXStateLength);
    Thread->StateSaveArea->MxCsr = INITIAL_MXCSR;
    Thread->StateSaveArea->ControlWord = INITIAL_FPCSR;
 
    /* Check if we use XSAVE */
    if (KeFeatureBits & KF_XSTATE)
    {
        /* Enable the mask for legacy floating point state */
        PXSAVE_AREA XSaveArea = (PXSAVE_AREA)Thread->StateSaveArea;
        XSaveArea->Header.Mask |= XSTATE_MASK_LEGACY_FLOATING_POINT;
 
        /* Special initialization for XSAVES */
        if (KeFeatureBits & KF_XSAVES)
        {
            /* Set bit 63 in XCOMP_BV to mark the area as compacted.
               XRSTORS requires this and will #GP otherwise.
               Also mark legacy FP as compacted. */
            XSaveArea->Header.CompactionMask |= 0x8000000000000000ULL |
                                                XSTATE_MASK_LEGACY_FLOATING_POINT;
        }
    }
 
    /* Check if this is a With-Context Thread */
    if (Context)
    {
        PKUINIT_FRAME InitFrame;
 
        /* Set up the Initial Frame */
        InitFrame = ((PKUINIT_FRAME)Thread->InitialStack) - 1;
        StartFrame = &InitFrame->StartFrame;
        CtxSwitchFrame = &InitFrame->CtxSwitchFrame;
 
        /* Save back the new value of the kernel stack. */
        Thread->KernelStack = (PVOID)InitFrame;
 
        /* Tell the thread it will run in User Mode */
        Thread->PreviousMode = UserMode;
 
        /* Set the Thread's NPX State */
        Thread->NpxState = SharedUserData->XState.EnabledFeatures;
        Thread->Header.NpxIrql = PASSIVE_LEVEL;
 
        /* Make sure, we have control registers, disable debug registers */
        ASSERT((Context->ContextFlags & CONTEXT_CONTROL) == CONTEXT_CONTROL);
        ContextFlags = Context->ContextFlags & ~CONTEXT_DEBUG_REGISTERS;
 
        /* Zero-initialize the Trap Frame and exception frame */
        TrapFrame = &InitFrame->TrapFrame;
        RtlZeroMemory(TrapFrame, sizeof(KTRAP_FRAME));
        ExceptionFrame = &InitFrame->ExceptionFrame;
        RtlZeroMemory(ExceptionFrame, sizeof(KEXCEPTION_FRAME));
 
        /* Copy integer registers */
        TrapFrame->Rax = Context->Rax;
        TrapFrame->Rcx = Context->Rcx;
        TrapFrame->Rdx = Context->Rdx;
        TrapFrame->Rbp = 0; // Context->Rbp; // 0 on Vista, copied on Win 10
        TrapFrame->R8 = Context->R8;
        TrapFrame->R9 = Context->R9;
        TrapFrame->R10 = Context->R10;
        TrapFrame->R11 = Context->R11;
        ExceptionFrame->Rbx = Context->Rbx;
        ExceptionFrame->Rsi = Context->Rsi;
        ExceptionFrame->Rdi = Context->Rdi;
        ExceptionFrame->R12 = Context->R12;
        ExceptionFrame->R13 = Context->R13;
        ExceptionFrame->R14 = Context->R14;
        ExceptionFrame->R15 = Context->R15;
 
        /* Copy RIP, RSP, EFLAGS */
        TrapFrame->Rip = Context->Rip;
        TrapFrame->Rsp = Context->Rsp;
        TrapFrame->EFlags = Context->EFlags;
 
        /* Sanitize EFLAGS */
        TrapFrame->EFlags &= EFLAGS_USER_THREAD_SANITIZE;
        TrapFrame->EFlags |= EFLAGS_INTERRUPT_MASK;
 
        /* Set user mode segment selectors */
        TrapFrame->SegDs = KGDT64_R3_DATA | RPL_MASK;
        TrapFrame->SegEs = KGDT64_R3_DATA | RPL_MASK;
        TrapFrame->SegFs = KGDT64_R3_CMTEB | RPL_MASK;
        TrapFrame->SegGs = KGDT64_R3_DATA | RPL_MASK;
        TrapFrame->SegCs = KGDT64_R3_CODE | RPL_MASK;
        TrapFrame->SegSs = KGDT64_R3_DATA | RPL_MASK;
 
        /* Clear DR7 */
        TrapFrame->Dr7 = 0;
 
        /* Initialize floating point state */
        TrapFrame->MxCsr = INITIAL_MXCSR;
 
        /* Set the previous mode as user */
        TrapFrame->PreviousMode = UserMode;
 
        /* Terminate the Exception Handler List */
        TrapFrame->ExceptionFrame = 0;
 
        /* KiThreadStartup returns to KiUserThreadStartupExit */
        StartFrame->Return = (ULONG64)KiUserThreadStartupExit;
 
        /* KiUserThreadStartupExit returns to KiServiceExit3 */
        ExceptionFrame->Return = (ULONG64)KiServiceExit3;
 
        /* Allocate home space on the stack */
        TrapFrame->Rsp -= 5 * sizeof(PVOID);
    }
    else
    {
        PKKINIT_FRAME InitFrame;
 
        /* Set up the Initial Frame for the system thread */
        InitFrame = ((PKKINIT_FRAME)Thread->InitialStack) - 1;
        StartFrame = &InitFrame->StartFrame;
        CtxSwitchFrame = &InitFrame->CtxSwitchFrame;
 
        /* Save back the new value of the kernel stack. */
        Thread->KernelStack = (PVOID)InitFrame;
 
        /* Tell the thread it will run in Kernel Mode */
        Thread->PreviousMode = KernelMode;
 
        /* No NPX State */
        Thread->NpxState = 0;
 
        /* This must never return! */
        StartFrame->Return = (ULONG64)KiInvalidSystemThreadStartupExit;
    }
 
    /* Set up the Context Switch Frame */
    CtxSwitchFrame->Return = (ULONG64)KiThreadStartup;
    CtxSwitchFrame->ApcBypass = TRUE;
 
    StartFrame->P1Home = (ULONG64)StartRoutine;
    StartFrame->P2Home = (ULONG64)StartContext;
    StartFrame->P3Home = 0;
    StartFrame->P4Home = (ULONG64)SystemRoutine;
    StartFrame->Reserved = 0;
}

KiInvalidSystemThreadStartupExit()

void KiInvalidSystemThreadStartupExit

(

void

)

Referenced by KiInitializeContextThread().

KiServiceExit3()

void KiServiceExit3

(

void

)

Referenced by KiInitializeContextThread().

KiSwapContextResume()

BOOLEAN KiSwapContextResume	(	_In_ BOOLEAN	ApcBypass,
		_In_ PKTHREAD	OldThread,
		_In_ PKTHREAD	NewThread
	)

Definition at line 204 of file thrdini.c.

{
    PKIPCR Pcr = (PKIPCR)KeGetPcr();
    PKPROCESS OldProcess, NewProcess;
    ULONG64 CurrentCycleTime, ElapsedCycles;
 
    /* Setup ring 0 stack pointer */
    Pcr->TssBase->Rsp0 = (ULONG64)NewThread->InitialStack;
    Pcr->Prcb.RspBase = Pcr->TssBase->Rsp0;
 
    /* Save old thread's extended state */
    if (OldThread->NpxState != 0)
    {
        KiSaveXState(OldThread->StateSaveArea, OldThread->NpxState);
    }
 
    /* Load new thread's extended state */
    if (NewThread->NpxState != 0)
    {
        KiRestoreXState(NewThread->StateSaveArea, NewThread->NpxState);
    }
 
    /* Now we are the new thread. Check if it's in a new process */
    OldProcess = OldThread->ApcState.Process;
    NewProcess = NewThread->ApcState.Process;
    if (OldProcess != NewProcess)
    {
        /* Switch address space and flush TLB */
        __writecr3(NewProcess->DirectoryTableBase[0]);
 
        /* Set new TSS fields */
        //Pcr->TssBase->IoMapBase = NewProcess->IopmOffset;
    }
 
    /* Update the old thread's cycle time */
    CurrentCycleTime = __rdtsc();
    ElapsedCycles = CurrentCycleTime - Pcr->Prcb.StartCycles;
    ((PETHREAD)OldThread)->CycleTime += ElapsedCycles;
    InterlockedAdd64((PLONG64)&((PEPROCESS)OldProcess)->CycleTime, ElapsedCycles);
    Pcr->Prcb.StartCycles = CurrentCycleTime;
 
    /* Set TEB pointer and GS base */
    Pcr->NtTib.Self = (PVOID)NewThread->Teb;
    if (NewThread->Teb)
    {
       /* This will switch the usermode gs */
       __writemsr(MSR_GS_SWAP, (ULONG64)NewThread->Teb);
 
#if defined(_WIN64) && defined(BUILD_WOW64_ENABLED)
       PEPROCESS ENewProcess = (PEPROCESS)NewProcess;
 
       if (ENewProcess->Wow64Process != NULL)
       {
          ULONG_PTR Base = (ULONG_PTR)PS_GET_TEB32_FROM_TEB(NewThread->Teb);
 
          PKGDTENTRY64 CmTebEntry = KiGetGdtEntry(Pcr->GdtBase, KGDT64_R3_CMTEB);
          CmTebEntry->LimitLow = 0xFFFF;
          CmTebEntry->Bits.LimitHigh = 0xFFFF;
 
          CmTebEntry->BaseLow = Base & 0xFFFF;
          CmTebEntry->Bits.BaseMiddle = (Base & 0xFF0000) >> 16;
          CmTebEntry->Bits.BaseHigh = (Base & 0xFF000000) >> 24;
 
          KiReloadWow64Fs();
       }
#endif
    }
 
    /* Increase context switch count */
    Pcr->ContextSwitches++;
    NewThread->ContextSwitches++;
 
    /* DPCs shouldn't be active */
    if (Pcr->Prcb.DpcRoutineActive)
    {
        /* Crash the machine */
        KeBugCheckEx(ATTEMPTED_SWITCH_FROM_DPC,
                     (ULONG_PTR)OldThread,
                     (ULONG_PTR)NewThread,
                     (ULONG_PTR)OldThread->InitialStack,
                     0);
    }
 
    /* Old thread os no longer busy */
    OldThread->SwapBusy = FALSE;
 
    /* Kernel APCs may be pending */
    if (NewThread->ApcState.KernelApcPending)
    {
        /* Are APCs enabled? */
        if ((NewThread->SpecialApcDisable == 0) &&
            (ApcBypass == 0))
        {
            /* Return TRUE to indicate that we want APCs to be delivered */
            return TRUE;
        }
 
        /* Request an APC interrupt to be delivered later */
        HalRequestSoftwareInterrupt(APC_LEVEL);
    }
 
    /* Return stating that no kernel APCs are pending*/
    return FALSE;
}

KiUserThreadStartupExit()

void KiUserThreadStartupExit

(

void

)

Referenced by KiInitializeContextThread().