Add PrivateSentrySDKOnly.isManagedRuntime

Author: jpnurmi

Sources/Sentry/PrivateSentrySDKOnly.m

@@ -33,6 +33,7 @@ @implementation PrivateSentrySDKOnly
 
 static SentryOnAppStartMeasurementAvailable _onAppStartMeasurementAvailable;
 static BOOL _appStartMeasurementHybridSDKMode = NO;
+static BOOL _isManagedRuntime = NO;
 #if SENTRY_HAS_UIKIT
 static BOOL _framesTrackingMeasurementHybridSDKMode = NO;
 #endif // SENTRY_HAS_UIKIT
@@ -169,6 +170,16 @@ + (void)setAppStartMeasurementHybridSDKMode:(BOOL)appStartMeasurementHybridSDKMo
     _appStartMeasurementHybridSDKMode = appStartMeasurementHybridSDKMode;
 }
 
++ (BOOL)isManagedRuntime
+{
+    return _isManagedRuntime;
+}
+
++ (void)setIsManagedRuntime:(BOOL)isManagedRuntime
+{
+    _isManagedRuntime = isManagedRuntime;
+}
+
 + (void)setSdkName:(NSString *)sdkName andVersionString:(NSString *)versionString
 {
     SentryMeta.sdkName = sdkName;

Sources/Sentry/SentryCrashIntegration.m

@@ -1,6 +1,7 @@
 #import "SentryCrashIntegration.h"
 #import "SentryCrashInstallationReporter.h"
 
+#import "PrivateSentrySDKOnly.h"
 #import "SentryCrashC.h"
 #import "SentryCrashIntegrationSessionHandler.h"
 #import "SentryCrashMonitor_CPPException.h"
@@ -157,6 +158,7 @@ - (void)startCrashHandler:(NSString *)cacheDirectory
         }
 
         sentrycrashcm_setEnableSigtermReporting(enableSigtermReporting);
+        sentrycrashcm_setManagedRuntime([PrivateSentrySDKOnly isManagedRuntime]);
 
         [installation install:cacheDirectory];
 

Sources/Sentry/include/HybridPublic/PrivateSentrySDKOnly.h

@@ -153,6 +153,12 @@ typedef void (^SentryOnAppStartMeasurementAvailable)(
  */
 @property (class, nonatomic, assign) BOOL appStartMeasurementHybridSDKMode;
 
+/**
+ * Whether the SDK is running in a managed Mono/CoreCLR runtime environment and
+ * needs to chain Unix signal handlers.
+ */
+@property (class, nonatomic, assign) BOOL isManagedRuntime;
+
 #if SENTRY_UIKIT_AVAILABLE
 /**
  * Allows hybrid SDKs to enable frame tracking measurements despite other options.

Sources/Sentry/include/SentryCrashMonitor.h

@@ -93,6 +93,13 @@ bool sentrycrashcm_notifyFatalExceptionCaptured(bool isAsyncSafeEnvironment);
  */
 void sentrycrashcm_handleException(struct SentryCrash_MonitorContext *context);
 
+/** Whether to chain Unix signal handlers for managed Mono/CoreCLR runtimes, and
+ * whether to register null Mach exception ports for EXC_MASK_BAD_ACCESS and
+ * EXC_MASK_ARITHMETIC.
+ */
+bool sentrycrashcm_isManagedRuntime(void);
+void sentrycrashcm_setManagedRuntime(bool isManagedRuntime);
+
 #ifdef __cplusplus
 }
 #endif

Sources/SentryCrash/Recording/Monitors/SentryCrashMonitor.c

@@ -85,6 +85,7 @@ static SentryCrashMonitorType g_activeMonitors = SentryCrashMonitorTypeNone;
 static bool g_handlingFatalException = false;
 static bool g_crashedDuringExceptionHandling = false;
 static bool g_requiresAsyncSafety = false;
+static bool g_isManagedRuntime = false;
 
 static void (*g_onExceptionEvent)(struct SentryCrash_MonitorContext *monitorContext);
 
@@ -226,3 +227,13 @@ sentrycrashcm_handleException(struct SentryCrash_MonitorContext *context)
         sentrycrashcm_setActiveMonitors(SentryCrashMonitorTypeNone);
     }
 }
+
+bool sentrycrashcm_isManagedRuntime(void)
+{
+    return g_isManagedRuntime;
+}
+
+void sentrycrashcm_setManagedRuntime(bool isManagedRuntime)
+{
+    g_isManagedRuntime = isManagedRuntime;
+}

Sources/SentryCrash/Recording/Monitors/SentryCrashMonitor_MachException.c

