/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS kernel
 * FILE:            ntdll/dispatch/amd64/dispatch.S
 * PURPOSE:         Usermode dispatcher stubs
 *
 * PROGRAMMER:      Timo kreuzer (timo.kreuzer@reactos.org)
 */

/* INCLUDES ******************************************************************/

#include <asm.inc>
#include <ksamd64.inc>

EXTERN NtContinue:PROC
EXTERN LdrpInit:PROC
EXTERN ZwCallbackReturn:PROC
EXTERN RtlRaiseStatus:PROC

.code

PUBLIC LdrInitializeThunk
.PROC LdrInitializeThunk
    mov rbp, 0
    .setframe rbp, 0
    .endprolog

    /* First parameter is the APC context */
    mov rcx, r9
    jmp LdrpInit

.ENDP

PUBLIC KiUserApcDispatcher
.PROC KiUserApcDispatcher
    .endprolog
    /* We enter with a 16 byte aligned stack */

    mov rcx, [rsp + CONTEXT_P1Home] /* NormalContext */
    mov rdx, [rsp + CONTEXT_P2Home] /* SystemArgument1 */
    mov r8, [rsp + CONTEXT_P3Home]  /* SystemArgument2 */
    lea r9, [rsp]                   /* Context */
    call qword ptr [rsp + CONTEXT_P4Home] /* NormalRoutine */

    /* NtContinue(Context, TRUE); */
    lea rcx, [rsp]
    mov dl, 1
    call NtContinue

    nop
    int 3
.ENDP


PUBLIC KiRaiseUserExceptionDispatcher
.PROC KiRaiseUserExceptionDispatcher
    .endprolog
    int 3

.ENDP

PUBLIC KiUserCallbackDispatcher
.PROC KiUserCallbackDispatcher

    ; The stack is set up with a UCALLOUT_FRAME
    ; The frame ends with a MACHINE_FRAME.
    .PUSHFRAME

    ; This is for the Home space, Buffer, Length and ApiNumber
    .ALLOCSTACK 6 * 8
    .ENDPROLOG

#if DBG
    ; We enter the function with a fully setup stack, so it must be aligned!
    test rsp, 15
    jz AlignmentOk
    int HEX(2C)
AlignmentOk:
#endif

    ; Get the parameters from the callout frame
    mov rcx, [rsp + CkBuffer]
    mov edx, [rsp + CkLength]
    mov r8d, [rsp + CkApiNumber]

    ; Get the callback table
    mov rax, gs:[TePeb]
    mov r9, [rax + PeKernelCallbackTable]

    ; Call the routine
    call qword ptr [r9 + r8 * 8]

    ; Return from callback
    xor ecx, ecx
    xor edx, edx
    mov r8d, eax
    call ZwCallbackReturn

    ; Save callback return value
    mov esi, eax

    ; Raise status
StatusRaise:
    mov ecx, esi
    call RtlRaiseStatus
    jmp StatusRaise

.ENDP

/*
    BOOLEAN
    NTAPI
    RtlDispatchException(
        _In_ PEXCEPTION_RECORD ExceptionRecord,
        _In_ PCONTEXT ContextRecord);
 */
EXTERN RtlDispatchException:PROC

/*
    NTSTATUS
    NTAPI
    ZwContinue(
        _In_ PCONTEXT Context,
        _In_ BOOLEAN TestAlert);
 */
EXTERN ZwContinue:PROC

/*
    NTSTATUS
    NTAPI
    ZwRaiseException(
        _In_ PEXCEPTION_RECORD ExceptionRecord,
        _In_ PCONTEXT Context,
        _In_ BOOLEAN SearchFrames);
 */
EXTERN ZwRaiseException:PROC

/*
    VOID
    NTAPI
    RtlRaiseStatus(
        _In_ PEXCEPTION_RECORD ExceptionRecord);
 */
EXTERN RtlRaiseException:PROC

/*
    VOID
    KiUserExceptionDispatcher(
        CONTEXT ContextRecord<rcx>,
        PEXCEPTION_RECORD ExceptionRecord<rdx>);

    This function is called with the following stack layout:
        CONTEXT ContextRecord  <- RSP, RCX
        EXCEPTION_RECORD ExceptionRecord <- RDX
        ULONG64 Alignment
        MACHINE_FRAME MachineFrame
 */
PUBLIC KiUserExceptionDispatcher
.PROC KiUserExceptionDispatcher

    ; The stack is set up with a KUSER_EXCEPTION_STACK
    ; The frame ends with a MACHINE_FRAME.
    .PUSHFRAME

    ; This is for the alignment, EXCEPTION_RECORD and CONTEXT
    .ALLOCSTACK 8 + EXCEPTION_RECORD_LENGTH + CONTEXT_FRAME_LENGTH
    .ENDPROLOG

    /* Clear direction flag */
    cld

    /* Dispatch the exception */
    call RtlDispatchException

    /* Check for success */
    or al, al
    jz RaiseException

    /* We're fine, continue execution */
    lea rcx, [rsp] ; ContextRecord
    mov dl, 0 ; TestAlert
    call ZwContinue

    /* Exit */
    jmp Exit

RaiseException:

    /* Raise the exception */
    lea rcx, [rsp + CONTEXT_FRAME_LENGTH] ; ExceptionRecord
    lea rdx, [rsp] ; ContextRecord
    xor r8, r8
    call ZwRaiseException

Exit:
    lea rcx, [rsp + CONTEXT_FRAME_LENGTH] ; ExceptionRecord
    mov rdx, rax
    call KiUserExceptionDispatcherNested
    ret

.ENDP

/*
    VOID
    KiUserExceptionDispatcherNested(
        _In_ ExceptionRecord<rcx>,
        _In_ Status<edx>
    )
 */
.PROC KiUserExceptionDispatcherNested
    /* Allocate space for the nested exception record */
    sub rsp, EXCEPTION_RECORD_LENGTH
    .ALLOCSTACK EXCEPTION_RECORD_LENGTH
    .ENDPROLOG

    /* Set it up */
    mov dword ptr [rsp + ErNumberParameters], 0
    mov dword ptr [rsp + ErExceptionFlags], EXCEPTION_NONCONTINUABLE
    mov [rsp + ErExceptionRecord], rcx
    mov [rsp + ErExceptionCode], edx
 
    /* Raise the exception */
    mov rcx, rsp
    call RtlRaiseException

    /* Cleanup stack and return */
    add rsp, EXCEPTION_RECORD_LENGTH
    ret
.ENDP

END