Add ExcServerSuccessfulReturnValue() and its test

util/mach/exc_server_variants.cc

 // Copyright 2014 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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/exc_server_variants.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "util/mach/exc.h"
+#include "util/mach/exception_behaviors.h"
 #include "util/mach/excServer.h"
 #include "util/mach/mach_exc.h"
 #include "util/mach/mach_excServer.h"
 
 extern "C" {
 
 // These six functions are not used, and are in fact obsoleted by the other
 // functionality implemented in this file. The standard MIG-generated exc_server
 // (in excServer.c) and mach_exc_server (in mach_excServer.c) server dispatch
 // routines usable with the standard mach_msg_server() function call out to
@@ skipping 161 matching lines @@
   return __MIG_check__Request__mach_exception_raise_state_identity_t(
       const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
 }
 
 }  // namespace
 
 namespace crashpad {
 namespace internal {
 
 ExcServer::ExcServer(ExcServer::Interface* interface)
-    : MachMessageServer::Interface(),

[Robert Sesek, 2014/09/17 15:29:38]

Not sure these clang-format changes are improvements.

[Mark Mentovai, 2014/09/17 15:35:38]

rsesek wrote:
I’d say it’s 50/50. What it did to the “check” calls is fine, but the
initializers are less good.

-      interface_(interface) {
+    : MachMessageServer::Interface(), interface_(interface) {
 }
 
 bool ExcServer::MachMessageServerFunction(const mach_msg_header_t* in_header,
                                           mach_msg_header_t* out_header,
                                           bool* destroy_complex_request) {
   PrepareReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDExceptionRaise: {
       // exception_raise(), catch_exception_raise().
@@ skipping 24 matching lines @@
     }
 
     case kMachMessageIDExceptionRaiseState: {
       // exception_raise_state(), catch_exception_raise_state().
       typedef __Request__exception_raise_state_t Request;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
-      kern_return_t kr = MIGCheckRequestExceptionRaiseState(
-          in_request, &in_request_1);
+      kern_return_t kr =
+          MIGCheckRequestExceptionRaiseState(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__exception_raise_state_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
@@ skipping 18 matching lines @@
 
     case kMachMessageIDExceptionRaiseStateIdentity: {
       // exception_raise_state_identity(),
       // catch_exception_raise_state_identity().
       typedef __Request__exception_raise_state_identity_t Request;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
-      kern_return_t kr = MIGCheckRequestExceptionRaiseStateIdentity(
-          in_request, &in_request_1);
+      kern_return_t kr =
+          MIGCheckRequestExceptionRaiseStateIdentity(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__exception_raise_state_identity_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode = interface_->CatchExceptionRaiseStateIdentity(
@@ skipping 26 matching lines @@
 
 mach_msg_size_t ExcServer::MachMessageServerRequestSize() {
   return sizeof(__RequestUnion__exc_subsystem);
 }
 
 mach_msg_size_t ExcServer::MachMessageServerReplySize() {
   return sizeof(__ReplyUnion__exc_subsystem);
 }
 
 MachExcServer::MachExcServer(MachExcServer::Interface* interface)
-    : MachMessageServer::Interface(),
-      interface_(interface) {
+    : MachMessageServer::Interface(), interface_(interface) {
 }
 
 bool MachExcServer::MachMessageServerFunction(
     const mach_msg_header_t* in_header,
     mach_msg_header_t* out_header,
     bool* destroy_complex_request) {
   PrepareReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDMachExceptionRaise: {
@@ skipping 25 matching lines @@
     }
 
     case kMachMessageIDMachExceptionRaiseState: {
       // mach_exception_raise_state(), catch_mach_exception_raise_state().
       typedef __Request__mach_exception_raise_state_t Request;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
-      kern_return_t kr = MIGCheckRequestMachExceptionRaiseState(
-          in_request, &in_request_1);
+      kern_return_t kr =
+          MIGCheckRequestMachExceptionRaiseState(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__mach_exception_raise_state_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
@@ skipping 67 matching lines @@
 mach_msg_size_t MachExcServer::MachMessageServerRequestSize() {
   return sizeof(__RequestUnion__mach_exc_subsystem);
 }
 
 mach_msg_size_t MachExcServer::MachMessageServerReplySize() {
   return sizeof(__ReplyUnion__mach_exc_subsystem);
 }
 
 SimplifiedExcServer::SimplifiedExcServer(
     SimplifiedExcServer::Interface* interface)
-    : ExcServer(this),
-      ExcServer::Interface(),
-      interface_(interface) {
+    : ExcServer(this), ExcServer::Interface(), interface_(interface) {
 }
 
 kern_return_t SimplifiedExcServer::CatchExceptionRaise(
     exception_handler_t exception_port,
     thread_t thread,
     task_t task,
     exception_type_t exception,
     const exception_data_type_t* code,
     mach_msg_type_number_t code_count,
     bool* destroy_request) {
@@ skipping 63 matching lines @@
                                     flavor,
                                     old_state,
                                     old_state_count,
                                     new_state,
                                     new_state_count,
                                     destroy_request);
 }
 
 SimplifiedMachExcServer::SimplifiedMachExcServer(
     SimplifiedMachExcServer::Interface* interface)
-    : MachExcServer(this),
-      MachExcServer::Interface(),
-      interface_(interface) {
+    : MachExcServer(this), MachExcServer::Interface(), interface_(interface) {
 }
 
 kern_return_t SimplifiedMachExcServer::CatchMachExceptionRaise(
     exception_handler_t exception_port,
     thread_t thread,
     task_t task,
     exception_type_t exception,
     const mach_exception_data_type_t* code,
     mach_msg_type_number_t code_count,
     bool* destroy_request) {
@@ skipping 142 matching lines @@
                             code_count ? &mach_codes[0] : NULL,
                             code_count,
                             flavor,
                             old_state,
                             old_state_count,
                             new_state,
                             new_state_count,
                             destroy_complex_request);
 }
 
+kern_return_t ExcServerSuccessfulReturnValue(exception_behavior_t behavior,
+                                             bool set_thread_state) {
+  if (!set_thread_state && ExceptionBehaviorHasState(behavior)) {
+    return MACH_RCV_PORT_DIED;
+  }
+
+  return KERN_SUCCESS;
+}
+
 }  // namespace crashpad