Recognize crashreporter_annotations_t version 5 found on OS X 10.11

snapshot/mac/mach_o_image_annotations_reader_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 29 matching lines @@
 #include "util/mach/exc_server_variants.h"
 #include "util/mach/exception_ports.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
 #include "util/mach/mach_message_server.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
+// \return The path to crashpad_snapshot_test_module_crashy_initializer.so
+std::string ModuleWithCrashyInitializer() {
+  return Paths::Executable().value() + "_module_crashy_initializer.so";
+}
+
 //! \return The path to the crashpad_snapshot_test_no_op executable.
 base::FilePath NoOpExecutable() {
   return base::FilePath(Paths::Executable().value() + "_no_op");
 }
 
 class TestMachOImageAnnotationsReader final
     : public MachMultiprocess,
       public UniversalMachExcServer::Interface {
  public:
   enum TestType {
     // Don’t crash, just test the CrashpadInfo interface.
     kDontCrash = 0,
 
     // The child process should crash by calling abort(). The parent verifies
     // that the system libraries set the expected annotations.
+    //
+    // This test verifies that the message field in crashreporter_annotations_t
+    // can be recovered. Either 10.10.2 Libc-1044.1.2/stdlib/FreeBSD/abort.c
+    // abort() or 10.10.2 Libc-1044.10.1/sys/_libc_fork_child.c
+    // _libc_fork_child() calls CRSetCrashLogMessage() to set the message field.
     kCrashAbort,
 
+    // The child process should crash at module initialization time, when dyld
+    // will have set an annotation matching the path of the module being
+    // initialized.
+    //
+    // This test exists to verify that the message2 field in
+    // crashreporter_annotations_t can be recovered. 10.10.2
+    // dyld-353.2.1/src/ImageLoaderMachO.cpp
+    // ImageLoaderMachO::doInitialization() calls CRSetCrashLogMessage2() to set
+    // the message2 field.
+    kCrashModuleInitialization,
+
     // The child process should crash by setting DYLD_INSERT_LIBRARIES to
     // contain a nonexistent library. The parent verifies that dyld sets the
     // expected annotations.
     kCrashDyld,
   };
 
   explicit TestMachOImageAnnotationsReader(TestType test_type)
       : MachMultiprocess(),
         UniversalMachExcServer::Interface(),
         test_type_(test_type) {
@@ skipping 42 matching lines @@
         }
       }
 
       // Mac OS X 10.6 doesn’t have support for CrashReporter annotations
       // (CrashReporterClient.h), so don’t look for any special annotations in
       // that version.
       int mac_os_x_minor_version = MacOSXMinorVersion();
       if (mac_os_x_minor_version > 7) {
         EXPECT_GE(all_annotations_vector.size(), 1u);
 
-        const char* expected_annotation = nullptr;
+        std::string expected_annotation;
         switch (test_type_) {
           case kCrashAbort:
             // The child process calls abort(), so the expected annotation
             // reflects this, with a string set by 10.7.5
             // Libc-763.13/stdlib/abort-fbsd.c abort(). This string is still
             // present in 10.9.5 Libc-997.90.3/stdlib/FreeBSD/abort.c abort(),
             // but because abort() tests to see if a message is already set and
             // something else in Libc will have set a message, this string is
             // not the expectation on 10.9 or higher. Instead, after fork(), the
             // child process has a message indicating that a fork() without
             // exec() occurred. See 10.9.5 Libc-997.90.3/sys/_libc_fork_child.c
             // _libc_fork_child().
             expected_annotation =
                 mac_os_x_minor_version <= 8
                     ? "abort() called"
                     : "crashed on child side of fork pre-exec";
             break;
 
+          case kCrashModuleInitialization:
+            // This message is set by dyld-353.2.1/src/ImageLoaderMachO.cpp
+            // ImageLoaderMachO::doInitialization().
+            expected_annotation = ModuleWithCrashyInitializer();
+            break;
+
           case kCrashDyld:
             // This is independent of dyld’s error_string, which is tested
             // below.
             expected_annotation = "dyld: launch, loading dependent libraries";
             break;
 
           default:
             ADD_FAILURE();
             break;
         }
 
-        size_t expected_annotation_length = strlen(expected_annotation);
         bool found = false;
         for (const std::string& annotation : all_annotations_vector) {
           // Look for the expectation as a leading susbtring, because the actual
           // string that dyld uses will have the contents of the
           // DYLD_INSERT_LIBRARIES environment variable appended to it on Mac
           // OS X 10.10.
-          if (annotation.substr(0, expected_annotation_length) ==
+          if (annotation.substr(0, expected_annotation.length()) ==
                   expected_annotation) {
             found = true;
             break;
           }
         }
-        EXPECT_TRUE(found);
+        EXPECT_TRUE(found) << expected_annotation;
       }
 
       // dyld exposes its error_string at least as far back as Mac OS X 10.4.
       if (test_type_ == kCrashDyld) {
         const char kExpectedAnnotation[] = "could not load inserted library";
         size_t expected_annotation_length = strlen(kExpectedAnnotation);
         bool found = false;
         for (const std::string& annotation : all_annotations_vector) {
           // Look for the expectation as a leading substring, because the actual
           // string will contain the library’s pathname and, on Mac OS X 10.9
           // and later, a reason.
           if (annotation.substr(0, expected_annotation_length) ==
                   kExpectedAnnotation) {
             found = true;
             break;
           }
         }
 
-        EXPECT_TRUE(found);
+        EXPECT_TRUE(found) << kExpectedAnnotation;
       }
     }
 
     return ExcServerSuccessfulReturnValue(behavior, false);
   }
 
  private:
   // MachMultiprocess:
 
   void MachMultiprocessParent() override {
@@ skipping 41 matching lines @@
                                  MachMessageServer::kReceiveLargeError,
                                  kMachMessageTimeoutWaitIndefinitely);
       EXPECT_EQ(MACH_MSG_SUCCESS, mr)
           << MachErrorMessage(mr, "MachMessageServer::Run");
 
       switch (test_type_) {
         case kCrashAbort:
           SetExpectedChildTermination(kTerminationSignal, SIGABRT);
           break;
 
+        case kCrashModuleInitialization:
+          // This crash is triggered by __builtin_trap(), which shows up as
+          // SIGILL.
+          SetExpectedChildTermination(kTerminationSignal, SIGILL);
+          break;
+
         case kCrashDyld:
           // dyld fatal errors result in the execution of an int3 instruction on
           // x86 and a trap instruction on ARM, both of which raise SIGTRAP.
           // 10.9.5 dyld-239.4/src/dyldStartup.s _dyld_fatal_error.
           SetExpectedChildTermination(kTerminationSignal, SIGTRAP);
           break;
 
         default:
           FAIL();
           break;
@@ skipping 23 matching lines @@
     CheckedReadFile(ReadPipeHandle(), &c, sizeof(c));
 
     // Direct an exception message to the exception server running in the
     // parent.
     ExceptionPorts exception_ports(ExceptionPorts::kTargetTypeTask,
                                    mach_task_self());
     ASSERT_TRUE(exception_ports.SetExceptionPort(
         EXC_MASK_CRASH, RemotePort(), EXCEPTION_DEFAULT, THREAD_STATE_NONE));
 
     switch (test_type_) {
-      case kDontCrash:
+      case kDontCrash: {
         break;
+      }
 
-      case kCrashAbort:
+      case kCrashAbort: {
         abort();
         break;
+      }
+
+      case kCrashModuleInitialization: {
+        // Load a module that crashes while executing a module initializer.
+        void* dl_handle = dlopen(ModuleWithCrashyInitializer().c_str(),
+                                 RTLD_LAZY | RTLD_LOCAL);
+
+        // This should have crashed in the dlopen(). If dlopen() failed, the
+        // ASSERT_NE() will show the message. If it succeeded without crashing,
+        // the FAIL() will fail the test.
+        ASSERT_NE(nullptr, dl_handle) << dlerror();
+        FAIL();
+        break;
+      }
 
       case kCrashDyld: {
         // Set DYLD_INSERT_LIBRARIES to contain a library that does not exist.
         // Unable to load it, dyld will abort with a fatal error.
         ASSERT_EQ(
             0,
             setenv(
                 "DYLD_INSERT_LIBRARIES", "/var/empty/NoDirectory/NoLibrary", 1))
             << ErrnoMessage("setenv");
 
@@ skipping 26 matching lines @@
       TestMachOImageAnnotationsReader::kDontCrash);
   test_mach_o_image_annotations_reader.Run();
 }
 
 TEST(MachOImageAnnotationsReader, CrashAbort) {
   TestMachOImageAnnotationsReader test_mach_o_image_annotations_reader(
       TestMachOImageAnnotationsReader::kCrashAbort);
   test_mach_o_image_annotations_reader.Run();
 }
 
+TEST(MachOImageAnnotationsReader, CrashModuleInitialization) {
+  TestMachOImageAnnotationsReader test_mach_o_image_annotations_reader(
+      TestMachOImageAnnotationsReader::kCrashModuleInitialization);
+  test_mach_o_image_annotations_reader.Run();
+}
+
 TEST(MachOImageAnnotationsReader, CrashDyld) {
   TestMachOImageAnnotationsReader test_mach_o_image_annotations_reader(
       TestMachOImageAnnotationsReader::kCrashDyld);
   test_mach_o_image_annotations_reader.Run();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad