Implement (and test) ProcessReader::Modules()

util/mac/process_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,
 // 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/mac/process_reader.h"
 
 #include <dispatch/dispatch.h>
+#include <mach-o/dyld.h>
+#include <mach-o/dyld_images.h>
 #include <mach/mach.h>
 #include <string.h>
+#include <sys/stat.h>
 
 #include <map>
 #include <string>
+#include <vector>
 
 #include "base/logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "gtest/gtest.h"
 #include "util/file/fd_io.h"
 #include "util/stdlib/pointer_container.h"
+#include "util/test/errors.h"
+#include "util/test/mac/dyld.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
-#include "util/test/errors.h"
 
 namespace {
 
 using namespace crashpad;
 using namespace crashpad::test;
 
 TEST(ProcessReader, SelfBasic) {
   ProcessReader process_reader;
   ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
 
@@ skipping 33 matching lines @@
 #else
     EXPECT_TRUE(process_reader.Is64Bit());
 #endif
 
     EXPECT_EQ(getpid(), process_reader.ParentProcessID());
     EXPECT_EQ(ChildPID(), process_reader.ProcessID());
 
     int read_fd = ReadPipeFD();
 
     mach_vm_address_t address;
-    int rv = ReadFD(read_fd, &address, sizeof(address));
+    ssize_t rv = ReadFD(read_fd, &address, sizeof(address));
     ASSERT_EQ(static_cast<ssize_t>(sizeof(address)), rv)
         << ErrnoMessage("read");
 
     std::string read_string;
     ASSERT_TRUE(process_reader.Memory()->ReadCString(address, &read_string));
     EXPECT_EQ(kTestMemory, read_string);
 
     // Tell the child that it’s OK to exit. The child needed to be kept alive
     // until the parent finished working with it.
     int write_fd = WritePipeFD();
     char c = '\0';
     rv = WriteFD(write_fd, &c, 1);
     ASSERT_EQ(1, rv) << ErrnoMessage("write");
   }
 
   void MachMultiprocessChild() override {
     int write_fd = WritePipeFD();
 
     mach_vm_address_t address =
         reinterpret_cast<mach_vm_address_t>(kTestMemory);
-    int rv = WriteFD(write_fd, &address, sizeof(address));
+    ssize_t rv = WriteFD(write_fd, &address, sizeof(address));
     ASSERT_EQ(static_cast<ssize_t>(sizeof(address)), rv)
         << ErrnoMessage("write");
 
     // Wait for the parent to say that it’s OK to exit.
     int read_fd = ReadPipeFD();
     char c;
     rv = ReadFD(read_fd, &c, 1);
     ASSERT_EQ(1, rv) << ErrnoMessage("read");
   }
 
@@ skipping 322 matching lines @@
     int read_fd = ReadPipeFD();
 
     // Build a map of all expected threads, keyed by each thread’s ID, and with
     // addresses that should lie somewhere within each thread’s stack as values.
     // These IDs and addresses all come from the child process via the pipe.
     ThreadMap thread_map;
     for (size_t thread_index = 0;
          thread_index < thread_count_ + 1;
          ++thread_index) {
       uint64_t thread_id;
-      int rv = ReadFD(read_fd, &thread_id, sizeof(thread_id));
+      ssize_t rv = ReadFD(read_fd, &thread_id, sizeof(thread_id));
       ASSERT_EQ(static_cast<ssize_t>(sizeof(thread_id)), rv)
           << ErrnoMessage("read");
 
       TestThreadPool::ThreadExpectation expectation;
       rv = ReadFD(read_fd,
                   &expectation.stack_address,
                   sizeof(expectation.stack_address));
       ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.stack_address)), rv)
           << ErrnoMessage("read");
 
@@ skipping 12 matching lines @@
     const std::vector<ProcessReaderThread>& threads = process_reader.Threads();
 
     // The child shouldn’t have any threads other than its main thread and the
     // ones it created in its pool, so pass false for |tolerate_extra_threads|.
     ExpectSeveralThreads(&thread_map, threads, false);
 
     // Tell the child that it’s OK to exit. The child needed to be kept alive
     // until the parent finished working with it.
     int write_fd = WritePipeFD();
     char c = '\0';
