stubs.c File Reference

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

Include dependency graph for stubs.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
PVOID	KiSwitchKernelStackHelper (LONG_PTR StackOffset, PVOID OldStackBase)
PVOID NTAPI	KiSwitchKernelStack (PVOID StackBase, PVOID StackLimit)
DECLSPEC_NORETURN VOID	KiIdleLoop (VOID)
VOID NTAPI	KiSwapProcess (IN PKPROCESS NewProcess, IN PKPROCESS OldProcess)
NTSTATUS NTAPI	NtSetLdtEntries (ULONG Selector1, LDT_ENTRY LdtEntry1, ULONG Selector2, LDT_ENTRY LdtEntry2)
NTSTATUS NTAPI	NtVdmControl (IN ULONG ControlCode, IN PVOID ControlData)

Variables
ULONG	ProcessCount
SIZE_T	KeXStateLength = sizeof(XSAVE_FORMAT)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file stubs.c.

Function Documentation

KiIdleLoop()

DECLSPEC_NORETURN VOID KiIdleLoop

(

VOID

)

Definition at line 99 of file stubs.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    PKTHREAD OldThread, NewThread;
 
    /* Now loop forever */
    while (TRUE)
    {
        /* Start of the idle loop: disable interrupts */
        _enable();
        YieldProcessor();
        YieldProcessor();
        _disable();
 
        /* Check for pending timers, pending DPCs, or pending ready threads */
        if ((Prcb->DpcData[0].DpcQueueDepth) ||
            (Prcb->TimerRequest) ||
            (Prcb->DeferredReadyListHead.Next))
        {
            /* Quiesce the DPC software interrupt */
            HalClearSoftwareInterrupt(DISPATCH_LEVEL);
 
            /* Handle it */
            KiRetireDpcList(Prcb);
        }
 
        /* Check if a new thread is scheduled for execution */
        if (Prcb->NextThread)
        {
            /* Enable interrupts */
            _enable();
 
            /* Capture current thread data */
            OldThread = Prcb->CurrentThread;
            NewThread = Prcb->NextThread;
 
            /* Set new thread data */
            Prcb->NextThread = NULL;
            Prcb->CurrentThread = NewThread;
 
            /* The thread is now running */
            NewThread->State = Running;
 
#ifdef CONFIG_SMP
            /* Do the swap at SYNCH_LEVEL */
            KfRaiseIrql(SYNCH_LEVEL);
#endif
 
            /* Switch away from the idle thread */
            KiSwapContext(APC_LEVEL, OldThread);
 
#ifdef CONFIG_SMP
            /* Go back to DISPATCH_LEVEL */
            KeLowerIrql(DISPATCH_LEVEL);
#endif
        }
        else
        {
            /* Continue staying idle. Note the HAL returns with interrupts on */
            Prcb->PowerState.IdleFunction(&Prcb->PowerState);
        }
    }
}

KiSwapProcess()

VOID NTAPI KiSwapProcess	(	IN PKPROCESS	NewProcess,
		IN PKPROCESS	OldProcess
	)

Definition at line 165 of file stubs.c.

{
    PKIPCR Pcr = (PKIPCR)KeGetPcr();
 
#ifdef CONFIG_SMP
    /* Update active processor mask */
    InterlockedXor64((PLONG64)&NewProcess->ActiveProcessors, Pcr->Prcb.SetMember);
    InterlockedXor64((PLONG64)&OldProcess->ActiveProcessors, Pcr->Prcb.SetMember);
#endif
 
    /* Update CR3 */
    __writecr3(NewProcess->DirectoryTableBase[0]);
 
    /* Update IOPM offset */
    Pcr->TssBase->IoMapBase = NewProcess->IopmOffset;
}

KiSwitchKernelStack()

PVOID NTAPI KiSwitchKernelStack	(	PVOID	StackBase,
		PVOID	StackLimit
	)

Definition at line 40 of file stubs.c.

{
    PKTHREAD CurrentThread;
    PVOID OldStackBase;
    LONG_PTR StackOffset;
    SIZE_T StackSize;
    PKIPCR Pcr;
    ULONG Eflags;
 
    /* Get the current thread */
    CurrentThread = KeGetCurrentThread();
 
    /* Save the old stack base */
    OldStackBase = CurrentThread->StackBase;
 
    /* Get the size of the current stack */
    StackSize = (ULONG_PTR)CurrentThread->StackBase - CurrentThread->StackLimit;
    ASSERT(StackSize <= (ULONG_PTR)StackBase - (ULONG_PTR)StackLimit);
 
    /* Copy the current stack contents to the new stack */
    RtlCopyMemory((PUCHAR)StackBase - StackSize,
                  (PVOID)CurrentThread->StackLimit,
                  StackSize);
 
    /* Calculate the offset between the old and the new stack */
    StackOffset = (PUCHAR)StackBase - (PUCHAR)CurrentThread->StackBase;
 
    /* Disable interrupts while messing with the stack */
    Eflags = __readeflags();
    _disable();
 
    /* Set the new trap frame */
    CurrentThread->TrapFrame = (PKTRAP_FRAME)Add2Ptr(CurrentThread->TrapFrame,
                                                     StackOffset);
 
    /* Set the new initial stack */
    CurrentThread->InitialStack = Add2Ptr(CurrentThread->InitialStack,
                                          StackOffset);
 
    /* Set the new stack limits */
    CurrentThread->StackBase = StackBase;
    CurrentThread->StackLimit = (ULONG_PTR)StackLimit;
    CurrentThread->LargeStack = TRUE;
 
    /* Adjust RspBase in the PCR */
    Pcr = (PKIPCR)KeGetPcr();
    Pcr->Prcb.RspBase += StackOffset;
 
    /* Adjust Rsp0 in the TSS */
    Pcr->TssBase->Rsp0 += StackOffset;
 
    /* Restore interrupts */
    __writeeflags(Eflags);
 
    return OldStackBase;
}

KiSwitchKernelStackHelper()

PVOID KiSwitchKernelStackHelper	(	LONG_PTR	StackOffset,
		PVOID	OldStackBase
	)

NtSetLdtEntries()

NTSTATUS NTAPI NtSetLdtEntries	(	ULONG	Selector1,
		LDT_ENTRY	LdtEntry1,
		ULONG	Selector2,
		LDT_ENTRY	LdtEntry2
	)

Definition at line 185 of file stubs.c.

{
    UNIMPLEMENTED;
    __debugbreak();
    return STATUS_UNSUCCESSFUL;
}

Referenced by init_funcs().

NtVdmControl()

NTSTATUS NTAPI NtVdmControl	(	IN ULONG	ControlCode,
		IN PVOID	ControlData
	)

Definition at line 194 of file stubs.c.

{
    /* Not supported */
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by KiEnterV86Mode().

Variable Documentation

KeXStateLength

SIZE_T KeXStateLength = sizeof(XSAVE_FORMAT)

Definition at line 18 of file stubs.c.

ProcessCount

ULONG ProcessCount

Definition at line 17 of file stubs.c.