Moved responsibility of de/ser into FdTable and FileMonitor

theIDinside · theIDinside · commit 84ddf4f45a2f · 2023-02-10T13:31:03.000+01:00
Deserializing and serializing an FdTable is now performed by the class itself instead of in a free function

FileMonitor has a public member function that is used for serialization.
Each derived type that requires special/additional logic, extends
the virtual member function serialize_type.
diff --git a/src/BpfMapMonitor.h b/src/BpfMapMonitor.h
@@ -14,12 +14,18 @@ class BpfMapMonitor : public FileMonitor {
 public:
   BpfMapMonitor(uint64_t key_size, uint64_t value_size) : key_size_(key_size), value_size_(value_size) {}
 
-  virtual Type type() override { return BpfMap; }
+  virtual Type type() const override { return BpfMap; }
 
   uint64_t key_size() const { return key_size_; }
   uint64_t value_size() const { return value_size_; }
 
 private:
+  virtual void serialize_type(pcp::FileMonitor::Builder& builder) const noexcept override {
+    auto bpf = builder.initBpf();
+    bpf.setKeySize(key_size_);
+    bpf.setValueSize(value_size_);
+  }
+
   uint64_t key_size_;
   uint64_t value_size_;
 };
diff --git a/src/FdTable.cc b/src/FdTable.cc
@@ -6,6 +6,19 @@
 
 #include <unordered_set>
 
+#include "BpfMapMonitor.h"
+#include "FileMonitor.h"
+#include "MagicSaveDataMonitor.h"
+#include "MmappedFileMonitor.h"
+#include "NonvirtualPerfCounterMonitor.h"
+#include "ODirectFileMonitor.h"
+#include "PreserveFileMonitor.h"
+#include "ProcFdDirMonitor.h"
+#include "ProcMemMonitor.h"
+#include "ProcStatMonitor.h"
+#include "RRPageMonitor.h"
+#include "StdioMonitor.h"
+#include "SysCpuMonitor.h"
 #include "rr/rr.h"
 
 #include "AddressSpace.h"
@@ -253,4 +266,86 @@ vector<int> FdTable::fds_to_close_after_exec(RecordTask* t) {
   return fds_to_close;
 }
 
