#define SO_RE "\\.so[\\.0-9]*$"
#define VERSION_RE "-[\\.0-9-]*$"
-// In lexicographic order (but this is currently not used in the code):
+// List of library which memory segments are not considered:
static const char *const filtered_libraries[] = {
"ld",
+ "libasan", /* gcc sanitizers */
+ "libtsan",
+ "libubsan",
"libbz2",
"libboost_chrono",
"libboost_context",
"libm",
"libpthread",
"librt",
- "libsigc",
"libstdc++",
"libunwind",
"libunwind-x86_64",
close(fd);
}
-static
-int open_process_file(pid_t pid, const char* file, int flags)
-{
- char buff[50];
- snprintf(buff, sizeof(buff), "/proc/%li/%s", (long) pid, file);
- return open(buff, flags);
-}
-
int open_vm(pid_t pid, int flags)
{
const size_t buffer_size = 30;
}
unw_destroy_addr_space(this->unw_addr_space);
-
- 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
*
- * Do not use direclty, this is used by the getters when appropriate
+ * Do not use directly, this is used by the getters when appropriate
* in order to have fresh data.
*/
void Process::refresh_heap()
regfree(&res.so_re);
regfree(&res.version_re);
- // Resolve time (including accross differents objects):
+ // Resolve time (including across different objects):
for (auto const& object_info : this->object_infos)
postProcessObjectInformation(this, object_info.get());
return info ? info->find_function((void*) ip.address()) : nullptr;
}
-/** Find (one occurence of) the named variable definition
+/** Find (one occurrence of) the named variable definition
*/
simgrid::mc::Variable* Process::find_variable(const char* name) const
{
// First lookup the variable in the executable shared object.
// A global variable used directly by the executable code from a library
// is reinstanciated in the executable memory .data/.bss.
- // We need to look up the variable in the execvutable first.
+ // We need to look up the variable in the executable first.
if (this->binary_info) {
std::shared_ptr<simgrid::mc::ObjectInformation> const& info = this->binary_info;
simgrid::mc::Variable* var = info->find_variable(name);
this->read_bytes(target, size, remote(var->address));
}
-char* Process::read_string(RemotePtr<void> address) const
+std::string Process::read_string(RemotePtr<char> address) const
{
if (!address)
- return nullptr;
+ return {};
- off_t len = 128;
- char* res = (char*) malloc(len);
+ // TODO, use std::vector with .data() in C++17 to avoid useless copies
+ std::vector<char> res(128);
off_t off = 0;
while (1) {
- ssize_t c = pread(this->memory_file, res + off, len - off, (off_t) address.address() + off);
+ ssize_t c = pread(this->memory_file, res.data() + off, res.size() - off, (off_t) address.address() + off);
if (c == -1) {
if (errno == EINTR)
continue;
if (c==0)
xbt_die("Could not read string from remote process");
- void* p = memchr(res + off, '\0', c);
+ void* p = memchr(res.data() + off, '\0', c);
if (p)
- return res;
+ return std::string(res.data());
off += c;
- if (off == len) {
- len *= 2;
- res = (char*) realloc(res, len);
- }
+ if (off == (off_t) res.size())
+ res.resize(res.size() * 2);
}
}
mc_model_checker->process().read<s_smpi_privatisation_region_t>(
remote(remote_smpi_privatisation_regions + process_index));
- // Address translation in the privaization segment:
+ // Address translation in the privatization segment:
size_t offset = address.address() - (std::uint64_t)info->start_rw;
address = remote((char*)privatisation_region.address + offset);
}
ignored_regions_.begin() + position, region);
}
-void Process::reset_soft_dirty()
-{
- if (this->clear_refs_fd_ < 0) {
- this->clear_refs_fd_ = open_process_file(pid_, "clear_refs", O_WRONLY|O_CLOEXEC);
- if (this->clear_refs_fd_ < 0)
- xbt_die("Could not open clear_refs file for soft-dirty tracking. Run as root?");
- }
- if(::write(this->clear_refs_fd_, "4\n", 2) != 2)
- xbt_die("Could not reset softdirty bits");
-}
-
-void Process::read_pagemap(uint64_t* pagemap, size_t page_start, size_t page_count)
-{
- if (pagemap_fd_ < 0) {
- pagemap_fd_ = open_process_file(pid_, "pagemap", O_RDONLY|O_CLOEXEC);
- if (pagemap_fd_ < 0)
- xbt_die("Could not open pagemap file for soft-dirty tracking. Run as root?");
- }
- ssize_t bytesize = sizeof(uint64_t) * page_count;
- off_t offset = sizeof(uint64_t) * page_start;
- if (pread_whole(pagemap_fd_, pagemap, bytesize, offset) != bytesize)
- xbt_die("Could not read pagemap");
-}
-
void Process::ignore_heap(IgnoredHeapRegion const& region)
{
if (ignored_heap_.empty()) {