From cae3be300ca4d61169cecb2a39cda0b9afafb205 Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Thu, 4 Jul 2024 17:20:56 +0200 Subject: [PATCH 1/9] fix: clean-up scope application for crash-events --- external/crashpad | 2 +- src/backends/sentry_backend_crashpad.cpp | 91 ++++++++++++------------ tests/assertions.py | 15 +++- vendor/mpack.c | 2 + vendor/mpack.h | 5 +- 5 files changed, 65 insertions(+), 50 deletions(-) diff --git a/external/crashpad b/external/crashpad index 84f5f87e8a..32a4900675 160000 --- a/external/crashpad +++ b/external/crashpad @@ -1 +1 @@ -Subproject commit 84f5f87e8a7f3500be5b534ac079033e8b4f3425 +Subproject commit 32a490067594483e23e307693bbc2734a0fc6bfc diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp index 19df8bf81d..73c2589f0c 100644 --- a/src/backends/sentry_backend_crashpad.cpp +++ b/src/backends/sentry_backend_crashpad.cpp @@ -92,7 +92,6 @@ typedef struct { sentry_path_t *breadcrumb1_path; sentry_path_t *breadcrumb2_path; size_t num_breadcrumbs; - sentry_value_t crash_event; } crashpad_state_t; /** @@ -161,41 +160,23 @@ crashpad_register_wer_module( #endif static void -crashpad_backend_flush_scope( - sentry_backend_t *backend, const sentry_options_t *options) +crashpad_backend_flush_scope_to_event(const sentry_path_t *event_path, + const sentry_options_t *options, sentry_value_t crash_event) { - auto *data = static_cast(backend->data); - if (!data->event_path) { - return; - } - - // This here is an empty object that we copy the scope into. - // Even though the API is specific to `event`, an `event` has a few default - // properties that we do not want here. But in case of a crash we use the - // crash-event filled in the crash-handler and on_crash/before_send - // respectively. - sentry_value_t event = data->crash_event; - if (sentry_value_is_null(event)) { - event = sentry_value_new_object(); - // FIXME: This should be handled in the FirstChanceHandler but that does - // not exist for macOS just yet. - sentry_value_set_by_key( - event, "level", sentry__value_new_level(SENTRY_LEVEL_FATAL)); - } - SENTRY_WITH_SCOPE (scope) { // we want the scope without any modules or breadcrumbs - sentry__scope_apply_to_event(scope, options, event, SENTRY_SCOPE_NONE); + sentry__scope_apply_to_event( + scope, options, crash_event, SENTRY_SCOPE_NONE); } size_t mpack_size; - char *mpack = sentry_value_to_msgpack(event, &mpack_size); - sentry_value_decref(event); + char *mpack = sentry_value_to_msgpack(crash_event, &mpack_size); + sentry_value_decref(crash_event); if (!mpack) { return; } - int rv = sentry__path_write_buffer(data->event_path, mpack, mpack_size); + int rv = sentry__path_write_buffer(event_path, mpack, mpack_size); sentry_free(mpack); if (rv != 0) { @@ -203,6 +184,34 @@ crashpad_backend_flush_scope( } } +// This function is only necessary for macOS since it has no +// `FirstChanceHandler`. This means we have to continuously flush the scope on +// every change so that `__sentry_event` is ready to upload when the crash +// happens. With platforms that have a `FirstChanceHandler` we can do that +// once in the handler. No need to share event- or crashpad-state mutation. +static void +crashpad_backend_flush_scope( + sentry_backend_t *backend, const sentry_options_t *options) +{ +#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_WINDOWS) + (void)backend; + (void)options; +#else + auto *data = static_cast(backend->data); + if (!data->event_path) { + return; + } + + sentry_value_t event = sentry_value_new_object(); + // Since this will only be uploaded in case of a crash we must make this + // event fatal. + sentry_value_set_by_key( + event, "level", sentry__value_new_level(SENTRY_LEVEL_FATAL)); + + crashpad_backend_flush_scope_to_event(data->event_path, options, event); +#endif +} + #if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_WINDOWS) # ifdef SENTRY_PLATFORM_WINDOWS static bool @@ -213,18 +222,15 @@ static bool sentry__crashpad_handler(int signum, siginfo_t *info, ucontext_t *user_context) { sentry__page_allocator_enable(); - sentry__enter_signal_handler(); # endif SENTRY_DEBUG("flushing session and queue before crashpad handler"); bool should_dump = true; SENTRY_WITH_OPTIONS (options) { - auto *data = static_cast(options->backend->data); - sentry_value_decref(data->crash_event); - data->crash_event = sentry_value_new_event(); - sentry_value_set_by_key(data->crash_event, "level", - sentry__value_new_level(SENTRY_LEVEL_FATAL)); + sentry_value_t crash_event = sentry_value_new_event(); + sentry_value_set_by_key( + crash_event, "level", sentry__value_new_level(SENTRY_LEVEL_FATAL)); if (options->on_crash_func) { sentry_ucontext_t uctx; @@ -237,17 +243,20 @@ sentry__crashpad_handler(int signum, siginfo_t *info, ucontext_t *user_context) # endif SENTRY_TRACE("invoking `on_crash` hook"); - data->crash_event = options->on_crash_func( - &uctx, data->crash_event, options->on_crash_data); + crash_event = options->on_crash_func( + &uctx, crash_event, options->on_crash_data); } else if (options->before_send_func) { SENTRY_TRACE("invoking `before_send` hook"); - data->crash_event = options->before_send_func( - data->crash_event, nullptr, options->before_send_data); + crash_event = options->before_send_func( + crash_event, nullptr, options->before_send_data); } - should_dump = !sentry_value_is_null(data->crash_event); + should_dump = !sentry_value_is_null(crash_event); if (should_dump) { - crashpad_backend_flush_scope(options->backend, options); + auto state + = static_cast(options->backend->data); + crashpad_backend_flush_scope_to_event( + state->event_path, options, crash_event); sentry__write_crash_marker(options); @@ -272,10 +281,6 @@ sentry__crashpad_handler(int signum, siginfo_t *info, ucontext_t *user_context) } SENTRY_DEBUG("handing control over to crashpad"); -# ifndef SENTRY_PLATFORM_WINDOWS - sentry__leave_signal_handler(); -# endif - // If we __don't__ want a minidump produced by crashpad we need to either // exit or longjmp at this point. The crashpad client handler which calls // back here (SetFirstChanceExceptionHandler) does the same if the @@ -527,7 +532,6 @@ crashpad_backend_free(sentry_backend_t *backend) sentry__path_free(data->event_path); sentry__path_free(data->breadcrumb1_path); sentry__path_free(data->breadcrumb2_path); - sentry_value_decref(data->crash_event); sentry_free(data); } @@ -609,7 +613,6 @@ sentry__backend_new(void) return nullptr; } memset(data, 0, sizeof(crashpad_state_t)); - data->crash_event = sentry_value_new_null(); backend->startup_func = crashpad_backend_startup; backend->shutdown_func = crashpad_backend_shutdown; diff --git a/tests/assertions.py b/tests/assertions.py index 8ab0861240..583a4d0b5d 100644 --- a/tests/assertions.py +++ b/tests/assertions.py @@ -59,7 +59,19 @@ def assert_meta( sdk_override=None, ): event = envelope.get_event() + assert_event_meta( + event, release, integration, transaction, transaction_data, sdk_override + ) + +def assert_event_meta( + event, + release="test-example-release", + integration=None, + transaction="test-transaction", + transaction_data=None, + sdk_override=None, +): extra = { "extra stuff": "some value", "…unicode key…": "őá…–🤮🚀¿ 한글 테스트", @@ -316,8 +328,7 @@ def assert_crashpad_upload(req): attachments = _load_crashpad_attachments(msg) assert_overflowing_breadcrumb(attachments) - assert attachments.event["level"] == "fatal" - + assert_event_meta(attachments.event, integration="crashpad") assert any( b'name="upload_file_minidump"' in part.as_bytes() and b"\n\nMDMP" in part.as_bytes() diff --git a/vendor/mpack.c b/vendor/mpack.c index 67e54e8c6e..ca27d80f61 100644 --- a/vendor/mpack.c +++ b/vendor/mpack.c @@ -34,6 +34,8 @@ #include "mpack.h" +extern void* sentry_malloc(size_t); +extern void sentry_free(void*); /* mpack/mpack-platform.c.c */ diff --git a/vendor/mpack.h b/vendor/mpack.h index 2067a8af3f..f72fb3c4b4 100644 --- a/vendor/mpack.h +++ b/vendor/mpack.h @@ -201,9 +201,8 @@ * to grow buffers. */ #if defined(MPACK_STDLIB) && MPACK_STDLIB && !defined(MPACK_MALLOC) -#define MPACK_MALLOC malloc -#define MPACK_REALLOC realloc -#define MPACK_FREE free +#define MPACK_MALLOC sentry_malloc +#define MPACK_FREE sentry_free #endif /** From 35f0ec8943c9e93c24efc7a24c0d628c943cbc08 Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Fri, 5 Jul 2024 13:53:30 +0200 Subject: [PATCH 2/9] explicitly sync handler flushing with atomics * reenable flushing on Windows due to WER module * TODO: std::memory_order_[relaxed|acquire|release] --- src/backends/sentry_backend_crashpad.cpp | 44 +++++++++++++++++++----- tests/test_integration_crashpad.py | 2 ++ 2 files changed, 37 insertions(+), 9 deletions(-) diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp index 73c2589f0c..115c4ed79d 100644 --- a/src/backends/sentry_backend_crashpad.cpp +++ b/src/backends/sentry_backend_crashpad.cpp @@ -92,6 +92,8 @@ typedef struct { sentry_path_t *breadcrumb1_path; sentry_path_t *breadcrumb2_path; size_t num_breadcrumbs; + std::atomic crashed; + std::atomic scope_flush; } crashpad_state_t; /** @@ -184,8 +186,9 @@ crashpad_backend_flush_scope_to_event(const sentry_path_t *event_path, } } -// This function is only necessary for macOS since it has no -// `FirstChanceHandler`. This means we have to continuously flush the scope on +// This function is necessary for macOS since it has no `FirstChanceHandler`. +// but it is also necessary on Windows if the WER handler is enabled. +// This means we have to continuously flush the scope on // every change so that `__sentry_event` is ready to upload when the crash // happens. With platforms that have a `FirstChanceHandler` we can do that // once in the handler. No need to share event- or crashpad-state mutation. @@ -193,12 +196,16 @@ static void crashpad_backend_flush_scope( sentry_backend_t *backend, const sentry_options_t *options) { -#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_WINDOWS) +#if defined(SENTRY_PLATFORM_LINUX) (void)backend; (void)options; #else auto *data = static_cast(backend->data); - if (!data->event_path) { + bool expected = false; + + // + if (!data->event_path || data->crashed.load() + || !data->scope_flush.compare_exchange_strong(expected, true)) { return; } @@ -209,9 +216,30 @@ crashpad_backend_flush_scope( event, "level", sentry__value_new_level(SENTRY_LEVEL_FATAL)); crashpad_backend_flush_scope_to_event(data->event_path, options, event); + data->scope_flush.store(false); #endif } +static void +flush_scope_from_handler( + const sentry_options_t *options, sentry_value_t crash_event) +{ + auto state = static_cast(options->backend->data); + + // this blocks any further calls to `crashpad_backend_flush_scope` + state->crashed.store(true); + + // busy-wait until any in-progress scope flushes are finished + bool expected = false; + while (!state->scope_flush.compare_exchange_strong(expected, true)) { + expected = false; + } + + // now we are the sole flusher and can flush into the crash event + crashpad_backend_flush_scope_to_event( + state->event_path, options, crash_event); +} + #if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_WINDOWS) # ifdef SENTRY_PLATFORM_WINDOWS static bool @@ -253,11 +281,7 @@ sentry__crashpad_handler(int signum, siginfo_t *info, ucontext_t *user_context) should_dump = !sentry_value_is_null(crash_event); if (should_dump) { - auto state - = static_cast(options->backend->data); - crashpad_backend_flush_scope_to_event( - state->event_path, options, crash_event); - + flush_scope_from_handler(options, crash_event); sentry__write_crash_marker(options); sentry__record_errors_on_current_session(1); @@ -613,6 +637,8 @@ sentry__backend_new(void) return nullptr; } memset(data, 0, sizeof(crashpad_state_t)); + data->scope_flush = false; + data->crashed = false; backend->startup_func = crashpad_backend_startup; backend->shutdown_func = crashpad_backend_shutdown; diff --git a/tests/test_integration_crashpad.py b/tests/test_integration_crashpad.py index ccbbfdea51..a8eca6ad6f 100644 --- a/tests/test_integration_crashpad.py +++ b/tests/test_integration_crashpad.py @@ -118,6 +118,8 @@ def test_crashpad_wer_crash(cmake, httpserver, run_args): assert_session(envelope, {"status": "crashed", "errors": 1}) assert_crashpad_upload(multipart) + # Windows throttles WER crash reporting frequency, so let's wait a bit + time.sleep(1) @pytest.mark.parametrize( "run_args,build_args", From 562f7c2ded256dbd6eb726d73041a3320b8e3944 Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Fri, 19 Jul 2024 15:48:44 +0200 Subject: [PATCH 3/9] replace std::atomic with std::atomic_flag... ...which ensures block-free synchronization on all platforms. --- src/backends/sentry_backend_crashpad.cpp | 49 ++++++++++++------------ 1 file changed, 25 insertions(+), 24 deletions(-) diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp index 115c4ed79d..d1e9c5ba00 100644 --- a/src/backends/sentry_backend_crashpad.cpp +++ b/src/backends/sentry_backend_crashpad.cpp @@ -85,16 +85,16 @@ constexpr int g_CrashSignals[] = { }; #endif -typedef struct { - crashpad::CrashReportDatabase *db; - crashpad::CrashpadClient *client; - sentry_path_t *event_path; - sentry_path_t *breadcrumb1_path; - sentry_path_t *breadcrumb2_path; - size_t num_breadcrumbs; - std::atomic crashed; - std::atomic scope_flush; -} crashpad_state_t; +struct crashpad_state_t { + crashpad::CrashReportDatabase *db {}; + crashpad::CrashpadClient *client {}; + sentry_path_t *event_path {}; + sentry_path_t *breadcrumb1_path {}; + sentry_path_t *breadcrumb2_path {}; + size_t num_breadcrumbs {}; + std::atomic_flag crashed = ATOMIC_FLAG_INIT; + std::atomic_flag scope_flush_in_progress = ATOMIC_FLAG_INIT; +}; /** * Correctly destruct C++ members of the crashpad state. @@ -201,11 +201,12 @@ crashpad_backend_flush_scope( (void)options; #else auto *data = static_cast(backend->data); - bool expected = false; - // - if (!data->event_path || data->crashed.load() - || !data->scope_flush.compare_exchange_strong(expected, true)) { + if (!data->event_path + || data->crashed.test_and_set(std::memory_order_relaxed) + || data->scope_flush_in_progress.test_and_set( + std::memory_order_acquire)) { + SENTRY_DEBUG("flush scope via callback blocked"); return; } @@ -216,7 +217,7 @@ crashpad_backend_flush_scope( event, "level", sentry__value_new_level(SENTRY_LEVEL_FATAL)); crashpad_backend_flush_scope_to_event(data->event_path, options, event); - data->scope_flush.store(false); + data->scope_flush_in_progress.clear(std::memory_order_release); #endif } @@ -227,12 +228,15 @@ flush_scope_from_handler( auto state = static_cast(options->backend->data); // this blocks any further calls to `crashpad_backend_flush_scope` - state->crashed.store(true); + state->crashed.test_and_set(std::memory_order_relaxed); // busy-wait until any in-progress scope flushes are finished - bool expected = false; - while (!state->scope_flush.compare_exchange_strong(expected, true)) { - expected = false; + while (state->scope_flush_in_progress.test_and_set( + std::memory_order_acquire)) { +#if defined(__cpp_lib_atomic_flag_test) + while (lock.test(std::memory_order_relaxed)) // test lock +#endif + ; } // now we are the sole flusher and can flush into the crash event @@ -556,7 +560,7 @@ crashpad_backend_free(sentry_backend_t *backend) sentry__path_free(data->event_path); sentry__path_free(data->breadcrumb1_path); sentry__path_free(data->breadcrumb2_path); - sentry_free(data); + delete data; } static void @@ -631,14 +635,11 @@ sentry__backend_new(void) } memset(backend, 0, sizeof(sentry_backend_t)); - auto *data = SENTRY_MAKE(crashpad_state_t); + auto *data = new (std::nothrow) crashpad_state_t; if (!data) { sentry_free(backend); return nullptr; } - memset(data, 0, sizeof(crashpad_state_t)); - data->scope_flush = false; - data->crashed = false; backend->startup_func = crashpad_backend_startup; backend->shutdown_func = crashpad_backend_shutdown; From fa9de7161c3fc4bfc073a3a88144cfffb1b4697f Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Fri, 19 Jul 2024 16:19:47 +0200 Subject: [PATCH 4/9] Revert "replace std::atomic with std::atomic_flag..." This reverts commit 562f7c2ded256dbd6eb726d73041a3320b8e3944. --- src/backends/sentry_backend_crashpad.cpp | 49 ++++++++++++------------ 1 file changed, 24 insertions(+), 25 deletions(-) diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp index d1e9c5ba00..115c4ed79d 100644 --- a/src/backends/sentry_backend_crashpad.cpp +++ b/src/backends/sentry_backend_crashpad.cpp @@ -85,16 +85,16 @@ constexpr int g_CrashSignals[] = { }; #endif -struct crashpad_state_t { - crashpad::CrashReportDatabase *db {}; - crashpad::CrashpadClient *client {}; - sentry_path_t *event_path {}; - sentry_path_t *breadcrumb1_path {}; - sentry_path_t *breadcrumb2_path {}; - size_t num_breadcrumbs {}; - std::atomic_flag crashed = ATOMIC_FLAG_INIT; - std::atomic_flag scope_flush_in_progress = ATOMIC_FLAG_INIT; -}; +typedef struct { + crashpad::CrashReportDatabase *db; + crashpad::CrashpadClient *client; + sentry_path_t *event_path; + sentry_path_t *breadcrumb1_path; + sentry_path_t *breadcrumb2_path; + size_t num_breadcrumbs; + std::atomic crashed; + std::atomic scope_flush; +} crashpad_state_t; /** * Correctly destruct C++ members of the crashpad state. @@ -201,12 +201,11 @@ crashpad_backend_flush_scope( (void)options; #else auto *data = static_cast(backend->data); + bool expected = false; - if (!data->event_path - || data->crashed.test_and_set(std::memory_order_relaxed) - || data->scope_flush_in_progress.test_and_set( - std::memory_order_acquire)) { - SENTRY_DEBUG("flush scope via callback blocked"); + // + if (!data->event_path || data->crashed.load() + || !data->scope_flush.compare_exchange_strong(expected, true)) { return; } @@ -217,7 +216,7 @@ crashpad_backend_flush_scope( event, "level", sentry__value_new_level(SENTRY_LEVEL_FATAL)); crashpad_backend_flush_scope_to_event(data->event_path, options, event); - data->scope_flush_in_progress.clear(std::memory_order_release); + data->scope_flush.store(false); #endif } @@ -228,15 +227,12 @@ flush_scope_from_handler( auto state = static_cast(options->backend->data); // this blocks any further calls to `crashpad_backend_flush_scope` - state->crashed.test_and_set(std::memory_order_relaxed); + state->crashed.store(true); // busy-wait until any in-progress scope flushes are finished - while (state->scope_flush_in_progress.test_and_set( - std::memory_order_acquire)) { -#if defined(__cpp_lib_atomic_flag_test) - while (lock.test(std::memory_order_relaxed)) // test lock -#endif - ; + bool expected = false; + while (!state->scope_flush.compare_exchange_strong(expected, true)) { + expected = false; } // now we are the sole flusher and can flush into the crash event @@ -560,7 +556,7 @@ crashpad_backend_free(sentry_backend_t *backend) sentry__path_free(data->event_path); sentry__path_free(data->breadcrumb1_path); sentry__path_free(data->breadcrumb2_path); - delete data; + sentry_free(data); } static void @@ -635,11 +631,14 @@ sentry__backend_new(void) } memset(backend, 0, sizeof(sentry_backend_t)); - auto *data = new (std::nothrow) crashpad_state_t; + auto *data = SENTRY_MAKE(crashpad_state_t); if (!data) { sentry_free(backend); return nullptr; } + memset(data, 0, sizeof(crashpad_state_t)); + data->scope_flush = false; + data->crashed = false; backend->startup_func = crashpad_backend_startup; backend->shutdown_func = crashpad_backend_shutdown; From f56fd601f37b77b4fd34334d9cb0ba39481b51f9 Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Fri, 19 Jul 2024 16:46:54 +0200 Subject: [PATCH 5/9] Clean up memory order and assert atomics to be lock-free --- src/backends/sentry_backend_crashpad.cpp | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp index 115c4ed79d..4f7d213fd7 100644 --- a/src/backends/sentry_backend_crashpad.cpp +++ b/src/backends/sentry_backend_crashpad.cpp @@ -85,6 +85,10 @@ constexpr int g_CrashSignals[] = { }; #endif +static_assert(std::atomic::is_always_lock_free, + "The crashpad-backend requires lock-free atomic to safely handle " + "crashes"); + typedef struct { crashpad::CrashReportDatabase *db; crashpad::CrashpadClient *client; @@ -204,8 +208,9 @@ crashpad_backend_flush_scope( bool expected = false; // - if (!data->event_path || data->crashed.load() - || !data->scope_flush.compare_exchange_strong(expected, true)) { + if (!data->event_path || data->crashed.load(std::memory_order_relaxed) + || !data->scope_flush.compare_exchange_strong( + expected, true, std::memory_order_acquire)) { return; } @@ -216,7 +221,7 @@ crashpad_backend_flush_scope( event, "level", sentry__value_new_level(SENTRY_LEVEL_FATAL)); crashpad_backend_flush_scope_to_event(data->event_path, options, event); - data->scope_flush.store(false); + data->scope_flush.store(false, std::memory_order_release); #endif } @@ -227,11 +232,12 @@ flush_scope_from_handler( auto state = static_cast(options->backend->data); // this blocks any further calls to `crashpad_backend_flush_scope` - state->crashed.store(true); + state->crashed.store(true, std::memory_order_relaxed); // busy-wait until any in-progress scope flushes are finished bool expected = false; - while (!state->scope_flush.compare_exchange_strong(expected, true)) { + while (!state->scope_flush.compare_exchange_strong( + expected, true, std::memory_order_acquire)) { expected = false; } From ccddc71392e3eaeec3bbe703868a06fc618a6b06 Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Fri, 19 Jul 2024 18:01:05 +0200 Subject: [PATCH 6/9] Update changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index f8ac347ffe..bf6f54a460 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ **Fixes**: - Further clean up of the exported dependency configuration. ([#1013](https://github.com/getsentry/sentry-native/pull/1013), [crashpad#106](https://github.com/getsentry/crashpad/pull/106)) +- Clean-up scope flushing synchronization in crashpad-backend. ([#1019](https://github.com/getsentry/sentry-native/pull/1019), [crashpad#109](https://github.com/getsentry/crashpad/pull/109)) **Internal**: @@ -14,6 +15,7 @@ - [@JonLiu1993](https://github.com/JonLiu1993) - [@dg0yt](https://github.com/dg0yt) +- [@stima](https://github.com/stima) ## 0.7.6 From 13bbbfc3fbe8f8ecbfe7755c73690210ccbc9f5c Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Sat, 20 Jul 2024 11:43:04 +0200 Subject: [PATCH 7/9] Fix python lint --- tests/test_integration_crashpad.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_integration_crashpad.py b/tests/test_integration_crashpad.py index a8eca6ad6f..0340cfbb29 100644 --- a/tests/test_integration_crashpad.py +++ b/tests/test_integration_crashpad.py @@ -121,6 +121,7 @@ def test_crashpad_wer_crash(cmake, httpserver, run_args): # Windows throttles WER crash reporting frequency, so let's wait a bit time.sleep(1) + @pytest.mark.parametrize( "run_args,build_args", [ From e9f139a426d9f92054213e3548b5497c9b5c3533 Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Sat, 20 Jul 2024 12:01:37 +0200 Subject: [PATCH 8/9] Conditionally exclude handler flush from non-linux/-windows builds --- src/backends/sentry_backend_crashpad.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp index 4f7d213fd7..6941f95c02 100644 --- a/src/backends/sentry_backend_crashpad.cpp +++ b/src/backends/sentry_backend_crashpad.cpp @@ -225,6 +225,7 @@ crashpad_backend_flush_scope( #endif } +#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_WINDOWS) static void flush_scope_from_handler( const sentry_options_t *options, sentry_value_t crash_event) @@ -246,7 +247,6 @@ flush_scope_from_handler( state->event_path, options, crash_event); } -#if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_WINDOWS) # ifdef SENTRY_PLATFORM_WINDOWS static bool sentry__crashpad_handler(EXCEPTION_POINTERS *ExceptionInfo) From c4c613e98d242fe5b6911e2d5c09d2f13559db39 Mon Sep 17 00:00:00 2001 From: Mischan Toosarani-Hausberger Date: Tue, 23 Jul 2024 18:38:19 +0200 Subject: [PATCH 9/9] Update crashpad reference after merging fork PR onto getsentry --- external/crashpad | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/crashpad b/external/crashpad index 32a4900675..04101eb874 160000 --- a/external/crashpad +++ b/external/crashpad @@ -1 +1 @@ -Subproject commit 32a490067594483e23e307693bbc2734a0fc6bfc +Subproject commit 04101eb874f109f98c22f341dfa3162879d5b92a