| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/crash/content/browser/crash_metrics_reporter_android.h" |
| |
| #include "base/logging.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/metrics/user_metrics.h" |
| #include "base/optional.h" |
| #include "base/rand_util.h" |
| |
| namespace crash_reporter { |
| namespace { |
| |
| // These values are persisted to logs. Entries should not be renumbered and |
| // numeric values should never be reused. |
| enum class BindingStateCombo { |
| kNoWaivedNoModerateNoStrong = 0, |
| kNoWaivedNoModerateHasStrong = 1, |
| kNoWaivedHasModerateNoStrong = 2, |
| kNoWaivedHasModerateHasStrong = 3, |
| kHasWaivedNoModerateNoStrong = 4, |
| kHasWaivedNoModerateHasStrong = 5, |
| kHasWaivedHasModerateNoStrong = 6, |
| kHasWaivedHasModerateHasStrong = 7, |
| kMaxValue = kHasWaivedHasModerateHasStrong |
| }; |
| |
| void ReportCrashCount(CrashMetricsReporter::ProcessedCrashCounts crash_type, |
| CrashMetricsReporter::ReportedCrashTypeSet* counts) { |
| UMA_HISTOGRAM_ENUMERATION("Stability.Android.ProcessedCrashCounts", |
| crash_type); |
| counts->insert(crash_type); |
| } |
| |
| void ReportLegacyCrashUma(const ChildExitObserver::TerminationInfo& info, |
| bool has_valid_dump) { |
| // TODO(wnwen): If these numbers match up to TabWebContentsObserver's |
| // TabRendererCrashStatus histogram, then remove that one as this is more |
| // accurate with more detail. |
| if ((info.process_type == content::PROCESS_TYPE_RENDERER || |
| info.process_type == content::PROCESS_TYPE_GPU) && |
| info.app_state != base::android::APPLICATION_STATE_UNKNOWN) { |
| CrashMetricsReporter::ExitStatus exit_status; |
| bool is_running = (info.app_state == |
| base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); |
| bool is_paused = (info.app_state == |
| base::android::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES); |
| if (!has_valid_dump) { |
| if (is_running) { |
| exit_status = CrashMetricsReporter::EMPTY_MINIDUMP_WHILE_RUNNING; |
| } else if (is_paused) { |
| exit_status = CrashMetricsReporter::EMPTY_MINIDUMP_WHILE_PAUSED; |
| } else { |
| exit_status = CrashMetricsReporter::EMPTY_MINIDUMP_WHILE_BACKGROUND; |
| } |
| } else { |
| if (is_running) { |
| exit_status = CrashMetricsReporter::VALID_MINIDUMP_WHILE_RUNNING; |
| } else if (is_paused) { |
| exit_status = CrashMetricsReporter::VALID_MINIDUMP_WHILE_PAUSED; |
| } else { |
| exit_status = CrashMetricsReporter::VALID_MINIDUMP_WHILE_BACKGROUND; |
| } |
| } |
| if (info.process_type == content::PROCESS_TYPE_RENDERER) { |
| if (info.was_oom_protected_status) { |
| UMA_HISTOGRAM_ENUMERATION( |
| "Tab.RendererDetailedExitStatus", exit_status, |
| CrashMetricsReporter::ExitStatus::MINIDUMP_STATUS_COUNT); |
| } else { |
| UMA_HISTOGRAM_ENUMERATION( |
| "Tab.RendererDetailedExitStatusUnbound", exit_status, |
| CrashMetricsReporter::ExitStatus::MINIDUMP_STATUS_COUNT); |
| } |
| } else if (info.process_type == content::PROCESS_TYPE_GPU) { |
| UMA_HISTOGRAM_ENUMERATION( |
| "GPU.GPUProcessDetailedExitStatus", exit_status, |
| CrashMetricsReporter::ExitStatus::MINIDUMP_STATUS_COUNT); |
| } |
| } |
| } |
| |
| } // namespace |
| |
| // static |
| CrashMetricsReporter* CrashMetricsReporter::GetInstance() { |
| static CrashMetricsReporter* instance = new CrashMetricsReporter(); |
| return instance; |
| } |
| |
| CrashMetricsReporter::CrashMetricsReporter() |
| : async_observers_( |
| base::MakeRefCounted< |
| base::ObserverListThreadSafe<CrashMetricsReporter::Observer>>()) { |
| } |
| |
| CrashMetricsReporter::~CrashMetricsReporter() {} |
| |
| void CrashMetricsReporter::AddObserver( |
| CrashMetricsReporter::Observer* observer) { |
| async_observers_->AddObserver(observer); |
| } |
| |
| void CrashMetricsReporter::RemoveObserver( |
| CrashMetricsReporter::Observer* observer) { |
| async_observers_->RemoveObserver(observer); |
| } |
| |
| void CrashMetricsReporter::ChildProcessExited( |
| const ChildExitObserver::TerminationInfo& info) { |
| ReportedCrashTypeSet reported_counts; |
| const bool crashed = info.is_crashed(); |
| const bool app_foreground = |
| info.app_state == |
| base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES || |
| info.app_state == base::android::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES; |
| const bool intentional_kill = info.was_killed_intentionally_by_browser; |
| const bool android_oom_kill = !info.was_killed_intentionally_by_browser && |
| !crashed && !info.normal_termination; |
| const bool renderer_visible = info.renderer_has_visible_clients; |
| const bool renderer_subframe = info.renderer_was_subframe; |
| const bool renderer_allocation_failed = |
| info.blink_oom_metrics.allocation_failed; |
| const uint64_t private_footprint_kb = |
| info.blink_oom_metrics.current_private_footprint_kb; |
| const uint64_t swap_kb = info.blink_oom_metrics.current_swap_kb; |
| const uint64_t vm_size_kb = info.blink_oom_metrics.current_vm_size_kb; |
| const uint64_t blink_usage_kb = info.blink_oom_metrics.current_blink_usage_kb; |
| |
| if (app_foreground && android_oom_kill) { |
| if (info.process_type == content::PROCESS_TYPE_GPU) { |
| ReportCrashCount(ProcessedCrashCounts::kGpuForegroundOom, |
| &reported_counts); |
| } else if (info.process_type == content::PROCESS_TYPE_UTILITY) { |
| ReportCrashCount(ProcessedCrashCounts::kUtilityForegroundOom, |
| &reported_counts); |
| } |
| } |
| |
| if (info.process_type == content::PROCESS_TYPE_RENDERER && |
| !intentional_kill && !info.normal_termination && |
| renderer_allocation_failed) { |
| ReportCrashCount(ProcessedCrashCounts::kRendererAllocationFailureAll, |
| &reported_counts); |
| if (app_foreground && renderer_visible) |
| ReportCrashCount( |
| ProcessedCrashCounts::kRendererForegroundVisibleAllocationFailure, |
| &reported_counts); |
| } |
| |
| if (info.process_type == content::PROCESS_TYPE_RENDERER && app_foreground) { |
| if (renderer_visible) { |
| if (crashed) { |
| ReportCrashCount( |
| renderer_subframe |
| ? ProcessedCrashCounts::kRendererForegroundVisibleSubframeCrash |
| : ProcessedCrashCounts::kRendererForegroundVisibleCrash, |
| &reported_counts); |
| } else if (intentional_kill) { |
| ReportCrashCount( |
| renderer_subframe |
| ? ProcessedCrashCounts:: |
| kRendererForegroundVisibleSubframeIntentionalKill |
| : ProcessedCrashCounts:: |
| kRendererForegroundVisibleMainFrameIntentionalKill, |
| &reported_counts); |
| } else if (info.normal_termination) { |
| ReportCrashCount(ProcessedCrashCounts:: |
| kRendererForegroundVisibleNormalTermNoMinidump, |
| &reported_counts); |
| } else { |
| DCHECK(android_oom_kill); |
| if (renderer_subframe) { |
| ReportCrashCount( |
| ProcessedCrashCounts::kRendererForegroundVisibleSubframeOom, |
| &reported_counts); |
| } else { |
| ReportCrashCount(ProcessedCrashCounts::kRendererForegroundVisibleOom, |
| &reported_counts); |
| base::RecordAction( |
| base::UserMetricsAction("RendererForegroundMainFrameOOM")); |
| } |
| // Report memory metrics when visible foreground renderer is OOM. |
| if (private_footprint_kb > 0) { |
| // Report only when the metrics are not non-0, because the metrics |
| // are recorded only when oom intervention is on. |
| UMA_HISTOGRAM_MEMORY_LARGE_MB( |
| "Memory.Experimental.OomIntervention." |
| "RendererPrivateMemoryFootprintAtOOM", |
| private_footprint_kb / 1024); |
| UMA_HISTOGRAM_MEMORY_MB( |
| "Memory.Experimental.OomIntervention.RendererSwapFootprintAtOOM", |
| swap_kb / 1024); |
| UMA_HISTOGRAM_MEMORY_MB( |
| "Memory.Experimental.OomIntervention.RendererBlinkUsageAtOOM", |
| blink_usage_kb / 1024); |
| UMA_HISTOGRAM_MEMORY_LARGE_MB( |
| "Memory.Experimental.OomIntervention.RendererVmSizeAtOOMLarge", |
| vm_size_kb / 1024); |
| } |
| } |
| } else if (!crashed) { |
| // Record stats when renderer is not visible, but the process has oom |
| // protected bindings. This case occurs when a tab is switched or closed, |
| // the bindings are updated later than visibility on web contents. |
| switch (info.binding_state) { |
| case base::android::ChildBindingState::UNBOUND: |
| case base::android::ChildBindingState::WAIVED: |
| break; |
| case base::android::ChildBindingState::STRONG: |
| if (intentional_kill || info.normal_termination) { |
| ReportCrashCount( |
| ProcessedCrashCounts:: |
| kRendererForegroundInvisibleWithStrongBindingKilled, |
| &reported_counts); |
| } else { |
| ReportCrashCount( |
| ProcessedCrashCounts:: |
| kRendererForegroundInvisibleWithStrongBindingOom, |
| &reported_counts); |
| } |
| break; |
| case base::android::ChildBindingState::MODERATE: |
| if (intentional_kill || info.normal_termination) { |
| ReportCrashCount( |
| ProcessedCrashCounts:: |
| kRendererForegroundInvisibleWithModerateBindingKilled, |
| &reported_counts); |
| } else { |
| ReportCrashCount( |
| ProcessedCrashCounts:: |
| kRendererForegroundInvisibleWithModerateBindingOom, |
| &reported_counts); |
| } |
| break; |
| } |
| } |
| } |
| |
| if (info.process_type == content::PROCESS_TYPE_RENDERER && |
| (info.app_state == |
| base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES || |
| info.app_state == |
| base::android::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES) && |
| info.was_killed_intentionally_by_browser) { |
| ReportCrashCount(ProcessedCrashCounts::kRendererForegroundIntentionalKill, |
| &reported_counts); |
| } |
| |
| if (crashed) { |
| if (info.process_type == content::PROCESS_TYPE_RENDERER) { |
| ReportCrashCount(ProcessedCrashCounts::kRendererCrashAll, |
| &reported_counts); |
| } else if (info.process_type == content::PROCESS_TYPE_GPU) { |
| ReportCrashCount(ProcessedCrashCounts::kGpuCrashAll, &reported_counts); |
| } else if (info.process_type == content::PROCESS_TYPE_UTILITY) { |
| ReportCrashCount(ProcessedCrashCounts::kUtilityCrashAll, |
| &reported_counts); |
| } |
| } |
| |
| if (app_foreground && android_oom_kill && |
| info.binding_state == base::android::ChildBindingState::STRONG) { |
| const bool has_waived = info.remaining_process_with_waived_binding > 0; |
| const bool has_moderate = info.remaining_process_with_moderate_binding > 0; |
| const bool has_strong = info.remaining_process_with_strong_binding > 0; |
| BindingStateCombo combo; |
| if (has_waived && has_moderate) { |
| combo = has_strong ? BindingStateCombo::kHasWaivedHasModerateHasStrong |
| : BindingStateCombo::kHasWaivedHasModerateNoStrong; |
| } else if (has_waived) { |
| combo = has_strong ? BindingStateCombo::kHasWaivedNoModerateHasStrong |
| : BindingStateCombo::kHasWaivedNoModerateNoStrong; |
| } else if (has_moderate) { |
| combo = has_strong ? BindingStateCombo::kNoWaivedHasModerateHasStrong |
| : BindingStateCombo::kNoWaivedHasModerateNoStrong; |
| } else { |
| combo = has_strong ? BindingStateCombo::kNoWaivedNoModerateHasStrong |
| : BindingStateCombo::kNoWaivedNoModerateNoStrong; |
| } |
| UMA_HISTOGRAM_ENUMERATION( |
| "Stability.Android.StrongBindingOomRemainingBindingState", combo); |
| UMA_HISTOGRAM_EXACT_LINEAR( |
| "Stability.Android.StrongBindingOomRemainingStrongBindingCount", |
| info.remaining_process_with_strong_binding, 20); |
| } |
| |
| ReportLegacyCrashUma(info, crashed); |
| NotifyObservers(info.process_host_id, reported_counts); |
| } |
| |
| void CrashMetricsReporter::NotifyObservers( |
| int rph_id, |
| const CrashMetricsReporter::ReportedCrashTypeSet& reported_counts) { |
| async_observers_->Notify( |
| FROM_HERE, &CrashMetricsReporter::Observer::OnCrashDumpProcessed, rph_id, |
| reported_counts); |
| } |
| |
| } // namespace crash_reporter |
