Async safe number to string conversion (#10)

* Async-safe number-to-string conversion

* Changes requested in code review

---------

Co-authored-by: Robert <[email protected]>

Author: 2 people

Samples/Common/Sources/IntegrationTestsHelper/InstallConfig.swift

@@ -31,6 +31,7 @@ public struct InstallConfig: Codable {
     public var installPath: String
     public var isCxaThrowEnabled: Bool?
     public var isSigTermMonitoringEnabled: Bool?
+    public var isMemoryIntrospectionEnabled: Bool?
 
     public init(installPath: String) {
         self.installPath = installPath
@@ -47,6 +48,9 @@ extension InstallConfig {
         if let isSigTermMonitoringEnabled {
             config.enableSigTermMonitoring = isSigTermMonitoringEnabled
         }
+        if let isMemoryIntrospectionEnabled {
+            config.enableMemoryIntrospection = isMemoryIntrospectionEnabled
+        }
         try KSCrash.shared.install(with: config)
     }
 }

Samples/Tests/Core/PartialCrashReport.swift

@@ -85,11 +85,16 @@ struct PartialCrashReport: Decodable {
 
                 var contents: [Frame]
             }
+            struct Address: Decodable {
+                var address: UInt64?
+                var type: String?
+            }
 
             var index: Int
             var state: String?
             var crashed: Bool
             var backtrace: Backtrace
+            var notable_addresses: [String: Address]?
         }
 
         var error: Error?

Samples/Tests/IntegrationTests.swift

@@ -113,6 +113,20 @@ final class CppTests: IntegrationTestBase {
             print(appleReport)
             XCTAssertTrue(appleReport.contains("SIGTERM"))
         }
+
+        func testTerminationWithMemoryIntrospection() throws {
+            try launchAndInstall { config in
+                config.isSigTermMonitoringEnabled = true
+                config.isMemoryIntrospectionEnabled = true
+            }
+            try terminate()
+
+            let rawReport = try readPartialCrashReport()
+            try rawReport.validate()
+            XCTAssertNotNil(rawReport.crash?.threads?.first?.notable_addresses)
+            XCTAssertTrue(
+                rawReport.crash?.threads?.first?.notable_addresses?.keys.contains { $0.hasPrefix("stack@0x") } ?? false)
+        }
     }
 
 #endif

Sources/KSCrashCore/include/KSCrashNamespace.h

@@ -177,10 +177,7 @@
 #define isSwiftSymbol KSCRASH_NS(isSwiftSymbol)
 #define ksapp_transitionStateIsUserPerceptible KSCRASH_NS(ksapp_transitionStateIsUserPerceptible)
 #define ksapp_transitionStateToString KSCRASH_NS(ksapp_transitionStateToString)
-#define ksbic_imageCount KSCRASH_NS(ksbic_imageCount)
-#define ksbic_imageHeader KSCRASH_NS(ksbic_imageHeader)
-#define ksbic_imageName KSCRASH_NS(ksbic_imageName)
-#define ksbic_imageVMAddrSlide KSCRASH_NS(ksbic_imageVMAddrSlide)
+#define ksbic_getImages KSCRASH_NS(ksbic_getImages)
 #define ksbic_init KSCRASH_NS(ksbic_init)
 #define ksbic_resetCache KSCRASH_NS(ksbic_resetCache)
 #define ksbt_captureBacktrace KSCRASH_NS(ksbt_captureBacktrace)
@@ -272,12 +269,8 @@
 #define ksdate_utcStringFromMicroseconds KSCRASH_NS(ksdate_utcStringFromMicroseconds)
 #define ksdate_utcStringFromTimestamp KSCRASH_NS(ksdate_utcStringFromTimestamp)
 #define ksdebug_isBeingTraced KSCRASH_NS(ksdebug_isBeingTraced)
+#define ksdl_binaryImageForHeader KSCRASH_NS(ksdl_binaryImageForHeader)
 #define ksdl_dladdr KSCRASH_NS(ksdl_dladdr)
-#define ksdl_getBinaryImage KSCRASH_NS(ksdl_getBinaryImage)
-#define ksdl_getBinaryImageForHeader KSCRASH_NS(ksdl_getBinaryImageForHeader)
-#define ksdl_imageCount KSCRASH_NS(ksdl_imageCount)
-#define ksdl_imageNamed KSCRASH_NS(ksdl_imageNamed)
-#define ksdl_imageUUID KSCRASH_NS(ksdl_imageUUID)
 #define ksdm_demangleCPP KSCRASH_NS(ksdm_demangleCPP)
 #define ksdm_demangleSwift KSCRASH_NS(ksdm_demangleSwift)
 #define ksfu_closeBufferedReader KSCRASH_NS(ksfu_closeBufferedReader)
