xref: /openbmc/qemu/replay/replay.c (revision 2b74dd91)
1 /*
2  * replay.c
3  *
4  * Copyright (c) 2010-2015 Institute for System Programming
5  *                         of the Russian Academy of Sciences.
6  *
7  * This work is licensed under the terms of the GNU GPL, version 2 or later.
8  * See the COPYING file in the top-level directory.
9  *
10  */
11 
12 #include "qemu/osdep.h"
13 #include "qapi/error.h"
14 #include "sysemu/cpu-timers.h"
15 #include "sysemu/replay.h"
16 #include "sysemu/runstate.h"
17 #include "replay-internal.h"
18 #include "qemu/main-loop.h"
19 #include "qemu/option.h"
20 #include "sysemu/cpus.h"
21 #include "qemu/error-report.h"
22 
23 /* Current version of the replay mechanism.
24    Increase it when file format changes. */
25 #define REPLAY_VERSION              0xe0200c
26 /* Size of replay log header */
27 #define HEADER_SIZE                 (sizeof(uint32_t) + sizeof(uint64_t))
28 
29 ReplayMode replay_mode = REPLAY_MODE_NONE;
30 char *replay_snapshot;
31 
32 /* Name of replay file  */
33 static char *replay_filename;
34 ReplayState replay_state;
35 static GSList *replay_blockers;
36 
37 /* Replay breakpoints */
38 uint64_t replay_break_icount = -1ULL;
39 QEMUTimer *replay_break_timer;
40 
41 /* Pretty print event names */
42 
43 static const char *replay_async_event_name(ReplayAsyncEventKind event)
44 {
45     switch (event) {
46 #define ASYNC_EVENT(_x) case REPLAY_ASYNC_EVENT_ ## _x: return "ASYNC_EVENT_"#_x
47         ASYNC_EVENT(BH);
48         ASYNC_EVENT(BH_ONESHOT);
49         ASYNC_EVENT(INPUT);
50         ASYNC_EVENT(INPUT_SYNC);
51         ASYNC_EVENT(CHAR_READ);
52         ASYNC_EVENT(BLOCK);
53         ASYNC_EVENT(NET);
54 #undef ASYNC_EVENT
55     default:
56         g_assert_not_reached();
57     }
58 }
59 
60 static const char *replay_clock_event_name(ReplayClockKind clock)
61 {
62     switch (clock) {
63 #define CLOCK_EVENT(_x) case REPLAY_CLOCK_ ## _x: return "CLOCK_" #_x
64         CLOCK_EVENT(HOST);
65         CLOCK_EVENT(VIRTUAL_RT);
66 #undef CLOCK_EVENT
67     default:
68         g_assert_not_reached();
69     }
70 }
71 
72 /* Pretty print shutdown event names */
73 static const char *replay_shutdown_event_name(ShutdownCause cause)
74 {
75     switch (cause) {
76 #define SHUTDOWN_EVENT(_x) case SHUTDOWN_CAUSE_ ## _x: return "SHUTDOWN_CAUSE_" #_x
77         SHUTDOWN_EVENT(NONE);
78         SHUTDOWN_EVENT(HOST_ERROR);
79         SHUTDOWN_EVENT(HOST_QMP_QUIT);
80         SHUTDOWN_EVENT(HOST_QMP_SYSTEM_RESET);
81         SHUTDOWN_EVENT(HOST_SIGNAL);
82         SHUTDOWN_EVENT(HOST_UI);
83         SHUTDOWN_EVENT(GUEST_SHUTDOWN);
84         SHUTDOWN_EVENT(GUEST_RESET);
85         SHUTDOWN_EVENT(GUEST_PANIC);
86         SHUTDOWN_EVENT(SUBSYSTEM_RESET);
87         SHUTDOWN_EVENT(SNAPSHOT_LOAD);
88 #undef SHUTDOWN_EVENT
89     default:
90         g_assert_not_reached();
91     }
92 }
93 
94 static const char *replay_checkpoint_event_name(enum ReplayCheckpoint checkpoint)
95 {
96     switch (checkpoint) {
97 #define CHECKPOINT_EVENT(_x) case CHECKPOINT_ ## _x: return "CHECKPOINT_" #_x
98         CHECKPOINT_EVENT(CLOCK_WARP_START);
99         CHECKPOINT_EVENT(CLOCK_WARP_ACCOUNT);
100         CHECKPOINT_EVENT(RESET_REQUESTED);
101         CHECKPOINT_EVENT(SUSPEND_REQUESTED);
102         CHECKPOINT_EVENT(CLOCK_VIRTUAL);
103         CHECKPOINT_EVENT(CLOCK_HOST);
104         CHECKPOINT_EVENT(CLOCK_VIRTUAL_RT);
105         CHECKPOINT_EVENT(INIT);
106         CHECKPOINT_EVENT(RESET);
107 #undef CHECKPOINT_EVENT
108     default:
109         g_assert_not_reached();
110     }
111 }
112 
113 static const char *replay_event_name(enum ReplayEvents event)
114 {
115     /* First deal with the simple ones */
116     switch (event) {
117 #define EVENT(_x) case EVENT_ ## _x: return "EVENT_"#_x
118         EVENT(INSTRUCTION);
119         EVENT(INTERRUPT);
120         EVENT(EXCEPTION);
121         EVENT(CHAR_WRITE);
122         EVENT(CHAR_READ_ALL);
123         EVENT(AUDIO_OUT);
124         EVENT(AUDIO_IN);
125         EVENT(RANDOM);
126 #undef EVENT
127     default:
128         if (event >= EVENT_ASYNC && event <= EVENT_ASYNC_LAST) {
129             return replay_async_event_name(event - EVENT_ASYNC);
130         } else if (event >= EVENT_SHUTDOWN && event <= EVENT_SHUTDOWN_LAST) {
131             return replay_shutdown_event_name(event - EVENT_SHUTDOWN);
132         } else if (event >= EVENT_CLOCK && event <= EVENT_CLOCK_LAST) {
133             return replay_clock_event_name(event - EVENT_CLOCK);
134         } else if (event >= EVENT_CHECKPOINT && event <= EVENT_CHECKPOINT_LAST) {
135             return replay_checkpoint_event_name(event - EVENT_CHECKPOINT);
136         }
137     }
138 
139     g_assert_not_reached();
140 }
141 
142 bool replay_next_event_is(int event)
143 {
144     bool res = false;
145 
146     /* nothing to skip - not all instructions used */
147     if (replay_state.instruction_count != 0) {
148         assert(replay_state.data_kind == EVENT_INSTRUCTION);
149         return event == EVENT_INSTRUCTION;
150     }
151 
152     while (true) {
153         unsigned int data_kind = replay_state.data_kind;
154         if (event == data_kind) {
155             res = true;
156         }
157         switch (data_kind) {
158         case EVENT_SHUTDOWN ... EVENT_SHUTDOWN_LAST:
159             replay_finish_event();
160             qemu_system_shutdown_request(data_kind - EVENT_SHUTDOWN);
161             break;
162         default:
163             /* clock, time_t, checkpoint and other events */
164             return res;
165         }
166     }
167     return res;
168 }
169 
170 uint64_t replay_get_current_icount(void)
171 {
172     return icount_get_raw();
173 }
174 
175 int replay_get_instructions(void)
176 {
177     int res = 0;
178     g_assert(replay_mutex_locked());
179     if (replay_next_event_is(EVENT_INSTRUCTION)) {
180         res = replay_state.instruction_count;
181         if (replay_break_icount != -1LL) {
182             uint64_t current = replay_get_current_icount();
183             assert(replay_break_icount >= current);
184             if (current + res > replay_break_icount) {
185                 res = replay_break_icount - current;
186             }
187         }
188     }
189     return res;
190 }
191 
192 void replay_account_executed_instructions(void)
193 {
194     if (replay_mode == REPLAY_MODE_PLAY) {
195         g_assert(replay_mutex_locked());
196         if (replay_state.instruction_count > 0) {
197             replay_advance_current_icount(replay_get_current_icount());
198         }
199     }
200 }
201 
202 bool replay_exception(void)
203 {
204 
205     if (replay_mode == REPLAY_MODE_RECORD) {
206         g_assert(replay_mutex_locked());
207         replay_save_instructions();
208         replay_put_event(EVENT_EXCEPTION);
209         return true;
210     } else if (replay_mode == REPLAY_MODE_PLAY) {
211         g_assert(replay_mutex_locked());
212         bool res = replay_has_exception();
213         if (res) {
214             replay_finish_event();
215         }
216         return res;
217     }
218 
219     return true;
220 }
221 
222 bool replay_has_exception(void)
223 {
224     bool res = false;
225     if (replay_mode == REPLAY_MODE_PLAY) {
226         g_assert(replay_mutex_locked());
227         replay_account_executed_instructions();
228         res = replay_next_event_is(EVENT_EXCEPTION);
229     }
230 
231     return res;
232 }
233 
234 bool replay_interrupt(void)
235 {
236     if (replay_mode == REPLAY_MODE_RECORD) {
237         g_assert(replay_mutex_locked());
238         replay_save_instructions();
239         replay_put_event(EVENT_INTERRUPT);
240         return true;
241     } else if (replay_mode == REPLAY_MODE_PLAY) {
242         g_assert(replay_mutex_locked());
243         bool res = replay_has_interrupt();
244         if (res) {
245             replay_finish_event();
246         }
247         return res;
248     }
249 
250     return true;
251 }
252 
253 bool replay_has_interrupt(void)
254 {
255     bool res = false;
256     if (replay_mode == REPLAY_MODE_PLAY) {
257         g_assert(replay_mutex_locked());
258         replay_account_executed_instructions();
259         res = replay_next_event_is(EVENT_INTERRUPT);
260     }
261     return res;
262 }
263 
264 void replay_shutdown_request(ShutdownCause cause)
265 {
266     if (replay_mode == REPLAY_MODE_RECORD) {
267         g_assert(replay_mutex_locked());
268         replay_put_event(EVENT_SHUTDOWN + cause);
269     }
270 }
271 
272 bool replay_checkpoint(ReplayCheckpoint checkpoint)
273 {
274     assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);
275 
276     replay_save_instructions();
277 
278     if (replay_mode == REPLAY_MODE_PLAY) {
279         g_assert(replay_mutex_locked());
280         if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
281             replay_finish_event();
282         } else {
283             return false;
284         }
285     } else if (replay_mode == REPLAY_MODE_RECORD) {
286         g_assert(replay_mutex_locked());
287         replay_put_event(EVENT_CHECKPOINT + checkpoint);
288     }
289     return true;
290 }
291 
292 void replay_async_events(void)
293 {
294     static bool processing = false;
295     /*
296      * If we are already processing the events, recursion may occur
297      * in case of incorrect implementation when HW event modifies timers.
298      * Timer modification may invoke the icount warp, event processing,
299      * and cause the recursion.
300      */
301     g_assert(!processing);
302     processing = true;
303 
304     replay_save_instructions();
305 
306     if (replay_mode == REPLAY_MODE_PLAY) {
307         g_assert(replay_mutex_locked());
308         replay_read_events();
309     } else if (replay_mode == REPLAY_MODE_RECORD) {
310         g_assert(replay_mutex_locked());
311         replay_save_events();
312     }
313     processing = false;
314 }
315 
316 bool replay_has_event(void)
317 {
318     bool res = false;
319     if (replay_mode == REPLAY_MODE_PLAY) {
320         g_assert(replay_mutex_locked());
321         replay_account_executed_instructions();
322         res = EVENT_CHECKPOINT <= replay_state.data_kind
323               && replay_state.data_kind <= EVENT_CHECKPOINT_LAST;
324         res = res || (EVENT_ASYNC <= replay_state.data_kind
325                      && replay_state.data_kind <= EVENT_ASYNC_LAST);
326     }
327     return res;
328 }
329 
330 G_NORETURN void replay_sync_error(const char *error)
331 {
332     error_report("%s (insn total %"PRId64"/%d left, event %d is %s)", error,
333                  replay_state.current_icount, replay_state.instruction_count,
334                  replay_state.current_event,
335                  replay_event_name(replay_state.data_kind));
336     abort();
337 }
338 
339 static void replay_enable(const char *fname, int mode)
340 {
341     const char *fmode = NULL;
342     assert(!replay_file);
343 
344     switch (mode) {
345     case REPLAY_MODE_RECORD:
346         fmode = "wb";
347         break;
348     case REPLAY_MODE_PLAY:
349         fmode = "rb";
350         break;
351     default:
352         fprintf(stderr, "Replay: internal error: invalid replay mode\n");
353         exit(1);
354     }
355 
356     atexit(replay_finish);
357 
358     replay_file = fopen(fname, fmode);
359     if (replay_file == NULL) {
360         fprintf(stderr, "Replay: open %s: %s\n", fname, strerror(errno));
361         exit(1);
362     }
363 
364     replay_filename = g_strdup(fname);
365     replay_mode = mode;
366     replay_mutex_init();
367 
368     replay_state.data_kind = -1;
369     replay_state.instruction_count = 0;
370     replay_state.current_icount = 0;
371     replay_state.current_event = 0;
372     replay_state.has_unread_data = 0;
373 
374     /* skip file header for RECORD and check it for PLAY */
375     if (replay_mode == REPLAY_MODE_RECORD) {
376         fseek(replay_file, HEADER_SIZE, SEEK_SET);
377     } else if (replay_mode == REPLAY_MODE_PLAY) {
378         unsigned int version = replay_get_dword();
379         if (version != REPLAY_VERSION) {
380             fprintf(stderr, "Replay: invalid input log file version\n");
381             exit(1);
382         }
383         /* go to the beginning */
384         fseek(replay_file, HEADER_SIZE, SEEK_SET);
385         replay_fetch_data_kind();
386     }
387 
388     runstate_replay_enable();
389 
390     replay_init_events();
391 }
392 
393 void replay_configure(QemuOpts *opts)
394 {
395     const char *fname;
396     const char *rr;
397     ReplayMode mode = REPLAY_MODE_NONE;
398     Location loc;
399 
400     if (!opts) {
401         return;
402     }
403 
404     loc_push_none(&loc);
405     qemu_opts_loc_restore(opts);
406 
407     rr = qemu_opt_get(opts, "rr");
408     if (!rr) {
409         /* Just enabling icount */
410         goto out;
411     } else if (!strcmp(rr, "record")) {
412         mode = REPLAY_MODE_RECORD;
413     } else if (!strcmp(rr, "replay")) {
414         mode = REPLAY_MODE_PLAY;
415     } else {
416         error_report("Invalid icount rr option: %s", rr);
417         exit(1);
418     }
419 
420     fname = qemu_opt_get(opts, "rrfile");
421     if (!fname) {
422         error_report("File name not specified for replay");
423         exit(1);
424     }
425 
426     replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot"));
427     replay_vmstate_register();
428     replay_enable(fname, mode);
429 
430 out:
431     loc_pop(&loc);
432 }
433 
434 void replay_start(void)
435 {
436     if (replay_mode == REPLAY_MODE_NONE) {
437         return;
438     }
439 
440     if (replay_blockers) {
441         error_reportf_err(replay_blockers->data, "Record/replay: ");
442         exit(1);
443     }
444     if (!icount_enabled()) {
445         error_report("Please enable icount to use record/replay");
446         exit(1);
447     }
448 
449     /* Timer for snapshotting will be set up here. */
450 
451     replay_enable_events();
452 }
453 
454 void replay_finish(void)
455 {
456     if (replay_mode == REPLAY_MODE_NONE) {
457         return;
458     }
459 
460     replay_save_instructions();
461 
462     /* finalize the file */
463     if (replay_file) {
464         if (replay_mode == REPLAY_MODE_RECORD) {
465             /*
466              * Can't do it in the signal handler, therefore
467              * add shutdown event here for the case of Ctrl-C.
468              */
469             replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL);
470             /* write end event */
471             replay_put_event(EVENT_END);
472 
473             /* write header */
474             fseek(replay_file, 0, SEEK_SET);
475             replay_put_dword(REPLAY_VERSION);
476         }
477 
478         fclose(replay_file);
479         replay_file = NULL;
480     }
481     g_free(replay_filename);
482     replay_filename = NULL;
483 
484     g_free(replay_snapshot);
485     replay_snapshot = NULL;
486 
487     replay_finish_events();
488     replay_mode = REPLAY_MODE_NONE;
489 }
490 
491 void replay_add_blocker(const char *feature)
492 {
493     Error *reason = NULL;
494 
495     error_setg(&reason, "Record/replay is not supported with %s",
496                feature);
497     replay_blockers = g_slist_prepend(replay_blockers, reason);
498 }
499 
500 const char *replay_get_filename(void)
501 {
502     return replay_filename;
503 }
504