spellcheck mc. Don't ask why

[simgrid.git] / src / mc / Process.cpp

diff --git a/src/mc/Process.cpp b/src/mc/Process.cpp
index dd04f15..9197cb9 100644 (file)
--- a/src/mc/Process.cpp
+++ b/src/mc/Process.cpp
@@ -77,7 +77,6 @@ static const char *const filtered_libraries[] = {
   "libm",
   "libpthread",
   "librt",
-  "libsigc",
   "libstdc++",
   "libunwind",
   "libunwind-x86_64",
@@ -181,14 +180,6 @@ static void zero_buffer_init(void)
   close(fd);
 }
 
-static
-int open_process_file(pid_t pid, const char* file, int flags)
-{
-  char buff[50];
-  snprintf(buff, sizeof(buff), "/proc/%li/%s", (long) pid, file);
-  return open(buff, flags);
-}
-
 int open_vm(pid_t pid, int flags)
 {
   const size_t buffer_size = 30;
@@ -246,16 +237,11 @@ Process::~Process()
   }
 
   unw_destroy_addr_space(this->unw_addr_space);
-
-  if (this->clear_refs_fd_ >= 0)
-    close(this->clear_refs_fd_);
-  if (this->pagemap_fd_ >= 0)
-    close(this->pagemap_fd_);
 }
 
 /** Refresh the information about the process
  *
- *  Do not use direclty, this is used by the getters when appropriate
+ *  Do not use directly, this is used by the getters when appropriate
  *  in order to have fresh data.
  */
 void Process::refresh_heap()
@@ -359,7 +345,7 @@ void Process::init_memory_map_info()
   regfree(&res.so_re);
   regfree(&res.version_re);
 
-  // Resolve time (including accross differents objects):
+  // Resolve time (including across different objects):
   for (auto const& object_info : this->object_infos)
     postProcessObjectInformation(this, object_info.get());
 
@@ -402,14 +388,14 @@ simgrid::mc::Frame* Process::find_function(RemotePtr<void> ip) const
   return info ? info->find_function((void*) ip.address()) : nullptr;
 }
 
-/** Find (one occurence of) the named variable definition
+/** Find (one occurrence of) the named variable definition
  */
 simgrid::mc::Variable* Process::find_variable(const char* name) const
 {
   // First lookup the variable in the executable shared object.
   // A global variable used directly by the executable code from a library
   // is reinstanciated in the executable memory .data/.bss.
-  // We need to look up the variable in the execvutable first.
+  // We need to look up the variable in the executable first.
   if (this->binary_info) {
     std::shared_ptr<simgrid::mc::ObjectInformation> const& info = this->binary_info;
     simgrid::mc::Variable* var = info->find_variable(name);
@@ -439,17 +425,17 @@ void Process::read_variable(const char* name, void* target, size_t size) const
   this->read_bytes(target, size, remote(var->address));
 }
 
-char* Process::read_string(RemotePtr<void> address) const
+std::string Process::read_string(RemotePtr<char> address) const
 {
   if (!address)
-    return nullptr;
+    return {};
 
-  off_t len = 128;
-  char* res = (char*) malloc(len);
+  // TODO, use std::vector with .data() in C++17 to avoid useless copies
+  std::vector<char> res(128);
   off_t off = 0;
 
   while (1) {
-    ssize_t c = pread(this->memory_file, res + off, len - off, (off_t) address.address() + off);
+    ssize_t c = pread(this->memory_file, res.data() + off, res.size() - off, (off_t) address.address() + off);
     if (c == -1) {
       if (errno == EINTR)
         continue;
@@ -459,15 +445,13 @@ char* Process::read_string(RemotePtr<void> address) const
     if (c==0)
       xbt_die("Could not read string from remote process");
 
-    void* p = memchr(res + off, '\0', c);
+    void* p = memchr(res.data() + off, '\0', c);
     if (p)
-      return res;
+      return std::string(res.data());
 
     off += c;
-    if (off == len) {
-      len *= 2;
-      res = (char*) realloc(res, len);
-    }
+    if (off == (off_t) res.size())
+      res.resize(res.size() * 2);
   }
 }
 
@@ -495,7 +479,7 @@ const void *Process::read_bytes(void* buffer, std::size_t size,
         mc_model_checker->process().read<s_smpi_privatisation_region_t>(
           remote(remote_smpi_privatisation_regions + process_index));
 
-      // Address translation in the privaization segment:
+      // Address translation in the privatization segment:
       size_t offset = address.address() - (std::uint64_t)info->start_rw;
       address = remote((char*)privatisation_region.address + offset);
     }
@@ -577,30 +561,6 @@ void Process::ignore_region(std::uint64_t addr, std::size_t size)
     ignored_regions_.begin() + position, region);
 }
 
-void Process::reset_soft_dirty()
-{
-  if (this->clear_refs_fd_ < 0) {
-    this->clear_refs_fd_ = open_process_file(pid_, "clear_refs", O_WRONLY|O_CLOEXEC);
-    if (this->clear_refs_fd_ < 0)
-      xbt_die("Could not open clear_refs file for soft-dirty tracking. Run as root?");
-  }
-  if(::write(this->clear_refs_fd_, "4\n", 2) != 2)
-    xbt_die("Could not reset softdirty bits");
-}
-
-void Process::read_pagemap(uint64_t* pagemap, size_t page_start, size_t page_count)
-{
-  if (pagemap_fd_ < 0) {
-    pagemap_fd_ = open_process_file(pid_, "pagemap", O_RDONLY|O_CLOEXEC);
-    if (pagemap_fd_ < 0)
-      xbt_die("Could not open pagemap file for soft-dirty tracking. Run as root?");
-  }
-  ssize_t bytesize = sizeof(uint64_t) * page_count;
-  off_t offset = sizeof(uint64_t) * page_start;
-  if (pread_whole(pagemap_fd_, pagemap, bytesize, offset) != bytesize)
-    xbt_die("Could not read pagemap");
-}
-
 void Process::ignore_heap(IgnoredHeapRegion const& region)
 {
   if (ignored_heap_.empty()) {