Handle EXC_RESOURCE and EXC_GUARD exceptions properly

handler/mac/crash_report_exception_handler.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 13 matching lines @@
 #include "client/settings.h"
 #include "minidump/minidump_file_writer.h"
 #include "snapshot/mac/crashpad_info_client_options.h"
 #include "snapshot/mac/process_snapshot_mac.h"
 #include "util/file/file_writer.h"
 #include "util/mach/exc_client_variants.h"
 #include "util/mach/exception_behaviors.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
 #include "util/mach/scoped_task_suspend.h"
+#include "util/mach/symbolic_constants_mach.h"
 #include "util/misc/tri_state.h"
 #include "util/misc/uuid.h"
 
 namespace crashpad {
 
 namespace {
 
 // Calls CrashReportDatabase::ErrorWritingCrashReport() upon destruction unless
 // disarmed by calling Disarm(). Armed upon construction.
 class CallErrorWritingCrashReport {
@@ skipping 50 matching lines @@
     mach_msg_type_number_t* new_state_count,
     const mach_msg_trailer_t* trailer,
     bool* destroy_complex_request) {
   *destroy_complex_request = true;
 
   // The expected behavior is EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES,
   // but it’s possible to deal with any exception behavior as long as it
   // carries identity information (valid thread and task ports).
   if (!ExceptionBehaviorHasIdentity(behavior)) {
     LOG(ERROR) << base::StringPrintf(
-        "unexpected exception behavior 0x%x, rejecting", behavior);
+        "unexpected exception behavior %s, rejecting",
+        ExceptionBehaviorToString(
+            behavior, kUseFullName | kUnknownIsNumeric | kUseOr).c_str());
     return KERN_FAILURE;
   } else if (behavior != (EXCEPTION_STATE_IDENTITY | kMachExceptionCodes)) {
     LOG(WARNING) << base::StringPrintf(
-        "unexpected exception behavior 0x%x, proceeding", behavior);
+        "unexpected exception behavior %s, proceeding",
+        ExceptionBehaviorToString(
+            behavior, kUseFullName | kUnknownIsNumeric | kUseOr).c_str());
   }
 
   if (task == mach_task_self()) {
     LOG(ERROR) << "cannot suspend myself";
     return KERN_FAILURE;
   }
 
   ScopedTaskSuspend suspend(task);
 
   ProcessSnapshotMac process_snapshot;
@@ skipping 14 matching lines @@
     if (exception_pid != audit_pid) {
       LOG(WARNING) << "exception for pid " << exception_pid << " sent by pid "
                    << audit_pid;
     }
   }
 
   CrashpadInfoClientOptions client_options;
   process_snapshot.GetCrashpadOptions(&client_options);
 
   if (client_options.crashpad_handler_behavior != TriState::kDisabled) {
-    if (!process_snapshot.InitializeException(thread,
+    if (!process_snapshot.InitializeException(behavior,
+                                              thread,
                                               exception,
                                               code,
                                               code_count,
                                               *flavor,
                                               old_state,
                                               old_state_count)) {
       return KERN_FAILURE;
     }
 
     UUID client_id;
@@ skipping 45 matching lines @@
        exception == EXC_RESOURCE ||
        exception == EXC_GUARD)) {
     // Don’t forward simulated exceptions such as kMachExceptionSimulated to the
     // system crash reporter. Only forward the types of exceptions that it would
     // receive under normal conditions. Although the system crash reporter is
     // able to deal with other exceptions including simulated ones, forwarding
     // them to the system crash reporter could present the system’s crash UI for
     // processes that haven’t actually crashed, and could result in reports not
     // actually associated with crashes being sent to the operating system
     // vendor.
+    //
+    // Note that normally, EXC_RESOURCE and EXC_GUARD exceptions are sent to the
+    // system-level com.apple.ReportCrash.Root job, and not to the user-level
+    // job that they are forwarded to here.
     mach_port_t system_crash_reporter_port;
     const char kSystemCrashReporterServiceName[] = "com.apple.ReportCrash";
     kern_return_t kr = bootstrap_look_up(bootstrap_port,
                                          kSystemCrashReporterServiceName,
                                          &system_crash_reporter_port);
     if (kr != BOOTSTRAP_SUCCESS) {
       BOOTSTRAP_LOG(ERROR, kr) << "bootstrap_look_up "
                                << kSystemCrashReporterServiceName;
     } else {
       // Make copies of mutable out parameters so that the system crash reporter
@@ skipping 36 matching lines @@
 
   if (!forwarded) {
     ExcServerCopyState(
         behavior, old_state, old_state_count, new_state, new_state_count);
   }
 
   return ExcServerSuccessfulReturnValue(behavior, false);
 }
 
 }  // namespace crashpad