Ros-diffs October 2020

ros-diffs@reactos.org

22 participants
156 discussions

[reactos] 01/01: [NTOS:CC] CcMdl*Complete(): Return if FastIO succeeded (#3303)

by Serge Gautherie

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=81be201d982969c728ac1… commit 81be201d982969c728ac14df6a4f48a4fc6cf26b Author: Serge Gautherie <32623169+SergeGautherie(a)users.noreply.github.com> AuthorDate: Sat Oct 31 15:18:02 2020 +0100 Commit: GitHub <noreply(a)github.com> CommitDate: Sat Oct 31 15:18:02 2020 +0100 [NTOS:CC] CcMdl*Complete(): Return if FastIO succeeded (#3303) CORE-17342 --- ntoskrnl/cc/mdl.c | 26 +++++++++++++++++--------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/ntoskrnl/cc/mdl.c b/ntoskrnl/cc/mdl.c index 12d63c1a39e..a1b726c35c2 100644 --- a/ntoskrnl/cc/mdl.c +++ b/ntoskrnl/cc/mdl.c @@ -101,10 +101,14 @@ CcMdlReadComplete ( /* Check if we support Fast Calls, and check this one */ if (FastDispatch && FastDispatch->MdlReadComplete) { - /* Use the fast path */ - FastDispatch->MdlReadComplete(FileObject, - MdlChain, - DeviceObject); + /* Use the fast path */ + if (FastDispatch->MdlReadComplete(FileObject, + MdlChain, + DeviceObject)) + { + /* Request was handled */ + return; + } } /* Use slow path */ @@ -131,11 +135,15 @@ CcMdlWriteComplete ( /* Check if we support Fast Calls, and check this one */ if (FastDispatch && FastDispatch->MdlWriteComplete) { - /* Use the fast path */ - FastDispatch->MdlWriteComplete(FileObject, - FileOffset, - MdlChain, - DeviceObject); + /* Use the fast path */ + if (FastDispatch->MdlWriteComplete(FileObject, + FileOffset, + MdlChain, + DeviceObject)) + { + /* Request was handled */ + return; + } } /* Use slow path */

4 years, 1 month

[reactos] 02/02: [GDI32] Fix up GdiFixUpHandle

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=cef57d3c4428899289b98… commit cef57d3c4428899289b9855dc48fc9ae35f0839d Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Sat Jan 4 13:58:06 2020 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:24:09 2020 +0100 [GDI32] Fix up GdiFixUpHandle --- win32ss/gdi/gdi32/misc/misc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/win32ss/gdi/gdi32/misc/misc.c b/win32ss/gdi/gdi32/misc/misc.c index 04be375853f..5382c67aab0 100644 --- a/win32ss/gdi/gdi32/misc/misc.c +++ b/win32ss/gdi/gdi32/misc/misc.c @@ -745,7 +745,7 @@ GdiFixUpHandle(HGDIOBJ hGdiObj) Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hGdiObj); /* Rebuild handle for Object */ - return hGdiObj = (HGDIOBJ)(((LONG_PTR)(hGdiObj)) | (Entry->Type << GDI_ENTRY_UPPER_SHIFT)); + return (HGDIOBJ)(((ULONG_PTR)(hGdiObj)) | (Entry->Type << GDI_ENTRY_UPPER_SHIFT)); } /*

4 years, 1 month

[reactos] 01/02: [GDI32_APITEST] Add tests for truncated and extended handle to GetObject test

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=40489359883ab583a5424… commit 40489359883ab583a54246b0733df3596961140a Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Sat Jan 4 13:13:45 2020 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:24:09 2020 +0100 [GDI32_APITEST] Add tests for truncated and extended handle to GetObject test --- modules/rostests/apitests/gdi32/GetObject.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/modules/rostests/apitests/gdi32/GetObject.c b/modules/rostests/apitests/gdi32/GetObject.c index 6ac232b78a7..df2a87170f7 100644 --- a/modules/rostests/apitests/gdi32/GetObject.c +++ b/modules/rostests/apitests/gdi32/GetObject.c @@ -344,6 +344,21 @@ Test_Brush(void) ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_BRUSH, sizeof(LOGBRUSH), &logbrush) == 0, "\n"); ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError()); + + /* Test handle fixup */ + hBrush = (HBRUSH)((ULONG_PTR)GetStockObject(WHITE_BRUSH) & 0xFFFF); + ok(GetObjectW(hBrush, sizeof(LOGBRUSH), &logbrush) == sizeof(LOGBRUSH), + "GetObject(0x%p, ...) failed.\n", hBrush); + +#ifdef _WIN64 + /* Test upper 32 bits */ + hBrush = (HBRUSH)((ULONG64)GetStockObject(WHITE_BRUSH) | 0xFFFFFFFF00000000ULL); + ok(GetObjectW(hBrush, sizeof(LOGBRUSH), &logbrush) == sizeof(LOGBRUSH), + "GetObject(0x%p, ...) failed.\n", hBrush); + hBrush = (HBRUSH)((ULONG64)GetStockObject(WHITE_BRUSH) | 0x537F9F2F00000000ULL); + ok(GetObjectW(hBrush, sizeof(LOGBRUSH), &logbrush) == sizeof(LOGBRUSH), + "GetObject(0x%p, ...) failed.\n", hBrush); +#endif } void

4 years, 1 month