@@ -487,8 +487,8 @@ installExceptionHandler(void)
     }
 
     if (sentrycrashcm_isManagedRuntime()) {
-        SENTRY_ASYNC_SAFE_LOG_DEBUG("Detected managed Mono/CoreCLR runtime. Not registering "
-                                    "exception port for EXC_BAD_ACCESS or EXC_MASK_ARITHMETIC.");
+        SENTRY_ASYNC_SAFE_LOG_DEBUG("Not registering Mach exception port for EXC_BAD_ACCESS "
+                                    "or EXC_MASK_ARITHMETIC in a managed Mono/CoreCLR runtime");
         mask &= ~(EXC_MASK_BAD_ACCESS | EXC_MASK_ARITHMETIC);
     }
 
@@ -568,23 +568,6 @@ addContextualInfoToEvent(struct SentryCrash_MonitorContext *eventContext)
 
 #endif // SENTRY_HAS_MACH
 
-bool
-sentrycrashcm_isManagedRuntime(void)
-{
-#if SENTRY_HAS_MACH
-    for (mach_msg_type_number_t i = 0; i < g_previousExceptionPorts.count; i++) {
-        // https://github.com/dotnet/runtime/blob/6d96e28597e7da0d790d495ba834cc4908e442cd/src/mono/mono/mini/mini-darwin.c#L85-L90
-        // https://github.com/dotnet/runtime/blob/6d96e28597e7da0d790d495ba834cc4908e442cd/src/coreclr/nativeaot/Runtime/unix/HardwareExceptions.cpp#L615-L621
-        if (g_previousExceptionPorts.masks[i] == (EXC_MASK_BAD_ACCESS | EXC_MASK_ARITHMETIC)
-            && g_previousExceptionPorts.behaviors[i] == EXCEPTION_STATE_IDENTITY
-            && g_previousExceptionPorts.flavors[i] == MACHINE_THREAD_STATE) {
-            return true;
-        }
-    }
-#endif // SENTRY_HAS_MACH
-    return false;
-}
-
 SentryCrashMonitorAPI *
 sentrycrashcm_machexception_getAPI(void)
 {

Sources/SentryCrash/Recording/Monitors/SentryCrashMonitor_MachException.h

@@ -49,10 +49,6 @@ bool sentrycrashcm_isReservedThread(thread_t thread);
  */
 bool sentrycrashcm_hasReservedThreads(void);
 
-/** Detect managed Mono/CoreCLR runtime's Mach exception port.
- */
-bool sentrycrashcm_isManagedRuntime(void);
-
 #ifdef __cplusplus
 }
 #endif

Sources/SentryCrash/Recording/Monitors/SentryCrashMonitor_Signal.c

@@ -51,7 +51,6 @@
 
 static volatile bool g_isEnabled = false;
 static bool g_isSigtermReportingEnabled = false;
-static bool g_isManagedRuntime = false;
 
 static SentryCrash_MonitorContext g_monitorContext;
 static SentryCrashStackCursor g_stackCursor;
@@ -110,9 +109,9 @@ handleSignal(int sigNum, siginfo_t *signalInfo, void *userContext)
 {
     SENTRY_ASYNC_SAFE_LOG_DEBUG("Trapped signal %d", sigNum);
 
-    // Let managed Mono/CoreCLR runtime handle the signal first,
-    // as they may convert it into a managed exception.
-    if (g_isManagedRuntime) {
+    if (sentrycrashcm_isManagedRuntime()) {
+        // Let managed Mono/CoreCLR runtime handle the signal first,
+        // as they may convert it into a managed exception.
         SENTRY_ASYNC_SAFE_LOG_DEBUG(
             "Detected managed Mono/CoreCLR runtime. Passing signal to previous handlers.");
 
@@ -161,7 +160,7 @@ handleSignal(int sigNum, siginfo_t *signalInfo, void *userContext)
 
     // Re-raise the signal to invoke the previous handlers unless already called
     // above for managed runtimes.
-    if (!g_isManagedRuntime) {
+    if (!sentrycrashcm_isManagedRuntime()) {
         SENTRY_ASYNC_SAFE_LOG_DEBUG("Re-raising signal for regular handlers to catch.");
         // This is technically not allowed, but it works in OSX and iOS.
         raise(sigNum);
@@ -177,8 +176,6 @@ installSignalHandler(void)
 {
     SENTRY_ASYNC_SAFE_LOG_DEBUG("Installing signal handler.");
 
-    g_isManagedRuntime = sentrycrashcm_isManagedRuntime();
-
 #    if SENTRY_HAS_SIGNAL_STACK
 
     if (g_signalStack.ss_size == 0) {