#include <xbt/mmalloc.h>
-#include "mc_object_info.h"
-#include "mc_unw.h"
-#include "mc_snapshot.h"
-#include "mc_ignore.h"
-#include "mc_smx.h"
-#include "mc_server.h"
-
-#include "mc/Process.hpp"
-#include "mc/AddressSpace.hpp"
-#include "mc/ObjectInformation.hpp"
-#include "mc/Variable.hpp"
+#include "src/mc/mc_object_info.h"
+#include "src/mc/mc_unw.h"
+#include "src/mc/mc_snapshot.h"
+#include "src/mc/mc_ignore.h"
+#include "src/mc/mc_smx.h"
+
+#include "src/mc/Process.hpp"
+#include "src/mc/AddressSpace.hpp"
+#include "src/mc/ObjectInformation.hpp"
+#include "src/mc/Variable.hpp"
using simgrid::mc::remote;
"libelf",
"libgcc_s",
"liblua5.1",
+ "liblua5.3",
"liblzma",
"libm",
"libpthread",
static char* MC_get_lib_name(const char* pathname, struct s_mc_memory_map_re* res)
{
- const char* map_basename = basename((char*) pathname);
+ const char* map_basename = xbt_basename((char*) pathname);
regmatch_t match;
if(regexec(&res->so_re, map_basename, 1, &match, 0))
namespace simgrid {
namespace mc {
-Process::Process(pid_t pid, int sockfd) : AddressSpace(this)
+Process::Process(pid_t pid, int sockfd) :
+ AddressSpace(this),pid_(pid), socket_(sockfd), running_(true)
+{}
+
+void Process::init()
{
- Process* process = this;
- process->socket_ = sockfd;
- process->pid_ = pid;
- process->running_ = true;
- process->status_ = 0;
- process->memory_map_ = get_memory_map(pid);
- process->cache_flags = MC_PROCESS_CACHE_FLAG_NONE;
- process->heap = NULL;
- process->heap_info = NULL;
- process->init_memory_map_info();
- process->clear_refs_fd_ = -1;
- process->pagemap_fd_ = -1;
-
- int fd = open_vm(process->pid_, O_RDWR);
+ this->memory_map_ = simgrid::xbt::get_memory_map(this->pid_);
+ this->init_memory_map_info();
+
+ int fd = open_vm(this->pid_, O_RDWR);
if (fd<0)
xbt_die("Could not open file for process virtual address space");
- process->memory_file = fd;
+ this->memory_file = fd;
// Read std_heap (is a struct mdesc*):
- simgrid::mc::Variable* std_heap_var = process->find_variable("__mmalloc_default_mdp");
+ simgrid::mc::Variable* std_heap_var = this->find_variable("__mmalloc_default_mdp");
if (!std_heap_var)
xbt_die("No heap information in the target process");
if(!std_heap_var->address)
xbt_die("No constant address for this variable");
- process->read_bytes(&process->heap_address, sizeof(struct mdesc*),
+ this->read_bytes(&this->heap_address, sizeof(struct mdesc*),
remote(std_heap_var->address),
simgrid::mc::ProcessIndexDisabled);
- process->smx_process_infos = MC_smx_process_info_list_new();
- process->smx_old_process_infos = MC_smx_process_info_list_new();
- process->unw_addr_space = unw_create_addr_space(&mc_unw_accessors , __BYTE_ORDER);
- process->unw_underlying_addr_space = unw_create_addr_space(&mc_unw_vmread_accessors, __BYTE_ORDER);
- process->unw_underlying_context = _UPT_create(pid);
+ this->smx_process_infos = MC_smx_process_info_list_new();
+ this->smx_old_process_infos = MC_smx_process_info_list_new();
+ this->unw_addr_space = unw_create_addr_space(&mc_unw_accessors , __BYTE_ORDER);
+ this->unw_underlying_addr_space = unw_create_addr_space(&mc_unw_vmread_accessors, __BYTE_ORDER);
+ this->unw_underlying_context = _UPT_create(this->pid_);
}
Process::~Process()
{
- Process* process = this;
-
if (this->socket_ >= 0 && close(this->socket_) < 0)
xbt_die("Could not close communication socket");
- process->pid_ = 0;
-
- process->maestro_stack_start_ = nullptr;
- process->maestro_stack_end_ = nullptr;
+ this->maestro_stack_start_ = nullptr;
+ this->maestro_stack_end_ = nullptr;
- xbt_dynar_free(&process->smx_process_infos);
- xbt_dynar_free(&process->smx_old_process_infos);
+ xbt_dynar_free(&this->smx_process_infos);
+ xbt_dynar_free(&this->smx_old_process_infos);
- if (process->memory_file >= 0) {
- close(process->memory_file);
+ if (this->memory_file >= 0) {
+ close(this->memory_file);
}
- if (process->unw_underlying_addr_space != unw_local_addr_space) {
- unw_destroy_addr_space(process->unw_underlying_addr_space);
- _UPT_destroy(process->unw_underlying_context);
+ if (this->unw_underlying_addr_space != unw_local_addr_space) {
+ unw_destroy_addr_space(this->unw_underlying_addr_space);
+ _UPT_destroy(this->unw_underlying_context);
}
- process->unw_underlying_context = NULL;
- process->unw_underlying_addr_space = NULL;
-
- unw_destroy_addr_space(process->unw_addr_space);
- process->unw_addr_space = NULL;
+ this->unw_underlying_context = NULL;
+ this->unw_underlying_addr_space = NULL;
- process->cache_flags = MC_PROCESS_CACHE_FLAG_NONE;
+ unw_destroy_addr_space(this->unw_addr_space);
+ this->unw_addr_space = NULL;
- free(process->heap);
- process->heap = NULL;
+ this->cache_flags = MC_PROCESS_CACHE_FLAG_NONE;
- free(process->heap_info);
- process->heap_info = NULL;
-
- if (process->clear_refs_fd_ >= 0)
- close(process->clear_refs_fd_);
- if (process->pagemap_fd_ >= 0)
- close(process->pagemap_fd_);
+ 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
{
xbt_assert(mc_mode == MC_MODE_SERVER);
// Read/dereference/refresh the std_heap pointer:
- if (!this->heap) {
- this->heap = (struct mdesc*) malloc(sizeof(struct mdesc));
- }
- this->read_bytes(this->heap, sizeof(struct mdesc), remote(this->heap_address),
- simgrid::mc::ProcessIndexDisabled);
+ if (!this->heap)
+ this->heap = std::unique_ptr<s_xbt_mheap_t>(new s_xbt_mheap_t());
+ this->read_bytes(this->heap.get(), sizeof(struct mdesc),
+ remote(this->heap_address), simgrid::mc::ProcessIndexDisabled);
this->cache_flags |= MC_PROCESS_CACHE_FLAG_HEAP;
}
if (!(this->cache_flags & MC_PROCESS_CACHE_FLAG_HEAP))
this->refresh_heap();
// Refresh process->heapinfo:
- size_t malloc_info_bytesize =
- (this->heap->heaplimit + 1) * sizeof(malloc_info);
- this->heap_info = (malloc_info*) realloc(this->heap_info, malloc_info_bytesize);
- this->read_bytes(this->heap_info, malloc_info_bytesize,
+ size_t count = this->heap->heaplimit + 1;
+ if (this->heap_info.size() < count)
+ this->heap_info.resize(count);
+ this->read_bytes(this->heap_info.data(), count * sizeof(malloc_info),
remote(this->heap->heapinfo), simgrid::mc::ProcessIndexDisabled);
this->cache_flags |= MC_PROCESS_CACHE_FLAG_MALLOC_INFO;
}
if(regcomp(&res.so_re, SO_RE, 0) || regcomp(&res.version_re, VERSION_RE, 0))
xbt_die(".so regexp did not compile");
- std::vector<simgrid::mc::VmMap> const& maps = this->memory_map_;
+ std::vector<simgrid::xbt::VmMap> const& maps = this->memory_map_;
const char* current_name = NULL;
this->object_infos.resize(0);
for (size_t i=0; i < maps.size(); i++) {
- simgrid::mc::VmMap const& reg = maps[i];
+ simgrid::xbt::VmMap const& reg = maps[i];
const char* pathname = maps[i].pathname.c_str();
// Nothing to do
}
std::shared_ptr<simgrid::mc::ObjectInformation> info =
- MC_find_object_info(this->memory_map_, pathname, is_executable);
+ MC_find_object_info(this->memory_map_, pathname);
this->object_infos.push_back(info);
if (is_executable)
this->binary_info = info;
const void *Process::read_bytes(void* buffer, std::size_t size,
remote_ptr<void> address, int process_index,
- AddressSpace::ReadMode mode) const
+ ReadOptions options) const
{
if (process_index != simgrid::mc::ProcessIndexDisabled) {
std::shared_ptr<simgrid::mc::ObjectInformation> const& info =
this->find_object_info_rw((void*)address.address());
// Segment overlap is not handled.
#ifdef HAVE_SMPI
- if (info.get() && info.get()->privatized()) {
+ if (info.get() && this->privatized(*info)) {
if (process_index < 0)
xbt_die("Missing process index");
if (process_index >= (int) MC_smpi_process_count())
xbt_die("Could not read pagemap");
}
+void Process::ignore_heap(IgnoredHeapRegion const& region)
+{
+ if (ignored_heap_.empty()) {
+ ignored_heap_.push_back(std::move(region));
+ return;
+ }
+
+ typedef std::vector<IgnoredHeapRegion>::size_type size_type;
+
+ size_type start = 0;
+ size_type end = ignored_heap_.size() - 1;
+
+ // Binary search the position of insertion:
+ size_type cursor;
+ while (start <= end) {
+ cursor = start + (end - start) / 2;
+ auto& current_region = ignored_heap_[cursor];
+ if (current_region.address == region.address)
+ return;
+ else if (current_region.address < region.address)
+ start = cursor + 1;
+ else if (cursor != 0)
+ end = cursor - 1;
+ // Avoid underflow:
+ else
+ break;
+ }
+
+ // Insert it mc_heap_ignore_region_t:
+ if (ignored_heap_[cursor].address < region.address)
+ ++cursor;
+ ignored_heap_.insert( ignored_heap_.begin() + cursor, region);
+}
+
+void Process::unignore_heap(void *address, size_t size)
+{
+ typedef std::vector<IgnoredHeapRegion>::size_type size_type;
+
+ size_type start = 0;
+ size_type end = ignored_heap_.size() - 1;
+
+ // Binary search:
+ size_type cursor;
+ while (start <= end) {
+ cursor = (start + end) / 2;
+ auto& region = ignored_heap_[cursor];
+ if (region.address == address) {
+ ignored_heap_.erase(ignored_heap_.begin() + cursor);
+ return;
+ } else if (region.address < address)
+ start = cursor + 1;
+ else if ((char *) region.address <= ((char *) address + size)) {
+ ignored_heap_.erase(ignored_heap_.begin() + cursor);
+ return;
+ } else if (cursor != 0)
+ end = cursor - 1;
+ // Avoid underflow:
+ else
+ break;
+ }
+}
+
+void Process::ignore_local_variable(const char *var_name, const char *frame_name)
+{
+ if (frame_name != nullptr && strcmp(frame_name, "*") == 0)
+ frame_name = nullptr;
+ for (std::shared_ptr<simgrid::mc::ObjectInformation> const& info :
+ this->object_infos)
+ info->remove_local_variable(var_name, frame_name);
+}
+
}
}
