#include "xbt/module.h"
#include <xbt/mmalloc.h>
#include "src/smpi/private.h"
-#include <alloca.h>
#include "src/xbt/mmalloc/mmprivate.h"
break;
case simgrid::mc::StorageType::Flat:
- mc_model_checker->process().write_bytes(region->flat_data(),
+ mc_model_checker->process().write_bytes(region->flat_data().get(),
region->size(), region->permanent_address());
break;
const size_t n = process->object_infos.size();
snapshot->snapshot_regions.resize(n + 1);
int i = 0;
- for (auto const& object_info : process->object_infos) {
- add_region(i, snapshot, simgrid::mc::RegionType::Data,
+ for (auto const& object_info : process->object_infos)
+ add_region(i++, snapshot, simgrid::mc::RegionType::Data,
object_info.get(),
object_info->start_rw, object_info->start_rw,
object_info->end_rw - object_info->start_rw);
- ++i;
- }
xbt_mheap_t heap = process->get_heap();
void *start_heap = heap->base;
void *end_heap = heap->breakval;
- add_region(n, snapshot, simgrid::mc::RegionType::Heap, NULL,
+ add_region(n, snapshot, simgrid::mc::RegionType::Heap, nullptr,
start_heap, start_heap,
(char *) end_heap - (char *) start_heap);
snapshot->heap_bytes_used = mmalloc_get_bytes_used_remote(
process->get_malloc_info());
#ifdef HAVE_SMPI
- if (mc_model_checker->process().privatized() && MC_smpi_process_count()) {
+ if (mc_model_checker->process().privatized() && MC_smpi_process_count())
// snapshot->privatization_index = smpi_loaded_page
mc_model_checker->process().read_variable(
"smpi_loaded_page", &snapshot->privatization_index,
sizeof(snapshot->privatization_index));
- } else
+ else
#endif
- {
snapshot->privatization_index = simgrid::mc::ProcessIndexMissing;
- }
}
/** \brief Fills the position of the segments (executable, read-only, read/write).
// .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) {
+ && next.start_addr == reg.end_addr)
result->end_rw = (char*) maps[i + 1].end_addr;
- }
} else if ((reg.prot & PROT_READ) && (reg.prot & PROT_EXEC)) {
xbt_assert(!result->start_exec,
"Multiple executable segments for %s, not supported",
new_var.region = region_type;
new_var.address = nullptr;
- if (current_variable.address != NULL) {
+ if (current_variable.address != nullptr)
new_var.address = current_variable.address;
- } else if (!current_variable.location_list.empty()) {
+ else if (!current_variable.location_list.empty()) {
simgrid::dwarf::Location location =
simgrid::dwarf::resolve(
current_variable.location_list,
xbt_die("Cannot handle non-address variable");
new_var.address = location.address();
- } else {
+ } else
xbt_die("No address");
- }
result.push_back(std::move(new_var));
}
unw_cursor_t c;
// TODO, check condition check (unw_init_local==0 means end of frame)
- if (mc_unw_init_cursor(&c, stack_context) != 0) {
-
+ if (mc_unw_init_cursor(&c, stack_context) != 0)
xbt_die("Could not initialize stack unwinding");
- } else
while (1) {
s_mc_stack_frame_t stack_frame;
break;
int ret = unw_step(&c);
- if (ret == 0) {
+ if (ret == 0)
xbt_die("Unexpected end of stack.");
- } else if (ret < 0) {
+ else if (ret < 0)
xbt_die("Error while unwinding stack");
- }
}
if (result.empty()) {
&context, sizeof(context), remote(stack.context));
if (mc_unw_init_context(&st.context, &mc_model_checker->process(),
- &context) < 0) {
+ &context) < 0)
xbt_die("Could not initialise the libunwind context.");
- }
+
st.stack_frames = unwind_stack_frames(&st.context);
st.local_variables = get_local_variables_values(st.stack_frames, stack.process_index);
st.process_index = stack.process_index;
}
// Zero the memory:
- for(auto const& region : mc_model_checker->process().ignored_regions()) {
+ for(auto const& region : mc_model_checker->process().ignored_regions())
snapshot->process()->clear_bytes(remote(region.addr), region.size);
- }
}
xbt_die("Unexpected buffer is too small for fd_dir_path");
DIR* fd_dir = opendir(fd_dir_path);
- if (fd_dir == NULL)
+ if (fd_dir == nullptr)
xbt_die("Cannot open directory '/proc/self/fd'\n");
std::vector<s_fd_infos_t> fds;
const size_t link_size = 200;
char link[200];
res = readlink(source, link, link_size);
- if (res<0) {
+
+ if (res<0)
xbt_die("Could not read link for %s", source);
- }
- if (res==200) {
+ if (res==200)
xbt_die("Buffer to small for link of %s", source);
- }
+
link[res] = '\0';
#ifdef HAVE_SMPI
continue;
// If dot_output enabled, do not handle the corresponding file
- if (dot_output != NULL && strcmp(xbt_basename(link), _sg_mc_dot_output_file) == 0)
+ if (dot_output != nullptr && strcmp(xbt_basename(link), _sg_mc_dot_output_file) == 0)
continue;
// This is probably a shared memory used by lttng-ust:
snapshot->num_state = num_state;
- smx_process_t process;
- MC_EACH_SIMIX_PROCESS(process,
- snapshot->enabled_processes.insert(process->pid));
+ for (auto& p : mc_model_checker->process().simix_processes())
+ snapshot->enabled_processes.insert(p.copy.pid);
snapshot_handle_ignore(snapshot);
if (_sg_mc_snapshot_fds)
- snapshot->current_fds = get_current_fds(process->pid);
+ snapshot->current_fds = get_current_fds(mc_model_checker->process().pid());
const bool use_soft_dirty = _sg_mc_sparse_checkpoint && _sg_mc_soft_dirty;
if (_sg_mc_visited > 0 || strcmp(_sg_mc_property_file, "")) {
snapshot->stacks =
take_snapshot_stacks(&snapshot);
- if (_sg_mc_hash) {
+ if (_sg_mc_hash)
snapshot->hash = simgrid::mc::hash(*snapshot);
- } else {
+ else
snapshot->hash = 0;
- }
- } else {
+ } else
snapshot->hash = 0;
- }
snapshot_ignore_restore(snapshot);
if (use_soft_dirty)
for (auto const& fd : snapshot->current_fds) {
int new_fd = open(fd.filename.c_str(), fd.flags);
- if (new_fd < 0) {
+ if (new_fd < 0)
xbt_die("Could not reopen the file %s fo restoring the file descriptor",
fd.filename.c_str());
- }
if (new_fd != fd.number) {
dup2(new_fd, fd.number);
close(new_fd);
