1 files changed, 71 insertions, 0 deletions
diff --git a/packaging/0024-sigsegv_handler-handle-case-when-it-is-called-on-ori.patch b/packaging/0024-sigsegv_handler-handle-case-when-it-is-called-on-ori.patch
new file mode 100644
index 0000000000..08678dd416
--- /dev/null
+++ b/packaging/0024-sigsegv_handler-handle-case-when-it-is-called-on-ori.patch
@@ -0,0 +1,71 @@
+From 8b1bff743895942364a26df78ad1dd2f14760f28 Mon Sep 17 00:00:00 2001
+From: Konstantin Baladurin <k.baladurin@partner.samsung.com>
+Date: Tue, 13 Feb 2018 16:27:01 +0300
+Subject: [PATCH 24/47] sigsegv_handler: handle case when it is called on
+ original stack
+
+If sigsegv_handler is called on original stack (for example, if segmentation
+fault occurs in native application's thread that hasn't alternate signal stack)
+we should call common_signal_handler directly othersize sigsegv_handler's
+stackframe will be corrupted.
+---
+ src/pal/src/exception/signal.cpp | 38 ++++++++++++++++++++++++++------------
+ 1 file changed, 26 insertions(+), 12 deletions(-)
+
+diff --git a/src/pal/src/exception/signal.cpp b/src/pal/src/exception/signal.cpp
+index f795b81..bf48619 100644
+--- a/src/pal/src/exception/signal.cpp
++++ b/src/pal/src/exception/signal.cpp
+@@ -472,23 +472,37 @@ static void sigsegv_handler(int code, siginfo_t *siginfo, void *context)
+ 
+         // Establish a return point in case the common_signal_handler returns
+ 
+-        volatile bool contextInitialization = true;
++        if (GetCurrentPalThread())
++        {
++            volatile bool contextInitialization = true;
+ 
+-        SignalHandlerWorkerReturnPoint returnPoint;
+-        RtlCaptureContext(&returnPoint.context);
++            void *ptr = alloca(sizeof(SignalHandlerWorkerReturnPoint) + alignof(SignalHandlerWorkerReturnPoint) - 1);
++            SignalHandlerWorkerReturnPoint *pReturnPoint = (SignalHandlerWorkerReturnPoint *)ALIGN_UP(ptr, alignof(SignalHandlerWorkerReturnPoint));
++            RtlCaptureContext(&pReturnPoint->context);
+ 
+-        // When the signal handler worker completes, it uses setcontext to return to this point
++            // When the signal handler worker completes, it uses setcontext to return to this point
+ 
+-        if (contextInitialization)
+-        {
+-            contextInitialization = false;
+-            ExecuteHandlerOnOriginalStack(code, siginfo, context, &returnPoint);
+-            _ASSERTE(FALSE); // The ExecuteHandlerOnOriginalStack should never return
++            if (contextInitialization)
++            {
++                contextInitialization = false;
++                ExecuteHandlerOnOriginalStack(code, siginfo, context, pReturnPoint);
++                _ASSERTE(FALSE); // The ExecuteHandlerOnOriginalStack should never return
++            }
++
++            if (pReturnPoint->returnFromHandler)
++            {
++                return;
++            }
+         }
+-        
+-        if (returnPoint.returnFromHandler)
++        else
+         {
+-            return;
++            // If thread isn't created by coreclr and has alternate signal stack GetCurrentPalThread() will return NULL too.
++            // But since in this case we don't handle hardware exceptions (IsSafeToHandleHardwareException returns false)
++            // we can call common_signal_handler on the alternate stack.
++            if (common_signal_handler(code, siginfo, context, 2, (size_t)0, (size_t)siginfo->si_addr))
++            {
++                return;
++            }
+         }
+     }
+ 
+-- 
+2.7.4
+