+void FdTable::deserialize(Task* leader,
+                          const pcp::ProcessSpace::Reader& leader_reader) {
+  auto monitors = leader_reader.getMonitors();
+  for (auto m : monitors) {
+    FileMonitor::Type t = (FileMonitor::Type)m.getType();
+    auto fd = m.getFd();
+    if (!is_monitoring(m.getFd())) {
+      switch (t) {
+        case FileMonitor::Base:
+          FATAL() << "Can't add abstract type";
+          break;
+        case FileMonitor::MagicSaveData:
+          add_monitor(leader, fd, new MagicSaveDataMonitor());
+          break;
+        case FileMonitor::Mmapped: {
+          const auto mmap = m.getMmap();
+          add_monitor(leader, fd,
+                      new MmappedFileMonitor(mmap.getDead(), mmap.getDevice(),
+                                             mmap.getInode()));
+        } break;
+        case FileMonitor::Preserve:
+          add_monitor(leader, fd, new PreserveFileMonitor());
+          break;
+        case FileMonitor::ProcFd: {
+          const auto p_fd = m.getProcFd();
+          const auto tuid = TaskUid(p_fd.getTid(), p_fd.getSerial());
+          add_monitor(leader, fd, new ProcFdDirMonitor(tuid));
+          break;
+        }
+        case FileMonitor::ProcMem: {
+          const auto pmem = m.getProcMem();
+          add_monitor(leader, fd,
+                      new ProcMemMonitor(AddressSpaceUid(pmem.getTid(),
+                                                         pmem.getSerial(),
+                                                         pmem.getExecCount())));
+        } break;
+        case FileMonitor::Stdio:
+          add_monitor(leader, fd, new StdioMonitor(m.getStdio()));
+          break;
+        case FileMonitor::VirtualPerfCounter:
+          FATAL() << "VirtualPerCounter Monitor deserializing unimplemented!\n";
+          break;
+        case FileMonitor::NonvirtualPerfCounter:
+          add_monitor(leader, fd, new NonvirtualPerfCounterMonitor());
+          break;
+        case FileMonitor::SysCpu:
+          add_monitor(leader, fd, new SysCpuMonitor(leader, ""));
+          break;
+        case FileMonitor::ProcStat:
+          add_monitor(
+              leader, fd,
+              new ProcStatMonitor(leader, data_to_str(m.getProcStat())));
+          break;
+        case FileMonitor::RRPage:
+          add_monitor(leader, fd, new RRPageMonitor());
+          break;
+        case FileMonitor::ODirect:
+          add_monitor(leader, fd, new ODirectFileMonitor());
+          break;
+        case FileMonitor::BpfMap:
+          add_monitor(leader, fd,
+                      new BpfMapMonitor(m.getBpf().getKeySize(),
+                                        m.getBpf().getValueSize()));
+          break;
+        default:
+          FATAL() << "unhandled FileMonitor: " << file_monitor_type_name(t);
+      }
+    }
+  }
+}
+
+void FdTable::serialize(pcp::ProcessSpace::Builder& leader_builder) const {
+  auto serialized_fd_mons = leader_builder.initMonitors(fds.size());
+  auto mon_index = 0;
+  for (const auto& mon : fds) {
+    const auto fd = mon.first;
+    const auto& monitor = mon.second;
+    auto builder = serialized_fd_mons[mon_index++];
+    monitor->serialize(fd, builder);
+  }
+}
+
 } // namespace rr
diff --git a/src/FdTable.h b/src/FdTable.h
@@ -9,6 +9,7 @@
 
 #include "FileMonitor.h"
 #include "HasTaskSet.h"
+#include "rr_pcp.capnp.h"
 
 namespace rr {
 
@@ -69,7 +70,11 @@ class FdTable : public HasTaskSet {
    * Close fds in list after an exec.
    */
   void close_after_exec(ReplayTask* t, const std::vector<int>& fds_to_close);
-  const std::unordered_map<int, FileMonitor::shr_ptr>& monitored_fds() const { return fds; }
+
+  void serialize(pcp::ProcessSpace::Builder& leader_builder) const;
+
+  void deserialize(Task* leader, const pcp::ProcessSpace::Reader& leader_reader);
+
 private:
   FdTable() : fd_count_beyond_limit(0) {}
   FdTable(const FdTable& other) : fds(other.fds),
diff --git a/src/FileMonitor.cc b/src/FileMonitor.cc
@@ -113,4 +113,10 @@ std::string file_monitor_type_name(FileMonitor::Type t) {
   }
 }
 
+void FileMonitor::serialize(int fd, pcp::FileMonitor::Builder& builder) const noexcept {
+  builder.setFd(fd);
+  builder.setType(type());
+  serialize_type(builder);
+}
+
 }
diff --git a/src/FileMonitor.h b/src/FileMonitor.h
@@ -13,6 +13,7 @@ class Task;
 
 #include "preload/preload_interface.h"
 #include "util.h"
+#include "rr_pcp.capnp.h"
 
 namespace rr {
 
@@ -42,7 +43,7 @@ class FileMonitor {
     BpfMap,
   };
 
-  virtual Type type() { return Base; }
+  virtual Type type() const { return Base; }
 
   /**
    * Overriding this to return true will cause close() (and related fd-smashing
@@ -128,6 +129,13 @@ class FileMonitor {
   virtual enum syscallbuf_fd_classes get_syscallbuf_class() {
     return FD_CLASS_TRACED;
   }
+
+  /** Serialize this file monitor for persistent checkpoints. */
+  void serialize(int fd, pcp::FileMonitor::Builder& builder) const noexcept;
+
+private:
+  // default serialize_type does nothing
+  virtual void serialize_type(pcp::FileMonitor::Builder&) const noexcept {}
 };
 
 std::string file_monitor_type_name(FileMonitor::Type t);
