#include "mc_process.h"
#include "mc_object_info.h"
-#include "mc_address_space.h"
+#include "AddressSpace.hpp"
#include "mc_unw.h"
#include "mc_snapshot.h"
#include "mc_ignore.h"
return p;
}
-static const s_mc_address_space_class_t mc_process_class = {
- .read = (mc_address_space_class_read_callback_t) &MC_process_read,
- .get_process = (mc_address_space_class_get_process_callback_t) MC_process_get_process
-};
-
-bool MC_is_process(mc_address_space_t p)
-{
- return p->address_space_class == &mc_process_class;
}
// ***** mc_process
-void MC_process_init(mc_process_t process, pid_t pid, int sockfd)
+namespace simgrid {
+namespace mc {
+
+Process::Process(pid_t pid, int sockfd)
{
- process->address_space.address_space_class = &mc_process_class;
+ Process* process = this;
+
process->process_flags = MC_PROCESS_NO_FLAG;
process->socket = sockfd;
process->pid = pid;
MC_process_open_memory_file(process);
// Read std_heap (is a struct mdesc*):
- dw_variable_t std_heap_var = MC_process_find_variable_by_name(process, "std_heap");
+ dw_variable_t std_heap_var = MC_process_find_variable_by_name(process,
+ "__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");
- MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE,
+ MC_process_read(process, simgrid::mc::AddressSpace::Normal,
&process->heap_address, std_heap_var->address, sizeof(struct mdesc*),
- MC_PROCESS_INDEX_DISABLED);
+ simgrid::mc::ProcessIndexDisabled);
process->smx_process_infos = MC_smx_process_info_list_new();
process->smx_old_process_infos = MC_smx_process_info_list_new();
}
}
-void MC_process_clear(mc_process_t process)
+Process::~Process()
{
- process->address_space.address_space_class = NULL;
+ Process* process = this;
+
process->process_flags = MC_PROCESS_NO_FLAG;
process->pid = 0;
process->heap_info = NULL;
}
+}
+}
+
+extern "C" {
+
void MC_process_refresh_heap(mc_process_t process)
{
- assert(!MC_process_is_self(process));
+ xbt_assert(mc_mode == MC_MODE_SERVER);
+ xbt_assert(!MC_process_is_self(process));
// Read/dereference/refresh the std_heap pointer:
if (!process->heap) {
- xbt_mheap_t oldheap = mmalloc_set_current_heap(mc_heap);
process->heap = (struct mdesc*) malloc(sizeof(struct mdesc));
- mmalloc_set_current_heap(oldheap);
}
- MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE,
+ MC_process_read(process, simgrid::mc::AddressSpace::Normal,
process->heap, process->heap_address, sizeof(struct mdesc),
- MC_PROCESS_INDEX_DISABLED
+ simgrid::mc::ProcessIndexDisabled
);
+ process->cache_flags |= MC_PROCESS_CACHE_FLAG_HEAP;
}
void MC_process_refresh_malloc_info(mc_process_t process)
{
- assert(!MC_process_is_self(process));
+ xbt_assert(mc_mode == MC_MODE_SERVER);
+ xbt_assert(!MC_process_is_self(process));
if (!(process->cache_flags & MC_PROCESS_CACHE_FLAG_HEAP))
MC_process_refresh_heap(process);
// Refresh process->heapinfo:
size_t malloc_info_bytesize =
(process->heap->heaplimit + 1) * sizeof(malloc_info);
-
- xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
process->heap_info = (malloc_info*) realloc(process->heap_info, malloc_info_bytesize);
- mmalloc_set_current_heap(heap);
-
- MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE,
+ MC_process_read(process, simgrid::mc::AddressSpace::Normal,
process->heap_info,
process->heap->heapinfo, malloc_info_bytesize,
- MC_PROCESS_INDEX_DISABLED);
+ simgrid::mc::ProcessIndexDisabled);
+ process->cache_flags |= MC_PROCESS_CACHE_FLAG_MALLOC_INFO;
}
#define SO_RE "\\.so[\\.0-9]*$"
if ((size_t) var->type->full_type->byte_size != size)
xbt_die("Unexpected size for %s (expected %zi, was %zi)",
name, size, (size_t) var->type->full_type->byte_size);
- MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE, target, var->address, size,
- MC_PROCESS_INDEX_ANY);
+ MC_process_read(process, simgrid::mc::AddressSpace::Normal, target, var->address, size,
+ simgrid::mc::ProcessIndexAny);
}
char* MC_process_read_string(mc_process_t process, void* address)
return real_count;
}
-const void* MC_process_read(mc_process_t process, adress_space_read_flags_t flags,
- void* local, const void* remote, size_t len,
- int process_index)
+}
+
+namespace simgrid {
+namespace mc {
+
+const void *Process::read_bytes(void* buffer, std::size_t size,
+ std::uint64_t address, int process_index,
+ AddressSpace::ReadMode mode)
{
- if (process_index != MC_PROCESS_INDEX_DISABLED) {
- mc_object_info_t info = MC_process_find_object_info_rw(process, remote);
+ if (process_index != simgrid::mc::ProcessIndexDisabled) {
+ mc_object_info_t info = MC_process_find_object_info_rw(this, (void*)address);
// Segment overlap is not handled.
if (MC_object_info_is_privatized(info)) {
if (process_index < 0)
xbt_die("Missing process index");
// Address translation in the privaization segment:
- size_t offset = (const char*) remote - info->start_rw;
- remote = (const char*) remote - offset;
+ // TODO, fix me (broken)
+ size_t offset = address - (std::uint64_t)info->start_rw;
+ address = address - offset;
}
}
- if (MC_process_is_self(process)) {
- if (flags & MC_ADDRESS_SPACE_READ_FLAGS_LAZY)
- return remote;
+ if (MC_process_is_self(this)) {
+ if (mode == simgrid::mc::AddressSpace::Lazy)
+ return (void*)address;
else {
- memcpy(local, remote, len);
- return local;
+ memcpy(buffer, (void*)address, size);
+ return buffer;
}
} else {
- if (pread_whole(process->memory_file, local, len, (off_t) remote) < 0)
- xbt_die("Read from process %lli failed", (long long) process->pid);
- return local;
+ if (pread_whole(this->memory_file, buffer, size, (off_t) address) < 0)
+ xbt_die("Read from process %lli failed", (long long) this->pid);
+ return buffer;
}
}
-const void* MC_process_read_simple(mc_process_t process,
- void* local, const void* remote, size_t len)
-{
- adress_space_read_flags_t flags = MC_ADDRESS_SPACE_READ_FLAGS_NONE;
- int index = MC_PROCESS_INDEX_ANY;
- MC_process_read(process, flags, local, remote, len, index);
- return local;
}
+}
+
+extern "C" {
const void* MC_process_read_dynar_element(mc_process_t process,
void* local, const void* remote_dynar, size_t i, size_t len)
s_xbt_dynar_t d;
MC_process_read_simple(process, &d, remote_dynar, sizeof(d));
if (i >= d.used)
- xbt_die("Out of bound index %zi/%zi", i, d.used);
+ xbt_die("Out of bound index %zi/%lu", i, d.used);
if (len != d.elmsize)
xbt_die("Bad size in MC_process_read_dynar_element");
MC_process_read_simple(process, local, xbt_dynar_get_ptr(&d, i), len);
static pthread_once_t zero_buffer_flag = PTHREAD_ONCE_INIT;
static const void* zero_buffer;
-static const int zero_buffer_size = 10 * 4096;
+static const size_t zero_buffer_size = 10 * 4096;
static void MC_zero_buffer_init(void)
{
