src/mc/mc_server.cpp

   1 /* Copyright (c) 2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include <memory>
   8 #include <system_error>
   9
  10 #include <poll.h>
  11 #include <sys/types.h>
  12 #include <sys/wait.h>
  13 #include <sys/socket.h>
  14 #include <sys/signalfd.h>
  15
  16 #include <xbt/log.h>
  17
  18 #include "ModelChecker.hpp"
  19 #include "mc_protocol.h"
  20 #include "mc_server.h"
  21 #include "mc_private.h"
  22 #include "mc_ignore.h"
  23 #include "mcer_ignore.h"
  24
  25 using simgrid::mc::remote;
  26
  27 extern "C" {
  28
  29 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_server, mc, "MC server logic");
  30
  31 // HArdcoded index for now:
  32 #define SOCKET_FD_INDEX 0
  33 #define SIGNAL_FD_INDEX 1
  34
  35 mc_server_t mc_server;
  36
  37 struct mc_symbol_pointer_callback
  38 {
  39   mc_process_t process;
  40   void* value;
  41 };
  42
  43 static int mc_symbol_pointer_callback_evaluate(void* p)
  44 {
  45   struct mc_symbol_pointer_callback* callback = (struct mc_symbol_pointer_callback*) p;
  46   int value;
  47   callback->process->read_bytes(&value, sizeof(value), remote(callback->value));
  48   return value;
  49 }
  50
  51 s_mc_server::s_mc_server(pid_t pid, int socket)
  52 {
  53   this->pid = pid;
  54   this->socket = socket;
  55 }
  56
  57 void s_mc_server::start()
  58 {
  59   /* Wait for the target process to initialize and exchange a HELLO messages
  60    * before trying to look at its memory map.
  61    */
  62   int res = MC_protocol_hello(socket);
  63   if (res != 0)
  64     throw std::system_error(res, std::system_category());
  65
  66   // Block SIGCHLD (this will be handled with accept/signalfd):
  67   sigset_t set;
  68   sigemptyset(&set);
  69   sigaddset(&set, SIGCHLD);
  70   if (sigprocmask(SIG_BLOCK, &set, NULL) == -1)
  71     throw std::system_error(errno, std::system_category());
  72
  73   sigset_t full_set;
  74   sigfillset(&full_set);
  75
  76   // Prepare data for poll:
  77
  78   struct pollfd* socket_pollfd = &fds[SOCKET_FD_INDEX];
  79   socket_pollfd->fd = socket;
  80   socket_pollfd->events = POLLIN;
  81   socket_pollfd->revents = 0;
  82
  83   int signal_fd = signalfd(-1, &set, 0);
  84   if (signal_fd == -1)
  85     throw std::system_error(errno, std::system_category());
  86
  87   struct pollfd* signalfd_pollfd = &fds[SIGNAL_FD_INDEX];
  88   signalfd_pollfd->fd = signal_fd;
  89   signalfd_pollfd->events = POLLIN;
  90   signalfd_pollfd->revents = 0;
  91 }
  92
  93 void s_mc_server::shutdown()
  94 {
  95   XBT_DEBUG("Shuting down model-checker");
  96
  97   mc_process_t process = &mc_model_checker->process();
  98   int status = process->status();
  99   if (process->running()) {
 100     XBT_DEBUG("Killing process");
 101     kill(process->pid(), SIGTERM);
 102     if (waitpid(process->pid(), &status, 0) == -1)
 103       throw std::system_error(errno, std::system_category());
 104     // TODO, handle the case when the process does not want to die with a timeout
 105     process->terminate(status);
 106   }
 107 }
 108
 109 void s_mc_server::exit()
 110 {
 111   // Finished:
 112   int status = mc_model_checker->process().status();
 113   if (WIFEXITED(status))
 114     ::exit(WEXITSTATUS(status));
 115   else if (WIFSIGNALED(status)) {
 116     // Try to uplicate the signal of the model-checked process.
 117     // This is a temporary hack so we don't try too hard.
 118     kill(mc_model_checker->process().pid(), WTERMSIG(status));
 119     abort();
 120   } else {
 121     xbt_die("Unexpected status from model-checked process");
 122   }
 123 }
 124
 125 void s_mc_server::resume(mc_process_t process)
 126 {
 127   int res = process->send_message(MC_MESSAGE_CONTINUE);
 128   if (res)
 129     throw std::system_error(res, std::system_category());
 130   process->cache_flags = (mc_process_cache_flags_t) 0;
 131 }
 132
 133 static
 134 void throw_socket_error(int fd)
 135 {
 136   int error = 0;
 137   socklen_t errlen = sizeof(error);
 138   if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *)&error, &errlen) == -1)
 139     error = errno;
 140   throw std::system_error(error, std::system_category());
 141 }
 142
 143 bool s_mc_server::handle_events()
 144 {
 145   char buffer[MC_MESSAGE_LENGTH];
 146   struct pollfd* socket_pollfd = &fds[SOCKET_FD_INDEX];
 147   struct pollfd* signalfd_pollfd = &fds[SIGNAL_FD_INDEX];
 148
 149   while(poll(fds, 2, -1) == -1) {
 150     switch(errno) {
 151     case EINTR:
 152       continue;
 153     default:
 154       throw std::system_error(errno, std::system_category());
 155     }
 156   }
 157
 158   if (socket_pollfd->revents) {
 159     if (socket_pollfd->revents & POLLIN) {
 160
 161       ssize_t size = MC_receive_message(socket_pollfd->fd, buffer, sizeof(buffer), MSG_DONTWAIT);
 162       if (size == -1 && errno != EAGAIN)
 163         throw std::system_error(errno, std::system_category());
 164
 165       s_mc_message_t base_message;
 166       if (size < (ssize_t) sizeof(base_message))
 167         xbt_die("Broken message");
 168       memcpy(&base_message, buffer, sizeof(base_message));
 169
 170       switch(base_message.type) {
 171
 172       case MC_MESSAGE_IGNORE_HEAP:
 173         {
 174           s_mc_ignore_heap_message_t message;
 175           if (size != sizeof(message))
 176             xbt_die("Broken messsage");
 177           memcpy(&message, buffer, sizeof(message));
 178           mc_heap_ignore_region_t region = xbt_new(s_mc_heap_ignore_region_t, 1);
 179           *region = message.region;
 180           MC_heap_region_ignore_insert(region);
 181           break;
 182         }
 183
 184       case MC_MESSAGE_UNIGNORE_HEAP:
 185         {
 186           s_mc_ignore_memory_message_t message;
 187           if (size != sizeof(message))
 188             xbt_die("Broken messsage");
 189           memcpy(&message, buffer, sizeof(message));
 190           MC_heap_region_ignore_remove(message.addr, message.size);
 191           break;
 192         }
 193
 194       case MC_MESSAGE_IGNORE_MEMORY:
 195         {
 196           s_mc_ignore_memory_message_t message;
 197           if (size != sizeof(message))
 198             xbt_die("Broken messsage");
 199           memcpy(&message, buffer, sizeof(message));
 200           mc_model_checker->process().ignore_region(
 201             (std::uint64_t)message.addr, message.size);
 202           break;
 203         }
 204
 205       case MC_MESSAGE_STACK_REGION:
 206         {
 207           s_mc_stack_region_message_t message;
 208           if (size != sizeof(message))
 209             xbt_die("Broken messsage");
 210           memcpy(&message, buffer, sizeof(message));
 211           stack_region_t stack_region = xbt_new(s_stack_region_t, 1);
 212           *stack_region = message.stack_region;
 213           MC_stack_area_add(stack_region);
 214         }
 215         break;
 216
 217       case MC_MESSAGE_REGISTER_SYMBOL:
 218         {
 219           s_mc_register_symbol_message_t message;
 220           if (size != sizeof(message))
 221             xbt_die("Broken message");
 222           memcpy(&message, buffer, sizeof(message));
 223           if (message.callback)
 224             xbt_die("Support for callbacks/functions symbols not implemented in client/server mode.");
 225           XBT_DEBUG("Received symbol: %s", message.name);
 226
 227           struct mc_symbol_pointer_callback* callback = xbt_new(struct mc_symbol_pointer_callback, 1);
 228           callback->process = &mc_model_checker->process();
 229           callback->value   = message.data;
 230
 231           MC_automaton_new_propositional_symbol_callback(message.name,
 232             mc_symbol_pointer_callback_evaluate, callback, free);
 233           break;
 234         }
 235
 236       case MC_MESSAGE_WAITING:
 237         return false;
 238
 239       case MC_MESSAGE_ASSERTION_FAILED:
 240         MC_report_assertion_error();
 241         xbt_abort();
 242         break;
 243
 244       default:
 245         xbt_die("Unexpected message from model-checked application");
 246
 247       }
 248       return true;
 249     }
 250     if (socket_pollfd->revents & POLLERR) {
 251       throw_socket_error(socket_pollfd->fd);
 252     }
 253     if (socket_pollfd->revents & POLLHUP)
 254       xbt_die("Socket hang up?");
 255   }
 256
 257   if (signalfd_pollfd->revents) {
 258     if (signalfd_pollfd->revents & POLLIN) {
 259       this->handle_signals();
 260       return true;
 261     }
 262     if (signalfd_pollfd->revents & POLLERR) {
 263       throw_socket_error(signalfd_pollfd->fd);
 264     }
 265     if (signalfd_pollfd->revents & POLLHUP)
 266       xbt_die("Signalfd hang up?");
 267   }
 268
 269   return true;
 270 }
 271
 272 void s_mc_server::loop()
 273 {
 274   while (mc_model_checker->process().running())
 275     this->handle_events();
 276 }
 277
 278 void s_mc_server::handle_signals()
 279 {
 280   struct signalfd_siginfo info;
 281   struct pollfd* signalfd_pollfd = &fds[SIGNAL_FD_INDEX];
 282   while (1) {
 283     ssize_t size = read(signalfd_pollfd->fd, &info, sizeof(info));
 284     if (size == -1) {
 285       if (errno == EINTR)
 286         continue;
 287       else
 288         throw std::system_error(errno, std::system_category());
 289     } else if (size != sizeof(info))
 290         return throw std::runtime_error(
 291           "Bad communication with model-checked application");
 292     else
 293       break;
 294   }
 295   this->on_signal(&info);
 296 }
 297
 298 void s_mc_server::handle_waitpid()
 299 {
 300   XBT_DEBUG("Check for wait event");
 301   int status;
 302   pid_t pid;
 303   while ((pid = waitpid(-1, &status, WNOHANG)) != 0) {
 304     if (pid == -1) {
 305       if (errno == ECHILD) {
 306         // No more children:
 307         if (mc_model_checker->process().running())
 308           xbt_die("Inconsistent state");
 309         else
 310           break;
 311       } else {
 312         XBT_ERROR("Could not wait for pid");
 313         throw std::system_error(errno, std::system_category());
 314       }
 315     }
 316
 317     if (pid == mc_model_checker->process().pid()) {
 318       if (WIFEXITED(status) || WIFSIGNALED(status)) {
 319         XBT_DEBUG("Child process is over");
 320         mc_model_checker->process().terminate(status);
 321       }
 322     }
 323   }
 324 }
 325
 326 void s_mc_server::on_signal(const struct signalfd_siginfo* info)
 327 {
 328   switch(info->ssi_signo) {
 329   case SIGCHLD:
 330     this->handle_waitpid();
 331     break;
 332   default:
 333     break;
 334   }
 335 }
 336
 337 void MC_server_wait_client(mc_process_t process)
 338 {
 339   mc_server->resume(process);
 340   while (mc_model_checker->process().running()) {
 341     if (!mc_server->handle_events())
 342       return;
 343   }
 344 }
 345
 346 void MC_server_simcall_handle(mc_process_t process, unsigned long pid, int value)
 347 {
 348   s_mc_simcall_handle_message m;
 349   memset(&m, 0, sizeof(m));
 350   m.type  = MC_MESSAGE_SIMCALL_HANDLE;
 351   m.pid   = pid;
 352   m.value = value;
 353   mc_model_checker->process().send_message(m);
 354   process->cache_flags = (mc_process_cache_flags_t) 0;
 355   while (mc_model_checker->process().running()) {
 356     if (!mc_server->handle_events())
 357       return;
 358   }
 359 }
 360
 361 void MC_server_loop(mc_server_t server)
 362 {
 363   server->loop();
 364 }
 365
 366 }