+
+bool ModelChecker::handle_message(const char* buffer, ssize_t size)
+{
+ s_mc_message_t base_message;
+ xbt_assert(size >= (ssize_t)sizeof(base_message), "Broken message");
+ memcpy(&base_message, buffer, sizeof(base_message));
+
+ switch(base_message.type) {
+ case MC_MESSAGE_IGNORE_HEAP:
+ {
+ s_mc_message_ignore_heap_t message;
+ xbt_assert(size == sizeof(message), "Broken messsage");
+ memcpy(&message, buffer, sizeof(message));
+
+ IgnoredHeapRegion region;
+ region.block = message.block;
+ region.fragment = message.fragment;
+ region.address = message.address;
+ region.size = message.size;
+ process().ignore_heap(region);
+ break;
+ }
+
+ case MC_MESSAGE_UNIGNORE_HEAP:
+ {
+ s_mc_message_ignore_memory_t message;
+ xbt_assert(size == sizeof(message), "Broken messsage");
+ memcpy(&message, buffer, sizeof(message));
+ process().unignore_heap((void*)(std::uintptr_t)message.addr, message.size);
+ break;
+ }
+
+ case MC_MESSAGE_IGNORE_MEMORY:
+ {
+ s_mc_message_ignore_memory_t message;
+ xbt_assert(size == sizeof(message), "Broken messsage");
+ memcpy(&message, buffer, sizeof(message));
+ this->process().ignore_region(message.addr, message.size);
+ break;
+ }
+
+ case MC_MESSAGE_STACK_REGION:
+ {
+ s_mc_message_stack_region_t message;
+ xbt_assert(size == sizeof(message), "Broken messsage");
+ memcpy(&message, buffer, sizeof(message));
+ this->process().stack_areas().push_back(message.stack_region);
+ }
+ break;
+
+ case MC_MESSAGE_REGISTER_SYMBOL:
+ {
+ s_mc_message_register_symbol_t message;
+ xbt_assert(size == sizeof(message), "Broken message");
+ memcpy(&message, buffer, sizeof(message));
+ xbt_assert(not message.callback, "Support for client-side function proposition is not implemented.");
+ XBT_DEBUG("Received symbol: %s", message.name);
+
+ if (property_automaton == nullptr)
+ property_automaton = xbt_automaton_new();
+
+ RemoteClient* process = &this->process();
+ RemotePtr<int> address = remote((int*)message.data);
+ xbt::add_proposition(property_automaton, message.name, [process, address]() { return process->read(address); });
+
+ break;
+ }
+
+ case MC_MESSAGE_WAITING:
+ return false;
+
+ case MC_MESSAGE_ASSERTION_FAILED:
+ MC_report_assertion_error();
+ this->exit(SIMGRID_MC_EXIT_SAFETY);
+
+ default:
+ xbt_die("Unexpected message from model-checked application");
+ }
+ return true;
+}
+
+/** Terminate the model-checker application */
+void ModelChecker::exit(int status)
+{
+ // TODO, terminate the model checker politely instead of exiting rudely
+ if (process().running())
+ kill(process().pid(), SIGKILL);
+ ::exit(status);
+}
+
+void ModelChecker::handle_events(int fd, short events)
+{
+ if (events == EV_READ) {
+ char buffer[MC_MESSAGE_LENGTH];
+ ssize_t size = process_->get_channel().receive(buffer, sizeof(buffer), false);
+ if (size == -1 && errno != EAGAIN)
+ throw simgrid::xbt::errno_error();
+ if (not handle_message(buffer, size)) {
+ event_base_loopbreak(base_);
+ }
+ }
+ else if (events == EV_SIGNAL) {
+ on_signal(fd);
+ }
+ else {
+ xbt_die("Unexpected event");
+ }
+}
+
+void ModelChecker::loop()
+{
+ if (this->process().running())
+ event_base_dispatch(base_);
+}
+
+void ModelChecker::handle_waitpid()
+{
+ XBT_DEBUG("Check for wait event");
+ int status;
+ pid_t pid;
+ while ((pid = waitpid(-1, &status, WNOHANG)) != 0) {
+ if (pid == -1) {
+ if (errno == ECHILD) {
+ // No more children:
+ xbt_assert(not this->process().running(), "Inconsistent state");
+ break;
+ } else {
+ XBT_ERROR("Could not wait for pid");
+ throw simgrid::xbt::errno_error();
+ }
+ }
+
+ if (pid == this->process().pid()) {
+ // From PTRACE_O_TRACEEXIT:
+#ifdef __linux__
+ if (status>>8 == (SIGTRAP | (PTRACE_EVENT_EXIT<<8))) {
+ xbt_assert(ptrace(PTRACE_GETEVENTMSG, this->process().pid(), 0, &status) != -1, "Could not get exit status");
+ if (WIFSIGNALED(status)) {
+ MC_report_crash(status);
+ mc_model_checker->exit(SIMGRID_MC_EXIT_PROGRAM_CRASH);
+ }
+ }
+#endif
+
+ // We don't care about signals, just reinject them:
+ if (WIFSTOPPED(status)) {
+ XBT_DEBUG("Stopped with signal %i", (int) WSTOPSIG(status));
+ errno = 0;
+#ifdef __linux__
+ ptrace(PTRACE_CONT, this->process().pid(), 0, WSTOPSIG(status));
+#elif defined BSD
+ ptrace(PT_CONTINUE, this->process().pid(), (caddr_t)1, WSTOPSIG(status));
+#endif
+ xbt_assert(errno == 0, "Could not PTRACE_CONT");
+ }
+
+ else if (WIFSIGNALED(status)) {
+ MC_report_crash(status);
+ mc_model_checker->exit(SIMGRID_MC_EXIT_PROGRAM_CRASH);
+ } else if (WIFEXITED(status)) {
+ XBT_DEBUG("Child process is over");
+ this->process().terminate();
+ }
+ }
+ }
+}
+
+void ModelChecker::on_signal(int signo)
+{
+ if (signo == SIGCHLD)
+ this->handle_waitpid();
+}
+
+void ModelChecker::wait_for_requests()
+{
+ this->resume(process());
+ if (this->process().running())
+ event_base_dispatch(base_);
+}
+
+void ModelChecker::handle_simcall(Transition const& transition)
+{
+ s_mc_message_simcall_handle_t m;
+ memset(&m, 0, sizeof(m));
+ m.type = MC_MESSAGE_SIMCALL_HANDLE;
+ m.pid = transition.pid_;
+ m.value = transition.argument_;
+ this->process_->get_channel().send(m);
+ this->process_->clear_cache();
+ if (this->process_->running())
+ event_base_dispatch(base_);
+}
+
+bool ModelChecker::checkDeadlock()
+{
+ int res = this->process().get_channel().send(MC_MESSAGE_DEADLOCK_CHECK);
+ xbt_assert(res == 0, "Could not check deadlock state");
+ s_mc_message_int_t message;
+ ssize_t s = mc_model_checker->process().get_channel().receive(message);
+ xbt_assert(s != -1, "Could not receive message");
+ xbt_assert(s == sizeof(message) && message.type == MC_MESSAGE_DEADLOCK_CHECK_REPLY,
+ "Received unexpected message %s (%i, size=%i) "
+ "expected MC_MESSAGE_DEADLOCK_CHECK_REPLY (%i, size=%i)",
+ MC_message_type_name(message.type), (int)message.type, (int)s, (int)MC_MESSAGE_DEADLOCK_CHECK_REPLY,
+ (int)sizeof(message));
+ return message.value != 0;
+}
+
+} // namespace mc
+} // namespace simgrid