X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/347996b4a10c4e8579080692afa60e0afb88b60a..864d17d38d2f5ffecea2c9104af9e538a25b56db:/src/mc/Process.hpp diff --git a/src/mc/Process.hpp b/src/mc/Process.hpp index 8780e3cc5a..2b5383783c 100644 --- a/src/mc/Process.hpp +++ b/src/mc/Process.hpp @@ -7,22 +7,23 @@ #ifndef SIMGRID_MC_PROCESS_H #define SIMGRID_MC_PROCESS_H -#include - -#include +#include +#include +#include #include #include -#include "simgrid_config.h" #include +#include + #include +#include #include -#ifdef HAVE_MC #include "src/xbt/mmalloc/mmprivate.h" -#endif +#include "src/mc/Channel.hpp" #include #include "src/simix/popping_private.h" @@ -32,40 +33,73 @@ #include "src/mc/mc_forward.hpp" #include "src/mc/mc_base.h" -#include "src/mc/mc_mmalloc.h" // std_heap #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 namespace simgrid { namespace mc { +class SimixProcessInformation { +public: + /** MCed address of the process */ + void* address = nullptr; + union { + /** (Flat) Copy of the process data structure */ + struct s_smx_process copy; + }; + /** Hostname (owned by `mc_modelchecker->hostnames`) */ + const char* hostname = nullptr; + std::string name; + + void clear() + { + name.clear(); + address = nullptr; + hostname = nullptr; + } +}; + struct IgnoredRegion { std::uint64_t addr; - size_t size; + std::size_t size; }; struct IgnoredHeapRegion { int block; int fragment; void *address; - size_t size; + std::size_t size; }; /** Representation of a process + * + * This class is mixing a lot of differents responsabilities and is tied + * to SIMIX. It should probably split into different classes. + * + * Responsabilities: + * + * - reading from the process memory (`AddressSpace`); + * - accessing the system state of the porcess (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(); + void init(); Process(Process const&) = delete; Process(Process &&) = delete; @@ -74,7 +108,7 @@ public: // Read memory: const void* read_bytes(void* buffer, std::size_t size, - remote_ptr address, int process_index = ProcessIndexAny, + 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 @@ -85,32 +119,40 @@ public: read_variable(name, &res, sizeof(T)); return res; } - char* read_string(remote_ptr address) const; + char* read_string(RemotePtr address) const; // Write memory: - void write_bytes(const void* buffer, size_t len, remote_ptr address); - void clear_bytes(remote_ptr address, size_t len); + void write_bytes(const void* buffer, size_t len, RemotePtr address); + void clear_bytes(RemotePtr address, size_t len); // Debug information: - std::shared_ptr find_object_info(remote_ptr addr) const; - std::shared_ptr find_object_info_exec(remote_ptr addr) const; - std::shared_ptr find_object_info_rw(remote_ptr addr) const; - simgrid::mc::Frame* find_function(remote_ptr ip) const; + std::shared_ptr find_object_info(RemotePtr addr) const; + std::shared_ptr find_object_info_exec(RemotePtr addr) const; + std::shared_ptr find_object_info_rw(RemotePtr addr) const; + simgrid::mc::Frame* find_function(RemotePtr ip) const; simgrid::mc::Variable* find_variable(const char* name) const; // 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() { - 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 { @@ -120,7 +162,7 @@ public: pid_t pid() const { return pid_; } - bool in_maestro_stack(remote_ptr p) const + bool in_maestro_stack(RemotePtr p) const { return p >= this->maestro_stack_start_ && p < this->maestro_stack_end_; } @@ -135,25 +177,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); @@ -191,22 +214,26 @@ public: void unignore_heap(void *address, size_t size); void ignore_local_variable(const char *var_name, const char *frame_name); + std::vector& simix_processes(); + std::vector& old_simix_processes(); private: void init_memory_map_info(); void refresh_heap(); void refresh_malloc_info(); + void refresh_simix(); + private: - pid_t pid_; - int socket_; - bool running_; + pid_t pid_ = -1; + Channel channel_; + bool running_ = false; std::vector memory_map_; - remote_ptr maestro_stack_start_, maestro_stack_end_; - int memory_file; + RemotePtr maestro_stack_start_, maestro_stack_end_; + int memory_file = -1; std::vector ignored_regions_; - int clear_refs_fd_; - int pagemap_fd_; - bool privatized_; + int clear_refs_fd_ = -1; + int pagemap_fd_ = -1; + bool privatized_ = false; std::vector stack_areas_; std::vector ignored_heap_; @@ -221,17 +248,19 @@ public: // Copies of MCed SMX data structures * * See mc_smx.c. */ - xbt_dynar_t smx_process_infos; + std::vector smx_process_infos; /** Copy of `simix_global->process_to_destroy` * * See mc_smx.c. */ - xbt_dynar_t smx_old_process_infos; + std::vector smx_old_process_infos; +private: /** State of the cache (which variables are up to date) */ - mc_process_cache_flags_t cache_flags; + int cache_flags_ = Process::cache_none; +public: /** Address of the heap structure in the MCed process. */ void* heap_address;