[Backtracing] Add control over symbol caching.

al45tair · al45tair · commit 13af9c611421 · 2023-03-03T11:49:30.000Z
Some symbolication frameworks have a symbol cache; we probably don't want
to use that for test cases, to avoid running into problems where the cache
holds stale information.

rdar://105409147
diff --git a/docs/Backtracing.rst b/docs/Backtracing.rst
@@ -92,6 +92,10 @@ follows:
 | top             | 16      | Specify a minimum number of frames to capture    |
 |                 |         | from the top of the stack.  See below for more.  |
 +-----------------+---------+--------------------------------------------------+
+| cache           | yes     | Set to ``no`` to disable symbol caching.  This   |
+|                 |         | only has effect on platforms that have a symbol  |
+|                 |         | cache that can be controlled by the runtime.     |
++-----------------+---------+--------------------------------------------------+
 | swift-backtrace |         | If specified, gives the full path to the         |
 |                 |         | swift-backtrace binary to use for crashes.       |
 |                 |         | Otherwise, Swift will locate the binary relative |
diff --git a/include/swift/Runtime/Backtrace.h b/include/swift/Runtime/Backtrace.h
@@ -111,6 +111,7 @@ struct BacktraceSettings {
   unsigned         top;
   SanitizePaths    sanitize;
   Preset           preset;
+  bool             cache;
   const char      *swiftBacktracePath;
 };
 
diff --git a/stdlib/public/Backtracing/Backtrace.swift b/stdlib/public/Backtracing/Backtrace.swift
@@ -444,15 +444,20 @@ public struct Backtrace: CustomStringConvertible, Sendable {
   ///                         running on, add virtual frames to show inline
   ///                         function calls.
   ///
+  /// @param useSymbolCache   If the system we are on has a symbol cache,
+  ///                         says whether or not to use it.
+  ///
   /// @returns A new `SymbolicatedBacktrace`.
   public func symbolicated(with images: [Image]? = nil,
                            sharedCacheInfo: SharedCacheInfo? = nil,
-                           showInlineFrames: Bool = true)
+                           showInlineFrames: Bool = true,
+                           useSymbolCache: Bool = true)
     -> SymbolicatedBacktrace? {
     return SymbolicatedBacktrace.symbolicate(backtrace: self,
                                              images: images,
                                              sharedCacheInfo: sharedCacheInfo,
-                                             showInlineFrames: showInlineFrames)
+                                             showInlineFrames: showInlineFrames,
+                                             useSymbolCache: useSymbolCache)
   }
 
   /// Provide a textual version of the backtrace.
