+void AppSide::handle_fork(const s_mc_message_fork_t* msg)
+{
+ 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
+ int sock = socket(AF_UNIX,
+#ifdef __APPLE__
+ SOCK_STREAM, /* Mac OSX does not have AF_UNIX + SOCK_SEQPACKET, even if that's faster*/
+#else
+ SOCK_SEQPACKET,
+#endif
+ 0);
+
+ struct sockaddr_un addr = {};
+ addr.sun_family = AF_UNIX;
+ std::copy_n(begin(msg->socket_name), MC_SOCKET_NAME_LEN, addr.sun_path);
+
+ 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);
+
+ s_mc_message_int_t answer = {};
+ answer.type = MessageType::FORK_REPLY;
+ answer.value = getpid();
+ xbt_assert(channel_.send(answer) == 0, "Could not send response to WAIT_CHILD_REPLY: %s", strerror(errno));
+ } else {
+ 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;
+ 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 = {};
+ answer.type = MessageType::WAIT_CHILD_REPLY;
+ answer.value = status;
+ xbt_assert(channel_.send(answer) == 0, "Could not send response to WAIT_CHILD: %s", strerror(errno));
+}
+void AppSide::handle_need_meminfo()
+{
+#if SIMGRID_HAVE_STATEFUL_MC
+ this->need_memory_info_ = true;
+ 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: %s", strerror(errno));
+#else
+ xbt_die("SimGrid was compiled without MC suppport, so liveness and similar features are not available.");
+#endif
+}
+void AppSide::handle_actors_status() const
+{
+ auto const& actor_list = kernel::EngineImpl::get_instance()->get_actor_list();
+ XBT_DEBUG("Serialize the actors to answer ACTORS_STATUS from the checker. %zu actors to go.", actor_list.size());
+
+ std::vector<s_mc_message_actors_status_one_t> status;
+ for (auto const& [aid, actor] : actor_list) {
+ s_mc_message_actors_status_one_t one = {};
+ one.type = MessageType::ACTORS_STATUS_REPLY_TRANSITION;
+ one.aid = aid;
+ one.enabled = mc::actor_is_enabled(actor);
+ one.max_considered = actor->simcall_.observer_->get_max_consider();
+ status.push_back(one);
+ }
+
+ struct s_mc_message_actors_status_answer_t answer = {};
+ answer.type = MessageType::ACTORS_STATUS_REPLY_COUNT;
+ answer.count = static_cast<int>(status.size());
+
+ 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: %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) {
+ const auto& actor = actor_list.at(actor_status.aid);
+ const int max_considered = actor_status.max_considered;
+
+ for (int times_considered = 0; times_considered < max_considered; times_considered++) {
+ std::stringstream stream;
+ s_mc_message_simcall_probe_one_t probe;
+ probe.type = MessageType::ACTORS_STATUS_REPLY_SIMCALL;
+
+ if (actor->simcall_.observer_ != nullptr) {
+ actor->simcall_.observer_->prepare(times_considered);
+ actor->simcall_.observer_->serialize(stream);
+ } else {
+ stream << (short)mc::Transition::Type::UNKNOWN;
+ }
+
+ std::string str = stream.str();
+ xbt_assert(str.size() + 1 <= probe.buffer.size(),
+ "The serialized transition is too large for the buffer. Please fix the code.");
+ 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: %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
+ // multiple prepare() calls were made for serialization purposes) since
+ // each SIMCALL_EXECUTE provides a `times_considered` to be used to prepare
+ // the transition before execution.
+ }
+}
+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: %s", strerror(errno));
+}