stubs.c File Reference

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

Include dependency graph for stubs.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	MAX_SYSCALL_PARAMS   16

Functions
VOID	KiRetireDpcListInDpcStack (PKPRCB Prcb, PVOID DpcStack)
NTSTATUS	KiConvertToGuiThread (VOID)
	_Requires_lock_not_held_ (Prcb->PrcbLock) VOID NTAPI KiDpcInterruptHandler(VOID)
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	NtSyscallFailure (void)
PVOID	KiSystemCallHandler (VOID)
VOID	KiSystemService (IN PKTHREAD Thread, IN PKTRAP_FRAME TrapFrame, IN ULONG Instruction)
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

MAX_SYSCALL_PARAMS

#define MAX_SYSCALL_PARAMS   16

Definition at line 250 of file stubs.c.

NDEBUG

#define NDEBUG

Definition at line 13 of file stubs.c.

Function Documentation

_Requires_lock_not_held_()

_Requires_lock_not_held_

(

Prcb->

PrcbLock

)

Definition at line 28 of file stubs.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    PKTHREAD NewThread, OldThread;
    KIRQL OldIrql;
 
    /* Raise to DISPATCH_LEVEL */
    OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
 
    /* Send an EOI */
    KiSendEOI();
 
    /* Check for pending timers, pending DPCs, or pending ready threads */
    if ((Prcb->DpcData[0].DpcQueueDepth) ||
        (Prcb->TimerRequest) ||
        (Prcb->DeferredReadyListHead.Next))
    {
        /* Retire DPCs while under the DPC stack */
        KiRetireDpcListInDpcStack(Prcb, Prcb->DpcStack);
    }
 
    /* Enable interrupts */
    _enable();
 
    /* Check for quantum end */
    if (Prcb->QuantumEnd)
    {
        /* Handle quantum end */
        Prcb->QuantumEnd = FALSE;
        KiQuantumEnd();
    }
    else if (Prcb->NextThread)
    {
        /* Acquire the PRCB lock */
        KiAcquirePrcbLock(Prcb);
 
        /* 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;
        OldThread->WaitReason = WrDispatchInt;
 
        /* Make the old thread ready */
        KxQueueReadyThread(OldThread, Prcb);
 
        /* Swap to the new thread */
        KiSwapContext(APC_LEVEL, OldThread);
    }
 
    /* Disable interrupts and go back to old irql */
    _disable();
    KeLowerIrql(OldIrql);
}

KiConvertToGuiThread()

NTSTATUS KiConvertToGuiThread

(

VOID

)

Referenced by KiSystemCallHandler().

KiIdleLoop()

DECLSPEC_NORETURN VOID KiIdleLoop

(

VOID

)

Definition at line 170 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;
 
            /* Do the swap at SYNCH_LEVEL */
            KfRaiseIrql(SYNCH_LEVEL);
 
            /* Switch away from the idle thread */
            KiSwapContext(APC_LEVEL, OldThread);
 
            /* Go back to DISPATCH_LEVEL */
            KeLowerIrql(DISPATCH_LEVEL);
        }
        else
        {
            /* Continue staying idle. Note the HAL returns with interrupts on */
            Prcb->PowerState.IdleFunction(&Prcb->PowerState);
        }
    }
}

KiRetireDpcListInDpcStack()

VOID KiRetireDpcListInDpcStack	(	PKPRCB	Prcb,
		PVOID	DpcStack
	)

Referenced by _Requires_lock_not_held_().

KiSwapProcess()

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

Definition at line 232 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 111 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
	)

KiSystemCallHandler()

PVOID KiSystemCallHandler

(

VOID

)

Definition at line 260 of file stubs.c.