diff --git a/src/MagicSaveDataMonitor.h b/src/MagicSaveDataMonitor.h
@@ -14,7 +14,7 @@ class MagicSaveDataMonitor : public FileMonitor {
 public:
   MagicSaveDataMonitor() {}
 
-  virtual Type type() override { return MagicSaveData; }
+  virtual Type type() const override { return MagicSaveData; }
 
   virtual void did_write(Task* t, const std::vector<Range>& ranges,
                          LazyOffset& offset) override;
diff --git a/src/MmappedFileMonitor.cc b/src/MmappedFileMonitor.cc
@@ -110,4 +110,11 @@ void MmappedFileMonitor::did_write(Task* t, const std::vector<Range>& ranges,
   }
 }
 
+void MmappedFileMonitor::serialize_type(pcp::FileMonitor::Builder& builder) const noexcept {
+  auto mmap = builder.initMmap();
+  mmap.setDead(dead_);
+  mmap.setDevice(device_);
+  mmap.setInode(inode_);
+}
+
 } // namespace rr
diff --git a/src/MmappedFileMonitor.h b/src/MmappedFileMonitor.h
@@ -20,7 +20,7 @@ class MmappedFileMonitor : public FileMonitor {
   MmappedFileMonitor(Task* t, EmuFile::shr_ptr f);
   MmappedFileMonitor(bool dead, dev_t device, ino_t inode) noexcept;
 
-  virtual Type type() override { return Mmapped; }
+  virtual Type type() const override { return Mmapped; }
   void revive() { dead_ = false; }
   // If this write could potentially affect memory we need to PREVENT_SWITCH,
   // since the timing of the write is otherwise unpredictable from our
@@ -34,8 +34,9 @@ class MmappedFileMonitor : public FileMonitor {
    */
   virtual void did_write(Task* t, const std::vector<Range>& ranges,
                          LazyOffset& offset) override;
-  std::tuple<bool, dev_t, ino_t> info() const { return std::tuple<bool, dev_t, ino_t>{dead_, device_, inode_}; }
+
 private:
+  void serialize_type(pcp::FileMonitor::Builder& builder) const noexcept override;
   // Whether this monitor is still actively monitoring
   bool dead_;
   dev_t device_;
diff --git a/src/NonvirtualPerfCounterMonitor.h b/src/NonvirtualPerfCounterMonitor.h
@@ -15,7 +15,8 @@ class NonvirtualPerfCounterMonitor : public FileMonitor {
 public:
   NonvirtualPerfCounterMonitor() {}
 
-  virtual Type type() override { return NonvirtualPerfCounter; }
+  virtual Type type() const override { return NonvirtualPerfCounter; }
+  
 };
 
 } // namespace rr
diff --git a/src/ODirectFileMonitor.h b/src/ODirectFileMonitor.h
@@ -17,7 +17,7 @@ class ODirectFileMonitor : public FileMonitor {
 public:
   ODirectFileMonitor() : FileMonitor() {};
 
-  virtual Type type() override { return ODirect; }
+  virtual Type type() const override { return ODirect; }
 };
 
 } // namespace rr
diff --git a/src/PersistentCheckpointing.cc b/src/PersistentCheckpointing.cc
@@ -77,49 +77,6 @@ std::string checkpoints_index_file(const std::string& trace_dir) {
   return trace_dir + "/checkpoints";
 }
 
