X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/967d9394b584d0ccc87d801d96d4d240f4555187..da64c6383731d10c6174f81b4b6a20ff0ea186ae:/src/mc/remote/AppSide.cpp diff --git a/src/mc/remote/AppSide.cpp b/src/mc/remote/AppSide.cpp index 18315d3efb..90f221d1c4 100644 --- a/src/mc/remote/AppSide.cpp +++ b/src/mc/remote/AppSide.cpp @@ -24,6 +24,7 @@ #include #include +#include #include // setvbuf #include #include @@ -100,7 +101,7 @@ void AppSide::handle_deadlock_check(const s_mc_message_t*) const s_mc_message_int_t answer = {}; answer.type = MessageType::DEADLOCK_CHECK_REPLY; answer.value = deadlock; - xbt_assert(channel_.send(answer) == 0, "Could not send response"); + xbt_assert(channel_.send(answer) == 0, "Could not send response: %s", strerror(errno)); } void AppSide::handle_simcall_execute(const s_mc_message_simcall_execute_t* message) const { @@ -110,7 +111,8 @@ void AppSide::handle_simcall_execute(const s_mc_message_simcall_execute_t* messa // The client may send some messages to the server while processing the transition actor->simcall_handle(message->times_considered_); // Say the server that the transition is over and that it should proceed - xbt_assert(channel_.send(MessageType::WAITING) == 0, "Could not send MESSAGE_WAITING to model-checker"); + xbt_assert(channel_.send(MessageType::WAITING) == 0, "Could not send MESSAGE_WAITING to model-checker: %s", + strerror(errno)); // Finish the RPC from the server: return a serialized observer, to build a Transition on Checker side s_mc_message_simcall_execute_answer_t answer = {}; @@ -128,7 +130,7 @@ void AppSide::handle_simcall_execute(const s_mc_message_simcall_execute_t* messa answer.buffer.back() = '\0'; XBT_DEBUG("send SIMCALL_EXECUTE_ANSWER(%s) ~> '%s'", actor->get_cname(), str.c_str()); - xbt_assert(channel_.send(answer) == 0, "Could not send response"); + xbt_assert(channel_.send(answer) == 0, "Could not send response: %s", strerror(errno)); } void AppSide::handle_finalize(const s_mc_message_int_t* msg) const @@ -145,14 +147,20 @@ void AppSide::handle_finalize(const s_mc_message_int_t* msg) const #endif } coverage_checkpoint(); - xbt_assert(channel_.send(MessageType::FINALIZE_REPLY) == 0, "Could not answer to FINALIZE"); + xbt_assert(channel_.send(MessageType::FINALIZE_REPLY) == 0, "Could not answer to FINALIZE: %s", strerror(errno)); std::fflush(stdout); if (terminate_asap) ::_Exit(0); } -void AppSide::handle_fork(const s_mc_message_int_t* msg) +void AppSide::handle_fork(const s_mc_message_fork_t* msg) { - int pid = fork(); + int status; + int pid; + /* Reap any zombie child, saving its status for later use in AppSide::handle_wait_child() */ + while ((pid = waitpid(-1, &status, WNOHANG)) > 0) + child_statuses_[pid] = status; + + pid = fork(); xbt_assert(pid >= 0, "Could not fork application sub-process: %s.", strerror(errno)); if (pid == 0) { // Child @@ -166,11 +174,10 @@ void AppSide::handle_fork(const s_mc_message_int_t* msg) struct sockaddr_un addr = {}; addr.sun_family = AF_UNIX; - snprintf(addr.sun_path, 64, "/tmp/simgrid-mc-%lu", static_cast(msg->value)); - auto addr_size = offsetof(struct sockaddr_un, sun_path) + strlen(addr.sun_path); + std::copy_n(begin(msg->socket_name), MC_SOCKET_NAME_LEN, addr.sun_path); - xbt_assert(connect(sock, (struct sockaddr*)&addr, addr_size) >= 0, - "Cannot connect to Checker on %s: %s.", addr.sun_path, strerror(errno)); + xbt_assert(connect(sock, (struct sockaddr*)&addr, sizeof addr) >= 0, "Cannot connect to Checker on %c%s: %s.", + (addr.sun_path[0] ? addr.sun_path[0] : '@'), addr.sun_path + 1, strerror(errno)); channel_.reset_socket(sock); @@ -179,14 +186,19 @@ void AppSide::handle_fork(const s_mc_message_int_t* msg) answer.value = getpid(); xbt_assert(channel_.send(answer) == 0, "Could not send response to WAIT_CHILD_REPLY: %s", strerror(errno)); } else { - XBT_DEBUG("App %d forks subprocess %d.", getpid(), pid); + XBT_VERB("App %d forks subprocess %d.", getpid(), pid); } } void AppSide::handle_wait_child(const s_mc_message_int_t* msg) { int status; errno = 0; - waitpid(msg->value, &status, 0); + if (auto search = child_statuses_.find(msg->value); search != child_statuses_.end()) { + status = search->second; + child_statuses_.erase(search); // We only need this info once + } else { + waitpid(msg->value, &status, 0); + } xbt_assert(errno == 0, "Cannot wait on behalf of the checker: %s.", strerror(errno)); s_mc_message_int_t answer = {}; @@ -201,7 +213,7 @@ void AppSide::handle_need_meminfo() s_mc_message_need_meminfo_reply_t answer = {}; answer.type = MessageType::NEED_MEMINFO_REPLY; answer.mmalloc_default_mdp = mmalloc_get_current_heap(); - xbt_assert(channel_.send(answer) == 0, "Could not send response to the request for meminfo."); + xbt_assert(channel_.send(answer) == 0, "Could not send response to the request for meminfo: %s", strerror(errno)); #else xbt_die("SimGrid was compiled without MC suppport, so liveness and similar features are not available."); #endif @@ -225,18 +237,15 @@ void AppSide::handle_actors_status() const answer.type = MessageType::ACTORS_STATUS_REPLY_COUNT; answer.count = static_cast(status.size()); - xbt_assert(channel_.send(answer) == 0, "Could not send ACTORS_STATUS_REPLY msg"); + xbt_assert(channel_.send(answer) == 0, "Could not send ACTORS_STATUS_REPLY msg: %s", strerror(errno)); if (answer.count > 0) { size_t size = status.size() * sizeof(s_mc_message_actors_status_one_t); - xbt_assert(channel_.send(status.data(), size) == 0, "Could not send ACTORS_STATUS_REPLY data"); + xbt_assert(channel_.send(status.data(), size) == 0, "Could not send ACTORS_STATUS_REPLY data: %s", strerror(errno)); } // Serialize each transition to describe what each actor is doing XBT_DEBUG("Deliver ACTOR_TRANSITION_PROBE payload"); for (const auto& actor_status : status) { - if (not actor_status.enabled) - continue; - const auto& actor = actor_list.at(actor_status.aid); const int max_considered = actor_status.max_considered; @@ -258,7 +267,7 @@ void AppSide::handle_actors_status() const strncpy(probe.buffer.data(), str.c_str(), probe.buffer.size() - 1); probe.buffer.back() = '\0'; - xbt_assert(channel_.send(probe) == 0, "Could not send ACTOR_TRANSITION_PROBE payload"); + xbt_assert(channel_.send(probe) == 0, "Could not send ACTOR_TRANSITION_PROBE payload: %s", strerror(errno)); } // NOTE: We do NOT need to reset `times_considered` for each actor's // simcall observer here to the "original" value (i.e. the value BEFORE @@ -272,7 +281,7 @@ void AppSide::handle_actors_maxpid() const s_mc_message_int_t answer = {}; answer.type = MessageType::ACTORS_MAXPID_REPLY; answer.value = kernel::actor::ActorImpl::get_maxpid(); - xbt_assert(channel_.send(answer) == 0, "Could not send response"); + xbt_assert(channel_.send(answer) == 0, "Could not send response: %s", strerror(errno)); } #define assert_msg_size(_name_, _type_) \ @@ -291,7 +300,7 @@ void AppSide::handle_messages() XBT_DEBUG("Socket closed on the Checker side, bailing out."); ::_Exit(0); // Nobody's listening to that process anymore => exit as quickly as possible. } - xbt_assert(received_size >= 0, "Could not receive commands from the model-checker"); + xbt_assert(received_size >= 0, "Could not receive commands from the model-checker: %s", strerror(errno)); xbt_assert(static_cast(received_size) >= sizeof(s_mc_message_t), "Cannot handle short message (size=%zd)", received_size); @@ -317,8 +326,8 @@ void AppSide::handle_messages() break; case MessageType::FORK: - assert_msg_size("FORK", s_mc_message_int_t); - handle_fork((s_mc_message_int_t*)message_buffer.data()); + assert_msg_size("FORK", s_mc_message_fork_t); + handle_fork((s_mc_message_fork_t*)message_buffer.data()); break; case MessageType::WAIT_CHILD: @@ -353,20 +362,23 @@ void AppSide::main_loop() simgrid::mc::processes_time.resize(simgrid::kernel::actor::ActorImpl::get_maxpid()); MC_ignore_heap(simgrid::mc::processes_time.data(), simgrid::mc::processes_time.size() * sizeof(simgrid::mc::processes_time[0])); + kernel::activity::CommImpl::setup_mc(); sthread_disable(); coverage_checkpoint(); sthread_enable(); while (true) { simgrid::mc::execute_actors(); - xbt_assert(channel_.send(MessageType::WAITING) == 0, "Could not send WAITING message to model-checker"); + xbt_assert(channel_.send(MessageType::WAITING) == 0, "Could not send WAITING message to model-checker: %s", + strerror(errno)); this->handle_messages(); } } void AppSide::report_assertion_failure() { - xbt_assert(channel_.send(MessageType::ASSERTION_FAILED) == 0, "Could not send assertion to model-checker"); + xbt_assert(channel_.send(MessageType::ASSERTION_FAILED) == 0, "Could not send assertion to model-checker: %s", + strerror(errno)); this->handle_messages(); } @@ -380,9 +392,26 @@ void AppSide::ignore_memory(void* addr, std::size_t size) const message.type = MessageType::IGNORE_MEMORY; message.addr = (std::uintptr_t)addr; message.size = size; - xbt_assert(channel_.send(message) == 0, "Could not send IGNORE_MEMORY message to model-checker"); + xbt_assert(channel_.send(message) == 0, "Could not send IGNORE_MEMORY message to model-checker: %s", strerror(errno)); #else - xbt_die("Cannot really call ignore_heap() in non-SIMGRID_MC mode."); + xbt_die("Cannot really call ignore_memory() in non-SIMGRID_MC mode."); +#endif +} + +void AppSide::unignore_memory(void* addr, std::size_t size) const +{ + if (not MC_is_active() || not need_memory_info_) + return; + +#if SIMGRID_HAVE_STATEFUL_MC + s_mc_message_ignore_memory_t message = {}; + message.type = MessageType::UNIGNORE_MEMORY; + message.addr = (std::uintptr_t)addr; + message.size = size; + xbt_assert(channel_.send(message) == 0, "Could not send UNIGNORE_MEMORY message to model-checker: %s", + strerror(errno)); +#else + xbt_die("Cannot really call unignore_memory() in non-SIMGRID_MC mode."); #endif } @@ -407,7 +436,7 @@ void AppSide::ignore_heap(void* address, std::size_t size) const heap->heapinfo[message.block].busy_frag.ignore[message.fragment]++; } - xbt_assert(channel_.send(message) == 0, "Could not send ignored region to MCer"); + xbt_assert(channel_.send(message) == 0, "Could not send ignored region to MCer: %s", strerror(errno)); #else xbt_die("Cannot really call ignore_heap() in non-SIMGRID_MC mode."); #endif @@ -423,7 +452,7 @@ void AppSide::unignore_heap(void* address, std::size_t size) const message.type = MessageType::UNIGNORE_HEAP; message.addr = (std::uintptr_t)address; message.size = size; - xbt_assert(channel_.send(message) == 0, "Could not send IGNORE_HEAP message to model-checker"); + xbt_assert(channel_.send(message) == 0, "Could not send IGNORE_HEAP message to model-checker: %s", strerror(errno)); #else xbt_die("Cannot really call unignore_heap() in non-SIMGRID_MC mode."); #endif @@ -443,7 +472,7 @@ void AppSide::declare_symbol(const char* name, int* value) const strncpy(message.name.data(), name, message.name.size() - 1); message.callback = nullptr; message.data = value; - xbt_assert(channel_.send(message) == 0, "Could send REGISTER_SYMBOL message to model-checker"); + xbt_assert(channel_.send(message) == 0, "Could send REGISTER_SYMBOL message to model-checker: %s", strerror(errno)); #else xbt_die("Cannot really call declare_symbol() in non-SIMGRID_MC mode."); #endif @@ -473,7 +502,7 @@ void AppSide::declare_stack(void* stack, size_t size, ucontext_t* context) const s_mc_message_stack_region_t message = {}; message.type = MessageType::STACK_REGION; message.stack_region = region; - xbt_assert(channel_.send(message) == 0, "Could not send STACK_REGION to model-checker"); + xbt_assert(channel_.send(message) == 0, "Could not send STACK_REGION to model-checker: %s", strerror(errno)); #else xbt_die("Cannot really call declare_stack() in non-SIMGRID_MC mode."); #endif