Don't bother recording memory areas when the process has died; the ch…

…anged data is unobservable anyway.

src/AddressSpace.cc

@@ -2418,4 +2418,22 @@ void AddressSpace::fd_tables_changed() {
   }
 }
 
+bool AddressSpace::range_is_private_mapping(const MemoryRange& range) const {
+  MemoryRange r = range;
+  while (r.size() > 0) {
+    if (!has_mapping(r.start())) {
+      return false;
+    }
+    const AddressSpace::Mapping& m = mapping_of(r.start());
+    if (!(m.map.flags() & MAP_PRIVATE)) {
+      return false;
+    }
+    if (m.map.end() >= r.end()) {
+      return true;
+    }
+    r = MemoryRange(m.map.end(), r.end());
+  }
+  return true;
+}
+
 } // namespace rr

src/AddressSpace.h

@@ -889,6 +889,9 @@ class AddressSpace : public HasTaskSet {
   // suitable for hardware watchpoint registers.
   enum WatchpointAlignment { UNALIGNED, ALIGNED };
 
+  // Returns true if the range is completely covered by private mappings
+  bool range_is_private_mapping(const MemoryRange& range) const;
+
 private:
   struct Breakpoint;
   typedef std::map<remote_code_ptr, Breakpoint> BreakpointMap;

src/HasTaskSet.cc

@@ -26,4 +26,13 @@ Task* HasTaskSet::first_running_task() const {
   return nullptr;
 }
 
+Task* HasTaskSet::find_other_thread_group(Task* t) const {
+  for (Task* tt : task_set()) {
+    if (tt->thread_group() != t->thread_group()) {
+      return tt;
+    }
+  }
+  return nullptr;
+}
+
 } // namespace rr

src/HasTaskSet.h

@@ -21,6 +21,7 @@ class HasTaskSet {
   virtual void insert_task(Task* t);
   virtual void erase_task(Task* t);
   bool has_task(Task* t) const { return tasks.find(t) != tasks.end(); }
+  Task* find_other_thread_group(Task* t) const;
   Task* first_running_task() const;
 
 protected:

src/RecordTask.cc

@@ -1721,7 +1721,21 @@ void RecordTask::record_remote(remote_ptr<void> addr, ssize_t num_bytes) {
     return;
   }
 
-  auto buf = read_mem(addr.cast<uint8_t>(), num_bytes);
+  bool ok = true;
+  auto buf = read_mem(addr.cast<uint8_t>(), num_bytes, &ok);
+  if (!ok) {
+    // Tracee probably died unexpectely. This should only happen
+    // due to SIGKILL racing with our PTRACE_CONT.
+    if (!vm()->find_other_thread_group(this) &&
+        vm()->range_is_private_mapping(MemoryRange(addr, num_bytes))) {
+      // The recording range is mapped private and no other threadgroup shares the
+      // address space, so the new memory contents should be unobservable, and we can
+      // just not record the data.
+      return;
+    }
+    ASSERT(this, false) << "Should have recorded " << num_bytes << " bytes from "
+                        << addr << ", but failed";
+  }
   trace_writer().write_raw(rec_tid, buf.data(), num_bytes, addr);
 }