src/mc/remote/RemoteClient.cpp

   1 /* Copyright (c) 2014-2018. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #define _FILE_OFFSET_BITS 64 /* needed for pread_whole to work as expected on 32bits */
   7
   8 #include <algorithm>
   9 #include <cassert>
  10 #include <cerrno>
  11 #include <cstddef>
  12 #include <cstdint>
  13 #include <string>
  14 #include <vector>
  15
  16 #include <sys/ptrace.h>
  17
  18 #include <cstdio>
  19
  20 #include <fcntl.h>
  21 #include <sys/mman.h> // PROT_*
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24
  25 #include <pthread.h>
  26
  27 #include <libgen.h>
  28
  29 #include <libunwind-ptrace.h>
  30 #include <libunwind.h>
  31
  32 #include "xbt/base.h"
  33 #include "xbt/file.hpp"
  34 #include "xbt/log.h"
  35 #include <xbt/mmalloc.h>
  36
  37 #include "src/mc/mc_smx.hpp"
  38 #include "src/mc/mc_unw.hpp"
  39 #include "src/mc/sosp/mc_snapshot.hpp"
  40
  41 #include "src/mc/AddressSpace.hpp"
  42 #include "src/mc/ObjectInformation.hpp"
  43 #include "src/mc/Variable.hpp"
  44 #include "src/mc/remote/RemoteClient.hpp"
  45
  46 using simgrid::mc::remote;
  47
  48 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_process, mc, "MC process information");
  49
  50 namespace simgrid {
  51 namespace mc {
  52
  53 // ***** Helper stuff
  54
  55 // List of library which memory segments are not considered:
  56 static const std::vector<std::string> filtered_libraries = {
  57 #ifdef __linux__
  58     "ld",
  59 #elif defined __FreeBSD__
  60     "ld-elf",
  61     "ld-elf32",
  62     "libkvm",      /* kernel data access library */
  63     "libprocstat", /* process and file information retrieval */
  64     "libthr",      /* thread library */
  65     "libutil",
  66 #endif
  67     "libasan", /* gcc sanitizers */
  68     "libargp", /* workarounds for glibc-less systems */
  69     "libtsan",
  70     "libubsan",
  71     "libbz2",
  72     "libboost_chrono",
  73     "libboost_context",
  74     "libboost_context-mt",
  75     "libboost_system",
  76     "libboost_thread",
  77     "libc",
  78     "libc++",
  79     "libcdt",
  80     "libcgraph",
  81     "libcrypto",
  82     "libcxxrt",
  83     "libdl",
  84     "libdw",
  85     "libelf",
  86     "libevent",
  87     "libgcc_s",
  88     "libimf",
  89     "libintlc",
  90     "libirng",
  91     "liblua5.1",
  92     "liblua5.3",
  93     "liblzma",
  94     "libm",
  95     "libpthread",
  96     "librt",
  97     "libstdc++",
  98     "libsvml",
  99     "libunwind",
 100     "libunwind-x86_64",
 101     "libunwind-x86",
 102     "libunwind-ptrace",
 103     "libz"};
 104
 105 static bool is_simgrid_lib(const std::string& libname)
 106 {
 107   return libname == "libsimgrid";
 108 }
 109
 110 static bool is_filtered_lib(const std::string& libname)
 111 {
 112   return std::find(begin(filtered_libraries), end(filtered_libraries), libname) != end(filtered_libraries);
 113 }
 114
 115 static std::string get_lib_name(const std::string& pathname)
 116 {
 117   std::string map_basename = simgrid::xbt::Path(pathname).get_base_name();
 118   std::string libname;
 119
 120   size_t pos = map_basename.rfind(".so");
 121   if (pos != std::string::npos) {
 122     // strip the extension (matching regex "\.so.*$")
 123     libname.assign(map_basename, 0, pos);
 124
 125     // strip the version suffix (matching regex "-[.0-9-]*$")
 126     while (true) {
 127       pos = libname.rfind('-');
 128       if (pos == std::string::npos || libname.find_first_not_of(".0123456789", pos + 1) != std::string::npos)
 129         break;
 130       libname.erase(pos);
 131     }
 132   }
 133
 134   return libname;
 135 }
 136
 137 static ssize_t pread_whole(int fd, void* buf, size_t count, off_t offset)
 138 {
 139   char* buffer       = (char*)buf;
 140   ssize_t real_count = count;
 141   while (count) {
 142     ssize_t res = pread(fd, buffer, count, offset);
 143     if (res > 0) {
 144       count -= res;
 145       buffer += res;
 146       offset += res;
 147     } else if (res == 0)
 148       return -1;
 149     else if (errno != EINTR) {
 150       perror("pread_whole");
 151       return -1;
 152     }
 153   }
 154   return real_count;
 155 }
 156
 157 static ssize_t pwrite_whole(int fd, const void* buf, size_t count, off_t offset)
 158 {
 159   const char* buffer = (const char*)buf;
 160   ssize_t real_count = count;
 161   while (count) {
 162     ssize_t res = pwrite(fd, buffer, count, offset);
 163     if (res > 0) {
 164       count -= res;
 165       buffer += res;
 166       offset += res;
 167     } else if (res == 0)
 168       return -1;
 169     else if (errno != EINTR)
 170       return -1;
 171   }
 172   return real_count;
 173 }
 174
 175 static pthread_once_t zero_buffer_flag = PTHREAD_ONCE_INIT;
 176 static const void* zero_buffer;
 177 static const size_t zero_buffer_size = 10 * 4096;
 178
 179 static void zero_buffer_init()
 180 {
 181   int fd = open("/dev/zero", O_RDONLY);
 182   if (fd < 0)
 183     xbt_die("Could not open /dev/zero");
 184   zero_buffer = mmap(nullptr, zero_buffer_size, PROT_READ, MAP_SHARED, fd, 0);
 185   if (zero_buffer == MAP_FAILED)
 186     xbt_die("Could not map the zero buffer");
 187   close(fd);
 188 }
 189
 190 int open_vm(pid_t pid, int flags)
 191 {
 192   const size_t buffer_size = 30;
 193   char buffer[buffer_size];
 194   int res = snprintf(buffer, buffer_size, "/proc/%lli/mem", (long long)pid);
 195   if (res < 0 || (size_t)res >= buffer_size) {
 196     errno = ENAMETOOLONG;
 197     return -1;
 198   }
 199   return open(buffer, flags);
 200 }
 201
 202 // ***** Process
 203
 204 RemoteClient::RemoteClient(pid_t pid, int sockfd) : AddressSpace(this), pid_(pid), channel_(sockfd), running_(true)
 205 {
 206 }
 207
 208 void RemoteClient::init()
 209 {
 210   this->memory_map_ = simgrid::xbt::get_memory_map(this->pid_);
 211   this->init_memory_map_info();
 212
 213   int fd = open_vm(this->pid_, O_RDWR);
 214   if (fd < 0)
 215     xbt_die("Could not open file for process virtual address space");
 216   this->memory_file = fd;
 217
 218   // Read std_heap (is a struct mdesc*):
 219   simgrid::mc::Variable* std_heap_var = this->find_variable("__mmalloc_default_mdp");
 220   if (not std_heap_var)
 221     xbt_die("No heap information in the target process");
 222   if (not std_heap_var->address)
 223     xbt_die("No constant address for this variable");
 224   this->read_bytes(&this->heap_address, sizeof(mdesc*), remote(std_heap_var->address),
 225                    simgrid::mc::ProcessIndexDisabled);
 226
 227   this->smx_actors_infos.clear();
 228   this->smx_dead_actors_infos.clear();
 229   this->unw_addr_space            = simgrid::mc::UnwindContext::createUnwindAddressSpace();
 230   this->unw_underlying_addr_space = simgrid::unw::create_addr_space();
 231   this->unw_underlying_context    = simgrid::unw::create_context(this->unw_underlying_addr_space, this->pid_);
 232 }
 233
 234 RemoteClient::~RemoteClient()
 235 {
 236   if (this->memory_file >= 0)
 237     close(this->memory_file);
 238
 239   if (this->unw_underlying_addr_space != unw_local_addr_space) {
 240     if (this->unw_underlying_addr_space)
 241       unw_destroy_addr_space(this->unw_underlying_addr_space);
 242     if (this->unw_underlying_context)
 243       _UPT_destroy(this->unw_underlying_context);
 244   }
 245
 246   unw_destroy_addr_space(this->unw_addr_space);
 247 }
 248
 249 /** Refresh the information about the process
 250  *
 251  *  Do not use directly, this is used by the getters when appropriate
 252  *  in order to have fresh data.
 253  */
 254 void RemoteClient::refresh_heap()
 255 {
 256   // Read/dereference/refresh the std_heap pointer:
 257   if (not this->heap)
 258     this->heap = std::unique_ptr<s_xbt_mheap_t>(new s_xbt_mheap_t());
 259   this->read_bytes(this->heap.get(), sizeof(mdesc), remote(this->heap_address), simgrid::mc::ProcessIndexDisabled);
 260   this->cache_flags_ |= RemoteClient::cache_heap;
 261 }
 262
 263 /** Refresh the information about the process
 264  *
 265  *  Do not use direclty, this is used by the getters when appropriate
 266  *  in order to have fresh data.
 267  * */
 268 void RemoteClient::refresh_malloc_info()
 269 {
 270   // Refresh process->heapinfo:
 271   if (this->cache_flags_ & RemoteClient::cache_malloc)
 272     return;
 273   size_t count = this->heap->heaplimit + 1;
 274   if (this->heap_info.size() < count)
 275     this->heap_info.resize(count);
 276   this->read_bytes(this->heap_info.data(), count * sizeof(malloc_info), remote(this->heap->heapinfo),
 277                    simgrid::mc::ProcessIndexDisabled);
 278   this->cache_flags_ |= RemoteClient::cache_malloc;
 279 }
 280
 281 /** @brief Finds the range of the different memory segments and binary paths */
 282 void RemoteClient::init_memory_map_info()
 283 {
 284   XBT_DEBUG("Get debug information ...");
 285   this->maestro_stack_start_ = nullptr;
 286   this->maestro_stack_end_   = nullptr;
 287   this->object_infos.resize(0);
 288   this->binary_info     = nullptr;
 289   this->libsimgrid_info = nullptr;
 290
 291   std::vector<simgrid::xbt::VmMap> const& maps = this->memory_map_;
 292
 293   const char* current_name = nullptr;
 294
 295   this->object_infos.clear();
 296
 297   for (size_t i = 0; i < maps.size(); i++) {
 298     simgrid::xbt::VmMap const& reg = maps[i];
 299     const char* pathname           = maps[i].pathname.c_str();
 300
 301     // Nothing to do
 302     if (maps[i].pathname.empty()) {
 303       current_name = nullptr;
 304       continue;
 305     }
 306
 307     // [stack], [vvar], [vsyscall], [vdso] ...
 308     if (pathname[0] == '[') {
 309       if ((reg.prot & PROT_WRITE) && not memcmp(pathname, "[stack]", 7)) {
 310         this->maestro_stack_start_ = remote(reg.start_addr);
 311         this->maestro_stack_end_   = remote(reg.end_addr);
 312       }
 313       current_name = nullptr;
 314       continue;
 315     }
 316
 317     if (current_name && strcmp(current_name, pathname) == 0)
 318       continue;
 319
 320     current_name = pathname;
 321     if (not(reg.prot & PROT_READ) && (reg.prot & PROT_EXEC))
 322       continue;
 323
 324     const bool is_executable = not i;
 325     std::string libname;
 326     if (not is_executable) {
 327       libname = get_lib_name(pathname);
 328       if (is_filtered_lib(libname)) {
 329         continue;
 330       }
 331     }
 332
 333     std::shared_ptr<simgrid::mc::ObjectInformation> info =
 334         simgrid::mc::createObjectInformation(this->memory_map_, pathname);
 335     this->object_infos.push_back(info);
 336     if (is_executable)
 337       this->binary_info = info;
 338     else if (is_simgrid_lib(libname))
 339       this->libsimgrid_info = info;
 340   }
 341
 342   // Resolve time (including across different objects):
 343   for (auto const& object_info : this->object_infos)
 344     postProcessObjectInformation(this, object_info.get());
 345
 346   xbt_assert(this->maestro_stack_start_, "Did not find maestro_stack_start");
 347   xbt_assert(this->maestro_stack_end_, "Did not find maestro_stack_end");
 348
 349   XBT_DEBUG("Get debug information done !");
 350 }
 351
 352 std::shared_ptr<simgrid::mc::ObjectInformation> RemoteClient::find_object_info(RemotePtr<void> addr) const
 353 {
 354   for (auto const& object_info : this->object_infos)
 355     if (addr.address() >= (std::uint64_t)object_info->start && addr.address() <= (std::uint64_t)object_info->end)
 356       return object_info;
 357   return nullptr;
 358 }
 359
 360 std::shared_ptr<ObjectInformation> RemoteClient::find_object_info_exec(RemotePtr<void> addr) const
 361 {
 362   for (std::shared_ptr<ObjectInformation> const& info : this->object_infos)
 363     if (addr.address() >= (std::uint64_t)info->start_exec && addr.address() <= (std::uint64_t)info->end_exec)
 364       return info;
 365   return nullptr;
 366 }
 367
 368 std::shared_ptr<ObjectInformation> RemoteClient::find_object_info_rw(RemotePtr<void> addr) const
 369 {
 370   for (std::shared_ptr<ObjectInformation> const& info : this->object_infos)
 371     if (addr.address() >= (std::uint64_t)info->start_rw && addr.address() <= (std::uint64_t)info->end_rw)
 372       return info;
 373   return nullptr;
 374 }
 375
 376 simgrid::mc::Frame* RemoteClient::find_function(RemotePtr<void> ip) const
 377 {
 378   std::shared_ptr<simgrid::mc::ObjectInformation> info = this->find_object_info_exec(ip);
 379   return info ? info->find_function((void*)ip.address()) : nullptr;
 380 }
 381
 382 /** Find (one occurrence of) the named variable definition
 383  */
 384 simgrid::mc::Variable* RemoteClient::find_variable(const char* name) const
 385 {
 386   // First lookup the variable in the executable shared object.
 387   // A global variable used directly by the executable code from a library
 388   // is reinstanciated in the executable memory .data/.bss.
 389   // We need to look up the variable in the executable first.
 390   if (this->binary_info) {
 391     std::shared_ptr<simgrid::mc::ObjectInformation> const& info = this->binary_info;
 392     simgrid::mc::Variable* var                                  = info->find_variable(name);
 393     if (var)
 394       return var;
 395   }
 396
 397   for (std::shared_ptr<simgrid::mc::ObjectInformation> const& info : this->object_infos) {
 398     simgrid::mc::Variable* var = info->find_variable(name);
 399     if (var)
 400       return var;
 401   }
 402
 403   return nullptr;
 404 }
 405
 406 void RemoteClient::read_variable(const char* name, void* target, size_t size) const
 407 {
 408   simgrid::mc::Variable* var = this->find_variable(name);
 409   xbt_assert(var->address, "No simple location for this variable");
 410   xbt_assert(var->type->full_type, "Partial type for %s, cannot check size", name);
 411   xbt_assert((size_t)var->type->full_type->byte_size == size, "Unexpected size for %s (expected %zu, was %zu)", name,
 412              size, (size_t)var->type->full_type->byte_size);
 413   this->read_bytes(target, size, remote(var->address));
 414 }
 415
 416 std::string RemoteClient::read_string(RemotePtr<char> address) const
 417 {
 418   if (not address)
 419     return {};
 420
 421   std::vector<char> res(128);
 422   off_t off = 0;
 423
 424   while (1) {
 425     ssize_t c = pread(this->memory_file, res.data() + off, res.size() - off, (off_t)address.address() + off);
 426     if (c == -1) {
 427       if (errno == EINTR)
 428         continue;
 429       else
 430         xbt_die("Could not read from from remote process");
 431     }
 432     if (c == 0)
 433       xbt_die("Could not read string from remote process");
 434
 435     void* p = memchr(res.data() + off, '\0', c);
 436     if (p)
 437       return std::string(res.data());
 438
 439     off += c;
 440     if (off == (off_t)res.size())
 441       res.resize(res.size() * 2);
 442   }
 443 }
 444
 445 const void* RemoteClient::read_bytes(void* buffer, std::size_t size, RemotePtr<void> address, int process_index,
 446                                      ReadOptions options) const
 447 {
 448   if (process_index != simgrid::mc::ProcessIndexDisabled) {
 449     std::shared_ptr<simgrid::mc::ObjectInformation> const& info = this->find_object_info_rw(address);
 450 // Segment overlap is not handled.
 451 #if HAVE_SMPI
 452     if (info.get() && this->privatized(*info)) {
 453       if (process_index < 0)
 454         xbt_die("Missing process index");
 455       if (process_index >= (int)MC_smpi_process_count())
 456         xbt_die("Invalid process index");
 457
 458       // Read smpi_privatization_regions from MCed:
 459       smpi_privatization_region_t remote_smpi_privatization_regions =
 460           mc_model_checker->process().read_variable<smpi_privatization_region_t>("smpi_privatization_regions");
 461
 462       s_smpi_privatization_region_t privatization_region =
 463           mc_model_checker->process().read<s_smpi_privatization_region_t>(
 464               remote(remote_smpi_privatization_regions + process_index));
 465
 466       // Address translation in the privatization segment:
 467       size_t offset = address.address() - (std::uint64_t)info->start_rw;
 468       address       = remote((char*)privatization_region.address + offset);
 469     }
 470 #endif
 471   }
 472   if (pread_whole(this->memory_file, buffer, size, (size_t)address.address()) < 0)
 473     xbt_die("Read at %p from process %lli failed", (void*)address.address(), (long long)this->pid_);
 474   return buffer;
 475 }
 476
 477 /** Write data to a process memory
 478  *
 479  *  @param buffer   local memory address (source)
 480  *  @param len      data size
 481  *  @param address  target process memory address (target)
 482  */
 483 void RemoteClient::write_bytes(const void* buffer, size_t len, RemotePtr<void> address)
 484 {
 485   if (pwrite_whole(this->memory_file, buffer, len, (size_t)address.address()) < 0)
 486     xbt_die("Write to process %lli failed", (long long)this->pid_);
 487 }
 488
 489 void RemoteClient::clear_bytes(RemotePtr<void> address, size_t len)
 490 {
 491   pthread_once(&zero_buffer_flag, zero_buffer_init);
 492   while (len) {
 493     size_t s = len > zero_buffer_size ? zero_buffer_size : len;
 494     this->write_bytes(zero_buffer, s, address);
 495     address = remote((char*)address.address() + s);
 496     len -= s;
 497   }
 498 }
 499
 500 void RemoteClient::ignore_region(std::uint64_t addr, std::size_t size)
 501 {
 502   IgnoredRegion region;
 503   region.addr = addr;
 504   region.size = size;
 505
 506   if (ignored_regions_.empty()) {
 507     ignored_regions_.push_back(region);
 508     return;
 509   }
 510
 511   unsigned int cursor           = 0;
 512   IgnoredRegion* current_region = nullptr;
 513
 514   int start = 0;
 515   int end   = ignored_regions_.size() - 1;
 516   while (start <= end) {
 517     cursor         = (start + end) / 2;
 518     current_region = &ignored_regions_[cursor];
 519     if (current_region->addr == addr) {
 520       if (current_region->size == size)
 521         return;
 522       else if (current_region->size < size)
 523         start = cursor + 1;
 524       else
 525         end = cursor - 1;
 526     } else if (current_region->addr < addr)
 527       start = cursor + 1;
 528     else
 529       end = cursor - 1;
 530   }
 531
 532   std::size_t position;
 533   if (current_region->addr == addr) {
 534     if (current_region->size < size)
 535       position = cursor + 1;
 536     else
 537       position = cursor;
 538   } else if (current_region->addr < addr)
 539     position = cursor + 1;
 540   else
 541     position = cursor;
 542   ignored_regions_.insert(ignored_regions_.begin() + position, region);
 543 }
 544
 545 void RemoteClient::ignore_heap(IgnoredHeapRegion const& region)
 546 {
 547   if (ignored_heap_.empty()) {
 548     ignored_heap_.push_back(std::move(region));
 549     return;
 550   }
 551
 552   typedef std::vector<IgnoredHeapRegion>::size_type size_type;
 553
 554   size_type start = 0;
 555   size_type end   = ignored_heap_.size() - 1;
 556
 557   // Binary search the position of insertion:
 558   size_type cursor;
 559   while (start <= end) {
 560     cursor               = start + (end - start) / 2;
 561     auto& current_region = ignored_heap_[cursor];
 562     if (current_region.address == region.address)
 563       return;
 564     else if (current_region.address < region.address)
 565       start = cursor + 1;
 566     else if (cursor != 0)
 567       end = cursor - 1;
 568     // Avoid underflow:
 569     else
 570       break;
 571   }
 572
 573   // Insert it mc_heap_ignore_region_t:
 574   if (ignored_heap_[cursor].address < region.address)
 575     ++cursor;
 576   ignored_heap_.insert(ignored_heap_.begin() + cursor, region);
 577 }
 578
 579 void RemoteClient::unignore_heap(void* address, size_t size)
 580 {
 581   typedef std::vector<IgnoredHeapRegion>::size_type size_type;
 582
 583   size_type start = 0;
 584   size_type end   = ignored_heap_.size() - 1;
 585
 586   // Binary search:
 587   size_type cursor;
 588   while (start <= end) {
 589     cursor       = (start + end) / 2;
 590     auto& region = ignored_heap_[cursor];
 591     if (region.address < address)
 592       start = cursor + 1;
 593     else if ((char*)region.address <= ((char*)address + size)) {
 594       ignored_heap_.erase(ignored_heap_.begin() + cursor);
 595       return;
 596     } else if (cursor != 0)
 597       end = cursor - 1;
 598     // Avoid underflow:
 599     else
 600       break;
 601   }
 602 }
 603
 604 void RemoteClient::ignore_local_variable(const char* var_name, const char* frame_name)
 605 {
 606   if (frame_name != nullptr && strcmp(frame_name, "*") == 0)
 607     frame_name = nullptr;
 608   for (std::shared_ptr<simgrid::mc::ObjectInformation> const& info : this->object_infos)
 609     info->remove_local_variable(var_name, frame_name);
 610 }
 611
 612 std::vector<simgrid::mc::ActorInformation>& RemoteClient::actors()
 613 {
 614   this->refresh_simix();
 615   return smx_actors_infos;
 616 }
 617
 618 std::vector<simgrid::mc::ActorInformation>& RemoteClient::dead_actors()
 619 {
 620   this->refresh_simix();
 621   return smx_dead_actors_infos;
 622 }
 623
 624 void RemoteClient::dumpStack()
 625 {
 626   unw_addr_space_t as = unw_create_addr_space(&_UPT_accessors, BYTE_ORDER);
 627   if (as == nullptr) {
 628     XBT_ERROR("Could not initialize ptrace address space");
 629     return;
 630   }
 631
 632   void* context = _UPT_create(this->pid_);
 633   if (context == nullptr) {
 634     unw_destroy_addr_space(as);
 635     XBT_ERROR("Could not initialize ptrace context");
 636     return;
 637   }
 638
 639   unw_cursor_t cursor;
 640   if (unw_init_remote(&cursor, as, context) != 0) {
 641     _UPT_destroy(context);
 642     unw_destroy_addr_space(as);
 643     XBT_ERROR("Could not initialiez ptrace cursor");
 644     return;
 645   }
 646
 647   simgrid::mc::dumpStack(stderr, cursor);
 648
 649   _UPT_destroy(context);
 650   unw_destroy_addr_space(as);
 651 }
 652
 653 bool RemoteClient::actor_is_enabled(aid_t pid)
 654 {
 655   s_mc_message_actor_enabled_t msg{MC_MESSAGE_ACTOR_ENABLED, pid};
 656   process()->getChannel().send(msg);
 657   char buff[MC_MESSAGE_LENGTH];
 658   ssize_t received = process()->getChannel().receive(buff, MC_MESSAGE_LENGTH, true);
 659   xbt_assert(received == sizeof(s_mc_message_int_t), "Unexpected size in answer to ACTOR_ENABLED");
 660   return ((s_mc_message_int_t*)buff)->value;
 661 }
 662 }
 663 }