Add an optional root prefix to Linux dumpers

src/client/linux/minidump_writer/linux_dumper.h

 // Copyright (c) 2010, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 54 matching lines @@
 
 typedef __typeof__(((elf_aux_entry*) 0)->a_un.a_val) elf_aux_val_t;
 
 // When we find the VDSO mapping in the process's address space, this
 // is the name we use for it when writing it to the minidump.
 // This should always be less than NAME_MAX!
 const char kLinuxGateLibraryName[] = "linux-gate.so";
 
 class LinuxDumper {
  public:
-  explicit LinuxDumper(pid_t pid);
+  // The |root_prefix| is prepended to mapping paths before opening them, which
+  // is useful if the crash originates from a chroot.
+  explicit LinuxDumper(pid_t pid, const char* root_prefix = "");
 
   virtual ~LinuxDumper();
 
   // Parse the data for |threads| and |mappings|.
   virtual bool Init();
 
   // Take any actions that could not be taken in Init(). LateInit() is
   // called after all other caller's initialization is complete, and in
   // particular after it has called ThreadsSuspend(), so that ptrace is
   // available.
@@ skipping 47 matching lines @@
   void set_crash_address(uintptr_t crash_address) {
     crash_address_ = crash_address;
   }
 
   int crash_signal() const { return crash_signal_; }
   void set_crash_signal(int crash_signal) { crash_signal_ = crash_signal; }
 
   pid_t crash_thread() const { return crash_thread_; }
   void set_crash_thread(pid_t crash_thread) { crash_thread_ = crash_thread; }
 
+  // Concatenates the |root_prefix_| and |mapping| path. Writes into |path| and
+  // returns true unless the string is too long.
+  bool GetMappingAbsolutePath(const MappingInfo& mapping,
+                              char path[PATH_MAX]) const;
+
   // Extracts the effective path and file name of from |mapping|. In most cases
   // the effective name/path are just the mapping's path and basename. In some
   // other cases, however, a library can be mapped from an archive (e.g., when
   // loading .so libs from an apk on Android) and this method is able to
   // reconstruct the original file name.
-  static void GetMappingEffectiveNameAndPath(const MappingInfo& mapping,
-                                             char* file_path,
-                                             size_t file_path_size,
-                                             char* file_name,
-                                             size_t file_name_size);
+  void GetMappingEffectiveNameAndPath(const MappingInfo& mapping,
+                                      char* file_path,
+                                      size_t file_path_size,
+                                      char* file_name,
+                                      size_t file_name_size);
 
  protected:
   bool ReadAuxv();
 
   virtual bool EnumerateMappings();
 
   virtual bool EnumerateThreads() = 0;
 
   // For the case where a running program has been deleted, it'll show up in
   // /proc/pid/maps as "/path/to/program (deleted)". If this is the case, then
   // see if '/path/to/program (deleted)' matches /proc/pid/exe and return
   // /proc/pid/exe in |path| so ELF identifier generation works correctly. This
   // also checks to see if '/path/to/program (deleted)' exists, so it does not
   // get fooled by a poorly named binary.
   // For programs that don't end with ' (deleted)', this is a no-op.
   // This assumes |path| is a buffer with length NAME_MAX.
   // Returns true if |path| is modified.
   bool HandleDeletedFileInMapping(char* path) const;
 
    // ID of the crashed process.
   const pid_t pid_;
 
+  // Path of the root directory to which mapping paths are relative.
+  const char* const root_prefix_;
+
   // Virtual address at which the process crashed.
   uintptr_t crash_address_;
 
   // Signal that terminated the crashed process.
   int crash_signal_;
 
   // ID of the crashed thread.
   pid_t crash_thread_;
 
   mutable PageAllocator allocator_;
@@ skipping 60 matching lines @@
   // (or Chromium crazy linker) used. This value matches the addresses produced
   // when the non-relocation-packed library is used for breakpad symbol
   // generation.
   void LatePostprocessMappings();
 #endif  // __ANDROID__
 };
 
 }  // namespace google_breakpad
 
 #endif  // CLIENT_LINUX_HANDLER_LINUX_DUMPER_H_