region->permanent_addr = permanent_addr;
region->size = size;
region->flat.data = xbt_malloc(size);
- memcpy(region->flat.data, permanent_addr, size);
+ MC_process_read(&mc_model_checker->process, region->flat.data, permanent_addr, size);
XBT_DEBUG("New region : type : %d, data : %p (real addr %p), size : %zu",
region_type, region->flat.data, permanent_addr, size);
return region;
break;
case MC_REGION_STORAGE_TYPE_FLAT:
- memcpy(region->permanent_addr, region->flat.data, region->size);
+ MC_process_write(&mc_model_checker->process, region->flat.data,
+ region->permanent_addr, region->size);
break;
case MC_REGION_STORAGE_TYPE_CHUNKED:
- mc_region_restore_sparse(region, ref_region);
+ mc_region_restore_sparse(&mc_model_checker->process, region, ref_region);
break;
case MC_REGION_STORAGE_TYPE_PRIVATIZED:
MC_get_current_fd(snapshot);
+ const bool use_soft_dirty = _sg_mc_sparse_checkpoint
+ && _sg_mc_soft_dirty
+ && MC_process_is_self(&mc_model_checker->process);
+
/* Save the std heap and the writable mapped pages of libsimgrid and binary */
MC_get_memory_regions(snapshot);
- if (_sg_mc_sparse_checkpoint && _sg_mc_soft_dirty) {
+ if (use_soft_dirty)
mc_softdirty_reset();
- }
snapshot->to_ignore = MC_take_snapshot_ignore();
}
MC_snapshot_ignore_restore(snapshot);
- if (_sg_mc_sparse_checkpoint && _sg_mc_soft_dirty) {
+ if (use_soft_dirty)
mc_model_checker->parent_snapshot = snapshot;
- }
return snapshot;
}
void MC_restore_snapshot(mc_snapshot_t snapshot)
{
+ const bool use_soft_dirty = _sg_mc_sparse_checkpoint
+ && _sg_mc_soft_dirty
+ && MC_process_is_self(&mc_model_checker->process);
+
MC_restore_snapshot_regions(snapshot);
MC_restore_snapshot_fds(snapshot);
- if (_sg_mc_sparse_checkpoint && _sg_mc_soft_dirty) {
+ if (use_soft_dirty) {
mc_softdirty_reset();
}
MC_snapshot_ignore_restore(snapshot);
- if (_sg_mc_sparse_checkpoint && _sg_mc_soft_dirty) {
+ if (use_soft_dirty) {
mc_model_checker->parent_snapshot = snapshot;
}
}
+#include <unistd.h> // pread, pwrite
+
#include "mc_page_store.h"
#include "mc_mmu.h"
#include "mc_private.h"
* @param reference_pages Snapshot page numbers of the previous soft_dirty_reset (or NULL)
* @return Snapshot page numbers of this new snapshot
*/
-size_t* mc_take_page_snapshot_region(void* data, size_t page_count, uint64_t* pagemap, size_t* reference_pages)
+size_t* mc_take_page_snapshot_region(mc_process_t process,
+ void* data, size_t page_count, uint64_t* pagemap, size_t* reference_pages)
{
size_t* pagenos = (size_t*) malloc(page_count * sizeof(size_t));
+ const bool is_self = MC_process_is_self(process);
+
+ void* temp = NULL;
+ if (!is_self)
+ temp = malloc(xbt_pagebits);
+
for (size_t i=0; i!=page_count; ++i) {
bool softclean = pagemap && !(pagemap[i] & SOFT_DIRTY);
if (softclean && reference_pages) {
// Otherwise, we need to store the page the hard way
// (by reading its content):
void* page = (char*) data + (i << xbt_pagebits);
- pagenos[i] = mc_model_checker->pages->store_page(page);
+ xbt_assert(mc_page_offset(page)==0, "Not at the beginning of a page");
+ void* page_data;
+ if (is_self) {
+ page_data = page;
+ } else {
+ /* Adding another copy (and a syscall) will probably slow things a lot.
+ TODO, optimize this somehow (at least by grouping the syscalls)
+ if needed. Either:
+ - reduce the number of syscalls;
+ - let the application snapshot itself;
+ - move the segments in shared memory (this will break `fork` however).
+ */
+ page_data = temp;
+ MC_process_read(process, temp, page, xbt_pagesize);
+ }
+ pagenos[i] = mc_model_checker->pages->store_page(page_data);
}
}
+ free(temp);
return pagenos;
}
* @param pagemap Linux kernel pagemap values fot this region (or NULL)
* @param reference_pages Snapshot page numbers of the previous soft_dirty_reset (or NULL)
*/
-void mc_restore_page_snapshot_region(void* start_addr, size_t page_count, size_t* pagenos, uint64_t* pagemap, size_t* reference_pagenos)
+void mc_restore_page_snapshot_region(mc_process_t process,
+ void* start_addr, size_t page_count, size_t* pagenos, uint64_t* pagemap, size_t* reference_pagenos)
{
for (size_t i=0; i!=page_count; ++i) {
// Otherwise, copy the page:
void* target_page = mc_page_from_number(start_addr, i);
const void* source_page = mc_model_checker->pages->get_page(pagenos[i]);
- memcpy(target_page, source_page, xbt_pagesize);
+ MC_process_write(process, source_page, target_page, xbt_pagesize);
}
}
void *start_addr, void* permanent_addr, size_t size,
mc_mem_region_t ref_reg)
{
+ mc_process_t process = &mc_model_checker->process;
+
mc_mem_region_t region = xbt_new(s_mc_mem_region_t, 1);
region->region_type = region_type;
region->storage_type = MC_REGION_STORAGE_TYPE_CHUNKED;
size_t page_count = mc_page_count(size);
uint64_t* pagemap = NULL;
- if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot) {
+ if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot &&
+ MC_process_is_self(process)) {
pagemap = (uint64_t*) mmalloc_no_memset(mc_heap, sizeof(uint64_t) * page_count);
mc_read_pagemap(pagemap, mc_page_number(NULL, permanent_addr), page_count);
}
reg_page_numbers = ref_reg->chunked.page_numbers;
// Take incremental snapshot:
- region->chunked.page_numbers = mc_take_page_snapshot_region(
+ region->chunked.page_numbers = mc_take_page_snapshot_region(process,
permanent_addr, page_count, pagemap, reg_page_numbers);
if(pagemap) {
return region;
}
-void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg)
+void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg, mc_mem_region_t ref_reg)
{
xbt_assert((((uintptr_t)reg->permanent_addr) & (xbt_pagesize-1)) == 0,
"Not at the beginning of a page");
uint64_t* pagemap = NULL;
// Read soft-dirty bits if necessary in order to know which pages have changed:
- if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot) {
+ if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot
+ && MC_process_is_self(process)) {
pagemap = (uint64_t*) mmalloc_no_memset(mc_heap, sizeof(uint64_t) * page_count);
mc_read_pagemap(pagemap, mc_page_number(NULL, reg->permanent_addr), page_count);
}
if (ref_reg && ref_reg->storage_type == MC_REGION_STORAGE_TYPE_CHUNKED)
reg_page_numbers = ref_reg->chunked.page_numbers;
- mc_restore_page_snapshot_region(reg->permanent_addr, page_count, reg->chunked.page_numbers,
+ mc_restore_page_snapshot_region(process,
+ reg->permanent_addr, page_count, reg->chunked.page_numbers,
pagemap, reg_page_numbers);
if(pagemap) {
/** Store a page in memory */
size_t s_mc_pages_store::store_page(void* page)
{
- xbt_assert(mc_page_offset(page)==0, "Not at the beginning of a page");
xbt_assert(top_index_ <= this->capacity_, "top_index is not consistent");
// First, we check if a page with the same content is already in the page
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
+#include <errno.h>
#include <sys/types.h>
+#include <fcntl.h>
#include <unistd.h>
#include <regex.h>
#include <sys/mman.h> // PROT_*
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_process, mc,
"MC process information");
-static void MC_init_memory_map_info(mc_process_t process);
+static void MC_process_init_memory_map_info(mc_process_t process);
+static void MC_process_open_memory_file(mc_process_t process);
+
void MC_process_init(mc_process_t process, pid_t pid)
{
if (pid==getpid())
process->process_flags |= MC_PROCESS_SELF_FLAG;
process->memory_map = MC_get_memory_map(pid);
- MC_init_memory_map_info(process);
+ process->memory_file = -1;
+ MC_process_init_memory_map_info(process);
+ MC_process_open_memory_file(process);
}
void MC_process_clear(mc_process_t process)
free(process->object_infos);
process->object_infos = NULL;
process->object_infos_size = 0;
+ if (process->memory_file >= 0) {
+ close(process->memory_file);
+ }
}
#define SO_RE "\\.so[\\.0-9]*$"
}
/** @brief Finds the range of the different memory segments and binary paths */
-static void MC_init_memory_map_info(mc_process_t process)
+static void MC_process_init_memory_map_info(mc_process_t process)
{
XBT_INFO("Get debug information ...");
process->maestro_stack_start = NULL;
else
return MC_file_object_info_find_function(info, ip);
}
+
+// ***** Memory access
+
+static void MC_process_open_memory_file(mc_process_t process)
+{
+ if (MC_process_is_self(process) || process->memory_file >= 0)
+ return;
+
+ const size_t buffer_size = 30;
+ char buffer[buffer_size];
+ int res = snprintf(buffer, buffer_size, "/proc/%lli/mem", (long long) process->pid);
+ if (res < 0 || res>= buffer_size) {
+ XBT_ERROR("Could not open memory file descriptor for process %lli",
+ (long long) process->pid);
+ return;
+ }
+
+ int fd = open(buffer, O_RDWR);
+ if (fd<0)
+ xbt_die("Could not initialise memory access for remote process");
+ process->memory_file = fd;
+}
+
+static ssize_t pread_whole(int fd, void *buf, size_t count, off_t offset)
+{
+ char* buffer = (char*) buf;
+ ssize_t real_count = count;
+ while (count) {
+ ssize_t res = pread(fd, buffer, count, offset);
+ if (res >= 0) {
+ count -= res;
+ buffer += res;
+ offset += res;
+ } else if (res==0) {
+ return -1;
+ } else if (errno != EINTR) {
+ return -1;
+ }
+ }
+ return real_count;
+}
+
+static ssize_t pwrite_whole(int fd, const void *buf, size_t count, off_t offset)
+{
+ const char* buffer = (const char*) buf;
+ ssize_t real_count = count;
+ while (count) {
+ ssize_t res = pwrite(fd, buffer, count, offset);
+ if (res >= 0) {
+ count -= res;
+ buffer += res;
+ offset += res;
+ } else if (res==0) {
+ return -1;
+ } else if (errno != EINTR) {
+ return -1;
+ }
+ }
+ return real_count;
+}
+
+void MC_process_read(mc_process_t process, void* local, const void* remote, size_t len)
+{
+ if (MC_process_is_self(process)) {
+ memcpy(local, remote, len);
+ } else {
+ if (pread_whole(process->memory_file, local, len, (off_t) remote) < 0)
+ xbt_die("Read from process %lli failed", (long long) process->pid);
+ }
+}
+
+void MC_process_write(mc_process_t process, const void* local, void* remote, size_t len)
+{
+ if (MC_process_is_self(process)) {
+ memcpy(remote, local, len);
+ } else {
+ if (pwrite_whole(process->memory_file, local, len, (off_t) remote) < 0)
+ xbt_die("Write to process %lli failed", (long long) process->pid);
+ }
+}
#ifndef MC_PROCESS_H
#define MC_PROCESS_H
+#include <stdbool.h>
+
#include "simgrid_config.h"
#include <sys/types.h>
mc_object_info_t binary_info;
mc_object_info_t* object_infos;
size_t object_infos_size;
+ int memory_file;
};
void MC_process_init(mc_process_t process, pid_t pid);
void MC_process_clear(mc_process_t process);
+static inline
+bool MC_process_is_self(mc_process_t process)
+{
+ return process->process_flags & MC_PROCESS_SELF_FLAG;
+}
+
+/* Process memory access: */
+
+/** Read data from a process memory
+ *
+ * @param process the process
+ * @param local local memory address (destination)
+ * @param remote target process memory address (source)
+ * @param len data size
+ */
+void MC_process_read(mc_process_t process, void* local, const void* remote, size_t len);
+
+/** Write data to a process memory
+ *
+ * @param process the process
+ * @param local local memory address (source)
+ * @param remote target process memory address (target)
+ * @param len data size
+ */
+void MC_process_write(mc_process_t process, const void* local, void* remote, size_t len);
+
+/* Functions, variables of the process: */
+
mc_object_info_t MC_process_find_object_info(mc_process_t process, void* ip);
dw_frame_t MC_process_find_function(mc_process_t process, void* ip);
mc_mem_region_t mc_region_new_sparse(mc_region_type_t type, void *start_addr, void* data_addr, size_t size, mc_mem_region_t ref_reg);
void MC_region_destroy(mc_mem_region_t reg);
-void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg);
+void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg, mc_mem_region_t ref_reg);
static inline __attribute__ ((always_inline))
bool mc_region_contain(mc_mem_region_t region, void* p)
int mc_important_snapshot(mc_snapshot_t snapshot);
-size_t* mc_take_page_snapshot_region(void* data, size_t page_count, uint64_t* pagemap, size_t* reference_pages);
+size_t* mc_take_page_snapshot_region(mc_process_t process,
+ void* data, size_t page_count, uint64_t* pagemap, size_t* reference_pages);
void mc_free_page_snapshot_region(size_t* pagenos, size_t page_count);
-void mc_restore_page_snapshot_region(void* start_addr, size_t page_count, size_t* pagenos, uint64_t* pagemap, size_t* reference_pagenos);
+void mc_restore_page_snapshot_region(
+ mc_process_t process,
+ void* start_addr, size_t page_count, size_t* pagenos,
+ uint64_t* pagemap, size_t* reference_pagenos);
void* mc_snapshot_read_fragmented(void* addr, mc_mem_region_t region, void* target, size_t size);
