Ros-diffs June 2021

ros-diffs@reactos.org

19 participants
228 discussions

[reactos] 01/01: [RTL][KMTEST] RtlPcToFileHeader doesn't handle user mode images in kernel mode

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=20c1da7963debb69a46cf… commit 20c1da7963debb69a46cf9f19f3e4c5e504c7fc9 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu May 10 21:37:30 2018 +0200 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 14:39:29 2021 +0200 [RTL][KMTEST] RtlPcToFileHeader doesn't handle user mode images in kernel mode --- modules/rostests/kmtests/rtl/RtlStack.c | 64 +++++++++++++++++++++++++++++++++ ntoskrnl/rtl/libsupp.c | 11 ++++-- 2 files changed, 73 insertions(+), 2 deletions(-) diff --git a/modules/rostests/kmtests/rtl/RtlStack.c b/modules/rostests/kmtests/rtl/RtlStack.c index 45db416e152..273be2cc283 100644 --- a/modules/rostests/kmtests/rtl/RtlStack.c +++ b/modules/rostests/kmtests/rtl/RtlStack.c @@ -130,7 +130,71 @@ TestStackWalk1(VOID) TestStackWalk2(); } +#ifdef _M_AMD64 +NTSYSAPI +PVOID +NTAPI +RtlPcToFileHeader( + _In_ PVOID PcValue, + _Out_ PVOID *BaseOfImage); + +extern char __ImageBase; + +DECLSPEC_NOINLINE +static +VOID +TestRtlPcToFileHeader(VOID) +{ + PVOID ImageBase, Result; + PTEB Teb; + PPEB Peb; + + /* First test a function from this image */ + Result = RtlPcToFileHeader(&TestRtlPcToFileHeader, &ImageBase); + ok_eq_pointer(Result, ImageBase); + ok_eq_pointer(ImageBase, &__ImageBase); + +#ifdef NTOS_MODE_USER + Teb = NtCurrentTeb(); +#else + Teb = KeGetCurrentThread()->Teb; +#endif + ok(Teb != NULL, "Teb is NULL!\n"); + if (Teb == NULL) + { + return; + } + + _SEH2_TRY + { + Peb = Teb->ProcessEnvironmentBlock; + ok(Peb != NULL, "Peb is NULL!\n"); + if (Peb == NULL) + { + return; + } + + /* Test an address somewhere within the main image of the current process */ + Result = RtlPcToFileHeader((PUCHAR)Peb->ImageBaseAddress + 0x1000, &ImageBase); + ok_eq_pointer(Result, ImageBase); +#ifdef NTOS_MODE_USER + ok_eq_pointer(ImageBase, Peb->ImageBaseAddress); +#else + ok_eq_pointer(ImageBase, NULL); +#endif + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + ok(FALSE, "Got an exception!\n"); + } + _SEH2_END +} +#endif // _M_AMD64 + START_TEST(RtlStack) { TestStackWalk1(); +#ifdef _M_AMD64 + TestRtlPcToFileHeader(); +#endif // _M_AMD64 } diff --git a/ntoskrnl/rtl/libsupp.c b/ntoskrnl/rtl/libsupp.c index c1ded68d35c..432b9185b40 100644 --- a/ntoskrnl/rtl/libsupp.c +++ b/ntoskrnl/rtl/libsupp.c @@ -37,17 +37,24 @@ RtlPcToFileHeader( { PLDR_DATA_TABLE_ENTRY LdrEntry; BOOLEAN InSystem; + KIRQL OldIrql; /* Get the base for this file */ if ((ULONG_PTR)PcValue > (ULONG_PTR)MmHighestUserAddress) { + /* Acquire the loaded module spinlock */ + KeAcquireSpinLock(&PsLoadedModuleSpinLock, &OldIrql); + /* We are in kernel */ *BaseOfImage = KiPcToFileHeader(PcValue, &LdrEntry, FALSE, &InSystem); + + /* Release lock */ + KeReleaseSpinLock(&PsLoadedModuleSpinLock, OldIrql); } else { - /* We are in user land */ - *BaseOfImage = KiRosPcToUserFileHeader(PcValue, &LdrEntry); + /* User mode is not handled here! */ + *BaseOfImage = NULL; } return *BaseOfImage;

3 years, 4 months

[reactos] 07/07: [RTL] Fix RtlWalkFrameChain and wrap it in SEH

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3cf2bea0def78939382f0… commit 3cf2bea0def78939382f0aa4045c6d7cef2b3ef2 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Wed Mar 7 15:38:24 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 13:52:42 2021 +0200 [RTL] Fix RtlWalkFrameChain and wrap it in SEH --- sdk/lib/rtl/amd64/unwind.c | 100 +++++++++++++++++++++++++++------------------ 1 file changed, 61 insertions(+), 39 deletions(-) diff --git a/sdk/lib/rtl/amd64/unwind.c b/sdk/lib/rtl/amd64/unwind.c index 859ef783043..87e370ed89f 100644 --- a/sdk/lib/rtl/amd64/unwind.c +++ b/sdk/lib/rtl/amd64/unwind.c @@ -956,53 +956,75 @@ RtlWalkFrameChain(OUT PVOID *Callers, { } - /* Loop the frames */ - for (i = 0; i < FramesToSkip + Count; i++) + _SEH2_TRY { - /* Lookup the FunctionEntry for the current ControlPc */ - FunctionEntry = RtlLookupFunctionEntry(ControlPc, &ImageBase, NULL); - - /* Is this a leaf function? */ - if (!FunctionEntry) + /* Loop the frames */ + for (i = 0; i < FramesToSkip + Count; i++) { - Context.Rip = *(DWORD64*)Context.Rsp; - Context.Rsp += sizeof(DWORD64); - DPRINT("leaf funtion, new Rip = %p, new Rsp = %p\n", (PVOID)Context.Rip, (PVOID)Context.Rsp); - } - else - { - RtlVirtualUnwind(0, - ImageBase, - ControlPc, - FunctionEntry, - &Context, - &HandlerData, - &EstablisherFrame, - NULL); - DPRINT("normal funtion, new Rip = %p, new Rsp = %p\n", (PVOID)Context.Rip, (PVOID)Context.Rsp); - } + /* Lookup the FunctionEntry for the current ControlPc */ + FunctionEntry = RtlLookupFunctionEntry(ControlPc, &ImageBase, NULL); - /* Check if new Rip is valid */ - if (!Context.Rip) - { - break; - } + /* Is this a leaf function? */ + if (!FunctionEntry) + { + Context.Rip = *(DWORD64*)Context.Rsp; + Context.Rsp += sizeof(DWORD64); + DPRINT("leaf funtion, new Rip = %p, new Rsp = %p\n", (PVOID)Context.Rip, (PVOID)Context.Rsp); + } + else + { + RtlVirtualUnwind(UNW_FLAG_NHANDLER, + ImageBase, + ControlPc, + FunctionEntry, + &Context, + &HandlerData, + &EstablisherFrame, + NULL); + DPRINT("normal funtion, new Rip = %p, new Rsp = %p\n", (PVOID)Context.Rip, (PVOID)Context.Rsp); + } - /* Check, if we have left our stack */ - if ((Context.Rsp < StackLow) || (Context.Rsp > StackHigh)) - { - break; - } + /* Check if we are in kernel mode */ + if (RtlpGetMode() == KernelMode) + { + /* Check if we left the kernel range */ + if (!(Flags & 1) && (Context.Rip < 0xFFFF800000000000ULL)) + { + break; + } + } + else + { + /* Check if we left the user range */ + if ((Context.Rip < 0x10000) || + (Context.Rip > 0x000007FFFFFEFFFFULL)) + { + break; + } + } - /* Continue with new Rip */ - ControlPc = Context.Rip; + /* Check, if we have left our stack */ + if ((Context.Rsp < StackLow) || (Context.Rsp > StackHigh)) + { + break; + } - /* Save value, if we are past the frames to skip */ - if (i >= FramesToSkip) - { - Callers[i - FramesToSkip] = (PVOID)ControlPc; + /* Continue with new Rip */ + ControlPc = Context.Rip; + + /* Save value, if we are past the frames to skip */ + if (i >= FramesToSkip) + { + Callers[i - FramesToSkip] = (PVOID)ControlPc; + } } } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + DPRINT1("Exception while getting callers!\n"); + i = 0; + } + _SEH2_END; DPRINT("RtlWalkFrameChain returns %ld\n", i); return i;

