Implement (and test) ProcessReader::Modules()

util/mac/process_reader.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 <AvailabilityMacros.h>
 #include <mach/mach_vm.h>
 #include <mach-o/loader.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/mac/scoped_mach_vm.h"
+#include "util/mac/mach_o_image_reader.h"
+#include "util/mac/process_types.h"
 #include "util/misc/scoped_forbid_return.h"
 
 namespace {
 
 void MachTimeValueToTimeval(const time_value& mach, timeval* tv) {
   tv->tv_sec = mach.seconds;
   tv->tv_usec = mach.microseconds;
 }
 
 kern_return_t MachVMRegionRecurseDeepest(mach_port_t task,
@@ skipping 308 matching lines @@
 
   threads_need_owners.Disarm();
 }
 
 void ProcessReader::InitializeModules() {
   DCHECK(!initialized_modules_);
   DCHECK(modules_.empty());
 
   initialized_modules_ = true;
 
-  // TODO(mark): Complete this implementation. The implementation depends on
-  // process_types, which cannot land yet because it depends on this file,
-  // process_reader. This temporary “cut” was made to avoid a review that’s too
-  // large. Yes, this circular dependency is unfortunate. Suggestions are
-  // welcome.
+  // This API only works on Mac OS X 10.6 and higher. On Mac OS X 10.5, find the
+  // “_dyld_all_image_infos” symbol in the loaded LC_LOAD_DYLINKER (dyld).
+  task_dyld_info_data_t dyld_info;
+  mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
+  kern_return_t kr = task_info(
+      task_, TASK_DYLD_INFO, reinterpret_cast<task_info_t>(&dyld_info), &count);
+  if (kr != KERN_SUCCESS) {
+    MACH_LOG(WARNING, kr) << "task_info";
+    return;
+  }
+
+  // TODO(mark): Deal with statically linked executables which don’t use dyld.
+  // This may look for the module that matches the executable path in the same
+  // data set that vmmap uses.
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
+  // The task_dyld_info_data_t struct grew in 10.7, adding the format field.
+  // Don’t check this field if it’s not present, which can happen when either
+  // the SDK used at compile time or the kernel at run time are too old and
+  // don’t know about it.
+  if (count >= TASK_DYLD_INFO_COUNT) {
+    const integer_t kExpectedFormat =
+        !Is64Bit() ? TASK_DYLD_ALL_IMAGE_INFO_32 : TASK_DYLD_ALL_IMAGE_INFO_64;
+    if (dyld_info.all_image_info_format != kExpectedFormat) {
+      LOG(WARNING) << "unexpected task_dyld_info_data_t::all_image_info_format "
+                   << dyld_info.all_image_info_format;
+      DCHECK_EQ(dyld_info.all_image_info_format, kExpectedFormat);
+      return;
+    }
+  }
+#endif
+
+  process_types::dyld_all_image_infos all_image_infos;
+  if (!all_image_infos.Read(this, dyld_info.all_image_info_addr)) {
+    LOG(WARNING) << "could not read dyld_all_image_infos";
+    return;
+  }
+
+  // Note that all_image_infos.infoArrayCount may be 0 if a crash occurred while
+  // dyld was loading the executable. This can happen if a required dynamic
+  // library was not found.
+  DCHECK_GE(all_image_infos.version, 1u);
+  DCHECK_NE(all_image_infos.infoArray, 0u);

[Robert Sesek, 2014/09/05 17:14:58]

Why not NULL instead of 0u?

+
+  std::vector<process_types::dyld_image_info> image_info_vector(
+      all_image_infos.infoArrayCount);
+  if (!process_types::dyld_image_info::ReadArrayInto(this,
+                                                     all_image_infos.infoArray,
+                                                     image_info_vector.size(),
+                                                     &image_info_vector[0])) {
+    LOG(WARNING) << "could not read dyld_image_info array";
+    return;
+  }
+
+  bool found_dyld = false;
+  for (const process_types::dyld_image_info& image_info : image_info_vector) {
+    ProcessReaderModule module;
+    module.address = image_info.imageLoadAddress;
+    module.timestamp = image_info.imageFileModDate;
+    if (!task_memory_->ReadCString(image_info.imageFilePath, &module.name)) {
+      LOG(WARNING) << "could not read dyld_image_info::imageFilePath";
+      // Proceed anyway with an empty module name.
+    }
+
+    modules_.push_back(module);
+
+    if (all_image_infos.version >= 2 && all_image_infos.dyldImageLoadAddress &&
+        image_info.imageLoadAddress == all_image_infos.dyldImageLoadAddress) {
+      found_dyld = true;
+    }
+  }
+
+  // all_image_infos.infoArray doesn’t include an entry for dyld, but dyld is
+  // loaded into the process’ address space as a module. Its load address is
+  // easily known given a sufficiently recent all_image_infos.version, but the
+  // timestamp and pathname are not given as they are for other modules.
+  //
+  // The timestamp is a lost cause, because the kernel doesn’t record the
+  // timestamp of the dynamic linker at the time it’s loaded in the same way
+  // that dyld records the timestamps of other modules when they’re loaded. (The
+  // timestamp for the main executable is also not reported and appears as 0
+  // even when accessed via dyld APIs, because it’s loaded by the kernel, not by
+  // dyld.)
+  //
+  // The name can be determined, but it’s not as simple as hardcoding the
+  // default "/usr/lib/dyld" because an executable could have specified anything
+  // in its LC_LOAD_DYLINKER command.
+  if (!found_dyld && all_image_infos.version >= 2 &&
+      all_image_infos.dyldImageLoadAddress) {
+    ProcessReaderModule module;
+    module.address = all_image_infos.dyldImageLoadAddress;
+    module.timestamp = 0;
+
+    // Examine the executable’s LC_LOAD_DYLINKER load command to find the path
+    // used to load dyld.
+    MachOImageReader executable;
+    if (all_image_infos.infoArrayCount >= 1 &&
+        executable.Initialize(this, modules_[0].address, modules_[0].name) &&
+        executable.FileType() == MH_EXECUTE &&
+        !executable.DylinkerName().empty()) {
+      module.name = executable.DylinkerName();
+    } else {
+      // Look inside dyld directly to find its preferred path.
+      MachOImageReader dyld;
+      if (dyld.Initialize(this, module.address, "(dyld)") &&
+          dyld.FileType() == MH_DYLINKER && !dyld.DylinkerName().empty()) {
+        module.name = dyld.DylinkerName();
+      }
+    }
+
+    // dyld is loaded in the process even if its path can’t be determined.
+    modules_.push_back(module);
+  }
 }
 
 mach_vm_address_t ProcessReader::CalculateStackRegion(
     mach_vm_address_t stack_pointer,
     mach_vm_size_t* stack_region_size) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   // For pthreads, it may be possible to compute the stack region based on the
   // internal _pthread::stackaddr and _pthread::stacksize. The _pthread struct
   // for a thread can be located at TSD slot 0, or the known offsets of
@@ skipping 154 matching lines @@
       // The red zone would go lower into another region in memory, but no
       // region was found. Memory can only be captured to an address as low as
       // the base address of the region already found.
       *start_address = *region_base;
     }
   }
 #endif
 }
 
 }  // namespace crashpad