[reactos] 19/19: [NTOS:KE:X64] Set the exception frame as well in KiInitializeContextThread

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bdd4d5d8d8f81d1145458… commit bdd4d5d8d8f81d114545857c6e5eddc8c96fcf7b Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Mon Jan 6 00:56:20 2020 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:23:16 2020 +0100 [NTOS:KE:X64] Set the exception frame as well in KiInitializeContextThread --- ntoskrnl/ke/amd64/thrdini.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ntoskrnl/ke/amd64/thrdini.c b/ntoskrnl/ke/amd64/thrdini.c index 6548a385651..71d4179843a 100644 --- a/ntoskrnl/ke/amd64/thrdini.c +++ b/ntoskrnl/ke/amd64/thrdini.c @@ -77,10 +77,11 @@ KiInitializeContextThread(IN PKTHREAD Thread, /* Zero out the trap frame */ RtlZeroMemory(TrapFrame, sizeof(KTRAP_FRAME)); + RtlZeroMemory(&InitFrame->ExceptionFrame, sizeof(KEXCEPTION_FRAME)); /* Set up a trap frame from the context. */ KeContextToTrapFrame(Context, - NULL, + &InitFrame->ExceptionFrame, TrapFrame, CONTEXT_AMD64 | ContextFlags, UserMode);

4 years, 1 month

[reactos] 18/19: [NTOS:KE:X64] Zero out the context in KiDispatchException

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f66a7e2e482f6dbcf1710… commit f66a7e2e482f6dbcf171018a60e6807d5a66a6ba Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Mon Jan 6 00:51:43 2020 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:23:16 2020 +0100 [NTOS:KE:X64] Zero out the context in KiDispatchException --- ntoskrnl/ke/amd64/except.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/ntoskrnl/ke/amd64/except.c b/ntoskrnl/ke/amd64/except.c index 23ff7e016a9..40b01064d84 100644 --- a/ntoskrnl/ke/amd64/except.c +++ b/ntoskrnl/ke/amd64/except.c @@ -245,10 +245,13 @@ KiDispatchException(IN PEXCEPTION_RECORD ExceptionRecord, /* Increase number of Exception Dispatches */ KeGetCurrentPrcb()->KeExceptionDispatchCount++; + /* Zero out the context to avoid leaking kernel stack memor to user mode */ + RtlZeroMemory(&Context, sizeof(Context)); + /* Set the context flags */ Context.ContextFlags = CONTEXT_ALL; - /* Get a Context */ + /* Get the Context from the trap and exception frame */ KeTrapFrameToContext(TrapFrame, ExceptionFrame, &Context); /* Look at our exception code */

4 years, 1 month

[reactos] 17/19: [NTOS:KE:X64] Handle pending user APC on syscall exit (should be done on trap exit, too)

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=637183a12c6627f09d732… commit 637183a12c6627f09d732377142696628ef5bdec Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu Jun 27 18:07:58 2019 +0200 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:23:16 2020 +0100 [NTOS:KE:X64] Handle pending user APC on syscall exit (should be done on trap exit, too) --- ntoskrnl/ke/amd64/trap.S | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/ntoskrnl/ke/amd64/trap.S b/ntoskrnl/ke/amd64/trap.S index 9c3c085d2e7..731e21b250a 100644 --- a/ntoskrnl/ke/amd64/trap.S +++ b/ntoskrnl/ke/amd64/trap.S @@ -806,6 +806,13 @@ PUBLIC KiSystemServiceExit IntsEnabled: #endif + /* Check for pending user APC */ + mov rcx, gs:qword ptr [PcCurrentThread] + cmp byte ptr [rcx + ThApcState + AsUserApcPending], 0 + jz no_user_apc_pending + call KiInitiateUserApc +no_user_apc_pending: + /* Disable interrupts for return */ cli

4 years, 1 month

[reactos] 16/19: [NTOS:KE:X64][NTDLL:X64] Implement KiUserExceptionDispatcher and fix KiDispatchExceptionToUser

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2a8c680dbe6392fa8f21c… commit 2a8c680dbe6392fa8f21cbd44b7641cf4b6b074b Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu Apr 18 16:41:48 2019 +0200 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:23:16 2020 +0100 [NTOS:KE:X64][NTDLL:X64] Implement KiUserExceptionDispatcher and fix KiDispatchExceptionToUser --- dll/ntdll/dispatch/amd64/dispatch.S | 118 +++++++++++++++++++++++++++++++++++- ntoskrnl/ke/amd64/except.c | 47 +++++++------- sdk/include/ndk/amd64/ketypes.h | 12 ++++ 3 files changed, 152 insertions(+), 25 deletions(-) diff --git a/dll/ntdll/dispatch/amd64/dispatch.S b/dll/ntdll/dispatch/amd64/dispatch.S index 6d132df7755..86fe423ab2c 100644 --- a/dll/ntdll/dispatch/amd64/dispatch.S +++ b/dll/ntdll/dispatch/amd64/dispatch.S @@ -107,11 +107,125 @@ 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 - .endprolog - int 3 + ; 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 diff --git a/ntoskrnl/ke/amd64/except.c b/ntoskrnl/ke/amd64/except.c index ed0757d84fb..23ff7e016a9 100644 --- a/ntoskrnl/ke/amd64/except.c +++ b/ntoskrnl/ke/amd64/except.c @@ -100,10 +100,8 @@ KiDispatchExceptionToUser( IN PEXCEPTION_RECORD ExceptionRecord) { EXCEPTION_RECORD LocalExceptRecord; - ULONG Size; ULONG64 UserRsp; - PCONTEXT UserContext; - PEXCEPTION_RECORD UserExceptionRecord; + PKUSER_EXCEPTION_STACK UserStack; /* Make sure we have a valid SS */ if (TrapFrame->SegSs != (KGDT64_R3_DATA | RPL_MASK)) @@ -115,27 +113,29 @@ KiDispatchExceptionToUser( ExceptionRecord = &LocalExceptRecord; } - /* Calculate the size of the exception record */ - Size = FIELD_OFFSET(EXCEPTION_RECORD, ExceptionInformation) + - ExceptionRecord->NumberParameters * sizeof(ULONG64); - /* Get new stack pointer and align it to 16 bytes */ - UserRsp = (Context->Rsp - Size - sizeof(CONTEXT)) & ~15; + UserRsp = (Context->Rsp - sizeof(KUSER_EXCEPTION_STACK)) & ~15; - /* Get pointers to the usermode context and exception record */ - UserContext = (PVOID)UserRsp; - UserExceptionRecord = (PVOID)(UserRsp + sizeof(CONTEXT)); + /* Get pointer to the usermode context, exception record and machine frame */ + UserStack = (PKUSER_EXCEPTION_STACK)UserRsp; /* Set up the user-stack */ _SEH2_TRY { - /* Probe stack and copy Context */ - ProbeForWrite(UserContext, sizeof(CONTEXT), sizeof(ULONG64)); - *UserContext = *Context; - - /* Probe stack and copy exception record */ - ProbeForWrite(UserExceptionRecord, Size, sizeof(ULONG64)); - *UserExceptionRecord = *ExceptionRecord; + /* Probe the user stack frame and zero it out */ + ProbeForWrite(UserStack, sizeof(*UserStack), TYPE_ALIGNMENT(KUSER_EXCEPTION_STACK)); + RtlZeroMemory(UserStack, sizeof(*UserStack)); + + /* Copy Context and ExceptionFrame */ + UserStack->Context = *Context; + UserStack->ExceptionRecord = *ExceptionRecord; + + /* Setup the machine frame */ + UserStack->MachineFrame.Rip = Context->Rip; + UserStack->MachineFrame.SegCs = Context->SegCs; + UserStack->MachineFrame.EFlags = Context->EFlags; + UserStack->MachineFrame.Rsp = Context->Rsp; + UserStack->MachineFrame.SegSs = Context->SegSs; } _SEH2_EXCEPT((LocalExceptRecord = *_SEH2_GetExceptionInformation()->ExceptionRecord), EXCEPTION_EXECUTE_HANDLER) @@ -148,8 +148,8 @@ KiDispatchExceptionToUser( _SEH2_END; /* Now set the two params for the user-mode dispatcher */ - TrapFrame->Rcx = (ULONG64)UserContext; - TrapFrame->Rdx = (ULONG64)UserExceptionRecord; + TrapFrame->Rcx = (ULONG64)&UserStack->ExceptionRecord; + TrapFrame->Rdx = (ULONG64)&UserStack->Context; /* Set new Stack Pointer */ TrapFrame->Rsp = UserRsp; @@ -346,9 +346,10 @@ KiDispatchException(IN PEXCEPTION_RECORD ExceptionRecord, /* Forward exception to user mode debugger */ if (DbgkForwardException(ExceptionRecord, TRUE, FALSE)) return; - - //KiDispatchExceptionToUser() - __debugbreak(); + + /* Forward exception to user mode (does not return) */ + KiDispatchExceptionToUser(TrapFrame, &Context, ExceptionRecord); + NT_ASSERT(FALSE); } /* Try second chance */ diff --git a/sdk/include/ndk/amd64/ketypes.h b/sdk/include/ndk/amd64/ketypes.h index d2c4da16cc8..c989b4be0ca 100644 --- a/sdk/include/ndk/amd64/ketypes.h +++ b/sdk/include/ndk/amd64/ketypes.h @@ -998,6 +998,18 @@ typedef struct _UCALLOUT_FRAME MACHINE_FRAME MachineFrame; } UCALLOUT_FRAME, *PUCALLOUT_FRAME; // size = 0x0058 +// +// Stack frame layout for KiUserExceptionDispatcher +// The name is totally made up +// +typedef struct _KUSER_EXCEPTION_STACK +{ + CONTEXT Context; + EXCEPTION_RECORD ExceptionRecord; + ULONG64 Alignment; + MACHINE_FRAME MachineFrame; +} KUSER_EXCEPTION_STACK, * PKUSER_EXCEPTION_STACK; + typedef struct _DISPATCHER_CONTEXT { ULONG64 ControlPc;

4 years, 1 month

[reactos] 15/19: [NTOS:KE:X64] Zero out volatiles when returning from a system call

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=1bfacf06f7c215f2ada4c… commit 1bfacf06f7c215f2ada4c7870519aceee1e90768 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Tue May 15 14:07:12 2018 +0200 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:23:16 2020 +0100 [NTOS:KE:X64] Zero out volatiles when returning from a system call --- ntoskrnl/ke/amd64/trap.S | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/ntoskrnl/ke/amd64/trap.S b/ntoskrnl/ke/amd64/trap.S index 8efcd81d9d8..9c3c085d2e7 100644 --- a/ntoskrnl/ke/amd64/trap.S +++ b/ntoskrnl/ke/amd64/trap.S @@ -824,6 +824,16 @@ IntsEnabled: /* Swap gs back to user */ swapgs + ; Zero out volatiles + pxor xmm0, xmm0 + pxor xmm1, xmm1 + pxor xmm2, xmm2 + pxor xmm3, xmm3 + pxor xmm4, xmm4 + pxor xmm5, xmm5 + xor rdx, rdx + xor r10, r10 + /* return to user mode */ .byte HEX(48) // REX prefix to return to long mode sysret

4 years, 1 month

[reactos] 14/19: [NTOS:KE:X64][ASM:X64] Fix delivery of APCs

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a016ccd1171ecaa39bc0f… commit a016ccd1171ecaa39bc0f86edd451e32c716d2c7 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Mon Feb 12 20:53:15 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:23:16 2020 +0100 [NTOS:KE:X64][ASM:X64] Fix delivery of APCs - Deliver pending APCs on trap exit - Pass the trapframe of KiApcInterrupt to KiDeliverApcs, not NULL. - Fix parameter passing from KiSwapContext to KiSwapContextInternal and KiSwapContextResume, so that the ApcBypass parameter is not uninitialized - Fix return value of KiSwapContextResume to correctly indicate whether we want to have APCs directly delivered or not (when there are non, or when delivery is suppressed) --- ntoskrnl/ke/amd64/ctxswitch.S | 41 +++++++++++++++++++-------------------- ntoskrnl/ke/amd64/thrdini.c | 19 +++++++++--------- ntoskrnl/ke/amd64/trap.S | 45 ++++++++++++++++++++++++++++++++++++++++--- sdk/include/asm/trapamd64.inc | 6 ++++-- 4 files changed, 76 insertions(+), 35 deletions(-) diff --git a/ntoskrnl/ke/amd64/ctxswitch.S b/ntoskrnl/ke/amd64/ctxswitch.S index a8346021e89..a88188e00d0 100644 --- a/ntoskrnl/ke/amd64/ctxswitch.S +++ b/ntoskrnl/ke/amd64/ctxswitch.S @@ -11,6 +11,11 @@ #include <ksamd64.inc> +; BOOLEAN +; KiSwapContextResume( +; _In_ KIRQL WaitIrql, +; _In_ PKTHREAD OldThread, +; _In_ PKTHREAD NewThread) EXTERN KiSwapContextResume:PROC /* FUNCTIONS ****************************************************************/ @@ -118,23 +123,22 @@ PUBLIC KiThreadStartup * \brief * The KiSwapContextInternal routine switches context to another thread. * - * \param rcx - * Pointer to the KTHREAD to which the caller wishes to switch to. + * \param cl + * The IRQL at wich the old thread is suspended * * \param rdx * Pointer to the KTHREAD to which the caller wishes to switch from. * - * \param r8b - * APC bypass + * \param r8 + * Pointer to the KTHREAD to which the caller wishes to switch to. * * \return - * None. + * The WaitStatus of the Target Thread. * * \remarks * ... * *--*/ -PUBLIC KiSwapContextInternal .PROC KiSwapContextInternal push rbp @@ -143,22 +147,17 @@ PUBLIC KiSwapContextInternal .allocstack 6 * 8 .endprolog - /* Save APC bypass */ - mov [rsp + SwApcBypass], r8b + /* Save WaitIrql as KSWITCH_FRAME::ApcBypass */ + mov [rsp + SwApcBypass], cl /* Save kernel stack of old thread */ mov [rdx + KTHREAD_KernelStack], rsp - /* Save new thread in rbp */ - mov rbp, rcx - - //call KiSwapContextSuspend - /* Load stack of new thread */ - mov rsp, [rbp + KTHREAD_KernelStack] + mov rsp, [r8 + KTHREAD_KernelStack] /* Reload APC bypass */ - mov r8b, [rsp + SwApcBypass] + mov cl, [rsp + SwApcBypass] call KiSwapContextResume @@ -178,13 +177,13 @@ PUBLIC KiSwapContextInternal * The KiSwapContext routine switches context to another thread. * * BOOLEAN - * KiSwapContext(KIRQL WaitIrql, PKTHREAD CurrentThread); + * KiSwapContext(KIRQL WaitIrql, PKTHREAD OldThread); * - * \param WaitIrql <rcx> - * ... + * \param WaitIrql <cl> + * The IRQL at wich the old thread is suspended * - * \param CurrentThread <rdx> - * Pointer to the KTHREAD of the current thread. + * \param OldThread <rdx> + * Pointer to the KTHREAD of the previous thread. * * \return * The WaitStatus of the Target Thread. @@ -205,7 +204,7 @@ PUBLIC KiSwapContext GENERATE_EXCEPTION_FRAME /* Do the swap with the registers correctly setup */ - mov rcx, gs:[PcCurrentThread] /* Pointer to the new thread */ + mov r8, gs:[PcCurrentThread] /* Pointer to the new thread */ call KiSwapContextInternal /* Restore the registers from the KEXCEPTION_FRAME */ diff --git a/ntoskrnl/ke/amd64/thrdini.c b/ntoskrnl/ke/amd64/thrdini.c index c064d8aba16..6548a385651 100644 --- a/ntoskrnl/ke/amd64/thrdini.c +++ b/ntoskrnl/ke/amd64/thrdini.c @@ -137,9 +137,9 @@ KiInitializeContextThread(IN PKTHREAD Thread, BOOLEAN KiSwapContextResume( - IN PKTHREAD NewThread, - IN PKTHREAD OldThread, - IN BOOLEAN ApcBypass) + _In_ BOOLEAN ApcBypass, + _In_ PKTHREAD OldThread, + _In_ PKTHREAD NewThread) { PKIPCR Pcr = (PKIPCR)KeGetPcr(); PKPROCESS OldProcess, NewProcess; @@ -187,14 +187,15 @@ KiSwapContextResume( if (NewThread->ApcState.KernelApcPending) { /* Are APCs enabled? */ - if (!NewThread->SpecialApcDisable) + if ((NewThread->SpecialApcDisable == 0) && + (ApcBypass == 0)) { - /* Request APC delivery */ - if (!ApcBypass) - HalRequestSoftwareInterrupt(APC_LEVEL); - else - return TRUE; + /* 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*/ diff --git a/ntoskrnl/ke/amd64/trap.S b/ntoskrnl/ke/amd64/trap.S index 7dbe7a291f4..8efcd81d9d8 100644 --- a/ntoskrnl/ke/amd64/trap.S +++ b/ntoskrnl/ke/amd64/trap.S @@ -592,7 +592,7 @@ PUBLIC KiApcInterrupt mov cl, [rbp + KTRAP_FRAME_SegCs] // ProcessorMode and cl, 1 mov rdx, 0 // ExceptionFrame - mov r8, rdx // TrapFrame + mov r8, rbp // TrapFrame call KiDeliverApc /* Disable interrupts */ @@ -1000,8 +1000,47 @@ KiConvertToGuiThreadFailed: ENDFUNC -KiExitToUserApc: - int 3 +; +; VOID +; KiDeliverApc( +; _In_ KPROCESSOR_MODE DeliveryMode, +; _In_ PKEXCEPTION_FRAME ExceptionFrame, +; _In_ PKTRAP_FRAME TrapFrame); +; +EXTERN KiDeliverApc:PROC + +PUBLIC KiInitiateUserApc +.PROC KiInitiateUserApc + + ; Generate a KEXCEPTION_FRAME on the stack + GENERATE_EXCEPTION_FRAME + + ; Raise IRQL to APC_LEVEL + mov rax, APC_LEVEL + mov cr8, rax + + ; Enable interrupts + sti + + ; Get the current trap frame + mov rax, gs:[PcCurrentThread] + mov r8, [rax + KTHREAD_TrapFrame] + + ; Call the C function + mov ecx, 1 + mov rdx, rsp + call KiDeliverApc + + ; Disable interrupts again + cli + + ; Restore the registers from the KEXCEPTION_FRAME + RESTORE_EXCEPTION_STATE + + ; Return + ret + +.ENDP PUBLIC KiInitializeSegments diff --git a/sdk/include/asm/trapamd64.inc b/sdk/include/asm/trapamd64.inc index f5ae982a380..4774fc09076 100644 --- a/sdk/include/asm/trapamd64.inc +++ b/sdk/include/asm/trapamd64.inc @@ -150,6 +150,7 @@ ENDM MACRO(ExitTrap, Flags) LOCAL kernel_mode_return LOCAL IntsEnabled + LOCAL NoUserApc #if DBG /* Check previous irql */ @@ -181,8 +182,9 @@ MACRO(ExitTrap, Flags) /* Load current thread into r10 */ mov r10, gs:[PcCurrentThread] cmp byte ptr [r10 + KTHREAD_UserApcPending], 0 - jne KiExitToUserApc - + je NoUserApc + call KiInitiateUserApc + NoUserApc: endif #if DBG

4 years, 1 month

[reactos] 13/19: [NTOS:KE:X64][NTDLL:X64] Implement x64 version of user callback code

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=fdc1261fb77879cde0afb… commit fdc1261fb77879cde0afb14912f928a44b5b6305 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Mon Feb 5 01:26:11 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Oct 31 14:23:16 2020 +0100 [NTOS:KE:X64][NTDLL:X64] Implement x64 version of user callback code --- dll/ntdll/dispatch/amd64/dispatch.S | 47 +++++- dll/ntdll/dispatch/amd64/stubs.c | 67 -------- ntoskrnl/include/internal/amd64/ke.h | 7 + ntoskrnl/ke/amd64/ctxswitch.S | 62 +------- ntoskrnl/ke/amd64/stubs.c | 39 ----- ntoskrnl/ke/amd64/trap.S | 70 +++++---- ntoskrnl/ke/amd64/usercall.c | 290 +++++++++++++++++++++++++++++++++++ ntoskrnl/ke/amd64/usercall_asm.S | 75 +++++++++ ntoskrnl/ntos.cmake | 3 +- 9 files changed, 466 insertions(+), 194 deletions(-) diff --git a/dll/ntdll/dispatch/amd64/dispatch.S b/dll/ntdll/dispatch/amd64/dispatch.S index f433c5fb22e..6d132df7755 100644 --- a/dll/ntdll/dispatch/amd64/dispatch.S +++ b/dll/ntdll/dispatch/amd64/dispatch.S @@ -14,6 +14,8 @@ EXTERN NtContinue:PROC EXTERN LdrpInit:PROC +EXTERN ZwCallbackReturn:PROC +EXTERN RtlRaiseStatus:PROC .code @@ -59,8 +61,49 @@ PUBLIC KiRaiseUserExceptionDispatcher PUBLIC KiUserCallbackDispatcher .PROC KiUserCallbackDispatcher - .endprolog - int 3 + + ; 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 diff --git a/dll/ntdll/dispatch/amd64/stubs.c b/dll/ntdll/dispatch/amd64/stubs.c deleted file mode 100644 index b5af8f7ba2e..00000000000 --- a/dll/ntdll/dispatch/amd64/stubs.c +++ /dev/null @@ -1,67 +0,0 @@ -/* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS NT Library - * FILE: dll/ntdll/dispatch/amd64/stubs.c - * PURPOSE: AMD64 stubs - * PROGRAMMERS: Stefan Ginsberg (stefan.ginsberg(a)reactos.org) - */ - -/* INCLUDES *****************************************************************/ - -#include <ntdll.h> -#define NDEBUG -#include <debug.h> - -/* PUBLIC FUNCTIONS **********************************************************/ - -/* - * @unimplemented - */ -VOID -NTAPI -LdrInitializeThunk(ULONG Unknown1, // FIXME: Parameters! - ULONG Unknown2, - ULONG Unknown3, - ULONG Unknown4) -{ - UNIMPLEMENTED; - return; -} - -/* - * @unimplemented - */ -VOID -NTAPI -KiUserApcDispatcher(IN PVOID NormalRoutine, - IN PVOID NormalContext, - IN PVOID SystemArgument1, - IN PVOID SystemArgument2) -{ - UNIMPLEMENTED; - return; -} - -VOID -NTAPI -KiRaiseUserExceptionDispatcher(VOID) -{ - UNIMPLEMENTED; - return; -} - -VOID -NTAPI -KiUserCallbackDispatcher(VOID) -{ - UNIMPLEMENTED; - return; -} - -VOID -NTAPI -KiUserExceptionDispatcher(VOID) -{ - UNIMPLEMENTED; - return; -} diff --git a/ntoskrnl/include/internal/amd64/ke.h b/ntoskrnl/include/internal/amd64/ke.h index 21a2c66a4f2..fa0408b921e 100644 --- a/ntoskrnl/include/internal/amd64/ke.h +++ b/ntoskrnl/include/internal/amd64/ke.h @@ -383,6 +383,13 @@ HalAllocateAdapterChannel( IN ULONG NumberOfMapRegisters, IN PDRIVER_CONTROL ExecutionRoutine); +FORCEINLINE +PULONG_PTR +KiGetUserModeStackAddress(void) +{ + return &PsGetCurrentThread()->Tcb.TrapFrame->Rsp; +} + #endif /* __NTOSKRNL_INCLUDE_INTERNAL_AMD64_KE_H */ /* EOF */ diff --git a/ntoskrnl/ke/amd64/ctxswitch.S b/ntoskrnl/ke/amd64/ctxswitch.S index b91f314ced9..a8346021e89 100644 --- a/ntoskrnl/ke/amd64/ctxswitch.S +++ b/ntoskrnl/ke/amd64/ctxswitch.S @@ -9,7 +9,6 @@ /* INCLUDES ******************************************************************/ -#include <asm.inc> #include <ksamd64.inc> EXTERN KiSwapContextResume:PROC @@ -202,66 +201,17 @@ PUBLIC KiSwapContextInternal PUBLIC KiSwapContext .PROC KiSwapContext - /* Allocate a KEXCEPTION_FRAME on the stack (+8 for proper alignment) */ - sub rsp, KEXCEPTION_FRAME_LENGTH + 8 - .allocstack KEXCEPTION_FRAME_LENGTH + 8 - - /* save non-volatiles in KEXCEPTION_FRAME */ - mov [rsp + KEXCEPTION_FRAME_Rbp], rbp - .savereg rbp, KEXCEPTION_FRAME_Rbp - mov [rsp + KEXCEPTION_FRAME_Rbx], rbx - .savereg rbx, KEXCEPTION_FRAME_Rbx - mov [rsp + KEXCEPTION_FRAME_Rdi], rdi - .savereg rdi, KEXCEPTION_FRAME_Rdi - mov [rsp + KEXCEPTION_FRAME_Rsi], rsi - .savereg rsi, KEXCEPTION_FRAME_Rsi - mov [rsp + KEXCEPTION_FRAME_R12], r12 - .savereg r12, KEXCEPTION_FRAME_R12 - mov [rsp + KEXCEPTION_FRAME_R13], r13 - .savereg r13, KEXCEPTION_FRAME_R13 - mov [rsp + KEXCEPTION_FRAME_R14], r14 - .savereg r14, KEXCEPTION_FRAME_R14 - mov [rsp + KEXCEPTION_FRAME_R15], r15 - .savereg r15, KEXCEPTION_FRAME_R15 - movdqa [rsp + KEXCEPTION_FRAME_Xmm6], xmm6 - movdqa [rsp + KEXCEPTION_FRAME_Xmm7], xmm7 - movdqa [rsp + KEXCEPTION_FRAME_Xmm8], xmm8 - movdqa [rsp + KEXCEPTION_FRAME_Xmm9], xmm9 - movdqa [rsp + KEXCEPTION_FRAME_Xmm10], xmm10 - movdqa [rsp + KEXCEPTION_FRAME_Xmm11], xmm11 - movdqa [rsp + KEXCEPTION_FRAME_Xmm12], xmm12 - movdqa [rsp + KEXCEPTION_FRAME_Xmm13], xmm13 - movdqa [rsp + KEXCEPTION_FRAME_Xmm14], xmm14 - movdqa [rsp + KEXCEPTION_FRAME_Xmm15], xmm15 - // KEXCEPTION_FRAME_MxCsr - .endprolog + /* Generate a KEXCEPTION_FRAME on the stack */ + GENERATE_EXCEPTION_FRAME /* Do the swap with the registers correctly setup */ mov rcx, gs:[PcCurrentThread] /* Pointer to the new thread */ call KiSwapContextInternal - /* restore non-volatile registers */ - mov rbp, [rsp + KEXCEPTION_FRAME_Rbp] - mov rbx, [rsp + KEXCEPTION_FRAME_Rbx] - mov rdi, [rsp + KEXCEPTION_FRAME_Rdi] - mov rsi, [rsp + KEXCEPTION_FRAME_Rsi] - mov r12, [rsp + KEXCEPTION_FRAME_R12] - mov r13, [rsp + KEXCEPTION_FRAME_R13] - mov r14, [rsp + KEXCEPTION_FRAME_R14] - mov r15, [rsp + KEXCEPTION_FRAME_R15] - movdqa xmm6, [rsp + KEXCEPTION_FRAME_Xmm6] - movdqa xmm7, [rsp + KEXCEPTION_FRAME_Xmm7] - movdqa xmm8, [rsp + KEXCEPTION_FRAME_Xmm8] - movdqa xmm9, [rsp + KEXCEPTION_FRAME_Xmm9] - movdqa xmm10, [rsp + KEXCEPTION_FRAME_Xmm10] - movdqa xmm11, [rsp + KEXCEPTION_FRAME_Xmm11] - movdqa xmm12, [rsp + KEXCEPTION_FRAME_Xmm12] - movdqa xmm13, [rsp + KEXCEPTION_FRAME_Xmm13] - movdqa xmm14, [rsp + KEXCEPTION_FRAME_Xmm14] - movdqa xmm15, [rsp + KEXCEPTION_FRAME_Xmm15] - - /* Clean stack and return */ - add rsp, KEXCEPTION_FRAME_LENGTH + 8 + /* Restore the registers from the KEXCEPTION_FRAME */ + RESTORE_EXCEPTION_STATE + + /* Return */ ret .ENDP diff --git a/ntoskrnl/ke/amd64/stubs.c b/ntoskrnl/ke/amd64/stubs.c index 185d68988de..c99a0efcfac 100644 --- a/ntoskrnl/ke/amd64/stubs.c +++ b/ntoskrnl/ke/amd64/stubs.c @@ -167,20 +167,6 @@ KiSwitchKernelStack(PVOID StackBase, PVOID StackLimit) return OldStackBase; } - -NTSTATUS -NTAPI -KeUserModeCallback(IN ULONG RoutineIndex, - IN PVOID Argument, - IN ULONG ArgumentLength, - OUT PVOID *Result, - OUT PULONG ResultLength) -{ - UNIMPLEMENTED; - __debugbreak(); - return STATUS_UNSUCCESSFUL; -} - VOID FASTCALL KiIdleLoop(VOID) @@ -426,17 +412,6 @@ KiSystemService(IN PKTHREAD Thread, __debugbreak(); } -NTSYSAPI -NTSTATUS -NTAPI -NtCallbackReturn -( IN PVOID Result OPTIONAL, IN ULONG ResultLength, IN NTSTATUS Status ) -{ - UNIMPLEMENTED; - __debugbreak(); - return STATUS_UNSUCCESSFUL; -} - NTSTATUS NTAPI NtSetLdtEntries @@ -456,18 +431,4 @@ NtVdmControl(IN ULONG ControlCode, return STATUS_NOT_IMPLEMENTED; } -NTSTATUS -NTAPI -KiCallUserMode( - IN PVOID *OutputBuffer, - IN PULONG OutputLength) -{ - UNIMPLEMENTED; - __debugbreak(); - return STATUS_UNSUCCESSFUL; -} - -ULONG ProcessCount; -BOOLEAN CcPfEnablePrefetcher; - diff --git a/ntoskrnl/ke/amd64/trap.S b/ntoskrnl/ke/amd64/trap.S index d361acb1fb1..7dbe7a291f4 100644 --- a/ntoskrnl/ke/amd64/trap.S +++ b/ntoskrnl/ke/amd64/trap.S @@ -787,6 +787,15 @@ PUBLIC KiSystemCallEntry64 mov r9, [rsp + MAX_SYSCALL_PARAM_SIZE + KTRAP_FRAME_R9] call rax +.ENDP + +PUBLIC KiSystemServiceExit +.PROC KiSystemServiceExit + + /* Old stack pointer is in rcx, lie and say we saved it in rbp */ + .setframe rbp, 0 + .endprolog + #if DBG /* Restore rbp */ mov rbp, [rsp + MAX_SYSCALL_PARAM_SIZE + KTRAP_FRAME_Rbp] @@ -822,6 +831,38 @@ IntsEnabled: .ENDP +/*! + * VOID + * DECLSPEC_NORETURN + * KiServiceExit(IN PKTRAP_FRAME TrapFrame, IN NTSTATUS Status)); + */ +PUBLIC KiServiceExit +.PROC KiServiceExit + .endprolog + + lea rsp, [rcx - MAX_SYSCALL_PARAM_SIZE] + jmp KiSystemServiceExit + +.ENDP + + +/*! + * VOID + * DECLSPEC_NORETURN + * KiServiceExit2(IN PKTRAP_FRAME TrapFrame); + */ +PUBLIC KiServiceExit2 +.PROC KiServiceExit2 + .ENDPROLOG + + mov rbp, rcx + mov rsp, rcx + + /* Return */ + ExitTrap TF_SAVE_ALL +.ENDP + + PUBLIC KiSystemCallEntry32 KiSystemCallEntry32: swapgs @@ -962,35 +1003,6 @@ ENDFUNC KiExitToUserApc: int 3 -/*! - * VOID - * DECLSPEC_NORETURN - * KiServiceExit(IN PKTRAP_FRAME TrapFrame, IN NTSTATUS Status)); - */ -PUBLIC KiServiceExit -KiServiceExit: - mov [rcx + KTRAP_FRAME_Rax], rdx - mov rbp, rcx - mov rsp, rcx - - /* Return */ - //ExitTrap TF_SAVE_ALL - -/*! - * VOID - * DECLSPEC_NORETURN - * KiServiceExit2(IN PKTRAP_FRAME TrapFrame); - */ -PUBLIC KiServiceExit2 -.PROC KiServiceExit2 - .ENDPROLOG - - mov rbp, rcx - mov rsp, rcx - - /* Return */ - ExitTrap TF_SAVE_ALL -.ENDP PUBLIC KiInitializeSegments KiInitializeSegments: diff --git a/ntoskrnl/ke/amd64/usercall.c b/ntoskrnl/ke/amd64/usercall.c index 38517cb58fc..42976d340ef 100644 --- a/ntoskrnl/ke/amd64/usercall.c +++ b/ntoskrnl/ke/amd64/usercall.c @@ -106,3 +106,293 @@ KiInitializeUserApc( TrapFrame->EFlags &= EFLAGS_USER_SANITIZE; TrapFrame->EFlags |= EFLAGS_INTERRUPT_MASK; } + +/* + * Stack layout for KiUserModeCallout: + * ---------------------------------- + * KCALLOUT_FRAME.ResultLength <= 2nd Parameter to KiCallUserMode + * KCALLOUT_FRAME.Result <= 1st Parameter to KiCallUserMode + * KCALLOUT_FRAME.ReturnAddress <= Return address of KiCallUserMode + * KCALLOUT_FRAME.Ebp \ + * KCALLOUT_FRAME.Ebx | = non-volatile registers, pushed + * KCALLOUT_FRAME.Esi | by KiCallUserMode + * KCALLOUT_FRAME.Edi / + * KCALLOUT_FRAME.CallbackStack + * KCALLOUT_FRAME.TrapFrame + * KCALLOUT_FRAME.InitialStack <= CalloutFrame points here + * ---------------------------------- + * ~~ optional alignment ~~ + * ---------------------------------- + * FX_SAVE_AREA + * ---------------------------------- + * KTRAP_FRAME + * ---------------------------------- + * ~~ begin of stack frame for KiUserModeCallout ~~ + * + */ +NTSTATUS +FASTCALL +KiUserModeCallout( + _Out_ PKCALLOUT_FRAME CalloutFrame) +{ + PKTHREAD CurrentThread; + PKTRAP_FRAME TrapFrame; + KTRAP_FRAME CallbackTrapFrame; + PKIPCR Pcr; + ULONG_PTR InitialStack; + NTSTATUS Status; + + /* Get the current thread */ + CurrentThread = KeGetCurrentThread(); + + /* Check if we are at pasive level */ + ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL); + + /* Check if we are attached or APCs are disabled */ + ASSERT((CurrentThread->ApcStateIndex == OriginalApcEnvironment) && + (CurrentThread->CombinedApcDisable == 0)); + + /* Align stack on a 16-byte boundary */ + InitialStack = (ULONG_PTR)ALIGN_DOWN_POINTER_BY(CalloutFrame, 16); + + /* Check if we have enough space on the stack */ + if ((InitialStack - KERNEL_STACK_SIZE) < CurrentThread->StackLimit) + { + /* We don't, we'll have to grow our stack */ + Status = MmGrowKernelStack((PVOID)InitialStack); + + /* Quit if we failed */ + if (!NT_SUCCESS(Status)) return Status; + } + + /* Save the current callback stack and initial stack */ + CalloutFrame->CallbackStack = (ULONG_PTR)CurrentThread->CallbackStack; + CalloutFrame->InitialStack = (ULONG_PTR)CurrentThread->InitialStack; + + /* Get and save the trap frame */ + TrapFrame = CurrentThread->TrapFrame; + CalloutFrame->TrapFrame = (ULONG_PTR)TrapFrame; + + /* Set the new callback stack */ + CurrentThread->CallbackStack = CalloutFrame; + + /* Disable interrupts so we can fill the NPX State */ + _disable(); + + /* Set the stack address */ + CurrentThread->InitialStack = (PVOID)InitialStack; + + /* Copy the trap frame to the new location */ + CallbackTrapFrame = *TrapFrame; + + /* Get PCR */ + Pcr = (PKIPCR)KeGetPcr(); + + /* Set user-mode dispatcher address as EIP */ + Pcr->TssBase->Rsp0 = InitialStack; + Pcr->Prcb.RspBase = InitialStack; + CallbackTrapFrame.Rip = (ULONG_PTR)KeUserCallbackDispatcher; + + /* Bring interrupts back */ + _enable(); + + /* Exit to user-mode */ + KiServiceExit(&CallbackTrapFrame, 0); +} + +VOID +KiSetupUserCalloutFrame( + _Out_ PUCALLOUT_FRAME UserCalloutFrame, + _In_ PKTRAP_FRAME TrapFrame, + _In_ ULONG ApiNumber, + _In_ PVOID Buffer, + _In_ ULONG BufferLength) +{ +#ifdef _M_IX86 + CalloutFrame->Reserved = 0; + CalloutFrame->ApiNumber = ApiNumber; + CalloutFrame->Buffer = (ULONG_PTR)NewStack; + CalloutFrame->Length = ArgumentLength; +#elif defined(_M_AMD64) + UserCalloutFrame->Buffer = (PVOID)(UserCalloutFrame + 1); + UserCalloutFrame->Length = BufferLength; + UserCalloutFrame->ApiNumber = ApiNumber; + UserCalloutFrame->MachineFrame.Rip = TrapFrame->Rip; + UserCalloutFrame->MachineFrame.Rsp = TrapFrame->Rsp; +#else +#error "KiSetupUserCalloutFrame not implemented!" +#endif +} + +NTSTATUS +NTAPI +KeUserModeCallback( + IN ULONG RoutineIndex, + IN PVOID Argument, + IN ULONG ArgumentLength, + OUT PVOID *Result, + OUT PULONG ResultLength) +{ + ULONG_PTR OldStack; + PUCHAR UserArguments; + PUCALLOUT_FRAME CalloutFrame; + PULONG_PTR UserStackPointer; + NTSTATUS CallbackStatus; +#ifdef _M_IX86 + PEXCEPTION_REGISTRATION_RECORD ExceptionList; +#endif // _M_IX86 + PTEB Teb; + ULONG GdiBatchCount = 0; + ASSERT(KeGetCurrentThread()->ApcState.KernelApcInProgress == FALSE); + ASSERT(KeGetPreviousMode() == UserMode); + + /* Get the current user-mode stack */ + UserStackPointer = KiGetUserModeStackAddress(); + OldStack = *UserStackPointer; + + /* Enter a SEH Block */ + _SEH2_TRY + { + /* Calculate and align the stack size */ + UserArguments = (PUCHAR)ALIGN_DOWN_POINTER_BY(OldStack - ArgumentLength, sizeof(PVOID)); + + /* The callout frame is below the arguments */ + CalloutFrame = ((PUCALLOUT_FRAME)UserArguments) - 1; + + /* Make sure it's all writable */ + ProbeForWrite(CalloutFrame, + sizeof(PUCALLOUT_FRAME) + ArgumentLength, + sizeof(PVOID)); + + /* Copy the buffer into the stack */ + RtlCopyMemory(UserArguments, Argument, ArgumentLength); + + /* Write the arguments */ + KiSetupUserCalloutFrame(CalloutFrame, + KeGetCurrentThread()->TrapFrame, + RoutineIndex, + UserArguments, + ArgumentLength); + + /* Save the exception list */ + Teb = KeGetCurrentThread()->Teb; +#ifdef _M_IX86 + ExceptionList = Teb->NtTib.ExceptionList; +#endif // _M_IX86 + + /* Jump to user mode */ + *UserStackPointer = (ULONG_PTR)CalloutFrame; + CallbackStatus = KiCallUserMode(Result, ResultLength); + if (CallbackStatus != STATUS_CALLBACK_POP_STACK) + { +#ifdef _M_IX86 + /* Only restore the exception list if we didn't crash in ring 3 */ + Teb->NtTib.ExceptionList = ExceptionList; +#endif // _M_IX86 + } + else + { + /* Otherwise, pop the stack */ + OldStack = *UserStackPointer; + } + + /* Read the GDI Batch count */ + GdiBatchCount = Teb->GdiBatchCount; + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + /* Get the SEH exception */ + _SEH2_YIELD(return _SEH2_GetExceptionCode()); + } + _SEH2_END; + + /* Check if we have GDI Batch operations */ + if (GdiBatchCount) + { + *UserStackPointer -= 256; + KeGdiFlushUserBatch(); + } + + /* Restore stack and return */ + *UserStackPointer = OldStack; +#ifdef _M_AMD64 // could probably move the update to TrapFrame->Rsp from the C handler to the asm code + __writegsqword(FIELD_OFFSET(KIPCR, UserRsp), OldStack); +#endif + return CallbackStatus; +} + +NTSTATUS +NTAPI +NtCallbackReturn( + _In_ PVOID Result, + _In_ ULONG ResultLength, + _In_ NTSTATUS CallbackStatus) +{ + PKTHREAD CurrentThread; + PKCALLOUT_FRAME CalloutFrame; + PKTRAP_FRAME CallbackTrapFrame, TrapFrame; + PKIPCR Pcr; + + /* Get the current thread and make sure we have a callback stack */ + CurrentThread = KeGetCurrentThread(); + CalloutFrame = CurrentThread->CallbackStack; + if (CalloutFrame == NULL) + { + return STATUS_NO_CALLBACK_ACTIVE; + } + + /* Store the results in the callback stack */ + *((PVOID*)CalloutFrame->OutputBuffer) = Result; + *((ULONG*)CalloutFrame->OutputLength) = ResultLength; + + /* Get the trap frame */ + CallbackTrapFrame = CurrentThread->TrapFrame; + + /* Disable interrupts for NPX save and stack switch */ + _disable(); + + /* Restore the exception list */ + Pcr = (PKIPCR)KeGetPcr(); + + /* Get the previous trap frame */ + TrapFrame = (PKTRAP_FRAME)CalloutFrame->TrapFrame; + + /* Check if we failed in user mode */ + if (CallbackStatus == STATUS_CALLBACK_POP_STACK) + { + *TrapFrame = *CallbackTrapFrame; + } + + /* Clear DR7 */ + TrapFrame->Dr7 = 0; + + /* Check if debugging was active */ + if (CurrentThread->Header.DebugActive & 0xFF) + { + /* Copy debug registers data from it */ + TrapFrame->Dr0 = CallbackTrapFrame->Dr0; + TrapFrame->Dr1 = CallbackTrapFrame->Dr1; + TrapFrame->Dr2 = CallbackTrapFrame->Dr2; + TrapFrame->Dr3 = CallbackTrapFrame->Dr3; + TrapFrame->Dr6 = CallbackTrapFrame->Dr6; + TrapFrame->Dr7 = CallbackTrapFrame->Dr7; + } + + /* Switch the stack back to the previous value */ + Pcr->TssBase->Rsp0 = CalloutFrame->InitialStack; + Pcr->Prcb.RspBase = CalloutFrame->InitialStack; + + /* Get the initial stack and restore it */ + CurrentThread->InitialStack = (PVOID)CalloutFrame->InitialStack; + + /* Restore the trap frame and the previous callback stack */ + CurrentThread->TrapFrame = TrapFrame; + CurrentThread->CallbackStack = (PVOID)CalloutFrame->CallbackStack; + + /* Bring interrupts back */ + _enable(); + + /* Now switch back to the old stack */ + KiCallbackReturn(CalloutFrame, CallbackStatus); +} + diff --git a/ntoskrnl/ke/amd64/usercall_asm.S b/ntoskrnl/ke/amd64/usercall_asm.S new file mode 100644 index 00000000000..2d894161fed --- /dev/null +++ b/ntoskrnl/ke/amd64/usercall_asm.S @@ -0,0 +1,75 @@ +;++ +; PROJECT: ReactOS Kernel +; LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) +; PURPOSE: ReactOS AMD64 user mode callback helper +; COPYRIGHT: Timo Kreuzer (timo.kreuzer(a)reactos.org) +;-- + +#include <ksamd64.inc> + +; +; NTSTATUS +; KiUserModeCallout ( +; _Inout_ PKCALLOUT_FRAME CalloutFrame); +; +EXTERN KiUserModeCallout:PROC + +.code64 + +; +; NTSTATUS +; KiCallUserMode ( +; _In_ PVOID *OutputBuffer@<rcx>, +; _In_ PULONG OutputLength@<rdx>); +; +PUBLIC KiCallUserMode +.PROC KiCallUserMode + + ; Generate a KEXCEPTION_FRAME on the stack + ; This is identical to a KCALLOUT_FRAME + GENERATE_EXCEPTION_FRAME + + ; Save OutputBuffer and OutputLength + mov [rsp + ExOutputBuffer], rcx + mov [rsp + ExOutputLength], rdx + + ; Call the C function + mov rcx, rsp + call KiUserModeCallout + + ; Restore the registers from the KEXCEPTION_FRAME + RESTORE_EXCEPTION_STATE + + ; Return + ret + +.ENDP + +; +; DECLSPEC_NORETURN +; VOID +; KiCallbackReturn ( +; _In_ PVOID Stack, +; _In_ NTSTATUS Status); +; +PUBLIC KiCallbackReturn +.PROC KiCallbackReturn + + .ENDPROLOG + + ; Restore the stack + mov rsp, rcx + + ; Set return status + mov eax, edx + + ; Restore the registers from the KEXCEPTION_FRAME + RESTORE_EXCEPTION_STATE + + ; Return + ret + +.ENDP + + +END diff --git a/ntoskrnl/ntos.cmake b/ntoskrnl/ntos.cmake index c69c284cdf2..6b2a127c2fd 100644 --- a/ntoskrnl/ntos.cmake +++ b/ntoskrnl/ntos.cmake @@ -314,7 +314,8 @@ elseif(ARCH STREQUAL "amd64") list(APPEND ASM_SOURCE ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/boot.S ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/ctxswitch.S - ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/trap.S) + ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/trap.S + ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/usercall_asm.S) list(APPEND SOURCE ${REACTOS_SOURCE_DIR}/ntoskrnl/config/i386/cmhardwr.c ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/context.c

4 years, 1 month

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs October 2020