poc(native): Add Android support for out-of-process crash handling

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+**Features**:
+
+- Native: add Android support. ([#1725](https://github.com/getsentry/sentry-native/pull/1725))
+
 **Fixes**:
 
 - Reject overly deep msgpack payloads during deserialization. ([#1727](https://github.com/getsentry/sentry-native/pull/1727))

CMakeLists.txt

@@ -841,6 +841,11 @@ elseif(SENTRY_BACKEND_NATIVE)
 		${PROJECT_SOURCE_DIR}/src
 		${PROJECT_SOURCE_DIR}/src/backends/native
 	)
+	if(SENTRY_WITH_LIBUNWINDSTACK)
+		target_include_directories(sentry-crash PRIVATE
+			${PROJECT_SOURCE_DIR}/external/libunwindstack-ndk/include
+		)
+	endif()
 
 	# Link same libraries as sentry
 	target_link_libraries(sentry-crash PRIVATE ${_SENTRY_PLATFORM_LIBS})

ndk/gradle.properties

@@ -50,3 +50,6 @@ systemProp.org.gradle.internal.http.socketTimeout=120000
 android.nonTransitiveRClass=true
 
 android.suppressUnsupportedCompileSdk=34
+
+# TODO: clean up
+sentryBackend=native

ndk/lib/CMakeLists.txt

@@ -13,9 +13,29 @@ endif()
 set(BUILD_SHARED_LIBS ON)
 set(SENTRY_BUILD_SHARED_LIBS ON)
 
+if(SENTRY_BACKEND STREQUAL "native")
+	find_package(curl REQUIRED CONFIG)
+	if(NOT TARGET CURL::libcurl)
+		add_library(CURL::libcurl INTERFACE IMPORTED)
+		target_link_libraries(CURL::libcurl INTERFACE curl::curl_static)
+	endif()
+	set(SENTRY_TRANSPORT "curl" CACHE STRING "" FORCE)
+endif()
+
 # Adding sentry-native project
 add_subdirectory(${SENTRY_NATIVE_SRC} sentry_build)
 
+if(SENTRY_BACKEND STREQUAL "native")
+	target_compile_definitions(sentry-android PRIVATE SENTRY_BACKEND_NATIVE)
+	set_target_properties(sentry-crash PROPERTIES
+		PREFIX "lib"
+		OUTPUT_NAME "sentry-crash"
+		SUFFIX ".so"
+	)
+	target_link_options(sentry-crash PRIVATE "-Wl,-z,max-page-size=16384")
+	target_link_libraries(sentry-android PRIVATE dl)
+endif()
+
 # Android logging library
 find_library(LOG_LIB log)
 

ndk/lib/build.gradle.kts

@@ -5,6 +5,7 @@ plugins {
 }
 
 var sentryNativeSrc: String = "${project.projectDir}/../.."
+val sentryBackend = providers.gradleProperty("sentryBackend").orElse("inproc").get()
 
 android {
     compileSdk = 35
@@ -18,6 +19,7 @@ android {
         externalNativeBuild {
             cmake {
                 arguments.add(0, "-DANDROID_STL=c++_static")
+                arguments.add(0, "-DSENTRY_BACKEND=$sentryBackend")
                 arguments.add(0, "-DSENTRY_NATIVE_SRC=$sentryNativeSrc")
             }
         }
@@ -51,6 +53,7 @@ android {
     }
 
     buildFeatures {
+        prefab = true
         prefabPublishing = true
         buildConfig = true
     }
@@ -100,6 +103,9 @@ android {
 }
 
 dependencies {
+    // TODO: this was the first match on maven central..
+    implementation("io.github.vvb2060.ndk:curl:8.18.0")
+
     compileOnly("org.jetbrains:annotations:23.0.0")
 
     testImplementation("androidx.test.ext:junit:1.3.0")
@@ -137,10 +143,12 @@ dependencies {
  *
  */
 afterEvaluate {
-    tasks.getByName("prefabReleasePackage") {
+    tasks.matching { it.name.startsWith("prefab") && it.name.endsWith("Package") }.configureEach {
         doLast {
-            project.fileTree("build/intermediates/prefab_package/") {
+            project.fileTree("build/intermediates/") {
                 include("**/abi.json")
+                include("**/prefab_publication.json/debug")
+                include("**/prefab_publication.json/release")
             }.forEach { file ->
                 file.writeText(file.readText().replace("c++_static", "none"))
             }

ndk/lib/src/main/jni/sentry.c

@@ -4,6 +4,15 @@
 #include <sentry.h>
 #include <jni.h>
 
+#if defined(SENTRY_BACKEND_NATIVE)
+#include <dlfcn.h>
+#include <limits.h>
+
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+#endif
+
 #define ENSURE(Expr) \
     if (!(Expr))     \
         return
@@ -59,6 +68,31 @@ static char *call_get_string(JNIEnv *env, jobject obj, jmethodID mid) {
     return NULL;
 }
 
+#if defined(SENTRY_BACKEND_NATIVE)
+static void set_handler_path(sentry_options_t *options) {
+    Dl_info info;
+    if (dladdr((void *)set_handler_path, &info) == 0 || !info.dli_fname) {
+        return;
+    }
+
+    const char *slash = strrchr(info.dli_fname, '/');
+    if (!slash) {
+        return;
+    }
+
+    const char daemon_name[] = "libsentry-crash.so";
+    size_t dir_len = (size_t)(slash - info.dli_fname + 1);
+    if (dir_len + sizeof(daemon_name) > PATH_MAX) {
+        return;
+    }
+
+    char handler_path[PATH_MAX];
+    memcpy(handler_path, info.dli_fname, dir_len);
+    memcpy(handler_path + dir_len, daemon_name, sizeof(daemon_name));
+    sentry_options_set_handler_path(options, handler_path);
+}
+#endif
+
 JNIEXPORT void JNICALL
 Java_io_sentry_ndk_NativeScope_nativeSetTag(
         JNIEnv *env,
@@ -350,6 +384,10 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     options = sentry_options_new();
     ENSURE_OR_FAIL(options);
 
+#if defined(SENTRY_BACKEND_NATIVE)
+    set_handler_path(options);
+#endif
+
     // session tracking is enabled by default, but the Android SDK already handles it
     sentry_options_set_auto_session_tracking(options, 0);
 

ndk/sample/CMakeLists.txt

@@ -6,15 +6,15 @@ set(SENTRY_BUILD_SHARED_LIBS ON)
 
 add_library(ndk-sample SHARED src/main/cpp/ndk-sample.cpp)
 
-# Adding sentry-native project
-add_subdirectory(${SENTRY_NATIVE_SRC} sentry_build)
+# Use sentry-native from the NDK library's Prefab package
+find_package(sentry-native-ndk REQUIRED CONFIG)
 
 # Android logging library
 find_library(LOG_LIB log)
 
 target_link_libraries(ndk-sample PRIVATE
 	${LOG_LIB}
-	$<BUILD_INTERFACE:sentry::sentry>
+	sentry-native-ndk::sentry
 )
 # Support 16KB page sizes
 target_link_options(ndk-sample PRIVATE "-Wl,-z,max-page-size=16384")

ndk/sample/build.gradle.kts

@@ -3,12 +3,13 @@ plugins {
     kotlin("android")
 }
 
-var sentryNativeSrc: String = "${project.projectDir}/../.."
-
 android {
     compileSdk = 35
     namespace = "io.sentry.ndk.sample"
-    buildFeatures.buildConfig = true
+    buildFeatures {
+        buildConfig = true
+        prefab = true
+    }
 
     defaultConfig {
         applicationId = "io.sentry.ndk.sample"
@@ -20,7 +21,6 @@ android {
         externalNativeBuild {
             cmake {
                 arguments.add(0, "-DANDROID_STL=c++_shared")
-                arguments.add(0, "-DSENTRY_NATIVE_SRC=$sentryNativeSrc")
             }
         }
 

ndk/sample/src/main/AndroidManifest.xml

@@ -2,6 +2,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <uses-permission android:name="android.permission.INTERNET" />
+
     <application tools:ignore="MissingApplicationIcon">
 
         <activity

src/CMakeLists.txt

@@ -194,7 +194,7 @@ elseif(SENTRY_BACKEND_NATIVE)
 	target_include_directories(sentry PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/backends/native)
 
 	# Platform-specific libraries for native backend
-	if(LINUX OR ANDROID)
+	if(LINUX AND NOT ANDROID)
 		# Linux needs pthread and rt for shared memory
 		target_link_libraries(sentry PRIVATE pthread rt)
 	elseif(APPLE)

src/backends/native/minidump/sentry_minidump_linux.c

@@ -26,6 +26,7 @@
 #    include "sentry_minidump_format.h"
 #    include "sentry_minidump_indirect.h"
 #    include "sentry_minidump_writer.h"
+#    include "sentry_os.h"
 
 // NT_PRSTATUS is defined in linux/elf.h but we can't include that
 // because it conflicts with elf.h. Define it here if not available.
@@ -66,9 +67,6 @@ struct fpsimd_context {
 #        endif
 #    endif
 
-// Use process_vm_readv to read memory from crashed process
-#    include <sys/uio.h>
-
 // Use shared constants from crash context
 #    include "../sentry_crash_context.h"
 
@@ -346,7 +344,8 @@ read_process_memory(
     struct iovec local_iov = { .iov_base = buf, .iov_len = len };
     struct iovec remote_iov = { .iov_base = (void *)addr, .iov_len = len };
 
-    ssize_t nread = process_vm_readv(tid, &local_iov, 1, &remote_iov, 1, 0);
+    ssize_t nread
+        = sentry__process_vm_readv(tid, &local_iov, 1, &remote_iov, 1, 0);
     if (nread > 0) {
         return nread;
     }
@@ -2135,7 +2134,7 @@ linux_indirect_read_memory(void *ctx, uint64_t addr, void *buf, size_t len)
     pid_t tid = writer->crash_ctx->crashed_tid;
     struct iovec local_iov = { .iov_base = buf, .iov_len = len };
     struct iovec remote_iov = { .iov_base = (void *)addr, .iov_len = len };
-    return process_vm_readv(tid, &local_iov, 1, &remote_iov, 1, 0);
+    return sentry__process_vm_readv(tid, &local_iov, 1, &remote_iov, 1, 0);
 }
 
 /**

src/backends/native/sentry_crash_daemon.c

@@ -10,6 +10,7 @@
 #include "sentry_json.h"
 #include "sentry_logger.h"
 #include "sentry_options.h"
+#include "sentry_os.h"
 #include "sentry_path.h"
 #include "sentry_process.h"
 #include "sentry_screenshot.h"
@@ -351,6 +352,7 @@ build_registers_from_ctx(const sentry_crash_context_t *ctx, size_t thread_idx)
         && thread_idx < ctx->platform.num_threads) {
         uctx = &ctx->platform.threads[thread_idx].context;
     }
+    (void)uctx;
 
 #    if defined(__x86_64__)
     uintptr_t *mctx = (uintptr_t *)&uctx->uc_mcontext;
@@ -801,8 +803,8 @@ build_stacktrace_for_thread(
                 = { .iov_base = stack_buf, .iov_len = stack_size };
             struct iovec remote_iov
                 = { .iov_base = (void *)stack_start, .iov_len = stack_size };
-            ssize_t bytes_read
-                = process_vm_readv(pid, &local_iov, 1, &remote_iov, 1, 0);
+            ssize_t bytes_read = sentry__process_vm_readv(
+                pid, &local_iov, 1, &remote_iov, 1, 0);
             if (bytes_read <= 0) {
                 SENTRY_DEBUG(
                     "process_vm_readv failed, falling back to single frame");
@@ -3237,7 +3239,11 @@ daemon_file_logger(
     fflush(log_file); // Flush immediately to ensure logs are written
 }
 
-#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_ANDROID)
+#if defined(SENTRY_PLATFORM_ANDROID)
+int
+sentry__crash_daemon_main(pid_t app_pid, uint64_t app_tid, int notify_eventfd,
+    int ready_eventfd, int shm_fd)
+#elif defined(SENTRY_PLATFORM_LINUX)
 int
 sentry__crash_daemon_main(
     pid_t app_pid, uint64_t app_tid, int notify_eventfd, int ready_eventfd)
@@ -3253,7 +3259,10 @@ sentry__crash_daemon_main(pid_t app_pid, uint64_t app_tid, HANDLE event_handle,
 {
     // Initialize IPC first (attach to shared memory created by parent)
     // We need this to get the database path for logging
-#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_ANDROID)
+#if defined(SENTRY_PLATFORM_ANDROID)
+    sentry_crash_ipc_t *ipc = sentry__crash_ipc_init_daemon(
+        app_pid, app_tid, notify_eventfd, ready_eventfd, shm_fd);
+#elif defined(SENTRY_PLATFORM_LINUX)
     sentry_crash_ipc_t *ipc = sentry__crash_ipc_init_daemon(
         app_pid, app_tid, notify_eventfd, ready_eventfd);
 #elif defined(SENTRY_PLATFORM_MACOS)
@@ -3532,7 +3541,11 @@ sentry__crash_daemon_main(pid_t app_pid, uint64_t app_tid, HANDLE event_handle,
     return 0;
 }
 
-#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_ANDROID)
+#if defined(SENTRY_PLATFORM_ANDROID)
+pid_t
+sentry__crash_daemon_start(pid_t app_pid, uint64_t app_tid, int notify_eventfd,
+    int ready_eventfd, int shm_fd, const char *handler_path)
+#elif defined(SENTRY_PLATFORM_LINUX)
 pid_t
 sentry__crash_daemon_start(pid_t app_pid, uint64_t app_tid, int notify_eventfd,
     int ready_eventfd, const char *handler_path)
@@ -3653,6 +3666,12 @@ sentry__crash_daemon_start(pid_t app_pid, uint64_t app_tid, HANDLE event_handle,
         if (ready_flags != -1) {
             fcntl(ready_eventfd, F_SETFD, ready_flags & ~FD_CLOEXEC);
         }
+#    if defined(SENTRY_PLATFORM_ANDROID)
+        int shm_flags = fcntl(shm_fd, F_GETFD);
+        if (shm_flags != -1) {
+            fcntl(shm_fd, F_SETFD, shm_flags & ~FD_CLOEXEC);
+        }
+#    endif
 
         // Convert arguments to strings for exec
         char pid_str[32], tid_str[32], notify_str[32], ready_str[32];
@@ -3661,8 +3680,15 @@ sentry__crash_daemon_start(pid_t app_pid, uint64_t app_tid, HANDLE event_handle,
         snprintf(notify_str, sizeof(notify_str), "%d", notify_eventfd);
         snprintf(ready_str, sizeof(ready_str), "%d", ready_eventfd);
 
+#    if defined(SENTRY_PLATFORM_ANDROID)
+        char shm_str[32];
+        snprintf(shm_str, sizeof(shm_str), "%d", shm_fd);
+        char *argv[] = { "sentry-crash", pid_str, tid_str, notify_str,
+            ready_str, shm_str, NULL };
+#    else
         char *argv[]
             = { "sentry-crash", pid_str, tid_str, notify_str, ready_str, NULL };
+#    endif
 
         if (!sentry__string_empty(handler_path)) {
             execv(handler_path, argv);
@@ -3830,12 +3856,13 @@ main(int argc, char **argv)
 {
     // Expected arguments:
     //   Linux:  <app_pid> <app_tid> <notify_handle> <ready_handle>
-    //   macOS:  <app_pid> <app_tid> <notify_handle> <ready_handle> <shm_fd>
-#    if defined(SENTRY_PLATFORM_MACOS)
+    //   macOS/Android: <app_pid> <app_tid> <notify_handle> <ready_handle>
+    //   <shm_fd>
+#    if defined(SENTRY_PLATFORM_MACOS) || defined(SENTRY_PLATFORM_ANDROID)
     if (argc < 6) {
         fprintf(stderr,
-            "Usage: sentry-crash <app_pid> <app_tid> <notify_pipe> "
-            "<ready_pipe> <shm_fd>\n");
+            "Usage: sentry-crash <app_pid> <app_tid> <notify_handle> "
+            "<ready_handle> <shm_fd>\n");
         return 1;
     }
 #    else
@@ -3851,7 +3878,13 @@ main(int argc, char **argv)
     pid_t app_pid = (pid_t)strtoul(argv[1], NULL, 10);
     uint64_t app_tid = strtoull(argv[2], NULL, 16);
 
-#    if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_ANDROID)
+#    if defined(SENTRY_PLATFORM_ANDROID)
+    int notify_eventfd = atoi(argv[3]);
+    int ready_eventfd = atoi(argv[4]);
+    int shm_fd_arg = atoi(argv[5]);
+    return sentry__crash_daemon_main(
+        app_pid, app_tid, notify_eventfd, ready_eventfd, shm_fd_arg);
+#    elif defined(SENTRY_PLATFORM_LINUX)
     int notify_eventfd = atoi(argv[3]);
     int ready_eventfd = atoi(argv[4]);
     return sentry__crash_daemon_main(