-/* Copyright (c) 2014-2015. The SimGrid Team.
- * All rights reserved. */
+/* Copyright (c) 2014-2017. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#define _FILE_OFFSET_BITS 64
+#define _FILE_OFFSET_BITS 64 /* needed for pread_whole to work as expected on 32bits */
#include <assert.h>
#include <stddef.h>
#include <libunwind.h>
#include <libunwind-ptrace.h>
-#include <xbt/log.h>
-#include <xbt/base.h>
+#include "xbt/base.h"
+#include "xbt/log.h"
#include <xbt/mmalloc.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"
static bool is_simgrid_lib(const char* libname)
{
- return !strcmp(libname, "libsimgrid");
+ return not strcmp(libname, "libsimgrid");
}
static bool is_filtered_lib(const char* libname)
map_basename = nullptr;
// Strip the version suffix:
- if(libname && !regexec(&res->version_re, libname, 1, &match, 0)) {
+ if (libname && not regexec(&res->version_re, libname, 1, &match, 0)) {
char* temp = libname;
libname = strndup(temp, match.rm_so);
free(temp);
static const void* zero_buffer;
static const size_t zero_buffer_size = 10 * 4096;
-static void zero_buffer_init(void)
+static void zero_buffer_init()
{
int fd = open("/dev/zero", O_RDONLY);
if (fd<0)
// Read std_heap (is a struct mdesc*):
simgrid::mc::Variable* std_heap_var = this->find_variable("__mmalloc_default_mdp");
- if (!std_heap_var)
+ if (not std_heap_var)
xbt_die("No heap information in the target process");
- if(!std_heap_var->address)
+ if (not std_heap_var->address)
xbt_die("No constant address for this variable");
this->read_bytes(&this->heap_address, sizeof(struct mdesc*),
remote(std_heap_var->address),
close(this->memory_file);
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);
+ if (this->unw_underlying_addr_space)
+ unw_destroy_addr_space(this->unw_underlying_addr_space);
+ if (this->unw_underlying_context)
+ _UPT_destroy(this->unw_underlying_context);
}
unw_destroy_addr_space(this->unw_addr_space);
void Process::refresh_heap()
{
// Read/dereference/refresh the std_heap pointer:
- if (!this->heap)
+ if (not 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);
// [stack], [vvar], [vsyscall], [vdso] ...
if (pathname[0] == '[') {
- if ((reg.prot & PROT_WRITE) && !memcmp(pathname, "[stack]", 7)) {
+ if ((reg.prot & PROT_WRITE) && not memcmp(pathname, "[stack]", 7)) {
this->maestro_stack_start_ = remote(reg.start_addr);
this->maestro_stack_end_ = remote(reg.end_addr);
}
continue;
current_name = pathname;
- if (!(reg.prot & PROT_READ) && (reg.prot & PROT_EXEC))
+ if (not(reg.prot & PROT_READ) && (reg.prot & PROT_EXEC))
continue;
- const bool is_executable = !i;
+ const bool is_executable = not i;
char* libname = nullptr;
- if (!is_executable) {
+ if (not is_executable) {
libname = get_lib_name(pathname, &res);
- if(!libname)
+ if (not libname)
continue;
if (is_filtered_lib(libname)) {
free(libname);
std::string Process::read_string(RemotePtr<char> address) const
{
- if (!address)
+ if (not address)
return {};
// TODO, use std::vector with .data() in C++17 to avoid useless copies
if (process_index >= (int) MC_smpi_process_count())
xbt_die("Invalid process index");
- // Read smpi_privatisation_regions from MCed:
- smpi_privatisation_region_t remote_smpi_privatisation_regions =
- mc_model_checker->process().read_variable<smpi_privatisation_region_t>(
- "smpi_privatisation_regions");
+ // Read smpi_privatization_regions from MCed:
+ smpi_privatization_region_t remote_smpi_privatization_regions =
+ mc_model_checker->process().read_variable<smpi_privatization_region_t>(
+ "smpi_privatization_regions");
- s_smpi_privatisation_region_t privatisation_region =
- mc_model_checker->process().read<s_smpi_privatisation_region_t>(
- remote(remote_smpi_privatisation_regions + process_index));
+ s_smpi_privatization_region_t privatization_region =
+ mc_model_checker->process().read<s_smpi_privatization_region_t>(
+ remote(remote_smpi_privatization_regions + process_index));
// Address translation in the privatization segment:
size_t offset = address.address() - (std::uint64_t)info->start_rw;
- address = remote((char*)privatisation_region.address + offset);
+ address = remote((char*)privatization_region.address + offset);
}
#endif
}
-
- if (pread_whole(this->memory_file, buffer, size, (off_t) address.address()) < 0)
+ if (pread_whole(this->memory_file, buffer, size, (size_t) address.address()) < 0)
xbt_die("Read at %p from process %lli failed", (void*)address.address(), (long long)this->pid_);
return buffer;
}
*/
void Process::write_bytes(const void* buffer, size_t len, RemotePtr<void> address)
{
- if (pwrite_whole(this->memory_file, buffer, len, address.address()) < 0)
+ if (pwrite_whole(this->memory_file, buffer, len, (size_t)address.address()) < 0)
xbt_die("Write to process %lli failed", (long long) this->pid_);
}