diff --git a/stdlib/public/Backtracing/CoreSymbolication.swift b/stdlib/public/Backtracing/CoreSymbolication.swift
@@ -186,6 +186,7 @@ func CSIsNull(_ obj: CSTypeRef) -> Bool {
 
 // .. CSSymbolicator ...........................................................
 
+let kCSSymbolicatorDisallowDaemonCommunication = UInt32(0x00000800)
 
 struct BinaryRelocationInformation {
   var base: mach_vm_address_t
diff --git a/stdlib/public/Backtracing/SymbolicatedBacktrace.swift b/stdlib/public/Backtracing/SymbolicatedBacktrace.swift
@@ -259,6 +259,7 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
   /// Create a symbolicator.
   private static func withSymbolicator<T>(images: [Backtrace.Image],
                                           sharedCacheInfo: Backtrace.SharedCacheInfo?,
+                                          useSymbolCache: Bool,
                                           fn: (CSSymbolicatorRef) throws -> T) rethrows -> T {
     let binaryImageList = images.map{ image in
       BinaryImageInformation(
@@ -279,7 +280,9 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
     }
 
     let symbolicator = CSSymbolicatorCreateWithBinaryImageList(
-      binaryImageList, 0, nil
+      binaryImageList,
+      useSymbolCache ? 0 : kCSSymbolicatorDisallowDaemonCommunication,
+      nil
     )
 
     defer { CSRelease(symbolicator) }
@@ -345,7 +348,8 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
   internal static func symbolicate(backtrace: Backtrace,
                                    images: [Backtrace.Image]?,
                                    sharedCacheInfo: Backtrace.SharedCacheInfo?,
-                                   showInlineFrames: Bool)
+                                   showInlineFrames: Bool,
+                                   useSymbolCache: Bool)
     -> SymbolicatedBacktrace? {
 
     let theImages: [Backtrace.Image]
@@ -370,7 +374,8 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
 
     #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
     withSymbolicator(images: theImages,
-                     sharedCacheInfo: theCacheInfo) { symbolicator in
+                     sharedCacheInfo: theCacheInfo,
+                     useSymbolCache: useSymbolCache) { symbolicator in
       for frame in backtrace.frames {
         switch frame {
           case .omittedFrames(_), .truncated:
diff --git a/stdlib/public/libexec/swift-backtrace/Target.swift b/stdlib/public/libexec/swift-backtrace/Target.swift
@@ -141,7 +141,7 @@ class Target {
     }
   }
 
-  init(crashInfoAddr: UInt64, limit: Int?, top: Int) {
+  init(crashInfoAddr: UInt64, limit: Int?, top: Int, cache: Bool) {
     pid = getppid()
     if let parentTask = Self.getParentTask() {
       task = parentTask
@@ -177,10 +177,10 @@ class Target {
     images = Backtrace.captureImages(for: task)
     sharedCacheInfo = Backtrace.captureSharedCacheInfo(for: task)
 
-    fetchThreads(limit: limit, top: top)
+    fetchThreads(limit: limit, top: top, cache: cache)
   }
 
-  func fetchThreads(limit: Int?, top: Int) {
+  func fetchThreads(limit: Int?, top: Int, cache: Bool) {
     var threadPorts: thread_act_array_t? = nil
     var threadCount: mach_msg_type_number_t = 0
     let kr = task_threads(task,
@@ -248,7 +248,8 @@ class Target {
       }
 
       guard let symbolicated = backtrace.symbolicated(with: images,
-                                                      sharedCacheInfo: sharedCacheInfo) else {
+                                                      sharedCacheInfo: sharedCacheInfo,
+                                                      useSymbolCache: cache) else {
         print("unable to symbolicate backtrace from context for thread \(ndx)")
         exit(1)
       }
@@ -262,7 +263,7 @@ class Target {
     }
   }
 
-  public func redoBacktraces(limit: Int?, top: Int) {
+  public func redoBacktraces(limit: Int?, top: Int, cache: Bool) {
     for (ndx, thread) in threads.enumerated() {
       guard let context = thread.context else {
         continue
@@ -277,7 +278,8 @@ class Target {
       }
 
       guard let symbolicated = backtrace.symbolicated(with: images,
-                                                      sharedCacheInfo: sharedCacheInfo) else {
+                                                      sharedCacheInfo: sharedCacheInfo,
+                                                      useSymbolCache: cache) else {
         print("unable to symbolicate backtrace from context for thread \(ndx)")
         continue
       }
diff --git a/stdlib/public/libexec/swift-backtrace/main.swift b/stdlib/public/libexec/swift-backtrace/main.swift
@@ -65,6 +65,7 @@ internal struct SwiftBacktrace {
     var limit: Int? = 64
     var top = 16
     var sanitize: Bool? = nil
+    var cache = true
   }
 
   static var args = Arguments()
@@ -83,7 +84,7 @@ internal struct SwiftBacktrace {
 
   static func usage() {
     print("""
-usage: swift-backtrace [--unwind <algorithm>] [--demangle [<bool>]] [--interactive [<bool>]] [--color [<bool>]] [--timeout <seconds>] [--preset <preset>] [--threads [<bool>]] [--registers <registers>] [--images <images>] --crashinfo <addr>
+usage: swift-backtrace [--unwind <algorithm>] [--demangle [<bool>]] [--interactive [<bool>]] [--color [<bool>]] [--timeout <seconds>] [--preset <preset>] [--threads [<bool>]] [--registers <registers>] [--images <images>] [--cache [<bool>]] --crashinfo <addr>
 
 Generate a backtrace for the parent process.
 
@@ -130,6 +131,8 @@ Generate a backtrace for the parent process.
 --sanitize [<bool>]
 -s [<bool>]             Set whether or not to sanitize paths.
 
+--cache [<bool>]        Set whether or not to use the symbol cache, if any.
+
 --crashinfo <addr>
 -a <addr>               Provide a pointer to a platform specific CrashInfo
                         structure.  <addr> should be in hexadecimal.
@@ -295,6 +298,12 @@ Generate a backtrace for the parent process.
         } else {
           args.sanitize = true
         }
+      case "--cache":
+        if let v = value {
+          args.cache = parseBool(v)
+        } else {
+          args.cache = true
+        }
       case "-a", "--crashinfo":
         if let v = value {
           if let a = UInt64(v, radix: 16) {
@@ -381,7 +390,8 @@ Generate a backtrace for the parent process.
     formattingOptions = formattingOptions.showImages(.none)
 
     target = Target(crashInfoAddr: crashInfoAddr,
-                    limit: args.limit, top: args.top)
+                    limit: args.limit, top: args.top,
+                    cache: args.cache)
 
     currentThread = target!.crashingThreadNdx
 
@@ -903,7 +913,9 @@ Generate a backtrace for the parent process.
                 }
 
                 if changedBacktrace {
-                  target.redoBacktraces(limit: args.limit, top: args.top)
+                  target.redoBacktraces(limit: args.limit,
+                                        top: args.top,
+                                        cache: args.cache)
                 }
               }
             }
diff --git a/stdlib/public/runtime/Backtrace.cpp b/stdlib/public/runtime/Backtrace.cpp
@@ -104,6 +104,9 @@ SWIFT_RUNTIME_STDLIB_INTERNAL BacktraceSettings _swift_backtraceSettings = {
   // preset
   Preset::Auto,
 
+  // cache
+  true,
+
   // swiftBacktracePath
   NULL,
 };
@@ -599,6 +602,8 @@ _swift_processBacktracingSetting(llvm::StringRef key,
                      "swift runtime: bad backtrace top count '%.*s'\n",
                      static_cast<int>(value.size()), value.data());
     }
+  } else if (key.equals_insensitive("cache")) {
+    _swift_backtraceSettings.cache = parseBoolean(value);
   } else if (key.equals_insensitive("swift-backtrace")) {
     size_t len = value.size();
     char *path = (char *)std::malloc(len + 1);
diff --git a/stdlib/public/runtime/CrashHandlerMacOS.cpp b/stdlib/public/runtime/CrashHandlerMacOS.cpp
@@ -268,6 +268,8 @@ const char *backtracer_argv[] = {
   top_buf,                      // 24
   "--sanitize",                 // 25
   "preset",                     // 26
+  "--cache",                    // 27
+  "true",                       // 28
   NULL
 };
 
@@ -440,6 +442,8 @@ run_backtracer()
     break;
   }
 
+  backtracer_argv[28] = trueOrFalse(_swift_backtraceSettings.cache);
+
   format_unsigned(_swift_backtraceSettings.timeout, timeout_buf);
 
   if (_swift_backtraceSettings.limit < 0)
diff --git a/test/Backtracing/Crash.swift b/test/Backtracing/Crash.swift
@@ -7,11 +7,11 @@
 // RUN: %target-codesign %t/CrashNoDebug
 // RUN: %target-codesign %t/CrashOpt
 // RUN: %target-codesign %t/CrashOptNoDebug
-// RUN: (env SWIFT_BACKTRACE=enable=yes %target-run %t/Crash || true) | %FileCheck %s
-// RUN: (env SWIFT_BACKTRACE=preset=friendly,enable=yes %target-run %t/Crash || true) | %FileCheck %s --check-prefix FRIENDLY
-// RUN: (env SWIFT_BACKTRACE=enable=yes %target-run %t/CrashNoDebug || true) | %FileCheck %s --check-prefix NODEBUG
-// RUN: (env SWIFT_BACKTRACE=enable=yes %target-run %t/CrashOpt || true) | %FileCheck %s --check-prefix OPTIMIZED
-// RUN: (env SWIFT_BACKTRACE=enable=yes %target-run %t/CrashOptNoDebug || true) | %FileCheck %s --check-prefix OPTNODEBUG
+// RUN: (env SWIFT_BACKTRACE=enable=yes,cache=no %target-run %t/Crash || true) | %FileCheck %s
+// RUN: (env SWIFT_BACKTRACE=preset=friendly,enable=yes,cache=no %target-run %t/Crash || true) | %FileCheck %s --check-prefix FRIENDLY
+// RUN: (env SWIFT_BACKTRACE=enable=yes,cache=no %target-run %t/CrashNoDebug || true) | %FileCheck %s --check-prefix NODEBUG
+// RUN: (env SWIFT_BACKTRACE=enable=yes,cache=no %target-run %t/CrashOpt || true) | %FileCheck %s --check-prefix OPTIMIZED
+// RUN: (env SWIFT_BACKTRACE=enable=yes,cache=no %target-run %t/CrashOptNoDebug || true) | %FileCheck %s --check-prefix OPTNODEBUG
 
 // REQUIRES: executable_test
 // REQUIRES: OS=macosx
diff --git a/test/Backtracing/CrashWithThunk.swift b/test/Backtracing/CrashWithThunk.swift
@@ -1,8 +1,8 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-build-swift %s -parse-as-library -Onone -g -o %t/CrashWithThunk
 // RUN: %target-codesign %t/CrashWithThunk
-// RUN: (env SWIFT_BACKTRACE=enable=yes %target-run %t/CrashWithThunk || true) | %FileCheck %s
-// RUN: (env SWIFT_BACKTRACE=preset=friendly,enable=yes %target-run %t/CrashWithThunk || true) | %FileCheck %s --check-prefix FRIENDLY
+// RUN: (env SWIFT_BACKTRACE=enable=yes,cache=no %target-run %t/CrashWithThunk || true) | %FileCheck %s
+// RUN: (env SWIFT_BACKTRACE=preset=friendly,enable=yes,cache=no %target-run %t/CrashWithThunk || true) | %FileCheck %s --check-prefix FRIENDLY
 
 // REQUIRES: executable_test
 // REQUIRES: OS=macosx
diff --git a/test/Backtracing/Overflow.swift b/test/Backtracing/Overflow.swift
@@ -1,8 +1,8 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-build-swift %s -parse-as-library -Onone -g -o %t/Overflow
 // RUN: %target-codesign %t/Overflow
-// RUN: (env SWIFT_BACKTRACE=enable=yes %target-run %t/Overflow || true) | %FileCheck %s
-// RUN: (env SWIFT_BACKTRACE=preset=friendly,enable=yes %target-run %t/Overflow || true) | %FileCheck %s --check-prefix FRIENDLY
+// RUN: (env SWIFT_BACKTRACE=enable=yes,cache=no %target-run %t/Overflow || true) | %FileCheck %s
+// RUN: (env SWIFT_BACKTRACE=preset=friendly,enable=yes,cache=no %target-run %t/Overflow || true) | %FileCheck %s --check-prefix FRIENDLY
 
 // REQUIRES: executable_test
 // REQUIRES: OS=macosx
@@ -42,11 +42,11 @@ struct Overflow {
 // CHECK: Thread 0 crashed:
 
 // CHECK:      0 [inlined] [system] 0x{{[0-9a-f]+}} Swift runtime failure: arithmetic overflow in Overflow at {{.*}}/<compiler-generated>
-// CHECK-NEXT: 1                    0x{{[0-9a-f]+}} level5() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:{{30|29}}:5
-// CHECK-NEXT: 2 [ra]               0x{{[0-9a-f]+}} level4() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:{{24|23}}:3
-// CHECK-NEXT: 3 [ra]               0x{{[0-9a-f]+}} level3() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:{{20|19}}:3
-// CHECK-NEXT: 4 [ra]               0x{{[0-9a-f]+}} level2() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:{{16|15}}:3
-// CHECK-NEXT: 5 [ra]               0x{{[0-9a-f]+}} level1() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:{{12|11}}:3
+// CHECK-NEXT: 1                    0x{{[0-9a-f]+}} level5() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:30:5
+// CHECK-NEXT: 2 [ra]               0x{{[0-9a-f]+}} level4() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:24:3
+// CHECK-NEXT: 3 [ra]               0x{{[0-9a-f]+}} level3() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:20:3
+// CHECK-NEXT: 4 [ra]               0x{{[0-9a-f]+}} level2() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:16:3
+// CHECK-NEXT: 5 [ra]               0x{{[0-9a-f]+}} level1() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:12:3
 // CHECK-NEXT: 6 [ra]               0x{{[0-9a-f]+}} static Overflow.main() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:36:5
 // CHECK-NEXT: 7 [ra] [system]      0x{{[0-9a-f]+}} static Overflow.$main() + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift:33:1
 // CHECK-NEXT: 8 [ra] [system]      0x{{[0-9a-f]+}} main + {{[0-9]+}} in Overflow at {{.*}}/Overflow.swift
diff --git a/test/Backtracing/StackOverflow.swift b/test/Backtracing/StackOverflow.swift
diff --git a/test/Backtracing/SymbolicatedBacktrace.swift b/test/Backtracing/SymbolicatedBacktrace.swift
diff --git a/test/Backtracing/SymbolicatedBacktraceInline.swift b/test/Backtracing/SymbolicatedBacktraceInline.swift

Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ class Target {`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`
`144`		`- init(crashInfoAddr: UInt64, limit: Int?, top: Int) {`
	`144`	`+ init(crashInfoAddr: UInt64, limit: Int?, top: Int, cache: Bool) {`
`145`	`145`	`pid = getppid()`
`146`	`146`	`if let parentTask = Self.getParentTask() {`
`147`	`147`	`task = parentTask`
`@@ -177,10 +177,10 @@ class Target {`
`177`	`177`	`images = Backtrace.captureImages(for: task)`
`178`	`178`	`sharedCacheInfo = Backtrace.captureSharedCacheInfo(for: task)`
`179`	`179`
`180`		`- fetchThreads(limit: limit, top: top)`
	`180`	`+ fetchThreads(limit: limit, top: top, cache: cache)`
`181`	`181`	`}`
`182`	`182`
`183`		`- func fetchThreads(limit: Int?, top: Int) {`
	`183`	`+ func fetchThreads(limit: Int?, top: Int, cache: Bool) {`
`184`	`184`	`var threadPorts: thread_act_array_t? = nil`
`185`	`185`	`var threadCount: mach_msg_type_number_t = 0`
`186`	`186`	`let kr = task_threads(task,`
`@@ -248,7 +248,8 @@ class Target {`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`guard let symbolicated = backtrace.symbolicated(with: images,`
`251`		`- sharedCacheInfo: sharedCacheInfo) else {`
	`251`	`+ sharedCacheInfo: sharedCacheInfo,`
	`252`	`+ useSymbolCache: cache) else {`
`252`	`253`	`print("unable to symbolicate backtrace from context for thread \(ndx)")`
`253`	`254`	`exit(1)`
`254`	`255`	`}`
`@@ -262,7 +263,7 @@ class Target {`
`262`	`263`	`}`
`263`	`264`	`}`
`264`	`265`
`265`		`- public func redoBacktraces(limit: Int?, top: Int) {`
	`266`	`+ public func redoBacktraces(limit: Int?, top: Int, cache: Bool) {`
`266`	`267`	`for (ndx, thread) in threads.enumerated() {`
`267`	`268`	`guard let context = thread.context else {`
`268`	`269`	`continue`
`@@ -277,7 +278,8 @@ class Target {`
`277`	`278`	`}`
`278`	`279`
`279`	`280`	`guard let symbolicated = backtrace.symbolicated(with: images,`
`280`		`- sharedCacheInfo: sharedCacheInfo) else {`
	`281`	`+ sharedCacheInfo: sharedCacheInfo,`
	`282`	`+ useSymbolCache: cache) else {`
`281`	`283`	`print("unable to symbolicate backtrace from context for thread \(ndx)")`
`282`	`284`	`continue`
`283`	`285`	`}`