Adjust breakpad module size to match adjusted start_addr.

client/linux/minidump_writer/linux_dumper.cc

 // 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 492 matching lines @@
     MappingInfo* mapping = mappings_[i];
     if (!(mapping->exec && mapping->name[0] == '/')) {
       continue;
     }
     ElfW(Ehdr) ehdr;
     if (!GetLoadedElfHeader(mapping->start_addr, &ehdr)) {
       continue;
     }
     if (ehdr.e_type == ET_DYN) {
       // Compute the effective load bias for this mapped library, and update
-      // the mapping to hold that rather than |start_addr|. Where the library
-      // does not contain Android packed relocations, GetEffectiveLoadBias()
-      // returns |start_addr| and the mapping entry is not changed.
-      mapping->start_addr = GetEffectiveLoadBias(&ehdr, mapping->start_addr);
+      // the mapping to hold that rather than |start_addr|, at the same time
+      // adjusting |size| to account for the change in |start_addr|. Where
+      // the library does not contain Android packed relocations,
+      // GetEffectiveLoadBias() returns |start_addr| and the mapping entry
+      // is not changed.
+      const uintptr_t load_bias = GetEffectiveLoadBias(&ehdr,
+                                                       mapping->start_addr);
+      mapping->size += mapping->start_addr - load_bias;

[Primiano Tucci (use gerrit), 2015/06/25 14:44:01]

can load_bias ever be > start_addr (maybe by mistakenly parsing the elf header)?
Should you have a check in that case?

[simonb (inactive), 2015/06/25 15:14:35]

From coding errors in the proc/$$/maps or ELF data parsers?  A check here
wouldn't protect.  If start_addr is wrong from misparsing, substituting an
incorrect value for a different incorrect value won't make the result any more
correct.

If load_bias is genuinely > start_addr due to underflow from start_addr being in
very low memory -- beneath 6mb or so say, and a case we hope is pathological --
the symmetrical overflow in this expression means that size still comes out
correctly.  Demo:

#include <iostream>
#include <inttypes.h>
int main() {
  uint32_t start_addr = 0x1000;
  uint32_t size       = 0x200000;
  std::cout << std::hex << "Before: start_addr = " << start_addr
            << ", size = " << size << std::dec << std::endl;
  const uint32_t hole_size  = 0x30000;
  const uint32_t load_bias = start_addr - hole_size;
  // Model a load bias adjustment that wraps start_addr.
  if (load_bias > start_addr)
    std::cout << "Note  : start_addr > load_bias!" << std::endl;
  size += start_addr - load_bias;
  start_addr = load_bias;
  std::cout << std::hex << "After : start_addr = " << start_addr
            << ", size = " << size << std::dec << std::endl;
}

Before: start_addr = 1000, size = 200000
Note  : start_addr > load_bias!
After : start_addr = fffd1000, size = 230000

The case where load_bias can be genuinely > start_addr is a separate breakpad
issue.

+      mapping->start_addr = load_bias;
     }
   }
 }
 
 #endif  // __ANDROID__
 
 // Get information about the stack, given the stack pointer. We don't try to
 // walk the stack since we might not have all the information needed to do
 // unwind. So we just grab, up to, 32k of stack.
 bool LinuxDumper::GetStackInfo(const void** stack, size_t* stack_len,
@@ skipping 64 matching lines @@
       exe_stat.st_dev == new_path_stat.st_dev &&
       exe_stat.st_ino == new_path_stat.st_ino) {
     return false;
   }
 
   my_memcpy(path, exe_link, NAME_MAX);
   return true;
 }
 
 }  // namespace google_breakpad