src/mc/Process.cpp

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