Make async unsafe more clear (#5610)

Author: noahsmartin

Sources/Sentry/SentryThreadInspector.m

@@ -28,9 +28,11 @@ @interface SentryThreadInspector ()
 
 // We need a C function to retrieve information from the stack trace in order to avoid
 // calling into not async-signal-safe code while there are suspended threads.
+// If asyncUnsafeSymbolicate is `true` the stack will be symbolicated but the function is no longer
+// async-signal-safe.
 unsigned int
 getStackEntriesFromThread(SentryCrashThread thread, struct SentryCrashMachineContext *context,
-    SentryCrashStackEntry *buffer, unsigned int maxEntries, bool symbolicate)
+    SentryCrashStackEntry *buffer, unsigned int maxEntries, bool asyncUnsafeSymbolicate)
 {
     sentrycrashmc_getContextForThread(thread, context, NO);
     SentryCrashStackCursor stackCursor;
@@ -41,7 +43,7 @@ @interface SentryThreadInspector ()
     while (stackCursor.advanceCursor(&stackCursor)) {
         if (entries == maxEntries)
             break;
-        if (symbolicate == false || stackCursor.symbolicate(&stackCursor)) {
+        if (asyncUnsafeSymbolicate == false || stackCursor.symbolicate(&stackCursor)) {
             buffer[entries] = stackCursor.stackEntry;
             entries++;
         }

Sources/Sentry/SentryUseNSExceptionCallstackWrapper.m

@@ -45,7 +45,7 @@ - (instancetype)initWithName:(NSExceptionName)aName
         enumerateObjectsUsingBlock:^(NSNumber *_Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
             SentryCrashStackCursor stackCursor;
             stackCursor.stackEntry.address = [obj unsignedLongValue];
-            sentrycrashsymbolicator_symbolicate(&stackCursor);
+            sentrycrashsymbolicator_symbolicate_async_unsafe_sentryDlAddr(&stackCursor);
 
             [frames addObject:[crashStackToEntryMapper
                                   sentryCrashStackEntryToSentryFrame:stackCursor.stackEntry]];

Sources/SentryCrash/Recording/Tools/SentryCrashStackCursor.c

@@ -56,7 +56,7 @@ void
 sentrycrashsc_initCursor(SentryCrashStackCursor *cursor,
     void (*resetCursor)(SentryCrashStackCursor *), bool (*advanceCursor)(SentryCrashStackCursor *))
 {
-    cursor->symbolicate = sentrycrashsymbolicator_symbolicate;
+    cursor->symbolicate = sentrycrashsymbolicator_symbolicate_async_unsafe_sentryDlAddr;
     cursor->advanceCursor = advanceCursor != NULL ? advanceCursor : g_advanceCursor;
     cursor->resetCursor = resetCursor != NULL ? resetCursor : sentrycrashsc_resetCursor;
     cursor->resetCursor(cursor);

Sources/SentryCrash/Recording/Tools/SentryCrashSymbolicator.c

@@ -51,7 +51,7 @@
 #define CALL_INSTRUCTION_FROM_RETURN_ADDRESS(A) (DETAG_INSTRUCTION_ADDRESS((A)) - 1)
 
 static bool
-symbolicate_internal(SentryCrashStackCursor *cursor, bool asyncUnsafe)
+symbolicate_internal(SentryCrashStackCursor *cursor, bool useDlAddr)
 {
     if (cursor->stackEntry.address == SentryCrashSC_ASYNC_MARKER) {
         cursor->stackEntry.imageAddress = 0;
@@ -65,7 +65,7 @@ symbolicate_internal(SentryCrashStackCursor *cursor, bool asyncUnsafe)
 
     bool symbols_succeed = false;
 
-    if (asyncUnsafe) {
+    if (useDlAddr) {
         symbols_succeed = dladdr((void *)cursor->stackEntry.address, &symbolsBuffer) != 0;
     } else {
         // sentrycrashdl_dladdr isn't async safe, but we've been using it for
@@ -91,13 +91,15 @@ symbolicate_internal(SentryCrashStackCursor *cursor, bool asyncUnsafe)
 }
 
 bool
-sentrycrashsymbolicator_symbolicate(SentryCrashStackCursor *cursor)
+sentrycrashsymbolicator_symbolicate_async_unsafe_sentryDlAddr(SentryCrashStackCursor *cursor)
 {
+    // Symbolicate using `sentrycrashdl_dladdr` note this is not async-signal-safe
     return symbolicate_internal(cursor, false);
 }
 
 bool
 sentrycrashsymbolicator_symbolicate_async_unsafe(SentryCrashStackCursor *cursor)
 {
+    // Symbolicate using `dladdr` note this is not async-signal-safe
     return symbolicate_internal(cursor, true);
 }

Sources/SentryCrash/Recording/Tools/SentryCrashSymbolicator.h

@@ -39,9 +39,9 @@ extern "C" {
  *
  * @return True if successful.
  */
-bool sentrycrashsymbolicator_symbolicate(SentryCrashStackCursor *cursor);
+bool sentrycrashsymbolicator_symbolicate_async_unsafe_sentryDlAddr(SentryCrashStackCursor *cursor);
 
-/** Same as ``sentrycrashsymbolicator_symbolicate`` but faster and async unsafe.
+/** Same as ``sentrycrashsymbolicator_symbolicate_async_unsafe_sentryDlAddr`` but faster.
  */
 bool sentrycrashsymbolicator_symbolicate_async_unsafe(SentryCrashStackCursor *cursor);