-    int rv = WriteFD(write_fd, &c, 1);
+    ssize_t rv = WriteFD(write_fd, &c, 1);
     ASSERT_EQ(1, rv) << ErrnoMessage("write");
   }
 
   void MachMultiprocessChild() override {
     TestThreadPool thread_pool;
     thread_pool.StartThreads(thread_count_);
     if (testing::Test::HasFatalFailure()) {
       return;
     }
 
     int write_fd = WritePipeFD();
 
     // This thread isn’t part of the thread pool, but the parent will be able
     // to inspect it. Write an entry for it.
     uint64_t thread_id = PthreadToThreadID(pthread_self());
 
-    int rv = WriteFD(write_fd, &thread_id, sizeof(thread_id));
+    ssize_t rv = WriteFD(write_fd, &thread_id, sizeof(thread_id));
     ASSERT_EQ(static_cast<ssize_t>(sizeof(thread_id)), rv)
         << ErrnoMessage("write");
 
     TestThreadPool::ThreadExpectation expectation;
     expectation.stack_address = reinterpret_cast<mach_vm_address_t>(&thread_id);
     expectation.suspend_count = 0;
 
     rv = WriteFD(write_fd,
                  &expectation.stack_address,
                  sizeof(expectation.stack_address));
@@ skipping 48 matching lines @@
   ProcessReaderThreadedChild process_reader_threaded_child(kChildThreads);
   process_reader_threaded_child.Run();
 }
 
 TEST(ProcessReader, ChildSeveralThreads) {
   const size_t kChildThreads = 64;
   ProcessReaderThreadedChild process_reader_threaded_child(kChildThreads);
   process_reader_threaded_child.Run();
 }
 
