test(native): repro /dev/shm exhaustion on alpine/musl Docker CI

Add a Linux-only integration test that runs the native-backend crash
example 40 times in a row, well past the ~27-iteration threshold at
which Docker's default 64 MB /dev/shm fills with leaked /dev/shm/s-<id>
entries. With the leak present, the next ftruncate succeeds (lazy) but
the first page-fault from memset takes a SIGBUS and the app dies.

Also instrument sentry__crash_ipc_init_app on Linux/Android with raw
write(2) diagnostics around the new-shm ftruncate and the subsequent
memset, so a CI run can pinpoint the SIGBUS to the page-fault rather
than to ftruncate or any later step.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jpnurmi

src/backends/native/sentry_crash_ipc.c

@@ -16,6 +16,21 @@
 #    include <sys/stat.h>
 #    include <unistd.h>
 
+// Diagnostic: raw write(2) to stderr so the message survives a SIGBUS
+// that may kill the process mid-page-fault (e.g. /dev/shm exhausted).
+// Used to localize the hang/abort to the post-ftruncate memset.
+static void
+shm_diag(const char *tag, const char *shm_name)
+{
+    char buf[160];
+    int n = snprintf(buf, sizeof(buf), "[sentry-shm-diag pid=%d] %s shm=%s\n",
+        (int)getpid(), tag, shm_name ? shm_name : "?");
+    if (n > 0) {
+        ssize_t w = write(STDERR_FILENO, buf, (size_t)n);
+        (void)w;
+    }
+}
+
 sentry_crash_ipc_t *
 sentry__crash_ipc_init_app(sem_t *init_sem)
 {
@@ -89,6 +104,7 @@ sentry__crash_ipc_init_app(sem_t *init_sem)
         }
     } else {
         // New shared memory, set size
+        shm_diag("pre-ftruncate", ipc->shm_name);
         if (ftruncate(ipc->shm_fd, SENTRY_CRASH_SHM_SIZE) < 0) {
             SENTRY_WARNF("failed to resize shared memory: %s", strerror(errno));
             close(ipc->shm_fd);
@@ -99,6 +115,7 @@ sentry__crash_ipc_init_app(sem_t *init_sem)
             sentry_free(ipc);
             return NULL;
         }
+        shm_diag("post-ftruncate", ipc->shm_name);
     }
 
     // Map shared memory
@@ -152,7 +169,9 @@ sentry__crash_ipc_init_app(sem_t *init_sem)
 
     // Initialize shared memory only if newly created
     if (!shm_exists) {
+        shm_diag("pre-memset", ipc->shm_name);
         memset(ipc->shmem, 0, SENTRY_CRASH_SHM_SIZE);
+        shm_diag("post-memset", ipc->shm_name);
         ipc->shmem->magic = SENTRY_CRASH_MAGIC;
         ipc->shmem->version = SENTRY_CRASH_VERSION;
         sentry__atomic_store(&ipc->shmem->state, SENTRY_CRASH_STATE_READY);

tests/test_integration_native.py

@@ -247,6 +247,39 @@ def test_native_multiple_crashes(cmake, httpserver):
     assert waiting.result
 
 
+@pytest.mark.skipif(
+    sys.platform != "linux", reason="POSIX /dev/shm exhaustion only repros on Linux"
+)
+def test_native_crash_shm_exhaustion(cmake, httpserver):
+    """Reproduce /dev/shm exhaustion on alpine/musl Docker CI.
+
+    Each native-backend crash leaves /dev/shm/s-<id> behind (the app side
+    only unlinks on clean shutdown, and the daemon never unlinks). Under
+    Docker's default 64 MB /dev/shm, ~27 leaked entries are enough to fill
+    the tmpfs. The next ftruncate still succeeds (lazy), but the first
+    page-fault from memset gets SIGBUS and the app dies silently.
+
+    Loops past that threshold so CI surfaces the failure.
+    """
+    tmp_path = cmake(["sentry_example"], {"SENTRY_BACKEND": "native"})
+
+    iterations = 40
+    for _ in range(iterations):
+        httpserver.expect_oneshot_request("/api/123456/envelope/").respond_with_data(
+            "OK"
+        )
+
+    with httpserver.wait(timeout=120) as waiting:
+        for _ in range(iterations):
+            run_crash(
+                tmp_path,
+                "sentry_example",
+                ["log", "stdout", "crash"],
+                env=dict(os.environ, SENTRY_DSN=make_dsn(httpserver)),
+            )
+    assert waiting.result
+
+
 def test_native_context_capture(cmake, httpserver):
     """Test that scope and context are captured"""
     tmp_path = cmake(["sentry_example"], {"SENTRY_BACKEND": "native"})