[mc] Fix compilation

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

diff --git a/src/mc/mc_checkpoint.cpp b/src/mc/mc_checkpoint.cpp
index 5788d9c..485a5e3 100644 (file)
--- a/src/mc/mc_checkpoint.cpp
+++ b/src/mc/mc_checkpoint.cpp
@@ -15,6 +15,7 @@
 #include "src/mc/mc_private.h"
 #include "xbt/module.h"
 #include <xbt/mmalloc.h>
 #include "src/mc/mc_private.h"
 #include "xbt/module.h"
 #include <xbt/mmalloc.h>

+#include <xbt/memory.hpp>

 #include "src/smpi/private.h"
 
 #include "src/xbt/mmalloc/mmprivate.h"
 #include "src/smpi/private.h"
 
 #include "src/xbt/mmalloc/mmprivate.h"


@@ -41,13 +42,9 @@
 
 using simgrid::mc::remote;
 
 
 using simgrid::mc::remote;
 

-extern "C" {
-

 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_checkpoint, mc,
                                 "Logging specific to mc_checkpoint");
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_checkpoint, mc,
                                 "Logging specific to mc_checkpoint");
 

-}
-

 namespace simgrid {
 namespace mc {
 
 namespace simgrid {
 namespace mc {
 


@@ -118,7 +115,7 @@ RegionSnapshot privatized_region(
 #endif
 
 static
 #endif
 
 static

-void add_region(int index, mc_snapshot_t snapshot,
+void add_region(int index, simgrid::mc::Snapshot* snapshot,

                                   simgrid::mc::RegionType type,
                                   simgrid::mc::ObjectInformation* object_info,
                                   void *start_addr, void* permanent_addr,
                                   simgrid::mc::RegionType type,
                                   simgrid::mc::ObjectInformation* object_info,
                                   void *start_addr, void* permanent_addr,


@@ -151,7 +148,7 @@ void add_region(int index, mc_snapshot_t snapshot,
   return;
 }
 
   return;
 }
 

-static void get_memory_regions(simgrid::mc::Process* process, mc_snapshot_t snapshot)
+static void get_memory_regions(simgrid::mc::Process* process, simgrid::mc::Snapshot* snapshot)

 {
   const size_t n = process->object_infos.size();
   snapshot->snapshot_regions.resize(n + 1);
 {
   const size_t n = process->object_infos.size();
   snapshot->snapshot_regions.resize(n + 1);


@@ -184,39 +181,66 @@ static void get_memory_regions(simgrid::mc::Process* process, mc_snapshot_t snap
     snapshot->privatization_index = simgrid::mc::ProcessIndexMissing;
 }
 
     snapshot->privatization_index = simgrid::mc::ProcessIndexMissing;
 }
 

+#define PROT_RWX (PROT_READ | PROT_WRITE | PROT_EXEC)
+#define PROT_RW (PROT_READ | PROT_WRITE)
+#define PROT_RX (PROT_READ | PROT_EXEC)
+

 /** \brief Fills the position of the segments (executable, read-only, read/write).
 /** \brief Fills the position of the segments (executable, read-only, read/write).

- *
- *  `dl_iterate_phdr` would be more robust but would not work in cross-process.

  * */
  * */

+// TODO, use the ELF segment information for more robustness

 void find_object_address(
   std::vector<simgrid::xbt::VmMap> const& maps,
   simgrid::mc::ObjectInformation* result)
 {
 void find_object_address(
   std::vector<simgrid::xbt::VmMap> const& maps,
   simgrid::mc::ObjectInformation* result)
 {

-  char* file_name = xbt_strdup(result->file_name.c_str());
-  const char *name = xbt_basename(file_name);
+  char* name = xbt_basename(result->file_name.c_str());
+

   for (size_t i = 0; i < maps.size(); ++i) {
     simgrid::xbt::VmMap const& reg = maps[i];
   for (size_t i = 0; i < maps.size(); ++i) {
     simgrid::xbt::VmMap const& reg = maps[i];

-    if (maps[i].pathname.empty()
-        || strcmp(xbt_basename(maps[i].pathname.c_str()), name)) {
-      // Nothing to do
-    } else if ((reg.prot & PROT_WRITE)) {
+    if (maps[i].pathname.empty())
+      continue;
+    char* map_basename = xbt_basename(maps[i].pathname.c_str());
+    if (strcmp(name, map_basename) != 0) {
+      free(map_basename);
+      continue;
+    }
+    free(map_basename);
+
+    // This is the non-GNU_RELRO-part of the data segment:
+    if (reg.prot == PROT_RW) {

       xbt_assert(!result->start_rw,
                  "Multiple read-write segments for %s, not supported",
                  maps[i].pathname.c_str());
       result->start_rw = (char*) reg.start_addr;
       result->end_rw = (char*) reg.end_addr;
       xbt_assert(!result->start_rw,
                  "Multiple read-write segments for %s, not supported",
                  maps[i].pathname.c_str());
       result->start_rw = (char*) reg.start_addr;
       result->end_rw = (char*) reg.end_addr;

-      // .bss is usually after the .data:
-      simgrid::xbt::VmMap const& next = maps[i + 1];
-      if (next.pathname.empty() && (next.prot & PROT_WRITE)
-          && next.start_addr == reg.end_addr)
+
+      // The next VMA might be end of the data segment:
+      if (i + 1 < maps.size()
+          && maps[i + 1].pathname.empty()
+          && maps[i + 1].prot == PROT_RW
+          && maps[i + 1].start_addr == reg.end_addr)

         result->end_rw = (char*) maps[i + 1].end_addr;
         result->end_rw = (char*) maps[i + 1].end_addr;

-    } else if ((reg.prot & PROT_READ) && (reg.prot & PROT_EXEC)) {
+    }
+
+    // This is the text segment:
+    else if (reg.prot == PROT_RX) {

       xbt_assert(!result->start_exec,
                  "Multiple executable segments for %s, not supported",
                  maps[i].pathname.c_str());
       result->start_exec = (char*) reg.start_addr;
       result->end_exec = (char*) reg.end_addr;
       xbt_assert(!result->start_exec,
                  "Multiple executable segments for %s, not supported",
                  maps[i].pathname.c_str());
       result->start_exec = (char*) reg.start_addr;
       result->end_exec = (char*) reg.end_addr;

-    } else if ((reg.prot & PROT_READ) && !(reg.prot & PROT_EXEC)) {
+
+      // The next VMA might be end of the data segment:
+      if (i + 1 < maps.size()
+          && maps[i + 1].pathname.empty()
+          && maps[i + 1].prot == PROT_RW
+          && maps[i + 1].start_addr == reg.end_addr) {
+        result->start_rw = (char*) maps[i + 1].start_addr;
+        result->end_rw = (char*) maps[i + 1].end_addr;
+      }
+    }
+
+    // This is the GNU_RELRO-part of the data segment:
+    else if (reg.prot == PROT_READ) {

       xbt_assert(!result->start_ro,
                  "Multiple read only segments for %s, not supported",
                  maps[i].pathname.c_str());
       xbt_assert(!result->start_ro,
                  "Multiple read only segments for %s, not supported",
                  maps[i].pathname.c_str());


@@ -237,9 +261,9 @@ void find_object_address(
   if (result->end_exec && (const void*) result->end_exec > result->end)
     result->end = result->end_exec;
 
   if (result->end_exec && (const void*) result->end_exec > result->end)
     result->end = result->end_exec;
 

-  xbt_assert(result->start_rw);
-  xbt_assert(result->start_exec);
-  free(file_name);
+  xbt_assert(result->start_exec || result->start_rw || result->start_ro);
+
+  free(name);

 }
 
 /************************************* Take Snapshot ************************************/
 }
 
 /************************************* Take Snapshot ************************************/


@@ -332,16 +356,14 @@ static std::vector<s_local_variable> get_local_variables_values(
   return std::move(variables);
 }
 
   return std::move(variables);
 }
 

-static std::vector<s_mc_stack_frame_t> unwind_stack_frames(mc_unw_context_t stack_context)
+static std::vector<s_mc_stack_frame_t> unwind_stack_frames(simgrid::mc::UnwindContext* stack_context)

 {
   simgrid::mc::Process* process = &mc_model_checker->process();
   std::vector<s_mc_stack_frame_t> result;
 
 {
   simgrid::mc::Process* process = &mc_model_checker->process();
   std::vector<s_mc_stack_frame_t> result;
 

-  unw_cursor_t c;
+  unw_cursor_t c = stack_context->cursor();

 
   // TODO, check condition check (unw_init_local==0 means end of frame)
 
   // TODO, check condition check (unw_init_local==0 means end of frame)

-  if (mc_unw_init_cursor(&c, stack_context) != 0)
-    xbt_die("Could not initialize stack unwinding");

 
     while (1) {
 
 
     while (1) {
 


@@ -393,7 +415,7 @@ static std::vector<s_mc_stack_frame_t> unwind_stack_frames(mc_unw_context_t stac
   return std::move(result);
 };
 
   return std::move(result);
 };
 

-static std::vector<s_mc_snapshot_stack_t> take_snapshot_stacks(mc_snapshot_t * snapshot)
+static std::vector<s_mc_snapshot_stack_t> take_snapshot_stacks(simgrid::mc::Snapshot* * snapshot)

 {
   std::vector<s_mc_snapshot_stack_t> res;
 
 {
   std::vector<s_mc_snapshot_stack_t> res;
 


@@ -405,9 +427,7 @@ static std::vector<s_mc_snapshot_stack_t> take_snapshot_stacks(mc_snapshot_t * s
     mc_model_checker->process().read_bytes(
       &context, sizeof(context), remote(stack.context));
 
     mc_model_checker->process().read_bytes(
       &context, sizeof(context), remote(stack.context));
 

-    if (mc_unw_init_context(&st.context, &mc_model_checker->process(),
-      &context) < 0)
-      xbt_die("Could not initialise the libunwind context.");
+    st.context.initialize(&mc_model_checker->process(), &context);

 
     st.stack_frames = unwind_stack_frames(&st.context);
     st.local_variables = get_local_variables_values(st.stack_frames, stack.process_index);
 
     st.stack_frames = unwind_stack_frames(&st.context);
     st.local_variables = get_local_variables_values(st.stack_frames, stack.process_index);


@@ -426,7 +446,7 @@ static std::vector<s_mc_snapshot_stack_t> take_snapshot_stacks(mc_snapshot_t * s
 
 }
 
 
 }
 

-static void snapshot_handle_ignore(mc_snapshot_t snapshot)
+static void snapshot_handle_ignore(simgrid::mc::Snapshot* snapshot)

 {
   xbt_assert(snapshot->process());
   
 {
   xbt_assert(snapshot->process());
   


@@ -448,7 +468,7 @@ static void snapshot_handle_ignore(mc_snapshot_t snapshot)
 
 }
 
 
 }
 

-static void snapshot_ignore_restore(mc_snapshot_t snapshot)
+static void snapshot_ignore_restore(simgrid::mc::Snapshot* snapshot)

 {
   for (auto const& ignored_data : snapshot->ignored_data)
     snapshot->process()->write_bytes(
 {
   for (auto const& ignored_data : snapshot->ignored_data)
     snapshot->process()->write_bytes(


@@ -515,8 +535,14 @@ static std::vector<s_fd_infos_t> get_current_fds(pid_t pid)
       continue;
 
     // If dot_output enabled, do not handle the corresponding file
       continue;
 
     // If dot_output enabled, do not handle the corresponding file

-    if (dot_output !=  nullptr && strcmp(xbt_basename(link), _sg_mc_dot_output_file) == 0)
-      continue;
+    if (dot_output != nullptr) {
+      char* link_basename = xbt_basename(link);
+      if (strcmp(link_basename, _sg_mc_dot_output_file) == 0) {
+        free(link_basename);
+        continue;
+      }
+      free(link_basename);
+    }

 
     // This is probably a shared memory used by lttng-ust:
     if(strncmp("/dev/shm/ust-shm-tmp-", link, 21)==0)
 
     // This is probably a shared memory used by lttng-ust:
     if(strncmp("/dev/shm/ust-shm-tmp-", link, 21)==0)


@@ -535,13 +561,13 @@ static std::vector<s_fd_infos_t> get_current_fds(pid_t pid)
   return std::move(fds);
 }
 
   return std::move(fds);
 }
 

-mc_snapshot_t take_snapshot(int num_state)
+simgrid::mc::Snapshot* take_snapshot(int num_state)

 {
   XBT_DEBUG("Taking snapshot %i", num_state);
 
   simgrid::mc::Process* mc_process = &mc_model_checker->process();
 
 {
   XBT_DEBUG("Taking snapshot %i", num_state);
 
   simgrid::mc::Process* mc_process = &mc_model_checker->process();
 

-  mc_snapshot_t snapshot = new simgrid::mc::Snapshot(mc_process);
+  simgrid::mc::Snapshot* snapshot = new simgrid::mc::Snapshot(mc_process);

 
   snapshot->num_state = num_state;
 
 
   snapshot->num_state = num_state;
 


@@ -579,7 +605,7 @@ mc_snapshot_t take_snapshot(int num_state)
 }
 
 static inline
 }
 
 static inline

-void restore_snapshot_regions(mc_snapshot_t snapshot)
+void restore_snapshot_regions(simgrid::mc::Snapshot* snapshot)

 {
   for(std::unique_ptr<s_mc_mem_region_t> const& region : snapshot->snapshot_regions) {
     // For privatized, variables we decided it was not necessary to take the snapshot:
 {
   for(std::unique_ptr<s_mc_mem_region_t> const& region : snapshot->snapshot_regions) {
     // For privatized, variables we decided it was not necessary to take the snapshot:


@@ -594,13 +620,13 @@ void restore_snapshot_regions(mc_snapshot_t snapshot)
     s_mc_restore_message message;
     message.type = MC_MESSAGE_RESTORE;
     message.index = snapshot->privatization_index;
     s_mc_restore_message message;
     message.type = MC_MESSAGE_RESTORE;
     message.index = snapshot->privatization_index;

-    mc_model_checker->process().send_message(message);
+    mc_model_checker->process().getChannel().send(message);

   }
 #endif
 }
 
 static inline
   }
 #endif
 }
 
 static inline

-void restore_snapshot_fds(mc_snapshot_t snapshot)
+void restore_snapshot_fds(simgrid::mc::Snapshot* snapshot)

 {
   if (mc_mode == MC_MODE_SERVER)
     xbt_die("FD snapshot not implemented in client/server mode.");
 {
   if (mc_mode == MC_MODE_SERVER)
     xbt_die("FD snapshot not implemented in client/server mode.");


@@ -619,7 +645,7 @@ void restore_snapshot_fds(mc_snapshot_t snapshot)
   }
 }
 
   }
 }
 

-void restore_snapshot(mc_snapshot_t snapshot)
+void restore_snapshot(simgrid::mc::Snapshot* snapshot)

 {
   XBT_DEBUG("Restore snapshot %i", snapshot->num_state);
   const bool use_soft_dirty = _sg_mc_sparse_checkpoint && _sg_mc_soft_dirty;
 {
   XBT_DEBUG("Restore snapshot %i", snapshot->num_state);
   const bool use_soft_dirty = _sg_mc_sparse_checkpoint && _sg_mc_soft_dirty;


@@ -629,7 +655,7 @@ void restore_snapshot(mc_snapshot_t snapshot)
   if (use_soft_dirty)
     mc_model_checker->process().reset_soft_dirty();
   snapshot_ignore_restore(snapshot);
   if (use_soft_dirty)
     mc_model_checker->process().reset_soft_dirty();
   snapshot_ignore_restore(snapshot);

-  mc_model_checker->process().cache_flags = 0;
+  mc_model_checker->process().clear_cache();

   if (use_soft_dirty)
     mc_model_checker->parent_snapshot_ = snapshot;
 }
   if (use_soft_dirty)
     mc_model_checker->parent_snapshot_ = snapshot;
 }