+TEST(ProcessReader, SelfModules) {
+  ProcessReader process_reader;
+  ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
+
+  uint32_t dyld_image_count = _dyld_image_count();
+  const std::vector<ProcessReaderModule>& modules = process_reader.Modules();
+
+  // There needs to be at least an entry for the main executable, for a dylib,
+  // and for dyld.
+  ASSERT_GE(modules.size(), 3u);
+
+  // dyld_image_count doesn’t include an entry for dyld itself, but |modules|
+  // does.
+  ASSERT_EQ(dyld_image_count + 1, modules.size());
+
+  for (uint32_t index = 0; index < dyld_image_count; ++index) {
+    SCOPED_TRACE(base::StringPrintf(
+        "index %u, name %s", index, modules[index].name.c_str()));
+
+    const char* dyld_image_name = _dyld_get_image_name(index);
+    EXPECT_EQ(dyld_image_name, modules[index].name);
+    EXPECT_EQ(
+        reinterpret_cast<mach_vm_address_t>(_dyld_get_image_header(index)),
+        modules[index].address);
+
+    if (index == 0) {
+      // dyld didn’t load the main executable, so it couldn’t record its
+      // timestamp, and it is reported as 0.
+      EXPECT_EQ(0, modules[index].timestamp);
+    } else {
+      // Hope that the module didn’t change on disk.
+      struct stat stat_buf;
+      int rv = stat(dyld_image_name, &stat_buf);
+      EXPECT_EQ(0, rv) << ErrnoMessage("stat");
+      if (rv == 0) {
+        EXPECT_EQ(stat_buf.st_mtime, modules[index].timestamp);
+      }
+    }
+  }
+
+  size_t index = modules.size() - 1;
+  EXPECT_EQ("/usr/lib/dyld", modules[index].name);
+
+  // dyld didn’t load itself either, so it couldn’t record its timestamp, and it
+  // is also reported as 0.
+  EXPECT_EQ(0, modules[index].timestamp);
+
+  const struct dyld_all_image_infos* dyld_image_infos =
+      _dyld_get_all_image_infos();
+  if (dyld_image_infos->version >= 2) {
+    EXPECT_EQ(reinterpret_cast<mach_vm_address_t>(
+        dyld_image_infos->dyldImageLoadAddress), modules[index].address);
+  }
+}
+
+class ProcessReaderModulesChild final : public MachMultiprocess {
+ public:
+  ProcessReaderModulesChild() : MachMultiprocess() {}
+
+  ~ProcessReaderModulesChild() {}
+
+ private:
+  void MachMultiprocessParent() override {
+    ProcessReader process_reader;
+    ASSERT_TRUE(process_reader.Initialize(ChildTask()));
+
+    const std::vector<ProcessReaderModule>& modules = process_reader.Modules();
+
+    // There needs to be at least an entry for the main executable, for a dylib,
+    // and for dyld.
+    ASSERT_GE(modules.size(), 3u);
+
+    int read_fd = ReadPipeFD();
+
+    uint32_t expect_modules;
+    ssize_t rv = ReadFD(read_fd, &expect_modules, sizeof(expect_modules));
+    ASSERT_EQ(static_cast<ssize_t>(sizeof(expect_modules)), rv)
+        << ErrnoMessage("read");
+
+    ASSERT_EQ(expect_modules, modules.size());
+
+    for (size_t index = 0; index < modules.size(); ++index) {
+      SCOPED_TRACE(base::StringPrintf(
+          "index %zu, name %s", index, modules[index].name.c_str()));
+
+      uint32_t expect_name_length;
+      rv = ReadFD(
+          read_fd, &expect_name_length, sizeof(expect_name_length));
+      ASSERT_EQ(static_cast<ssize_t>(sizeof(expect_name_length)), rv)
+          << ErrnoMessage("read");
+
+      // The NUL terminator is not read.
+      std::string expect_name(expect_name_length, '\0');
+      rv = ReadFD(read_fd, &expect_name[0], expect_name_length);
+      ASSERT_EQ(static_cast<ssize_t>(expect_name_length), rv)
+          << ErrnoMessage("read");
+
+      EXPECT_EQ(expect_name, modules[index].name);
+
+      mach_vm_address_t expect_address;
+      rv = ReadFD(read_fd, &expect_address, sizeof(expect_address));
+      ASSERT_EQ(static_cast<ssize_t>(sizeof(expect_address)), rv)
+          << ErrnoMessage("read");
+
+      EXPECT_EQ(expect_address, modules[index].address);
+
+      if (index == 0 || index == modules.size() - 1) {
+        // dyld didn’t load the main executable or itself, so it couldn’t record
+        // these timestamps, and they are reported as 0.
+        EXPECT_EQ(0, modules[index].timestamp);
+      } else {
+        // Hope that the module didn’t change on disk.
+        struct stat stat_buf;
+        int rv = stat(expect_name.c_str(), &stat_buf);
+        EXPECT_EQ(0, rv) << ErrnoMessage("stat");
+        if (rv == 0) {
+          EXPECT_EQ(stat_buf.st_mtime, modules[index].timestamp);
+        }
+      }
+    }
+
+    // Tell the child that it’s OK to exit. The child needed to be kept alive
+    // until the parent finished working with it.
+    int write_fd = WritePipeFD();
+    char c = '\0';
+    rv = WriteFD(write_fd, &c, 1);
+    ASSERT_EQ(1, rv) << ErrnoMessage("write");
+  }
+
+  void MachMultiprocessChild() override {
+    int write_fd = WritePipeFD();
+
+    uint32_t dyld_image_count = _dyld_image_count();
+    const struct dyld_all_image_infos* dyld_image_infos =
+        _dyld_get_all_image_infos();
+
+    uint32_t write_image_count = dyld_image_count;
+    if (dyld_image_infos->version >= 2) {
+      // dyld_image_count doesn’t include an entry for dyld itself, but one will
+      // be written.
+      ++write_image_count;
+    }
+
+    ssize_t rv = WriteFD(
+        write_fd, &write_image_count, sizeof(write_image_count));
+    ASSERT_EQ(static_cast<ssize_t>(sizeof(write_image_count)), rv)
+        << ErrnoMessage("write");
+
+    for (size_t index = 0; index < write_image_count; ++index) {
+      const char* dyld_image_name;
+      mach_vm_address_t dyld_image_address;
+
+      if (index < dyld_image_count) {
+        dyld_image_name = _dyld_get_image_name(index);
+        dyld_image_address =
+            reinterpret_cast<mach_vm_address_t>(_dyld_get_image_header(index));
+      } else {
+        dyld_image_name = "/usr/lib/dyld";
+        dyld_image_address = reinterpret_cast<mach_vm_address_t>(
+            dyld_image_infos->dyldImageLoadAddress);
+      }
+
+      uint32_t dyld_image_name_length = strlen(dyld_image_name);
+      rv = WriteFD(
+          write_fd, &dyld_image_name_length, sizeof(dyld_image_name_length));
+      ASSERT_EQ(static_cast<ssize_t>(sizeof(dyld_image_name_length)), rv)
+          << ErrnoMessage("write");
+
+      // The NUL terminator is not written.
+      rv = WriteFD(write_fd, dyld_image_name, dyld_image_name_length);
+      ASSERT_EQ(static_cast<ssize_t>(dyld_image_name_length), rv)
+          << ErrnoMessage("write");
+
+      rv = WriteFD(write_fd, &dyld_image_address, sizeof(dyld_image_address));
+      ASSERT_EQ(static_cast<ssize_t>(sizeof(dyld_image_address)), rv)
+          << ErrnoMessage("write");
+    }
+
+    // Wait for the parent to say that it’s OK to exit.
+    int read_fd = ReadPipeFD();
+    char c;
+    rv = ReadFD(read_fd, &c, 1);
+    ASSERT_EQ(1, rv) << ErrnoMessage("read");
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(ProcessReaderModulesChild);
+};
+
+TEST(ProcessReader, ChildModules) {
+  ProcessReaderModulesChild process_reader_modules_child;
+  process_reader_modules_child.Run();
+}
+
 }  // namespace