@@ -396,6 +389,8 @@
 #define kssc_initWithBacktrace KSCRASH_NS(kssc_initWithBacktrace)
 #define kssc_initWithMachineContext KSCRASH_NS(kssc_initWithMachineContext)
 #define kssc_resetCursor KSCRASH_NS(kssc_resetCursor)
+#define kssc_uint64_to_hex KSCRASH_NS(kssc_uint64_to_hex)
+#define kssc_uuid_to_string KSCRASH_NS(kssc_uuid_to_string)
 #define kssignal_fatalSignals KSCRASH_NS(kssignal_fatalSignals)
 #define kssignal_numFatalSignals KSCRASH_NS(kssignal_numFatalSignals)
 #define kssignal_signalCodeName KSCRASH_NS(kssignal_signalCodeName)

Sources/KSCrashRecording/KSCrashReportC.c

@@ -53,6 +53,7 @@
 #include "KSStackCursor_Backtrace.h"
 #include "KSStackCursor_MachineContext.h"
 #include "KSString.h"
+#include "KSStringConversion.h"
 #include "KSSystemCapabilities.h"
 #include "KSThread.h"
 #include "KSThreadCache.h"
@@ -904,7 +905,9 @@ static void writeNotableStackContents(const KSCrashReportWriter *const writer,
     char nameBuffer[40];
     for (uintptr_t address = lowAddress; address < highAddress; address += sizeof(address)) {
         if (ksmem_copySafely((void *)address, &contentsAsPointer, sizeof(contentsAsPointer))) {
-            sprintf(nameBuffer, "stack@%p", (void *)address);
+            memcpy(nameBuffer, "stack@0x", 8);
+            char *addressStart = nameBuffer + 8;
+            kssc_uint64_to_hex((uintptr_t)address, addressStart, 1, false);
             writeMemoryContentsIfNotable(writer, nameBuffer, contentsAsPointer);
         }
     }

Sources/KSCrashRecordingCore/KSStringConversion.c

@@ -0,0 +1,84 @@
+//
+//  KSStringConversion.c
+//
+//  Created by Robert B on 2025-04-23.
+//
+//  Copyright (c) 2025 Karl Stenerud. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall remain in place
+// in this source code.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "KSStringConversion.h"
+
+#include <math.h>
+#include <memory.h>
+#include <stdio.h>
+#include <uuid/uuid.h>
+
+// Max uint64 is 18446744073709551615
+#define MAX_UINT64_DIGITS 20
+
+static char g_hexNybbles[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+static char g_hexNybblesUppercase[] = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+};
+
+static int uuidSegmentLengths[5] = { 4, 2, 2, 2, 6 };
+
+size_t kssc_uint64_to_hex(uint64_t value, char *dst, int min_digits, bool uppercase)
+{
+    if (min_digits < 1) {
+        min_digits = 1;
+    } else if (min_digits > 16) {
+        min_digits = 16;
+    }
+
+    char buff[MAX_UINT64_DIGITS + 1];
+    buff[sizeof(buff) - 1] = 0;
+    size_t index = sizeof(buff) - 2;
+    for (int digitCount = 1;; digitCount++) {
+        buff[index] = uppercase ? g_hexNybblesUppercase[(value & 15)] : g_hexNybbles[(value & 15)];
+        value >>= 4;
+        if (value == 0 && digitCount >= min_digits) {
+            break;
+        }
+        index--;
+    }
+
+    size_t length = sizeof(buff) - index;
+    memcpy(dst, buff + index, length);
+    return length - 1;
+}
+
+void kssc_uuid_to_string(uuid_t uuid, char *dst)
+{
+    char *currentDst = dst;
+    int valueIndex = 0;
+    for (int segmentIndex = 0; segmentIndex < 5; segmentIndex++) {
+        int segmentLength = uuidSegmentLengths[segmentIndex];
+        for (int i = 0; i < segmentLength; i++) {
+            kssc_uint64_to_hex(uuid[valueIndex++], currentDst, 2, true);
+            currentDst += 2;
+        }
+        if (segmentIndex != 4) {
+            memcpy(currentDst++, "-", 1);
+        }
+    }
+}

Sources/KSCrashRecordingCore/include/KSStringConversion.h

@@ -0,0 +1,60 @@
+//
+//  KSStringConversion.h
+//
+//  Created by Robert B on 2025-04-23.
+//
+//  Copyright (c) 2025 Karl Stenerud. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall remain in place
+// in this source code.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#ifndef HDR_KSStringConversion_h
+#define HDR_KSStringConversion_h
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <uuid/uuid.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Convert an unsigned integer to a hex string.
+ * This will write a maximum of 17 characters (including the NUL) to dst.
+ *
+ * If min_digits is greater than 1, it will prepad with zeroes to reach this number of digits
+ * (up to a maximum of 16 digits).
+ *
+ * Returns the length of the string written to dst (not including the NUL).
+ */
+size_t kssc_uint64_to_hex(uint64_t value, char *dst, int min_digits, bool uppercase);
+
+/**
+ * Convert an uuid_t to an uuid string.
+ * This will write 37 characters (including the NUL) to dst.
+ */
+void kssc_uuid_to_string(uuid_t value, char *dst);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // HDR_KSStringConversion_h

Tests/KSCrashRecordingCoreTests/KSStringConversion_Tests.m

@@ -0,0 +1,130 @@
+//
+//  KSStringConversion_Tests.m
+//
+//  Created by Robert B on 2025-04-23.
+//
+//  Copyright (c) 2012 Karl Stenerud. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall remain in place
+// in this source code.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#import <XCTest/XCTest.h>
+
+#import "KSStringConversion.h"
+
+@interface KSStringConversion_Tests : XCTestCase
+@end
+
+@implementation KSStringConversion_Tests
+
+- (void)testConvertUint64ZeroToString
+{
+    uint64_t value = 0;
+    char result[17];
+
+    size_t size = kssc_uint64_to_hex(value, result, 0, false);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertEqual(size, 1);
+    XCTAssertTrue([resultString isEqualToString:@"0"]);
+}
+
+- (void)testConvertUint64ZeroWithMinDigitsToString
+{
+    uint64_t value = 0;
+    char result[17];
+
+    size_t size = kssc_uint64_to_hex(value, result, 10, false);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertEqual(size, 10);
+    XCTAssertTrue([resultString isEqualToString:@"0000000000"]);
+}
+
+- (void)testConvertUint64MaxToString
+{
+    uint64_t value = UINT64_MAX;
+    char result[17];
+
+    size_t size = kssc_uint64_to_hex(value, result, 0, false);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertEqual(size, 16);
+    XCTAssertTrue([resultString isEqualToString:@"ffffffffffffffff"]);
+}
+
+- (void)testConvertUint64MaxToUppercaseString
+{
+    uint64_t value = UINT64_MAX;
+    char result[17];
+
+    size_t size = kssc_uint64_to_hex(value, result, 0, true);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertEqual(size, 16);
+    XCTAssertTrue([resultString isEqualToString:@"FFFFFFFFFFFFFFFF"]);
+}
+
+- (void)testConvertUint64ToString
+{
+    uint64_t value = 0x2fe5c7f8;
+    char result[17];
+
+    size_t size = kssc_uint64_to_hex(value, result, 0, false);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertEqual(size, 8);
+    XCTAssertTrue([resultString isEqualToString:@"2fe5c7f8"]);
+}
+
+- (void)testConvertUint64ToUppercaseString
+{
+    uint64_t value = 0x2fe5c7f8;
+    char result[17];
+
+    size_t size = kssc_uint64_to_hex(value, result, 0, true);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertEqual(size, 8);
+    XCTAssertTrue([resultString isEqualToString:@"2FE5C7F8"]);
+}
+
+- (void)testConvertAllZerosUUIDToString
+{
+    uuid_t uuid = { 0 };
+    char result[37];
+
+    kssc_uuid_to_string(uuid, result);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertTrue([resultString isEqualToString:@"00000000-0000-0000-0000-000000000000"]);
+}
+
+- (void)testConvertUUIDToString
+{
+    uuid_t uuid = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+    char result[37];
+
+    kssc_uuid_to_string(uuid, result);
+
+    NSString *resultString = [NSString stringWithCString:result encoding:NSUTF8StringEncoding];
+    XCTAssertTrue([resultString isEqualToString:@"00010203-0405-0607-0809-0A0B0C0D0E0F"]);
+}
+
+@end