-void write_monitor(rr::pcp::FileMonitor::Builder& builder, int fd,
-                   FileMonitor* monitor) {
-  builder.setFd(fd);
-  builder.setType(monitor->type());
-  switch (monitor->type()) {
-    case FileMonitor::Mmapped: {
-      auto contents = ((MmappedFileMonitor*)monitor)->info();
-      auto mmap = builder.initMmap();
-      mmap.setDead(std::get<0>(contents));
-      mmap.setDevice(std::get<1>(contents));
-      mmap.setInode(std::get<2>(contents));
-    } break;
-    case FileMonitor::ProcFd: {
-      auto pfd = builder.initProcFd();
-      const auto tuid = ((ProcFdDirMonitor*)monitor)->task_uuid();
-      pfd.setTid(tuid.tid());
-      pfd.setSerial(tuid.serial());
-    } break;
-    case FileMonitor::ProcMem: {
-      auto pm = builder.initProcMem();
-      const auto auid = ((ProcMemMonitor*)monitor)->get_auid();
-      pm.setExecCount(auid.exec_count());
-      pm.setTid(auid.tid());
-      pm.setSerial(auid.serial());
-    } break;
-    case FileMonitor::Stdio:
-      builder.setStdio(((StdioMonitor*)monitor)->fd());
-      break;
-    case FileMonitor::ProcStat:
-      builder.setProcStat(str_to_data(((ProcStatMonitor*)monitor)->get_data()));
-      break;
-    case FileMonitor::BpfMap: {
-      auto bpf = builder.initBpf();
-      bpf.setKeySize(((BpfMapMonitor*)monitor)->key_size());
-      bpf.setValueSize(((BpfMapMonitor*)monitor)->key_size());
-    } break;
-    case FileMonitor::VirtualPerfCounter:
-      FATAL() << "FileMonitor::VirtualPerfCounter not implemented";
-      break;
-    default:
-      break;
-  }
-}
 
 static void write_map(const WriteVmConfig& cfg,
                       rr::pcp::KernelMapping::Builder builder,
diff --git a/src/PreserveFileMonitor.h b/src/PreserveFileMonitor.h
@@ -20,7 +20,7 @@ namespace rr {
 class PreserveFileMonitor : public FileMonitor {
 public:
   PreserveFileMonitor() {}
-  virtual Type type() override { return Preserve; }
+  virtual Type type() const override { return Preserve; }
   virtual bool is_rr_fd() override { return true; }
 };
 
diff --git a/src/ProcFdDirMonitor.cc b/src/ProcFdDirMonitor.cc
@@ -126,4 +126,10 @@ void ProcFdDirMonitor::filter_getdents(RecordTask* t) {
   filter_dirents(t);
 }
 
+void ProcFdDirMonitor::serialize_type(pcp::FileMonitor::Builder &builder) const noexcept {
+  auto pfd = builder.initProcFd();
+  pfd.setTid(tuid.tid());
+  pfd.setSerial(tuid.serial());
+}
+
 } // namespace rr
diff --git a/src/ProcFdDirMonitor.h b/src/ProcFdDirMonitor.h
@@ -17,12 +17,12 @@ class ProcFdDirMonitor : public FileMonitor {
   ProcFdDirMonitor(Task* t, const std::string& pathname);
   ProcFdDirMonitor(TaskUid tuid) noexcept;
 
-  virtual Type type() override { return ProcFd; }
+  virtual Type type() const override { return ProcFd; }
 
   virtual void filter_getdents(RecordTask* t) override;
-  TaskUid task_uuid() const { return tuid; }
 
 private:
+  void serialize_type(pcp::FileMonitor::Builder& builder) const noexcept override;
   // 0 if this doesn't object doesn't refer to a tracee's proc-mem.
   TaskUid tuid;
 };
diff --git a/src/ProcMemMonitor.cc b/src/ProcMemMonitor.cc
@@ -71,4 +71,11 @@ bool ProcMemMonitor::target_is_vm(AddressSpace *vm) {
   return auid == vm->uid();
 }
 
+void ProcMemMonitor::serialize_type(pcp::FileMonitor::Builder& builder) const noexcept {
+  auto pm = builder.initProcMem();
+  pm.setExecCount(auid.exec_count());
+  pm.setTid(auid.tid());
+  pm.setSerial(auid.serial());
+}
+
 } // namespace rr