3 years, 4 months

[reactos] 06/07: [RTL] Simplify RtlRaiseException

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=e6af7d9dfef7426e687fb… commit e6af7d9dfef7426e687fb8436d630f0ecda3856b Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Fri Mar 2 07:48:34 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 13:52:42 2021 +0200 [RTL] Simplify RtlRaiseException --- sdk/lib/rtl/amd64/except.c | 64 ++++++++++++++++------------------------------ 1 file changed, 22 insertions(+), 42 deletions(-) diff --git a/sdk/lib/rtl/amd64/except.c b/sdk/lib/rtl/amd64/except.c index d93d77816e0..aebd525774b 100644 --- a/sdk/lib/rtl/amd64/except.c +++ b/sdk/lib/rtl/amd64/except.c @@ -19,57 +19,37 @@ RtlRaiseException(IN PEXCEPTION_RECORD ExceptionRecord) { CONTEXT Context; NTSTATUS Status = STATUS_INVALID_DISPOSITION; - ULONG64 ImageBase; - PRUNTIME_FUNCTION FunctionEntry; - PVOID HandlerData; - ULONG64 EstablisherFrame; - /* Capture the context */ + /* Capture the current context */ RtlCaptureContext(&Context); - /* Get the function entry for this function */ - FunctionEntry = RtlLookupFunctionEntry(Context.Rip, - &ImageBase, - NULL); + /* Fix up Context.Rip for the caller */ + Context.Rip = (ULONG64)_ReturnAddress(); - /* Check if we found it */ - if (FunctionEntry) + /* Fix up Context.Rsp for the caller */ + Context.Rsp = (ULONG64)_AddressOfReturnAddress() + 8; + + /* Save the exception address */ + ExceptionRecord->ExceptionAddress = (PVOID)Context.Rip; + + /* Check if user mode debugger is active */ + if (RtlpCheckForActiveDebugger()) + { + /* Raise an exception immediately */ + Status = ZwRaiseException(ExceptionRecord, &Context, TRUE); + } + else { - /* Unwind to the caller of this function */ - RtlVirtualUnwind(UNW_FLAG_NHANDLER, - ImageBase, - Context.Rip, - FunctionEntry, - &Context, - &HandlerData, - &EstablisherFrame, - NULL); - - /* Save the exception address */ - ExceptionRecord->ExceptionAddress = (PVOID)Context.Rip; - - /* Write the context flag */ - Context.ContextFlags = CONTEXT_FULL; - - /* Check if user mode debugger is active */ - if (RtlpCheckForActiveDebugger()) + /* Dispatch the exception and check if we should continue */ + if (!RtlDispatchException(ExceptionRecord, &Context)) { - /* Raise an exception immediately */ - Status = ZwRaiseException(ExceptionRecord, &Context, TRUE); + /* Raise the exception */ + Status = ZwRaiseException(ExceptionRecord, &Context, FALSE); } else { - /* Dispatch the exception and check if we should continue */ - if (!RtlDispatchException(ExceptionRecord, &Context)) - { - /* Raise the exception */ - Status = ZwRaiseException(ExceptionRecord, &Context, FALSE); - } - else - { - /* Continue, go back to previous context */ - Status = ZwContinue(&Context, FALSE); - } + /* Continue, go back to previous context */ + Status = ZwContinue(&Context, FALSE); } }

3 years, 4 months

[reactos] 05/07: [RTL] Implement RtplUnwindInternal and wrap RtlUnwindEx and RtlDispatchException around it

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3ec1ca9b46d04a2ad07a2… commit 3ec1ca9b46d04a2ad07a23f8aeb2d1f26718ba71 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu Mar 1 14:43:05 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 13:52:42 2021 +0200 [RTL] Implement RtplUnwindInternal and wrap RtlUnwindEx and RtlDispatchException around it Based on the description in this blog article: http://www.nynaeve.net/?p=106 --- sdk/lib/rtl/amd64/except.c | 44 ++++++++- sdk/lib/rtl/amd64/unwind.c | 236 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 273 insertions(+), 7 deletions(-) diff --git a/sdk/lib/rtl/amd64/except.c b/sdk/lib/rtl/amd64/except.c index 9e7dcf87c0e..d93d77816e0 100644 --- a/sdk/lib/rtl/amd64/except.c +++ b/sdk/lib/rtl/amd64/except.c @@ -88,15 +88,49 @@ RtlpGetExceptionAddress(VOID) return NULL; } +BOOLEAN +NTAPI +RtplUnwindInternal( + _In_opt_ PVOID TargetFrame, + _In_opt_ PVOID TargetIp, + _In_ PEXCEPTION_RECORD ExceptionRecord, + _In_ PVOID ReturnValue, + _In_ PCONTEXT ContextRecord, + _In_opt_ struct _UNWIND_HISTORY_TABLE *HistoryTable, + _In_ ULONG Flags); + /* * @unimplemented */ BOOLEAN NTAPI -RtlDispatchException(IN PEXCEPTION_RECORD ExceptionRecord, - IN PCONTEXT Context) +RtlDispatchException( + _In_ PEXCEPTION_RECORD ExceptionRecord, + _In_ PCONTEXT ContextRecord) { - __debugbreak(); - UNIMPLEMENTED; - return FALSE; + BOOLEAN Handled; + + /* Perform vectored exception handling for user mode */ + if (RtlCallVectoredExceptionHandlers(ExceptionRecord, ContextRecord)) + { + /* Exception handled, now call vectored continue handlers */ + RtlCallVectoredContinueHandlers(ExceptionRecord, ContextRecord); + + /* Continue execution */ + return TRUE; + } + + /* Call the internal unwind routine */ + Handled = RtplUnwindInternal(NULL, // TargetFrame + NULL, // TargetIp + ExceptionRecord, + 0, // ReturnValue + ContextRecord, + NULL, // HistoryTable + UNW_FLAG_EHANDLER); + + /* In user mode, call any registered vectored continue handlers */ + RtlCallVectoredContinueHandlers(ExceptionRecord, ContextRecord); + + return Handled; } diff --git a/sdk/lib/rtl/amd64/unwind.c b/sdk/lib/rtl/amd64/unwind.c index be0223e1dd5..859ef783043 100644 --- a/sdk/lib/rtl/amd64/unwind.c +++ b/sdk/lib/rtl/amd64/unwind.c @@ -668,6 +668,216 @@ Exit: return NULL; } +/*! + \remark The implementation is based on the description in this blog: http://www.nynaeve.net/?p=106 + + Differences to the desciption: + - Instead of using 2 pointers to the unwind context and previous context, + that are being swapped and the context copied, the unwind context is + kept in the local context and copied back into the context passed in + by the caller. + + \see http://www.nynaeve.net/?p=106 +*/ +BOOLEAN +NTAPI +RtplUnwindInternal( + _In_opt_ PVOID TargetFrame, + _In_opt_ PVOID TargetIp, + _In_ PEXCEPTION_RECORD ExceptionRecord, + _In_ PVOID ReturnValue, + _In_ PCONTEXT ContextRecord, + _In_opt_ struct _UNWIND_HISTORY_TABLE *HistoryTable, + _In_ ULONG HandlerType) +{ + DISPATCHER_CONTEXT DispatcherContext; + PEXCEPTION_ROUTINE ExceptionRoutine; + EXCEPTION_DISPOSITION Disposition; + PRUNTIME_FUNCTION FunctionEntry; + ULONG_PTR StackLow, StackHigh; + ULONG64 ImageBase, EstablisherFrame; + CONTEXT UnwindContext; + + /* Get the current stack limits and registration frame */ + RtlpGetStackLimits(&StackLow, &StackHigh); + + /* If we have a target frame, then this is our high limit */ + if (TargetFrame != NULL) + { + StackHigh = (ULONG64)TargetFrame + 1; + } + + /* Copy the context */ + UnwindContext = *ContextRecord; + + /* Set up the constant fields of the dispatcher context */ + DispatcherContext.ContextRecord = ContextRecord; + DispatcherContext.HistoryTable = HistoryTable; + DispatcherContext.TargetIp = (ULONG64)TargetIp; + + /* Start looping */ + while (TRUE) + { + /* Lookup the FunctionEntry for the current RIP */ + FunctionEntry = RtlLookupFunctionEntry(UnwindContext.Rip, &ImageBase, NULL); + if (FunctionEntry == NULL) + { + /* No function entry, so this must be a leaf function. Pop the return address from the stack. + Note: this can happen after the first frame as the result of an exception */ + UnwindContext.Rip = *(DWORD64*)UnwindContext.Rsp; + UnwindContext.Rsp += sizeof(DWORD64); + continue; + } + + /* Do a virtual unwind to get the next frame */ + ExceptionRoutine = RtlVirtualUnwind(HandlerType, + ImageBase, + UnwindContext.Rip, + FunctionEntry, + &UnwindContext, + &DispatcherContext.HandlerData, + &EstablisherFrame, + NULL); + + /* Check, if we are still within the stack boundaries */ + if ((EstablisherFrame < StackLow) || + (EstablisherFrame >= StackHigh) || + (EstablisherFrame & 7)) + { + /// TODO: Handle DPC stack + + /* If we are handling an exception, we are done here. */ + if (HandlerType == UNW_FLAG_EHANDLER) + { + ExceptionRecord->ExceptionFlags |= EXCEPTION_STACK_INVALID; + return FALSE; + } + + __debugbreak(); + RtlRaiseStatus(STATUS_BAD_STACK); + } + + /* Check if we have an exception routine */ + if (ExceptionRoutine != NULL) + { + /* Check if this is the target frame */ + if (EstablisherFrame == (ULONG64)TargetFrame) + { + /* Set flag to inform the language handler */ + ExceptionRecord->ExceptionFlags |= EXCEPTION_TARGET_UNWIND; + } + + /* Log the exception if it's enabled */ + RtlpCheckLogException(ExceptionRecord, + ContextRecord, + &DispatcherContext, + sizeof(DispatcherContext)); + + /* Set up the variable fields of the dispatcher context */ + DispatcherContext.ControlPc = ContextRecord->Rip; + DispatcherContext.ImageBase = ImageBase; + DispatcherContext.FunctionEntry = FunctionEntry; + DispatcherContext.LanguageHandler = ExceptionRoutine; + DispatcherContext.EstablisherFrame = EstablisherFrame; + DispatcherContext.ScopeIndex = 0; + + /* Store the return value in the unwind context */ + UnwindContext.Rax = (ULONG64)ReturnValue; + + /* Loop all nested handlers */ + do + { + /// TODO: call RtlpExecuteHandlerForUnwind instead + /* Call the language specific handler */ + Disposition = ExceptionRoutine(ExceptionRecord, + (PVOID)EstablisherFrame, + &UnwindContext, + &DispatcherContext); + + /* Clear exception flags for the next iteration */ + ExceptionRecord->ExceptionFlags &= ~(EXCEPTION_TARGET_UNWIND | + EXCEPTION_COLLIDED_UNWIND); + + /* Check if we do exception handling */ + if (HandlerType == UNW_FLAG_EHANDLER) + { + if (Disposition == ExceptionContinueExecution) + { + /* Check if it was non-continuable */ + if (ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE) + { + __debugbreak(); + RtlRaiseStatus(EXCEPTION_NONCONTINUABLE_EXCEPTION); + } + + /* Execution continues */ + return TRUE; + } + else if (Disposition == ExceptionNestedException) + { + /// TODO + __debugbreak(); + } + } + + if (Disposition == ExceptionCollidedUnwind) + { + /// TODO + __debugbreak(); + } + + /* This must be ExceptionContinueSearch now */ + if (Disposition != ExceptionContinueSearch) + { + __debugbreak(); + RtlRaiseStatus(STATUS_INVALID_DISPOSITION); + } + } while (ExceptionRecord->ExceptionFlags & EXCEPTION_COLLIDED_UNWIND); + } + + /* Check, if we have left our stack (8.) */ + if ((EstablisherFrame < StackLow) || + (EstablisherFrame > StackHigh) || + (EstablisherFrame & 7)) + { + /// TODO: Check for DPC stack + __debugbreak(); + + if (UnwindContext.Rip == ContextRecord->Rip) + { + RtlRaiseStatus(STATUS_BAD_FUNCTION_TABLE); + } + else + { + ZwRaiseException(ExceptionRecord, ContextRecord, FALSE); + } + } + + if (EstablisherFrame == (ULONG64)TargetFrame) + { + break; + } + + /* We have successfully unwound a frame. Copy the unwind context back. */ + *ContextRecord = UnwindContext; + } + + if (ExceptionRecord->ExceptionCode != STATUS_UNWIND_CONSOLIDATE) + { + ContextRecord->Rip = (ULONG64)TargetIp; + } + + /* Set the return value */ + ContextRecord->Rax = (ULONG64)ReturnValue; + + /* Restore the context */ + RtlRestoreContext(ContextRecord, ExceptionRecord); + + /* Should never get here! */ + ASSERT(FALSE); + return FALSE; +} + VOID NTAPI RtlUnwindEx( @@ -678,8 +888,30 @@ RtlUnwindEx( _In_ PCONTEXT ContextRecord, _In_opt_ struct _UNWIND_HISTORY_TABLE *HistoryTable) { - __debugbreak(); - return; + EXCEPTION_RECORD LocalExceptionRecord; + + /* Capture the current context */ + RtlCaptureContext(ContextRecord); + + /* Check if we have an exception record */ + if (ExceptionRecord == NULL) + { + /* No exception record was passed, so set up a local one */ + LocalExceptionRecord.ExceptionCode = STATUS_UNWIND; + LocalExceptionRecord.ExceptionAddress = (PVOID)ContextRecord->Rip; + LocalExceptionRecord.ExceptionRecord = NULL; + LocalExceptionRecord.NumberParameters = 0; + ExceptionRecord = &LocalExceptionRecord; + } + + /* Call the internal function */ + RtplUnwindInternal(TargetFrame, + TargetIp, + ExceptionRecord, + ReturnValue, + ContextRecord, + HistoryTable, + UNW_FLAG_UHANDLER); } VOID

3 years, 4 months

[reactos] 04/07: [RTL] Improve RtlVirtualUnwind

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=1d58e847364d6252fe055… commit 1d58e847364d6252fe055a8a227775d26a2427b4 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu Mar 1 14:14:13 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 13:52:42 2021 +0200 [RTL] Improve RtlVirtualUnwind * Add support for version 2 unwind info * Implement UnwindOpSlots() and use it (based on https://github.com/dotnet/coreclr/blob/master/src/unwinder/amd64/unwinder_a…) * Fix handling of UWOP_PUSH_MACHFRAME --- sdk/lib/rtl/amd64/unwind.c | 291 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 234 insertions(+), 57 deletions(-) diff --git a/sdk/lib/rtl/amd64/unwind.c b/sdk/lib/rtl/amd64/unwind.c index 6f3ce6efd51..be0223e1dd5 100644 --- a/sdk/lib/rtl/amd64/unwind.c +++ b/sdk/lib/rtl/amd64/unwind.c @@ -22,8 +22,13 @@ #define UWOP_SET_FPREG 3 #define UWOP_SAVE_NONVOL 4 #define UWOP_SAVE_NONVOL_FAR 5 +#if 0 // These are deprecated / not for x64 #define UWOP_SAVE_XMM 6 #define UWOP_SAVE_XMM_FAR 7 +#else +#define UWOP_EPILOG 6 +#define UWOP_SPARE_CODE 7 +#endif #define UWOP_SAVE_XMM128 8 #define UWOP_SAVE_XMM128_FAR 9 #define UWOP_PUSH_MACHFRAME 10 @@ -193,27 +198,121 @@ RtlInstallFunctionTableCallback( return FALSE; } +static +__inline +ULONG +UnwindOpSlots( + _In_ UNWIND_CODE UnwindCode) +{ + static const UCHAR UnwindOpExtraSlotTable[] = + { + 0, // UWOP_PUSH_NONVOL + 1, // UWOP_ALLOC_LARGE (or 3, special cased in lookup code) + 0, // UWOP_ALLOC_SMALL + 0, // UWOP_SET_FPREG + 1, // UWOP_SAVE_NONVOL + 2, // UWOP_SAVE_NONVOL_FAR + 1, // UWOP_EPILOG // previously UWOP_SAVE_XMM + 2, // UWOP_SPARE_CODE // previously UWOP_SAVE_XMM_FAR + 1, // UWOP_SAVE_XMM128 + 2, // UWOP_SAVE_XMM128_FAR + 0, // UWOP_PUSH_MACHFRAME + 2, // UWOP_SET_FPREG_LARGE + }; + + if ((UnwindCode.UnwindOp == UWOP_ALLOC_LARGE) && + (UnwindCode.OpInfo != 0)) + { + return 3; + } + else + { + return UnwindOpExtraSlotTable[UnwindCode.UnwindOp] + 1; + } +} + +static +__inline void -FORCEINLINE -SetReg(PCONTEXT Context, BYTE Reg, DWORD64 Value) +SetReg( + _Inout_ PCONTEXT Context, + _In_ BYTE Reg, + _In_ DWORD64 Value) { ((DWORD64*)(&Context->Rax))[Reg] = Value; } +static +__inline +void +SetRegFromStackValue( + _Inout_ PCONTEXT Context, + _Inout_opt_ PKNONVOLATILE_CONTEXT_POINTERS ContextPointers, + _In_ BYTE Reg, + _In_ PDWORD64 ValuePointer) +{ + SetReg(Context, Reg, *ValuePointer); + if (ContextPointers != NULL) + { + ContextPointers->IntegerContext[Reg] = ValuePointer; + } +} + +static +__inline DWORD64 -FORCEINLINE -GetReg(PCONTEXT Context, BYTE Reg) +GetReg( + _In_ PCONTEXT Context, + _In_ BYTE Reg) { return ((DWORD64*)(&Context->Rax))[Reg]; } +static +__inline +void +PopReg( + _Inout_ PCONTEXT Context, + _Inout_opt_ PKNONVOLATILE_CONTEXT_POINTERS ContextPointers, + _In_ BYTE Reg) +{ + SetRegFromStackValue(Context, ContextPointers, Reg, (PDWORD64)Context->Rsp); + Context->Rsp += sizeof(DWORD64); +} + +static +__inline void -FORCEINLINE -PopReg(PCONTEXT Context, BYTE Reg) +SetXmmReg( + _Inout_ PCONTEXT Context, + _In_ BYTE Reg, + _In_ M128A Value) +{ + ((M128A*)(&Context->Xmm0))[Reg] = Value; +} + +static +__inline +void +SetXmmRegFromStackValue( + _Out_ PCONTEXT Context, + _Inout_opt_ PKNONVOLATILE_CONTEXT_POINTERS ContextPointers, + _In_ BYTE Reg, + _In_ M128A *ValuePointer) +{ + SetXmmReg(Context, Reg, *ValuePointer); + if (ContextPointers != NULL) + { + ContextPointers->FloatingContext[Reg] = ValuePointer; + } +} + +static +__inline +M128A +GetXmmReg(PCONTEXT Context, BYTE Reg) { - DWORD64 Value = *(DWORD64*)Context->Rsp; - Context->Rsp += 8; - SetReg(Context, Reg, Value); + return ((M128A*)(&Context->Xmm0))[Reg]; } /*! RtlpTryToUnwindEpilog @@ -221,18 +320,19 @@ PopReg(PCONTEXT Context, BYTE Reg) * \return TRUE if we have been in an epilog and it could be unwound. * FALSE if the instructions were not allowed for an epilog. * \ref - * http://msdn.microsoft.com/en-us/library/8ydc79k6(VS.80).aspx - * http://msdn.microsoft.com/en-us/library/tawsa7cb.aspx + * https://docs.microsoft.com/en-us/cpp/build/unwind-procedure + * https://docs.microsoft.com/en-us/cpp/build/prolog-and-epilog * \todo * - Test and compare with Windows behaviour */ -BOOLEAN static __inline +BOOLEAN RtlpTryToUnwindEpilog( - PCONTEXT Context, - ULONG64 ImageBase, - PRUNTIME_FUNCTION FunctionEntry) + _Inout_ PCONTEXT Context, + _Inout_opt_ PKNONVOLATILE_CONTEXT_POINTERS ContextPointers, + _In_ ULONG64 ImageBase, + _In_ PRUNTIME_FUNCTION FunctionEntry) { CONTEXT LocalContext; BYTE *InstrPtr; @@ -302,7 +402,7 @@ RtlpTryToUnwindEpilog( { /* Opcode pops a basic register from stack */ Reg = Instr & 0x7; - PopReg(&LocalContext, Reg); + PopReg(&LocalContext, ContextPointers, Reg); InstrPtr++; continue; } @@ -312,7 +412,7 @@ RtlpTryToUnwindEpilog( { /* Opcode is pop r8 .. r15 */ Reg = ((Instr >> 8) & 0x7) + 8; - PopReg(&LocalContext, Reg); + PopReg(&LocalContext, ContextPointers, Reg); InstrPtr += 2; continue; } @@ -321,6 +421,10 @@ RtlpTryToUnwindEpilog( return FALSE; } + // check for popfq + + // also allow end with jmp imm, jmp [target], iretq + /* Check if we are at the ret instruction */ if ((DWORD64)InstrPtr != EndAddress) { @@ -344,6 +448,49 @@ RtlpTryToUnwindEpilog( return TRUE; } +/*! + + \ref https://docs.microsoft.com/en-us/cpp/build/unwind-data-definitions-in-c +*/ +static +ULONG64 +GetEstablisherFrame( + _In_ PCONTEXT Context, + _In_ PUNWIND_INFO UnwindInfo, + _In_ ULONG_PTR CodeOffset) +{ + ULONG i; + + /* Check if we have a frame register */ + if (UnwindInfo->FrameRegister == 0) + { + /* No frame register means we use Rsp */ + return Context->Rsp; + } + + if ((CodeOffset >= UnwindInfo->SizeOfProlog) || + ((UnwindInfo->Flags & UNW_FLAG_CHAININFO) != 0)) + { + return GetReg(Context, UnwindInfo->FrameRegister) - + UnwindInfo->FrameOffset * 16; + } + + /* Loop all unwind ops */ + for (i = 0; + i < UnwindInfo->CountOfCodes; + i += UnwindOpSlots(UnwindInfo->UnwindCode[i])) + { + /* Check for SET_FPREG */ + if (UnwindInfo->UnwindCode[i].UnwindOp == UWOP_SET_FPREG) + { + return GetReg(Context, UnwindInfo->FrameRegister) - + UnwindInfo->FrameOffset * 16; + } + } + + return Context->Rsp; +} + PEXCEPTION_ROUTINE NTAPI RtlVirtualUnwind( @@ -354,13 +501,14 @@ RtlVirtualUnwind( _Inout_ PCONTEXT Context, _Outptr_ PVOID *HandlerData, _Out_ PULONG64 EstablisherFrame, - _Inout_ PKNONVOLATILE_CONTEXT_POINTERS ContextPointers) + _Inout_opt_ PKNONVOLATILE_CONTEXT_POINTERS ContextPointers) { PUNWIND_INFO UnwindInfo; ULONG_PTR CodeOffset; - ULONG i; + ULONG i, Offset; UNWIND_CODE UnwindCode; BYTE Reg; + PULONG LanguageHandler; /* Use relative virtual address */ ControlPc -= ImageBase; @@ -375,13 +523,29 @@ RtlVirtualUnwind( /* Get a pointer to the unwind info */ UnwindInfo = RVA(ImageBase, FunctionEntry->UnwindData); + /* Check for chained info */ + if (UnwindInfo->Flags & UNW_FLAG_CHAININFO) + { + UNIMPLEMENTED_DBGBREAK(); + + /* See https://docs.microsoft.com/en-us/cpp/build/chained-unwind-info-structures */ + FunctionEntry = (PRUNTIME_FUNCTION)&(UnwindInfo->UnwindCode[(UnwindInfo->CountOfCodes + 1) & ~1]); + UnwindInfo = RVA(ImageBase, FunctionEntry->UnwindData); + } + + /* The language specific handler data follows the unwind info */ + LanguageHandler = ALIGN_UP_POINTER_BY(&UnwindInfo->UnwindCode[UnwindInfo->CountOfCodes], sizeof(ULONG)); + *HandlerData = (LanguageHandler + 1); + /* Calculate relative offset to function start */ CodeOffset = ControlPc - FunctionEntry->BeginAddress; + *EstablisherFrame = GetEstablisherFrame(Context, UnwindInfo, CodeOffset); + /* Check if we are in the function epilog and try to finish it */ if (CodeOffset > UnwindInfo->SizeOfProlog) { - if (RtlpTryToUnwindEpilog(Context, ImageBase, FunctionEntry)) + if (RtlpTryToUnwindEpilog(Context, ContextPointers, ImageBase, FunctionEntry)) { /* There's no exception routine */ return NULL; @@ -390,31 +554,10 @@ RtlVirtualUnwind( /* Skip all Ops with an offset greater than the current Offset */ i = 0; - while (i < UnwindInfo->CountOfCodes && - CodeOffset < UnwindInfo->UnwindCode[i].CodeOffset) + while ((i < UnwindInfo->CountOfCodes) && + (UnwindInfo->UnwindCode[i].CodeOffset > CodeOffset)) { - UnwindCode = UnwindInfo->UnwindCode[i]; - switch (UnwindCode.UnwindOp) - { - case UWOP_SAVE_NONVOL: - case UWOP_SAVE_XMM: - case UWOP_SAVE_XMM128: - i += 2; - break; - - case UWOP_SAVE_NONVOL_FAR: - case UWOP_SAVE_XMM_FAR: - case UWOP_SAVE_XMM128_FAR: - i += 3; - break; - - case UWOP_ALLOC_LARGE: - i += UnwindCode.OpInfo ? 3 : 2; - break; - - default: - i++; - } + i += UnwindOpSlots(UnwindInfo->UnwindCode[i]); } /* Process the remaining unwind ops */ @@ -425,21 +568,20 @@ RtlVirtualUnwind( { case UWOP_PUSH_NONVOL: Reg = UnwindCode.OpInfo; - SetReg(Context, Reg, *(DWORD64*)Context->Rsp); - Context->Rsp += sizeof(DWORD64); + PopReg(Context, ContextPointers, Reg); i++; break; case UWOP_ALLOC_LARGE: if (UnwindCode.OpInfo) { - ULONG Offset = *(ULONG*)(&UnwindInfo->UnwindCode[i+1]); + Offset = *(ULONG*)(&UnwindInfo->UnwindCode[i+1]); Context->Rsp += Offset; i += 3; } else { - USHORT Offset = UnwindInfo->UnwindCode[i+1].FrameOffset; + Offset = UnwindInfo->UnwindCode[i+1].FrameOffset; Context->Rsp += Offset * 8; i += 2; } @@ -451,44 +593,79 @@ RtlVirtualUnwind( break; case UWOP_SET_FPREG: + Reg = UnwindInfo->FrameRegister; + Context->Rsp = GetReg(Context, Reg) - UnwindInfo->FrameOffset * 16; i++; break; case UWOP_SAVE_NONVOL: + Reg = UnwindCode.OpInfo; + Offset = *(USHORT*)(&UnwindInfo->UnwindCode[i + 1]); + SetRegFromStackValue(Context, ContextPointers, Reg, (DWORD64*)Context->Rsp + Offset); i += 2; break; case UWOP_SAVE_NONVOL_FAR: + Reg = UnwindCode.OpInfo; + Offset = *(ULONG*)(&UnwindInfo->UnwindCode[i + 1]); + SetRegFromStackValue(Context, ContextPointers, Reg, (DWORD64*)Context->Rsp + Offset); i += 3; break; - case UWOP_SAVE_XMM: - i += 2; + case UWOP_EPILOG: + i += 1; break; - case UWOP_SAVE_XMM_FAR: - i += 3; + case UWOP_SPARE_CODE: + ASSERT(FALSE); + i += 2; break; case UWOP_SAVE_XMM128: + Reg = UnwindCode.OpInfo; + Offset = *(USHORT*)(&UnwindInfo->UnwindCode[i + 1]); + SetXmmRegFromStackValue(Context, ContextPointers, Reg, (M128A*)(Context->Rsp + Offset)); i += 2; break; case UWOP_SAVE_XMM128_FAR: + Reg = UnwindCode.OpInfo; + Offset = *(ULONG*)(&UnwindInfo->UnwindCode[i + 1]); + SetXmmRegFromStackValue(Context, ContextPointers, Reg, (M128A*)(Context->Rsp + Offset)); i += 3; break; case UWOP_PUSH_MACHFRAME: - i += 1; - break; + /* OpInfo is 1, when an error code was pushed, otherwise 0. */ + Context->Rsp += UnwindCode.OpInfo * sizeof(DWORD64); + + /* Now pop the MACHINE_FRAME (Yes, "magic numbers", deal with it) */ + Context->Rip = *(PDWORD64)(Context->Rsp + 0x00); + Context->SegCs = *(PDWORD64)(Context->Rsp + 0x08); + Context->EFlags = *(PDWORD64)(Context->Rsp + 0x10); + Context->SegSs = *(PDWORD64)(Context->Rsp + 0x20); + Context->Rsp = *(PDWORD64)(Context->Rsp + 0x18); + ASSERT((i + 1) == UnwindInfo->CountOfCodes); + goto Exit; } } /* Unwind is finished, pop new Rip from Stack */ - Context->Rip = *(DWORD64*)Context->Rsp; - Context->Rsp += sizeof(DWORD64); + if (Context->Rsp != 0) + { + Context->Rip = *(DWORD64*)Context->Rsp; + Context->Rsp += sizeof(DWORD64); + } - return 0; +Exit: + + /* Check if we have a handler and return it */ + if (UnwindInfo->Flags & (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER)) + { + return RVA(ImageBase, *LanguageHandler); + } + + return NULL; } VOID

3 years, 4 months

[reactos] 03/07: [RTL] Move exception handling code to except.c

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=5075f7d7462c30739f139… commit 5075f7d7462c30739f1391e0e1cc44415be6ee47 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu Mar 1 14:13:01 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 13:52:42 2021 +0200 [RTL] Move exception handling code to except.c --- sdk/lib/rtl/CMakeLists.txt | 1 + sdk/lib/rtl/amd64/except.c | 102 +++++++++++++++++++++++++++++++++++++++++++++ sdk/lib/rtl/amd64/stubs.c | 23 ---------- sdk/lib/rtl/amd64/unwind.c | 65 ----------------------------- 4 files changed, 103 insertions(+), 88 deletions(-) diff --git a/sdk/lib/rtl/CMakeLists.txt b/sdk/lib/rtl/CMakeLists.txt index c2b2e5d1025..f250931846a 100644 --- a/sdk/lib/rtl/CMakeLists.txt +++ b/sdk/lib/rtl/CMakeLists.txt @@ -89,6 +89,7 @@ elseif(ARCH STREQUAL "amd64") list(APPEND SOURCE bitmap64.c byteswap.c + amd64/except.c amd64/unwind.c amd64/stubs.c mem.c) diff --git a/sdk/lib/rtl/amd64/except.c b/sdk/lib/rtl/amd64/except.c new file mode 100644 index 00000000000..9e7dcf87c0e --- /dev/null +++ b/sdk/lib/rtl/amd64/except.c @@ -0,0 +1,102 @@ +/* + * PROJECT: ReactOS Run-Time Library + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: User-mode exception support for AMD64 + * COPYRIGHT: Copyright 2018-2021 Timo Kreuzer <timo.kreuzer(a)reactos.org> + */ + +/* INCLUDES *****************************************************************/ + +#include <rtl.h> +#define NDEBUG +#include <debug.h> + +/* PUBLIC FUNCTIONS **********************************************************/ + +VOID +NTAPI +RtlRaiseException(IN PEXCEPTION_RECORD ExceptionRecord) +{ + CONTEXT Context; + NTSTATUS Status = STATUS_INVALID_DISPOSITION; + ULONG64 ImageBase; + PRUNTIME_FUNCTION FunctionEntry; + PVOID HandlerData; + ULONG64 EstablisherFrame; + + /* Capture the context */ + RtlCaptureContext(&Context); + + /* Get the function entry for this function */ + FunctionEntry = RtlLookupFunctionEntry(Context.Rip, + &ImageBase, + NULL); + + /* Check if we found it */ + if (FunctionEntry) + { + /* Unwind to the caller of this function */ + RtlVirtualUnwind(UNW_FLAG_NHANDLER, + ImageBase, + Context.Rip, + FunctionEntry, + &Context, + &HandlerData, + &EstablisherFrame, + NULL); + + /* Save the exception address */ + ExceptionRecord->ExceptionAddress = (PVOID)Context.Rip; + + /* Write the context flag */ + Context.ContextFlags = CONTEXT_FULL; + + /* Check if user mode debugger is active */ + if (RtlpCheckForActiveDebugger()) + { + /* Raise an exception immediately */ + Status = ZwRaiseException(ExceptionRecord, &Context, TRUE); + } + else + { + /* Dispatch the exception and check if we should continue */ + if (!RtlDispatchException(ExceptionRecord, &Context)) + { + /* Raise the exception */ + Status = ZwRaiseException(ExceptionRecord, &Context, FALSE); + } + else + { + /* Continue, go back to previous context */ + Status = ZwContinue(&Context, FALSE); + } + } + } + + /* If we returned, raise a status */ + RtlRaiseStatus(Status); +} + +/* +* @unimplemented +*/ +PVOID +NTAPI +RtlpGetExceptionAddress(VOID) +{ + UNIMPLEMENTED; + return NULL; +} + +/* + * @unimplemented + */ +BOOLEAN +NTAPI +RtlDispatchException(IN PEXCEPTION_RECORD ExceptionRecord, + IN PCONTEXT Context) +{ + __debugbreak(); + UNIMPLEMENTED; + return FALSE; +} diff --git a/sdk/lib/rtl/amd64/stubs.c b/sdk/lib/rtl/amd64/stubs.c index 7eb61416c36..7ffc4fb9658 100644 --- a/sdk/lib/rtl/amd64/stubs.c +++ b/sdk/lib/rtl/amd64/stubs.c @@ -74,29 +74,6 @@ RtlInitializeContext( return; } -/* - * @unimplemented - */ -PVOID -NTAPI -RtlpGetExceptionAddress(VOID) -{ - UNIMPLEMENTED; - return NULL; -} - -/* - * @unimplemented - */ -BOOLEAN -NTAPI -RtlDispatchException(IN PEXCEPTION_RECORD ExceptionRecord, - IN PCONTEXT Context) -{ - UNIMPLEMENTED; - return FALSE; -} - NTSTATUS NTAPI RtlQueueApcWow64Thread( diff --git a/sdk/lib/rtl/amd64/unwind.c b/sdk/lib/rtl/amd64/unwind.c index 26a7610d250..6f3ce6efd51 100644 --- a/sdk/lib/rtl/amd64/unwind.c +++ b/sdk/lib/rtl/amd64/unwind.c @@ -622,71 +622,6 @@ RtlGetCallersAddress( return; } -// FIXME: move to different file -VOID -NTAPI -RtlRaiseException(IN PEXCEPTION_RECORD ExceptionRecord) -{ - CONTEXT Context; - NTSTATUS Status = STATUS_INVALID_DISPOSITION; - ULONG64 ImageBase; - PRUNTIME_FUNCTION FunctionEntry; - PVOID HandlerData; - ULONG64 EstablisherFrame; - - /* Capture the context */ - RtlCaptureContext(&Context); - - /* Get the function entry for this function */ - FunctionEntry = RtlLookupFunctionEntry(Context.Rip, - &ImageBase, - NULL); - - /* Check if we found it */ - if (FunctionEntry) - { - /* Unwind to the caller of this function */ - RtlVirtualUnwind(UNW_FLAG_NHANDLER, - ImageBase, - Context.Rip, - FunctionEntry, - &Context, - &HandlerData, - &EstablisherFrame, - NULL); - - /* Save the exception address */ - ExceptionRecord->ExceptionAddress = (PVOID)Context.Rip; - - /* Write the context flag */ - Context.ContextFlags = CONTEXT_FULL; - - /* Check if user mode debugger is active */ - if (RtlpCheckForActiveDebugger()) - { - /* Raise an exception immediately */ - Status = ZwRaiseException(ExceptionRecord, &Context, TRUE); - } - else - { - /* Dispatch the exception and check if we should continue */ - if (!RtlDispatchException(ExceptionRecord, &Context)) - { - /* Raise the exception */ - Status = ZwRaiseException(ExceptionRecord, &Context, FALSE); - } - else - { - /* Continue, go back to previous context */ - Status = ZwContinue(&Context, FALSE); - } - } - } - - /* If we returned, raise a status */ - RtlRaiseStatus(Status); -} - static VOID RtlpCaptureNonVolatileContextPointers(

3 years, 4 months

[reactos] 02/07: [RTL] Improve / fix the SList code

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=65c3911ffcf74a051c936… commit 65c3911ffcf74a051c9366892230380a81ad82bd Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Wed Mar 7 12:03:51 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 13:52:42 2021 +0200 [RTL] Improve / fix the SList code Don't push a register in the middle of a an asm function. Instead add a proper prolog and store rbx in a home param slot. --- sdk/lib/rtl/amd64/slist.S | 68 +++++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 26 deletions(-) diff --git a/sdk/lib/rtl/amd64/slist.S b/sdk/lib/rtl/amd64/slist.S index 08eb382351d..a29ecd6a169 100644 --- a/sdk/lib/rtl/amd64/slist.S +++ b/sdk/lib/rtl/amd64/slist.S @@ -83,17 +83,18 @@ PUBLIC ExpInterlockedPopEntrySListEnd16 PUBLIC ExpInterlockedPushEntrySList PUBLIC ExpInterlockedFlushSList -PUBLIC RtlInterlockedFlushSList PUBLIC RtlInterlockedPopEntrySList PUBLIC RtlInterlockedPushEntrySList +PUBLIC RtlInterlockedFlushSList /* PSLIST_ENTRY * NTAPI * RtlInterlockedPopEntrySList( * IN PSLIST_HEADER ListHead); */ -RtlInterlockedPopEntrySList: ExpInterlockedPopEntrySList: +FUNC RtlInterlockedPopEntrySList + .ENDPROLOG /* Load ListHead->Region into rdx */ mov rdx, [rcx + 8] @@ -106,8 +107,7 @@ ExpInterlockedPopEntrySList: jne RtlInterlockedPopEntrySList16 /* Use the 8 byte header */ - -ExpInterlockedPopEntrySListResume: +GLOBAL_LABEL ExpInterlockedPopEntrySListResume /* Check if ListHead->NextEntry is NULL */ mov r9, rax @@ -128,7 +128,7 @@ ExpInterlockedPopEntrySListResume: /* Combine to new pointer in rdx */ or rdx, r9 -ExpInterlockedPopEntrySListFault: +GLOBAL_LABEL ExpInterlockedPopEntrySListFault /* Load the next NextEntry pointer to r9 */ mov r9, [rdx] @@ -139,7 +139,7 @@ ExpInterlockedPopEntrySListFault: /* Combine into r8 */ or r8, r9 -ExpInterlockedPopEntrySListEnd: +GLOBAL_LABEL ExpInterlockedPopEntrySListEnd /* If [rcx] equals rax, exchange it with r8 */ lock cmpxchg [rcx], r8 @@ -160,29 +160,34 @@ ExpInterlockedPopEntrySListEnd: ret RtlInterlockedPopEntrySListEmpty: + xor rax, rax ret -RtlInterlockedPopEntrySList16: +ENDFUNC + + +FUNC RtlInterlockedPopEntrySList16 + mov [rsp + P3Home], rbx + .SAVEREG rbx, P3Home + .ENDPROLOG + /* This is a 16 byte header rcx == ListHead rdx == ListHead->Region rax == ListHead->Alignment */ - /* Save rbx */ - push rbx - /* Copy rcx to r8, as we need rcx for the exchange */ mov r8, rcx -ExpInterlockedPopEntrySListResume16: +GLOBAL_LABEL ExpInterlockedPopEntrySListResume16 /* Set r9 = ListHead->NextEntry and check if it is NULL */ mov r9, rdx and r9, SLIST16B_NEXTENTRY_MASK jz RtlInterlockedPopEntrySListEmpty16 -ExpInterlockedPopEntrySListFault16: +GLOBAL_LABEL ExpInterlockedPopEntrySListFault16 /* Set NewListHead.Next = ListHead->NextEntry->Next */ mov rcx, [r9] @@ -193,7 +198,7 @@ ExpInterlockedPopEntrySListFault16: /* Copy Depth and Sequence number and adjust Depth */ lea rbx, [rax - SLIST16A_DEPTH_INC] -ExpInterlockedPopEntrySListEnd16: +GLOBAL_LABEL ExpInterlockedPopEntrySListEnd16 /* If [r8] equals rdx:rax, exchange it with rcx:rbx */ lock cmpxchg16b [r8] @@ -206,13 +211,15 @@ ExpInterlockedPopEntrySListEnd16: and rax, SLIST16B_NEXTENTRY_MASK /* Return */ - pop rbx + mov rbx, [rsp + P3Home] ret RtlInterlockedPopEntrySListEmpty16: + xor rax, rax - pop rbx + mov rbx, [rsp + P3Home] ret +ENDFUNC /* PSLIST_ENTRY @@ -221,8 +228,9 @@ RtlInterlockedPopEntrySListEmpty16: * IN PSLIST_HEADER ListHead, * IN PSLIST_ENTRY ListEntry); */ -RtlInterlockedPushEntrySList: ExpInterlockedPushEntrySList: +FUNC RtlInterlockedPushEntrySList + .ENDPROLOG #if DBG /* Make sure the ListEntry is 16 bytes aligned */ @@ -298,16 +306,19 @@ RtlInterlockedPushEntrySListEmpty: mov rax, r9 ret -RtlInterlockedPushEntrySList16: +ENDFUNC + +FUNC RtlInterlockedPushEntrySList16 + mov [rsp + P3Home], rbx + .SAVEREG rbx, P3Home + .ENDPROLOG + /* This is a 16 byte header rcx = ListHead rdx = ListEntry rax = ListHead->Alignment r9 = ListHead->Region */ - /* Save rbx */ - push rbx - /* Copy rcx/rdx to r8/r9, as we need rcx/rdx for the exchange */ mov r8, rcx mov r9, rdx @@ -349,17 +360,23 @@ RtlInterlockedPushEntrySListLoop16: and rax, SLIST16B_NEXTENTRY_MASK /* Return */ - pop rbx + mov rbx, [rsp + P3Home] ret +ENDFUNC + /* PSLIST_ENTRY * NTAPI * RtlInterlockedFlushSList( * IN PSLIST_HEADER ListHead); */ -RtlInterlockedFlushSList: ExpInterlockedFlushSList: +FUNC RtlInterlockedFlushSList + + mov [rsp + P3Home], rbx + .SAVEREG rbx, P3Home + .ENDPROLOG /* Load ListHead->Region into rdx */ mov rdx, [rcx + 8] @@ -403,9 +420,6 @@ RtlInterlockedFlushSList16: rdx = ListHead->Region */ - /* Save rbx */ - push rbx - /* Load ListHead into r8, as we need rcx for the exchange */ mov r8, rcx @@ -426,8 +440,10 @@ RtlInterlockedFlushSListLoop16: and rax, SLIST16B_NEXTENTRY_MASK /* Return */ - pop rbx + mov rbx, [rsp + P3Home] ret +ENDFUNC + END

3 years, 4 months

[reactos] 01/07: [CRT] Implement __C_specific_handler

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0520c75aaf3a9334d209e… commit 0520c75aaf3a9334d209e6b5ec04f15cb9b773c4 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu Mar 1 14:22:18 2018 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sat Jun 5 13:52:42 2021 +0200 [CRT] Implement __C_specific_handler --- sdk/lib/crt/except/amd64/ehandler.c | 132 ++++++++++++++++++++++++++++++++++-- 1 file changed, 125 insertions(+), 7 deletions(-) diff --git a/sdk/lib/crt/except/amd64/ehandler.c b/sdk/lib/crt/except/amd64/ehandler.c index 6e28e78e604..b32b821d6c9 100644 --- a/sdk/lib/crt/except/amd64/ehandler.c +++ b/sdk/lib/crt/except/amd64/ehandler.c @@ -1,19 +1,137 @@ +/* + * PROJECT: ReactOS CRT library + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: C specific exception/unwind handler for AMD64 + * COPYRIGHT: Copyright 2018-2021 Timo Kreuzer <timo.kreuzer(a)reactos.org> +*/ #include <precomp.h> +#include <winnt.h> _CRTIMP EXCEPTION_DISPOSITION __cdecl __C_specific_handler( - struct _EXCEPTION_RECORD *_ExceptionRecord, - void *_EstablisherFrame, - struct _CONTEXT *_ContextRecord, - struct _DISPATCHER_CONTEXT *_DispatcherContext) + struct _EXCEPTION_RECORD *ExceptionRecord, + void *EstablisherFrame, + struct _CONTEXT *ContextRecord, + struct _DISPATCHER_CONTEXT *DispatcherContext) { - UNIMPLEMENTED; - __debugbreak(); - return 0; + PSCOPE_TABLE ScopeTable; + ULONG i, BeginAddress, EndAddress, Handler; + ULONG64 ImageBase, JumpTarget, IpOffset, TargetIpOffset; + EXCEPTION_POINTERS ExceptionPointers; + PTERMINATION_HANDLER TerminationHandler; + PEXCEPTION_FILTER ExceptionFilter; + LONG FilterResult; + + /* Set up the EXCEPTION_POINTERS */ + ExceptionPointers.ExceptionRecord = ExceptionRecord; + ExceptionPointers.ContextRecord = ContextRecord; + + /* Get the image base */ + ImageBase = (ULONG64)DispatcherContext->ImageBase; + + /* Get the image base relative instruction pointers */ + IpOffset = DispatcherContext->ControlPc - ImageBase; + TargetIpOffset = DispatcherContext->TargetIp - ImageBase; + + /* Get the scope table and current index */ + ScopeTable = (PSCOPE_TABLE)DispatcherContext->HandlerData; + + /* Loop while we have scope table entries */ + while (DispatcherContext->ScopeIndex < ScopeTable->Count) + { + /* Use i as index and update the dispatcher context */ + i = DispatcherContext->ScopeIndex++; + + /* Get the start and end of the scrope */ + BeginAddress = ScopeTable->ScopeRecord[i].BeginAddress; + EndAddress = ScopeTable->ScopeRecord[i].EndAddress; + + /* Skip this scope if we are not within the bounds */ + if ((IpOffset < BeginAddress) || (IpOffset >= EndAddress)) + { + continue; + } + + /* Check if this is an unwind */ + if (ExceptionRecord->ExceptionFlags & EXCEPTION_UNWIND) + { + /* Check if this is a target unwind */ + if (ExceptionRecord->ExceptionFlags & EXCEPTION_TARGET_UNWIND) + { + /* Check if the target is within the scope itself */ + if ((TargetIpOffset >= BeginAddress) && + (TargetIpOffset < EndAddress)) + { + return ExceptionContinueSearch; + } + } + + /* Check if this is a termination handler / finally function */ + if (ScopeTable->ScopeRecord[i].JumpTarget == 0) + { + /* Call the handler */ + Handler = ScopeTable->ScopeRecord[i].HandlerAddress; + TerminationHandler = (PTERMINATION_HANDLER)(ImageBase + Handler); + TerminationHandler(TRUE, EstablisherFrame); + } + else if (ScopeTable->ScopeRecord[i].JumpTarget == TargetIpOffset) + { + return ExceptionContinueSearch; + } + } + else + { + /* We are only unterested in exception handlers */ + if (ScopeTable->ScopeRecord[i].JumpTarget == 0) + { + continue; + } + + /* This is an exception filter, get the handler address */ + Handler = ScopeTable->ScopeRecord[i].HandlerAddress; + + /* Check for hardcoded EXCEPTION_EXECUTE_HANDLER */ + if (Handler == EXCEPTION_EXECUTE_HANDLER) + { + /* This is our result */ + FilterResult = EXCEPTION_EXECUTE_HANDLER; + } + else + { + /* Otherwise we need to call the handler */ + ExceptionFilter = (PEXCEPTION_FILTER)(ImageBase + Handler); + FilterResult = ExceptionFilter(&ExceptionPointers, EstablisherFrame); + } + + if (FilterResult == EXCEPTION_CONTINUE_EXECUTION) + { + return ExceptionContinueExecution; + } + + if (FilterResult == EXCEPTION_EXECUTE_HANDLER) + { + JumpTarget = (ImageBase + ScopeTable->ScopeRecord[i].JumpTarget); + + /* Unwind to the target address (This does not return) */ + RtlUnwindEx(EstablisherFrame, + (PVOID)JumpTarget, + ExceptionRecord, + UlongToPtr(ExceptionRecord->ExceptionCode), + DispatcherContext->ContextRecord, + DispatcherContext->HistoryTable); + + /* Should not get here */ + __debugbreak(); + } + } + } + + /* Reached the end of the scope table */ + return ExceptionContinueSearch; } void __cdecl _local_unwind(void* frame, void* target)

3 years, 4 months

[reactos] 01/01: [CPL][APPWIZ] Make gecko download cancellable by keyboard (#3726)

by Katayama Hirofumi MZ

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2106bc4a8172ba26655d4… commit 2106bc4a8172ba26655d45a564ee0d2d2baa5d44 Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> AuthorDate: Sat Jun 5 18:21:25 2021 +0900 Commit: GitHub <noreply(a)github.com> CommitDate: Sat Jun 5 18:21:25 2021 +0900 [CPL][APPWIZ] Make gecko download cancellable by keyboard (#3726) We shouldn't disable nor hide the control with focus. CORE-17550, CORE-5737 --- dll/cpl/appwiz/addons.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/dll/cpl/appwiz/addons.c b/dll/cpl/appwiz/addons.c index 32e29f9a46f..b9c089f744f 100644 --- a/dll/cpl/appwiz/addons.c +++ b/dll/cpl/appwiz/addons.c @@ -388,9 +388,17 @@ static DWORD WINAPI download_proc(PVOID arg) static INT_PTR CALLBACK installer_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { + HWND hwndProgress, hwndInstallButton; switch(msg) { case WM_INITDIALOG: - ShowWindow(GetDlgItem(hwnd, ID_DWL_PROGRESS), SW_HIDE); + + hwndProgress = GetDlgItem(hwnd, ID_DWL_PROGRESS); + if (hwndProgress == GetFocus()) /* Avoid CORE-5737 */ + { + SendMessageW(hwnd, WM_NEXTDLGCTL, 0, FALSE); + } + ShowWindow(hwndProgress, SW_HIDE); + install_dialog = hwnd; return TRUE; @@ -410,7 +418,15 @@ static INT_PTR CALLBACK installer_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARA case ID_DWL_INSTALL: ShowWindow(GetDlgItem(hwnd, ID_DWL_PROGRESS), SW_SHOW); - EnableWindow(GetDlgItem(hwnd, ID_DWL_INSTALL), 0); + + /* CORE-17550: Never leave focus on a disabled control (Old/New/Thing p.228) */ + hwndInstallButton = GetDlgItem(hwnd, ID_DWL_INSTALL); + if (hwndInstallButton == GetFocus()) + { + SendMessageW(hwnd, WM_NEXTDLGCTL, 0, FALSE); + } + EnableWindow(hwndInstallButton, FALSE); + CloseHandle( CreateThread(NULL, 0, download_proc, NULL, 0, NULL)); return FALSE; }

3 years, 4 months

[reactos] 01/01: [WINETESTS] Workaround crashes in riched20:richole on VBox/KVM bots CORE-16799

by Joachim Henze

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ae574e16f878618ff898d… commit ae574e16f878618ff898dcf01e6ca20c4cdf169a Author: Joachim Henze <Joachim.Henze(a)reactos.org> AuthorDate: Fri Jun 4 20:04:20 2021 +0200 Commit: Joachim Henze <Joachim.Henze(a)reactos.org> CommitDate: Fri Jun 4 20:04:20 2021 +0200 [WINETESTS] Workaround crashes in riched20:richole on VBox/KVM bots CORE-16799 The crashes began when those tests were synced to Wine Staging 4.18 in 0.4.14-dev-419-g 76cf09cfea15911082245a65547fb67512b710ce WHS 2k3sp2 Before the revert implies the tests were actually ok: https://reactos.org/testman/compare.php?ids=77492 Disabling some of the tests is very unsatisfying of course, but at least allows us to observe again the results of the other tests from that suite. VBox https://reactos.org/testman/compare.php?ids=77504,77506 KVM https://reactos.org/testman/compare.php?ids=77502,77505 --- modules/rostests/winetests/riched20/richole.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/modules/rostests/winetests/riched20/richole.c b/modules/rostests/winetests/riched20/richole.c index 492bdc3fa9a..6de6c02901a 100644 --- a/modules/rostests/winetests/riched20/richole.c +++ b/modules/rostests/winetests/riched20/richole.c @@ -113,6 +113,7 @@ static ULONG get_refcount(IUnknown *iface) return IUnknown_Release(iface); } +#if 0 /*avoid CORE-16799*/ #define CHECK_TYPEINFO(disp,expected_riid) _check_typeinfo((IDispatch *)disp, expected_riid, __LINE__) static void _check_typeinfo(IDispatch* disp, REFIID expected_riid, int line) { @@ -137,12 +138,15 @@ static void _check_typeinfo(IDispatch* disp, REFIID expected_riid, int line) ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr); ITypeInfo_Release(typeinfo); } +#endif static void test_Interfaces(void) { IRichEditOle *reOle = NULL, *reOle1 = NULL; ITextDocument *txtDoc = NULL; +#if 0 /*avoid CORE-16799*/ ITextDocument2Old *txtDoc2Old = NULL; +#endif ITextSelection *txtSel = NULL, *txtSel2; IUnknown *punk; HRESULT hres; @@ -170,7 +174,9 @@ static void test_Interfaces(void) (void **) &txtDoc); ok(hres == S_OK, "IRichEditOle_QueryInterface\n"); ok(txtDoc != NULL, "IRichEditOle_QueryInterface\n"); +#if 0 /*avoid CORE-16799*/ CHECK_TYPEINFO(txtDoc, &IID_ITextDocument); +#endif hres = ITextDocument_GetSelection(txtDoc, NULL); ok(hres == E_INVALIDARG, "ITextDocument_GetSelection: 0x%x\n", hres); @@ -222,6 +228,7 @@ static void test_Interfaces(void) hres = IRichEditOle_QueryInterface(reOle, &IID_IOleInPlaceSite, (void **) &punk); ok(hres == E_NOINTERFACE, "IRichEditOle_QueryInterface\n"); +#if 0 /*avoid CORE-16799*/ hres = IRichEditOle_QueryInterface(reOle, &IID_ITextDocument2Old, (void **)&txtDoc2Old); ok(hres == S_OK, "IRichEditOle_QueryInterface\n"); ok(txtDoc2Old != NULL, "IRichEditOle_QueryInterface\n"); @@ -231,6 +238,7 @@ static void test_Interfaces(void) CHECK_TYPEINFO(txtDoc2Old, &IID_ITextDocument); ITextDocument2Old_Release(txtDoc2Old); +#endif ITextDocument_Release(txtDoc); IRichEditOle_Release(reOle); @@ -245,6 +253,7 @@ static void test_Interfaces(void) ITextSelection_Release(txtSel); +#if 0 /*avoid CORE-16799*/ w = new_richedit(NULL); res = SendMessageA(w, EM_GETOLEINTERFACE, 0, (LPARAM)&reOle); ok(res, "SendMessage\n"); @@ -257,6 +266,7 @@ static void test_Interfaces(void) ITextDocument2Old_Release(txtDoc2Old); IRichEditOle_Release(reOle); DestroyWindow(w); +#endif } static void test_ITextDocument_Open(void)

3 years, 4 months

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 June 2021