Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[mc] Mark some Process attributes as private
[simgrid.git] / 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 socket = process->socket;
128   int res = MC_protocol_send_simple_message(socket, MC_MESSAGE_CONTINUE);
129   if (res)
130     throw std::system_error(res, std::system_category());
131   process->cache_flags = (mc_process_cache_flags_t) 0;
132 }
133
134 static
135 void throw_socket_error(int fd)
136 {
137   int error = 0;
138   socklen_t errlen = sizeof(error);
139   if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *)&error, &errlen) == -1)
140     error = errno;
141   throw std::system_error(error, std::system_category());
142 }
143
144 bool s_mc_server::handle_events()
145 {
146   char buffer[MC_MESSAGE_LENGTH];
147   struct pollfd* socket_pollfd = &fds[SOCKET_FD_INDEX];
148   struct pollfd* signalfd_pollfd = &fds[SIGNAL_FD_INDEX];
149
150   while(poll(fds, 2, -1) == -1) {
151     switch(errno) {
152     case EINTR:
153       continue;
154     default:
155       throw std::system_error(errno, std::system_category());
156     }
157   }
158
159   if (socket_pollfd->revents) {
160     if (socket_pollfd->revents & POLLIN) {
161
162       ssize_t size = MC_receive_message(socket_pollfd->fd, buffer, sizeof(buffer), MSG_DONTWAIT);
163       if (size == -1 && errno != EAGAIN)
164         throw std::system_error(errno, std::system_category());
165
166       s_mc_message_t base_message;
167       if (size < (ssize_t) sizeof(base_message))
168         xbt_die("Broken message");
169       memcpy(&base_message, buffer, sizeof(base_message));
170
171       switch(base_message.type) {
172
173       case MC_MESSAGE_IGNORE_HEAP:
174         {
175           s_mc_ignore_heap_message_t message;
176           if (size != sizeof(message))
177             xbt_die("Broken messsage");
178           memcpy(&message, buffer, sizeof(message));
179           mc_heap_ignore_region_t region = xbt_new(s_mc_heap_ignore_region_t, 1);
180           *region = message.region;
181           MC_heap_region_ignore_insert(region);
182           break;
183         }
184
185       case MC_MESSAGE_UNIGNORE_HEAP:
186         {
187           s_mc_ignore_memory_message_t message;
188           if (size != sizeof(message))
189             xbt_die("Broken messsage");
190           memcpy(&message, buffer, sizeof(message));
191           MC_heap_region_ignore_remove(message.addr, message.size);
192           break;
193         }
194
195       case MC_MESSAGE_IGNORE_MEMORY:
196         {
197           s_mc_ignore_memory_message_t message;
198           if (size != sizeof(message))
199             xbt_die("Broken messsage");
200           memcpy(&message, buffer, sizeof(message));
201           mc_model_checker->process().ignore_region(
202             (std::uint64_t)message.addr, message.size);
203           break;
204         }
205
206       case MC_MESSAGE_STACK_REGION:
207         {
208           s_mc_stack_region_message_t message;
209           if (size != sizeof(message))
210             xbt_die("Broken messsage");
211           memcpy(&message, buffer, sizeof(message));
212           stack_region_t stack_region = xbt_new(s_stack_region_t, 1);
213           *stack_region = message.stack_region;
214           MC_stack_area_add(stack_region);
215         }
216         break;
217
218       case MC_MESSAGE_REGISTER_SYMBOL:
219         {
220           s_mc_register_symbol_message_t message;
221           if (size != sizeof(message))
222             xbt_die("Broken message");
223           memcpy(&message, buffer, sizeof(message));
224           if (message.callback)
225             xbt_die("Support for callbacks/functions symbols not implemented in client/server mode.");
226           XBT_DEBUG("Received symbol: %s", message.name);
227
228           struct mc_symbol_pointer_callback* callback = xbt_new(struct mc_symbol_pointer_callback, 1);
229           callback->process = &mc_model_checker->process();
230           callback->value   = message.data;
231
232           MC_automaton_new_propositional_symbol_callback(message.name,
233             mc_symbol_pointer_callback_evaluate, callback, free);
234           break;
235         }
236
237       case MC_MESSAGE_WAITING:
238         return false;
239
240       case MC_MESSAGE_ASSERTION_FAILED:
241         MC_report_assertion_error();
242         xbt_abort();
243         break;
244
245       default:
246         xbt_die("Unexpected message from model-checked application");
247
248       }
249       return true;
250     }
251     if (socket_pollfd->revents & POLLERR) {
252       throw_socket_error(socket_pollfd->fd);
253     }
254     if (socket_pollfd->revents & POLLHUP)
255       xbt_die("Socket hang up?");
256   }
257
258   if (signalfd_pollfd->revents) {
259     if (signalfd_pollfd->revents & POLLIN) {
260       this->handle_signals();
261       return true;
262     }
263     if (signalfd_pollfd->revents & POLLERR) {
264       throw_socket_error(signalfd_pollfd->fd);
265     }
266     if (signalfd_pollfd->revents & POLLHUP)
267       xbt_die("Signalfd hang up?");
268   }
269
270   return true;
271 }
272
273 void s_mc_server::loop()
274 {
275   while (mc_model_checker->process().running())
276     this->handle_events();
277 }
278
279 void s_mc_server::handle_signals()
280 {
281   struct signalfd_siginfo info;
282   struct pollfd* signalfd_pollfd = &fds[SIGNAL_FD_INDEX];
283   while (1) {
284     ssize_t size = read(signalfd_pollfd->fd, &info, sizeof(info));
285     if (size == -1) {
286       if (errno == EINTR)
287         continue;
288       else
289         throw std::system_error(errno, std::system_category());
290     } else if (size != sizeof(info))
291         return throw std::runtime_error(
292           "Bad communication with model-checked application");
293     else
294       break;
295   }
296   this->on_signal(&info);
297 }
298
299 void s_mc_server::handle_waitpid()
300 {
301   XBT_DEBUG("Check for wait event");
302   int status;
303   pid_t pid;
304   while ((pid = waitpid(-1, &status, WNOHANG)) != 0) {
305     if (pid == -1) {
306       if (errno == ECHILD) {
307         // No more children:
308         if (mc_model_checker->process().running())
309           xbt_die("Inconsistent state");
310         else
311           break;
312       } else {
313         XBT_ERROR("Could not wait for pid");
314         throw std::system_error(errno, std::system_category());
315       }
316     }
317
318     if (pid == mc_model_checker->process().pid()) {
319       if (WIFEXITED(status) || WIFSIGNALED(status)) {
320         XBT_DEBUG("Child process is over");
321         mc_model_checker->process().terminate(status);
322       }
323     }
324   }
325 }
326
327 void s_mc_server::on_signal(const struct signalfd_siginfo* info)
328 {
329   switch(info->ssi_signo) {
330   case SIGCHLD:
331     this->handle_waitpid();
332     break;
333   default:
334     break;
335   }
336 }
337
338 void MC_server_wait_client(mc_process_t process)
339 {
340   mc_server->resume(process);
341   while (mc_model_checker->process().running()) {
342     if (!mc_server->handle_events())
343       return;
344   }
345 }
346
347 void MC_server_simcall_handle(mc_process_t process, unsigned long pid, int value)
348 {
349   s_mc_simcall_handle_message m;
350   memset(&m, 0, sizeof(m));
351   m.type  = MC_MESSAGE_SIMCALL_HANDLE;
352   m.pid   = pid;
353   m.value = value;
354   MC_protocol_send(mc_model_checker->process().socket, &m, sizeof(m));
355   process->cache_flags = (mc_process_cache_flags_t) 0;
356   while (mc_model_checker->process().running()) {
357     if (!mc_server->handle_events())
358       return;
359   }
360 }
361
362 void MC_server_loop(mc_server_t server)
363 {
364   server->loop();
365 }
366
367 }