diff --git a/src/ProcMemMonitor.h b/src/ProcMemMonitor.h
@@ -17,7 +17,7 @@ class ProcMemMonitor : public FileMonitor {
   ProcMemMonitor(Task* t, const std::string& pathname);
   ProcMemMonitor(AddressSpaceUid auid) noexcept;
 
-  virtual Type type() override { return ProcMem; }
+  virtual Type type() const override { return ProcMem; }
 
   // We need to PREVENT_SWITCH, since the timing of the write is otherwise
   // unpredictable from our perspective.
@@ -31,9 +31,9 @@ class ProcMemMonitor : public FileMonitor {
   }
 
   bool target_is_vm(AddressSpace *t);
-  AddressSpaceUid get_auid() const { return auid; }
 
 private:
+  void serialize_type(pcp::FileMonitor::Builder& builder) const noexcept override;
   // 0 if this doesn't object doesn't refer to a tracee's proc-mem.
   AddressSpaceUid auid;
 };
diff --git a/src/ProcStatMonitor.cc b/src/ProcStatMonitor.cc
@@ -61,4 +61,8 @@ bool ProcStatMonitor::emulate_read(
   return true;
 }
 
+void ProcStatMonitor::serialize_type(pcp::FileMonitor::Builder &builder) const noexcept {
+  builder.setProcStat(str_to_data(data));
+}
+
 } // namespace rr
diff --git a/src/ProcStatMonitor.h b/src/ProcStatMonitor.h
@@ -18,12 +18,13 @@ class ProcStatMonitor : public FileMonitor {
 public:
   ProcStatMonitor(Task* t, const std::string& pathname);
 
-  virtual Type type() override { return ProcStat; }
+  virtual Type type() const override { return ProcStat; }
 
   bool emulate_read(RecordTask* t, const std::vector<Range>& ranges,
                     LazyOffset&, uint64_t* result) override;
-  const std::string& get_data() const { return data; }
+
 private:
+  void serialize_type(pcp::FileMonitor::Builder& builder) const noexcept override;
   std::string data;
 };
 
diff --git a/src/RRPageMonitor.h b/src/RRPageMonitor.h
diff --git a/src/ReplaySession.cc b/src/ReplaySession.cc
diff --git a/src/StdioMonitor.cc b/src/StdioMonitor.cc
diff --git a/src/StdioMonitor.h b/src/StdioMonitor.h
diff --git a/src/SysCpuMonitor.h b/src/SysCpuMonitor.h
diff --git a/src/VirtualPerfCounterMonitor.cc b/src/VirtualPerfCounterMonitor.cc
diff --git a/src/VirtualPerfCounterMonitor.h b/src/VirtualPerfCounterMonitor.h

Original file line number	Diff line number	Diff line change
`@@ -113,4 +113,10 @@ std::string file_monitor_type_name(FileMonitor::Type t) {`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
	`116`	`+void FileMonitor::serialize(int fd, pcp::FileMonitor::Builder& builder) const noexcept {`
	`117`	`+ builder.setFd(fd);`
	`118`	`+ builder.setType(type());`
	`119`	`+ serialize_type(builder);`
	`120`	`+}`
	`121`	`+`
`116`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,4 +110,11 @@ void MmappedFileMonitor::did_write(Task* t, const std::vector<Range>& ranges,`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
	`113`	`+void MmappedFileMonitor::serialize_type(pcp::FileMonitor::Builder& builder) const noexcept {`
	`114`	`+ auto mmap = builder.initMmap();`
	`115`	`+ mmap.setDead(dead_);`
	`116`	`+ mmap.setDevice(device_);`
	`117`	`+ mmap.setInode(inode_);`
	`118`	`+}`
	`119`	`+`
`113`	`120`	`} // namespace rr`