X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fd769219531a772284d75320187a0ef9f8118afd..7097365f75e89b3b266987b2ec70b9dbc82bfded:/src/mc/Process.hpp diff --git a/src/mc/Process.hpp b/src/mc/Process.hpp index cd090fcdc2..07f510c931 100644 --- a/src/mc/Process.hpp +++ b/src/mc/Process.hpp @@ -13,18 +13,19 @@ #include #include #include +#include #include #include #include -#include #include -#if HAVE_MC #include "src/xbt/mmalloc/mmprivate.h" -#endif + +#include "src/mc/remote/Channel.hpp" +#include "src/mc/remote/RemotePtr.hpp" #include #include "src/simix/popping_private.h" @@ -32,31 +33,21 @@ #include "src/xbt/memory_map.hpp" -#include "src/mc/mc_forward.hpp" -#include "src/mc/mc_base.h" #include "src/mc/AddressSpace.hpp" -#include "src/mc/mc_protocol.h" #include "src/mc/ObjectInformation.hpp" - -// Those flags are used to track down which cached information -// is still up to date and which information needs to be updated. -typedef int mc_process_cache_flags_t; -#define MC_PROCESS_CACHE_FLAG_NONE 0 -#define MC_PROCESS_CACHE_FLAG_HEAP 1 -#define MC_PROCESS_CACHE_FLAG_MALLOC_INFO 2 -#define MC_PROCESS_CACHE_FLAG_SIMIX_PROCESSES 4 +#include "src/mc/mc_base.h" +#include "src/mc/mc_forward.hpp" +#include "src/mc/remote/mc_protocol.h" namespace simgrid { namespace mc { -class SimixProcessInformation { +class ActorInformation { public: /** MCed address of the process */ - void* address = nullptr; - union { - /** (Flat) Copy of the process data structure */ - struct s_smx_process copy; - }; + RemotePtr address = nullptr; + Remote copy; + /** Hostname (owned by `mc_modelchecker->hostnames`) */ const char* hostname = nullptr; std::string name; @@ -82,8 +73,28 @@ struct IgnoredHeapRegion { }; /** Representation of a process + * + * This class is mixing a lot of different responsibilities and is tied + * to SIMIX. It should probably be split into different classes. + * + * Responsibilities: + * + * - reading from the process memory (`AddressSpace`); + * - accessing the system state of the process (heap, …); + * - storing the SIMIX state of the process; + * - privatization; + * - communication with the model-checked process; + * - stack unwinding; + * - etc. */ class Process final : public AddressSpace { +private: + // Those flags are used to track down which cached information + // is still up to date and which information needs to be updated. + static constexpr int cache_none = 0; + static constexpr int cache_heap = 1; + static constexpr int cache_malloc = 2; + static constexpr int cache_simix_processes = 4; public: Process(pid_t pid, int sockfd); ~Process(); @@ -98,16 +109,25 @@ public: const void* read_bytes(void* buffer, std::size_t size, RemotePtr address, int process_index = ProcessIndexAny, ReadOptions options = ReadOptions::none()) const override; + void read_variable(const char* name, void* target, size_t size) const; + template void read_variable(const char* name, T* target) const + { + read_variable(name, target, sizeof(*target)); + } template - T read_variable(const char *name) const + Remote read_variable(const char *name) const { - static_assert(std::is_trivial::value, "Cannot read a non-trivial type"); - T res; - read_variable(name, &res, sizeof(T)); + Remote res; + read_variable(name, res.getBuffer(), sizeof(T)); return res; } - char* read_string(RemotePtr address) const; + + std::string read_string(RemotePtr address) const; + std::string read_string(RemotePtr address, std::size_t len) const + { + return AddressSpace::read_string(address, len); + } // Write memory: void write_bytes(const void* buffer, size_t len, RemotePtr address); @@ -123,16 +143,24 @@ public: // Heap access: xbt_mheap_t get_heap() { - if (!(this->cache_flags & MC_PROCESS_CACHE_FLAG_HEAP)) + if (!(this->cache_flags_ & Process::cache_heap)) this->refresh_heap(); return this->heap.get(); } - malloc_info* get_malloc_info() + const malloc_info* get_malloc_info() { - if (!(this->cache_flags & MC_PROCESS_CACHE_FLAG_MALLOC_INFO)) + if (!(this->cache_flags_ & Process::cache_malloc)) this->refresh_malloc_info(); return this->heap_info.data(); } + + void clear_cache() + { + this->cache_flags_ = Process::cache_none; + } + + Channel const& getChannel() const { return channel_; } + Channel& getChannel() { return channel_; } std::vector const& ignored_regions() const { @@ -157,28 +185,6 @@ public: running_ = false; } - template - typename std::enable_if< std::is_class::value && std::is_trivial::value, int >::type - send_message(M const& m) - { - return MC_protocol_send(this->socket_, &m, sizeof(M)); - } - - int send_message(e_mc_message_type message_id) - { - return MC_protocol_send_simple_message(this->socket_, message_id); - } - - template - typename std::enable_if< std::is_class::value && std::is_trivial::value, ssize_t >::type - receive_message(M& m) - { - return MC_receive_message(this->socket_, &m, sizeof(M), 0); - } - - void reset_soft_dirty(); - void read_pagemap(uint64_t* pagemap, size_t start_page, size_t page_count); - bool privatized(ObjectInformation const& info) const { return privatized_ && info.executable(); @@ -213,24 +219,51 @@ public: void unignore_heap(void *address, size_t size); void ignore_local_variable(const char *var_name, const char *frame_name); - int socket() { return socket_; } - std::vector& simix_processes(); + std::vector& actors(); + std::vector& dead_actors(); + + /** Get a local description of a remote SIMIX actor */ + simgrid::mc::ActorInformation* resolveActorInfo(simgrid::mc::RemotePtr actor) + { + xbt_assert(mc_model_checker != nullptr); + if (!actor) + return nullptr; + this->refresh_simix(); + for (auto& actor_info : this->smx_actors_infos) + if (actor_info.address == actor) + return &actor_info; + for (auto& actor_info : this->smx_dead_actors_infos) + if (actor_info.address == actor) + return &actor_info; + return nullptr; + } + + /** Get a local copy of the SIMIX actor structure */ + simgrid::simix::ActorImpl* resolveActor(simgrid::mc::RemotePtr process) + { + simgrid::mc::ActorInformation* actor_info = this->resolveActorInfo(process); + if (actor_info) + return actor_info->copy.getBuffer(); + else + return nullptr; + } + + void dumpStack(); private: void init_memory_map_info(); void refresh_heap(); void refresh_malloc_info(); + void refresh_simix(); private: pid_t pid_ = -1; - int socket_ = -1; + Channel channel_; bool running_ = false; std::vector memory_map_; RemotePtr maestro_stack_start_, maestro_stack_end_; int memory_file = -1; std::vector ignored_regions_; - int clear_refs_fd_ = -1; - int pagemap_fd_ = -1; bool privatized_ = false; std::vector stack_areas_; std::vector ignored_heap_; @@ -246,17 +279,19 @@ public: // Copies of MCed SMX data structures * * See mc_smx.c. */ - std::vector smx_process_infos; + std::vector smx_actors_infos; /** Copy of `simix_global->process_to_destroy` * * See mc_smx.c. */ - std::vector smx_old_process_infos; + std::vector smx_dead_actors_infos; +private: /** State of the cache (which variables are up to date) */ - mc_process_cache_flags_t cache_flags = MC_PROCESS_CACHE_FLAG_NONE; + int cache_flags_ = Process::cache_none; +public: /** Address of the heap structure in the MCed process. */ void* heap_address; @@ -280,13 +315,13 @@ public: // Libunwind-data /** Full-featured MC-aware libunwind address space for the process * - * This address space is using a mc_unw_context_t + * This address space is using a simgrid::mc::UnwindContext* * (with simgrid::mc::Process* / simgrid::mc::AddressSpace* * and unw_context_t). */ unw_addr_space_t unw_addr_space; - /** Underlying libunwind addres-space + /** Underlying libunwind address-space * * The `find_proc_info`, `put_unwind_info`, `get_dyn_info_list_addr` * operations of the native MC address space is currently delegated