Add ExcServerSuccessfulReturnValue() and its test

util/mach/exc_server_variants_test.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,
@@ skipping 537 matching lines @@
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
   request.InitializeForTesting();
 
   ExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
   reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_DEFAULT;
 
   EXPECT_CALL(server,
-              MockCatchMachException(
-                  kExceptionBehavior,
-                  kServerLocalPort,
-                  kExceptionThreadPort,
-                  kExceptionTaskPort,
-                  kExceptionType,
-                  AreExceptionCodes(
-                      kTestExceptonCodes[0], kTestExceptonCodes[1]),
-                  Pointee(Eq(THREAD_STATE_NONE)),
-                  IsThreadStateCount(0u),
-                  IsThreadStateCount(0u)))
+              MockCatchMachException(kExceptionBehavior,
+                                     kServerLocalPort,
+                                     kExceptionThreadPort,
+                                     kExceptionTaskPort,
+                                     kExceptionType,
+                                     AreExceptionCodes(kTestExceptonCodes[0],
+                                                       kTestExceptonCodes[1]),
+                                     Pointee(Eq(THREAD_STATE_NONE)),
+                                     IsThreadStateCount(0u),
+                                     IsThreadStateCount(0u)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   ExceptionRaiseStateRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
   request.InitializeForTesting();
 
   ExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
   reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE;
 
-  EXPECT_CALL(server,
-              MockCatchMachException(
-                  kExceptionBehavior,
-                  kServerLocalPort,
-                  MACH_PORT_NULL,
-                  MACH_PORT_NULL,
-                  kExceptionType,
-                  AreExceptionCodes(
-                      kTestExceptonCodes[0], kTestExceptonCodes[1]),
-                  Pointee(Eq(kThreadStateFlavor)),
-                  IsThreadStateCount(kThreadStateFlavorCount),
-                  IsThreadStateCount(arraysize(reply.new_state))))
+  EXPECT_CALL(
+      server,
+      MockCatchMachException(
+          kExceptionBehavior,
+          kServerLocalPort,
+          MACH_PORT_NULL,
+          MACH_PORT_NULL,
+          kExceptionType,
+          AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
+          Pointee(Eq(kThreadStateFlavor)),
+          IsThreadStateCount(kThreadStateFlavorCount),
+          IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
 
   // The request wasn’t complex, so nothing got a chance to change the value of
@@ skipping 11 matching lines @@
   ExceptionRaiseStateIdentityRequest request;
   EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
   request.InitializeForTesting();
 
   ExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
   reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE_IDENTITY;
 
-  EXPECT_CALL(server,
-              MockCatchMachException(
-                  kExceptionBehavior,
-                  kServerLocalPort,
-                  kExceptionThreadPort,
-                  kExceptionTaskPort,
-                  kExceptionType,
-                  AreExceptionCodes(
-                      kTestExceptonCodes[0], kTestExceptonCodes[1]),
-                  Pointee(Eq(kThreadStateFlavor)),
-                  IsThreadStateCount(kThreadStateFlavorCount),
-                  IsThreadStateCount(arraysize(reply.new_state))))
+  EXPECT_CALL(
+      server,
+      MockCatchMachException(
+          kExceptionBehavior,
+          kServerLocalPort,
+          kExceptionThreadPort,
+          kExceptionTaskPort,
+          kExceptionType,
+          AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
+          Pointee(Eq(kThreadStateFlavor)),
+          IsThreadStateCount(kThreadStateFlavorCount),
+          IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
@@ skipping 11 matching lines @@
 
   MachExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
   reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
-      MockCatchMachException(
-          kExceptionBehavior,
-          kServerLocalPort,
-          kExceptionThreadPort,
-          kExceptionTaskPort,
-          kExceptionType,
-          AreExceptionCodes(
-              kTestMachExceptionCodes[0], kTestMachExceptionCodes[1]),
-          Pointee(Eq(THREAD_STATE_NONE)),
-          IsThreadStateCount(0u),
-          IsThreadStateCount(0u)))
+      MockCatchMachException(kExceptionBehavior,
+                             kServerLocalPort,
+                             kExceptionThreadPort,
+                             kExceptionTaskPort,
+                             kExceptionType,
+                             AreExceptionCodes(kTestMachExceptionCodes[0],
+                                               kTestMachExceptionCodes[1]),
+                             Pointee(Eq(THREAD_STATE_NONE)),
+                             IsThreadStateCount(0u),
+                             IsThreadStateCount(0u)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
@@ skipping 11 matching lines @@
 
   MachExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
   reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
-      MockCatchMachException(
-          kExceptionBehavior,
-          kServerLocalPort,
-          MACH_PORT_NULL,
-          MACH_PORT_NULL,
-          kExceptionType,
-          AreExceptionCodes(
-              kTestMachExceptionCodes[0], kTestMachExceptionCodes[1]),
-          Pointee(Eq(kThreadStateFlavor)),
-          IsThreadStateCount(kThreadStateFlavorCount),
-          IsThreadStateCount(arraysize(reply.new_state))))
+      MockCatchMachException(kExceptionBehavior,
+                             kServerLocalPort,
+                             MACH_PORT_NULL,
+                             MACH_PORT_NULL,
+                             kExceptionType,
+                             AreExceptionCodes(kTestMachExceptionCodes[0],
+                                               kTestMachExceptionCodes[1]),
+                             Pointee(Eq(kThreadStateFlavor)),
+                             IsThreadStateCount(kThreadStateFlavorCount),
+                             IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
 
   // The request wasn’t complex, so nothing got a chance to change the value of
@@ skipping 14 matching lines @@
 
   MachExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
   reply.InitializeForTesting();
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
-      MockCatchMachException(
-          kExceptionBehavior,
-          kServerLocalPort,
-          kExceptionThreadPort,
-          kExceptionTaskPort,
-          kExceptionType,
-          AreExceptionCodes(
-              kTestMachExceptionCodes[0], kTestMachExceptionCodes[1]),
-          Pointee(Eq(kThreadStateFlavor)),
-          IsThreadStateCount(kThreadStateFlavorCount),
-          IsThreadStateCount(arraysize(reply.new_state))))
+      MockCatchMachException(kExceptionBehavior,
+                             kServerLocalPort,
+                             kExceptionThreadPort,
+                             kExceptionTaskPort,
+                             kExceptionType,
+                             AreExceptionCodes(kTestMachExceptionCodes[0],
+                                               kTestMachExceptionCodes[1]),
+                             Pointee(Eq(kThreadStateFlavor)),
+                             IsThreadStateCount(kThreadStateFlavorCount),
+                             IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
@@ skipping 71 matching lines @@
                               public MachMultiprocess {
  public:
   TestExcServerVariants(exception_behavior_t behavior,
                         thread_state_flavor_t flavor,
                         mach_msg_type_number_t state_count)
       : UniversalMachExcServer(),
         MachMultiprocess(),
         behavior_(behavior),
         flavor_(flavor),
         state_count_(state_count),
-        handled_(false) {
-  }
+        handled_(false) {}
 
   // UniversalMachExcServer:
 
   virtual kern_return_t CatchMachException(
       exception_behavior_t behavior,
       exception_handler_t exception_port,
       thread_t thread,
       task_t task,
       exception_type_t exception,
       const mach_exception_data_type_t* code,
@@ skipping 45 matching lines @@
                 *new_state_count);
       EXPECT_NE(static_cast<natural_t*>(NULL), new_state);
     } else {
       EXPECT_EQ(THREAD_STATE_NONE, *flavor);
       EXPECT_EQ(0u, old_state_count);
       EXPECT_EQ(NULL, old_state);
       EXPECT_EQ(0u, *new_state_count);
       EXPECT_EQ(NULL, new_state);
     }
 
-    // Even for an EXC_CRASH handler, returning KERN_SUCCESS with a
-    // state-carrying reply will cause the kernel to try to set a new thread
-    // state, leading to a perceptible waste of time. Returning
-    // MACH_RCV_PORT_DIED is the only way to suppress this behavior while also
-    // preventing the kernel from looking for another (host-level) EXC_CRASH
-    // handler. See 10.9.4 xnu-2422.110.17/osfmk/kern/exception.c
-    // exception_triage().
-    return has_state ? MACH_RCV_PORT_DIED : KERN_SUCCESS;
+    return ExcServerSuccessfulReturnValue(behavior, false);
   }
 
  private:
   // MachMultiprocess:
 
   virtual void MachMultiprocessParent() override {
     kern_return_t kr = MachMessageServer::Run(this,
                                               LocalPort(),
                                               MACH_MSG_OPTION_NONE,
                                               MachMessageServer::kOneShot,
@@ skipping 93 matching lines @@
     // thread_get_state()) encounters an undersized buffer as reported by the
     // buffer size parameter, it returns KERN_INVALID_ARGUMENT, which causes
     // exception_deliver() to not actually deliver the exception and instead
     // return that error code to exception_triage() as well.
     //
     // This bug is filed as radar 18312067.
     //
     // Additionaly, the AVX state flavors are also not tested because they’re
     // not available on all CPUs and OS versions.
 #if defined(ARCH_CPU_X86)
-    { x86_THREAD_STATE32, x86_THREAD_STATE32_COUNT },
-    { x86_FLOAT_STATE32, x86_FLOAT_STATE32_COUNT },
-    { x86_EXCEPTION_STATE32, x86_EXCEPTION_STATE32_COUNT },
+    {x86_THREAD_STATE32, x86_THREAD_STATE32_COUNT},
+    {x86_FLOAT_STATE32, x86_FLOAT_STATE32_COUNT},
+    {x86_EXCEPTION_STATE32, x86_EXCEPTION_STATE32_COUNT},
 #endif
 #if defined(ARCH_CPU_X86_64)
-    { x86_THREAD_STATE64, x86_THREAD_STATE64_COUNT },
-    { x86_FLOAT_STATE64, x86_FLOAT_STATE64_COUNT },
-    { x86_EXCEPTION_STATE64, x86_EXCEPTION_STATE64_COUNT },
+    {x86_THREAD_STATE64, x86_THREAD_STATE64_COUNT},
+    {x86_FLOAT_STATE64, x86_FLOAT_STATE64_COUNT},
+    {x86_EXCEPTION_STATE64, x86_EXCEPTION_STATE64_COUNT},
 #endif
-    { x86_THREAD_STATE, x86_THREAD_STATE_COUNT },
-    { x86_FLOAT_STATE, x86_FLOAT_STATE_COUNT },
-    { x86_EXCEPTION_STATE, x86_EXCEPTION_STATE_COUNT },
+    {x86_THREAD_STATE, x86_THREAD_STATE_COUNT},
+    {x86_FLOAT_STATE, x86_FLOAT_STATE_COUNT},
+    {x86_EXCEPTION_STATE, x86_EXCEPTION_STATE_COUNT},
 #else
 #error Port this test to your CPU architecture.
 #endif
   };
 
   for (size_t index = 0; index < arraysize(test_data); ++index) {
     const TestData& test = test_data[index];
-    SCOPED_TRACE(base::StringPrintf(
-        "index %zu, flavor %d", index, test.flavor));
+    SCOPED_TRACE(
+        base::StringPrintf("index %zu, flavor %d", index, test.flavor));
 
     TestExcServerVariants test_exc_server_variants(
         MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY,
         test.flavor,
         test.count);
     test_exc_server_variants.Run();
   }
 }
 
+TEST(ExcServerVariants, ExcServerSuccessfulReturnValue) {
+  struct TestData {
+    exception_behavior_t behavior;
+    bool set_thread_state;
+    kern_return_t kr;
+  };
+  const TestData kTestData[] = {
+      {EXCEPTION_DEFAULT, false, KERN_SUCCESS},
+      {EXCEPTION_STATE, false, MACH_RCV_PORT_DIED},
+      {EXCEPTION_STATE_IDENTITY, false, MACH_RCV_PORT_DIED},
+      {kMachExceptionCodes | EXCEPTION_DEFAULT, false, KERN_SUCCESS},
+      {kMachExceptionCodes | EXCEPTION_STATE, false, MACH_RCV_PORT_DIED},
+      {kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
+       false,
+       MACH_RCV_PORT_DIED},
+      {EXCEPTION_DEFAULT, true, KERN_SUCCESS},
+      {EXCEPTION_STATE, true, KERN_SUCCESS},
+      {EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
+      {kMachExceptionCodes | EXCEPTION_DEFAULT, true, KERN_SUCCESS},
+      {kMachExceptionCodes | EXCEPTION_STATE, true, KERN_SUCCESS},
+      {kMachExceptionCodes | EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
+  };
+
+  for (size_t index = 0; index < arraysize(kTestData); ++index) {
+    const TestData& test_data = kTestData[index];
+    SCOPED_TRACE(
+        base::StringPrintf("index %zu, behavior %d, set_thread_state %s",
+                           index,
+                           test_data.behavior,
+                           test_data.set_thread_state ? "true" : "false"));
+
+    EXPECT_EQ(test_data.kr,
+              ExcServerSuccessfulReturnValue(test_data.behavior,
+                                             test_data.set_thread_state));
+  }
+}
+
 }  // namespace