{
    PKTRAP_FRAME TrapFrame;
    PKSERVICE_TABLE_DESCRIPTOR DescriptorTable;
    PKTHREAD Thread;
    PULONG64 KernelParams, UserParams;
    ULONG ServiceNumber, Offset, Count;
    ULONG64 UserRsp;
 
    /* Get a pointer to the trap frame */
    TrapFrame = (PKTRAP_FRAME)((PULONG64)_AddressOfReturnAddress() + 1 + MAX_SYSCALL_PARAMS);
 
    /* Increase system call count */
    __addgsdword(FIELD_OFFSET(KIPCR, Prcb.KeSystemCalls), 1);
 
    /* Get the current thread */
    Thread = KeGetCurrentThread();
 
    /* Set previous mode */
    Thread->PreviousMode = TrapFrame->PreviousMode = UserMode;
 
    /* Save the old trap frame and set the new */
    TrapFrame->TrapFrame = (ULONG64)Thread->TrapFrame;
    Thread->TrapFrame = TrapFrame;
 
    /* We don't have an exception frame yet */
    TrapFrame->ExceptionFrame = 0;
 
    /* Before enabling interrupts get the user rsp from the KPCR */
    UserRsp = __readgsqword(FIELD_OFFSET(KIPCR, UserRsp));
    TrapFrame->Rsp = UserRsp;
 
    /* Enable interrupts */
    _enable();
 
    /* If the usermode rsp was not a usermode address, prepare an exception */
    if (UserRsp > MmUserProbeAddress) UserRsp = MmUserProbeAddress;
 
    /* Get the address of the usermode and kernelmode parameters */
    UserParams = (PULONG64)UserRsp + 1;
    KernelParams = (PULONG64)TrapFrame - MAX_SYSCALL_PARAMS;
 
    /* Get the system call number from the trap frame and decode it */
    ServiceNumber = (ULONG)TrapFrame->Rax;
    Offset = (ServiceNumber >> SERVICE_TABLE_SHIFT) & SERVICE_TABLE_MASK;
    ServiceNumber &= SERVICE_NUMBER_MASK;
 
    /* Check for win32k system calls */
    if (Offset & SERVICE_TABLE_TEST)
    {
        ULONG GdiBatchCount;
 
        /* Read the GDI batch count from the TEB */
        _SEH2_TRY
        {
            GdiBatchCount = NtCurrentTeb()->GdiBatchCount;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            GdiBatchCount = 0;
        }
        _SEH2_END;
 
        /* Flush batch, if there are entries */
        if (GdiBatchCount != 0)
        {
            KeGdiFlushUserBatch();
        }
    }
 
    /* Get descriptor table */
    DescriptorTable = (PVOID)((ULONG_PTR)Thread->ServiceTable + Offset);
 
    /* Validate the system call number */
    if (ServiceNumber >= DescriptorTable->Limit)
    {
        /* Check if this is a GUI call */
        if (!(Offset & SERVICE_TABLE_TEST))
        {
            /* Fail the call */
            TrapFrame->Rax = STATUS_INVALID_SYSTEM_SERVICE;
            return (PVOID)NtSyscallFailure;
        }
 
        /* Convert us to a GUI thread
           To be entirely correct. we return KiConvertToGuiThread,
           which allocates a new stack, switches to it, calls
           PsConvertToGuiThread and resumes in the middle of
           KiSystemCallEntry64 to restart the system call handling. */
        return (PVOID)KiConvertToGuiThread;
    }
 
    /* Get stack bytes and calculate argument count */
    Count = DescriptorTable->Number[ServiceNumber] / 8;
 
    _SEH2_TRY
    {
        switch (Count)
        {
            case 16: KernelParams[15] = UserParams[15];
            case 15: KernelParams[14] = UserParams[14];
            case 14: KernelParams[13] = UserParams[13];
            case 13: KernelParams[12] = UserParams[12];
            case 12: KernelParams[11] = UserParams[11];
            case 11: KernelParams[10] = UserParams[10];
            case 10: KernelParams[9] = UserParams[9];
            case 9: KernelParams[8] = UserParams[8];
            case 8: KernelParams[7] = UserParams[7];
            case 7: KernelParams[6] = UserParams[6];
            case 6: KernelParams[5] = UserParams[5];
            case 5: KernelParams[4] = UserParams[4];
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                break;
 
            default:
                ASSERT(FALSE);
                break;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        TrapFrame->Rax = _SEH2_GetExceptionCode();
        return (PVOID)NtSyscallFailure;
    }
    _SEH2_END;
 
    return (PVOID)DescriptorTable->Base[ServiceNumber];
}

KiSystemService()

VOID KiSystemService	(	IN PKTHREAD	Thread,
		IN PKTRAP_FRAME	TrapFrame,
		IN ULONG	Instruction
	)

Definition at line 397 of file stubs.c.

{
    UNIMPLEMENTED;
    __debugbreak();
}

NtSetLdtEntries()

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

Definition at line 407 of file stubs.c.

{
    UNIMPLEMENTED;
    __debugbreak();
    return STATUS_UNSUCCESSFUL;
}

Referenced by init_funcs().

NtSyscallFailure()

NTSTATUS NtSyscallFailure

(

void

)

Definition at line 253 of file stubs.c.

{
    /* This is the failure function */
    return (NTSTATUS)KeGetCurrentThread()->TrapFrame->Rax;
}

Referenced by KiSystemCallHandler().

NtVdmControl()

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

Definition at line 417 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 17 of file stubs.c.

ProcessCount

ULONG ProcessCount

Definition at line 16 of file stubs.c.