Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20210921' into staging
[qemu.git] / replay / replay.c
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 0xe0200a
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 bool replay_next_event_is(int event)
42 {
43 bool res = false;
44
45 /* nothing to skip - not all instructions used */
46 if (replay_state.instruction_count != 0) {
47 assert(replay_state.data_kind == EVENT_INSTRUCTION);
48 return event == EVENT_INSTRUCTION;
49 }
50
51 while (true) {
52 unsigned int data_kind = replay_state.data_kind;
53 if (event == data_kind) {
54 res = true;
55 }
56 switch (data_kind) {
57 case EVENT_SHUTDOWN ... EVENT_SHUTDOWN_LAST:
58 replay_finish_event();
59 qemu_system_shutdown_request(data_kind - EVENT_SHUTDOWN);
60 break;
61 default:
62 /* clock, time_t, checkpoint and other events */
63 return res;
64 }
65 }
66 return res;
67 }
68
69 uint64_t replay_get_current_icount(void)
70 {
71 return icount_get_raw();
72 }
73
74 int replay_get_instructions(void)
75 {
76 int res = 0;
77 replay_mutex_lock();
78 if (replay_next_event_is(EVENT_INSTRUCTION)) {
79 res = replay_state.instruction_count;
80 if (replay_break_icount != -1LL) {
81 uint64_t current = replay_get_current_icount();
82 assert(replay_break_icount >= current);
83 if (current + res > replay_break_icount) {
84 res = replay_break_icount - current;
85 }
86 }
87 }
88 replay_mutex_unlock();
89 return res;
90 }
91
92 void replay_account_executed_instructions(void)
93 {
94 if (replay_mode == REPLAY_MODE_PLAY) {
95 g_assert(replay_mutex_locked());
96 if (replay_state.instruction_count > 0) {
97 replay_advance_current_icount(replay_get_current_icount());
98 }
99 }
100 }
101
102 bool replay_exception(void)
103 {
104
105 if (replay_mode == REPLAY_MODE_RECORD) {
106 g_assert(replay_mutex_locked());
107 replay_save_instructions();
108 replay_put_event(EVENT_EXCEPTION);
109 return true;
110 } else if (replay_mode == REPLAY_MODE_PLAY) {
111 g_assert(replay_mutex_locked());
112 bool res = replay_has_exception();
113 if (res) {
114 replay_finish_event();
115 }
116 return res;
117 }
118
119 return true;
120 }
121
122 bool replay_has_exception(void)
123 {
124 bool res = false;
125 if (replay_mode == REPLAY_MODE_PLAY) {
126 g_assert(replay_mutex_locked());
127 replay_account_executed_instructions();
128 res = replay_next_event_is(EVENT_EXCEPTION);
129 }
130
131 return res;
132 }
133
134 bool replay_interrupt(void)
135 {
136 if (replay_mode == REPLAY_MODE_RECORD) {
137 g_assert(replay_mutex_locked());
138 replay_save_instructions();
139 replay_put_event(EVENT_INTERRUPT);
140 return true;
141 } else if (replay_mode == REPLAY_MODE_PLAY) {
142 g_assert(replay_mutex_locked());
143 bool res = replay_has_interrupt();
144 if (res) {
145 replay_finish_event();
146 }
147 return res;
148 }
149
150 return true;
151 }
152
153 bool replay_has_interrupt(void)
154 {
155 bool res = false;
156 if (replay_mode == REPLAY_MODE_PLAY) {
157 g_assert(replay_mutex_locked());
158 replay_account_executed_instructions();
159 res = replay_next_event_is(EVENT_INTERRUPT);
160 }
161 return res;
162 }
163
164 void replay_shutdown_request(ShutdownCause cause)
165 {
166 if (replay_mode == REPLAY_MODE_RECORD) {
167 g_assert(replay_mutex_locked());
168 replay_put_event(EVENT_SHUTDOWN + cause);
169 }
170 }
171
172 bool replay_checkpoint(ReplayCheckpoint checkpoint)
173 {
174 bool res = false;
175 static bool in_checkpoint;
176 assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);
177
178 if (!replay_file) {
179 return true;
180 }
181
182 if (in_checkpoint) {
183 /*
184 Recursion occurs when HW event modifies timers.
185 Prevent performing icount warp in this case and
186 wait for another invocation of the checkpoint.
187 */
188 g_assert(replay_mode == REPLAY_MODE_PLAY);
189 return false;
190 }
191 in_checkpoint = true;
192
193 replay_save_instructions();
194
195 if (replay_mode == REPLAY_MODE_PLAY) {
196 g_assert(replay_mutex_locked());
197 if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
198 replay_finish_event();
199 } else if (replay_state.data_kind != EVENT_ASYNC) {
200 res = false;
201 goto out;
202 }
203 replay_read_events(checkpoint);
204 /* replay_read_events may leave some unread events.
205 Return false if not all of the events associated with
206 checkpoint were processed */
207 res = replay_state.data_kind != EVENT_ASYNC;
208 } else if (replay_mode == REPLAY_MODE_RECORD) {
209 g_assert(replay_mutex_locked());
210 replay_put_event(EVENT_CHECKPOINT + checkpoint);
211 /* This checkpoint belongs to several threads.
212 Processing events from different threads is
213 non-deterministic */
214 if (checkpoint != CHECKPOINT_CLOCK_WARP_START
215 /* FIXME: this is temporary fix, other checkpoints
216 may also be invoked from the different threads someday.
217 Asynchronous event processing should be refactored
218 to create additional replay event kind which is
219 nailed to the one of the threads and which processes
220 the event queue. */
221 && checkpoint != CHECKPOINT_CLOCK_VIRTUAL) {
222 replay_save_events(checkpoint);
223 }
224 res = true;
225 }
226 out:
227 in_checkpoint = false;
228 return res;
229 }
230
231 bool replay_has_checkpoint(void)
232 {
233 bool res = false;
234 if (replay_mode == REPLAY_MODE_PLAY) {
235 g_assert(replay_mutex_locked());
236 replay_account_executed_instructions();
237 res = EVENT_CHECKPOINT <= replay_state.data_kind
238 && replay_state.data_kind <= EVENT_CHECKPOINT_LAST;
239 }
240 return res;
241 }
242
243 static void replay_enable(const char *fname, int mode)
244 {
245 const char *fmode = NULL;
246 assert(!replay_file);
247
248 switch (mode) {
249 case REPLAY_MODE_RECORD:
250 fmode = "wb";
251 break;
252 case REPLAY_MODE_PLAY:
253 fmode = "rb";
254 break;
255 default:
256 fprintf(stderr, "Replay: internal error: invalid replay mode\n");
257 exit(1);
258 }
259
260 atexit(replay_finish);
261
262 replay_file = fopen(fname, fmode);
263 if (replay_file == NULL) {
264 fprintf(stderr, "Replay: open %s: %s\n", fname, strerror(errno));
265 exit(1);
266 }
267
268 replay_filename = g_strdup(fname);
269 replay_mode = mode;
270 replay_mutex_init();
271
272 replay_state.data_kind = -1;
273 replay_state.instruction_count = 0;
274 replay_state.current_icount = 0;
275 replay_state.has_unread_data = 0;
276
277 /* skip file header for RECORD and check it for PLAY */
278 if (replay_mode == REPLAY_MODE_RECORD) {
279 fseek(replay_file, HEADER_SIZE, SEEK_SET);
280 } else if (replay_mode == REPLAY_MODE_PLAY) {
281 unsigned int version = replay_get_dword();
282 if (version != REPLAY_VERSION) {
283 fprintf(stderr, "Replay: invalid input log file version\n");
284 exit(1);
285 }
286 /* go to the beginning */
287 fseek(replay_file, HEADER_SIZE, SEEK_SET);
288 replay_fetch_data_kind();
289 }
290
291 replay_init_events();
292 }
293
294 void replay_configure(QemuOpts *opts)
295 {
296 const char *fname;
297 const char *rr;
298 ReplayMode mode = REPLAY_MODE_NONE;
299 Location loc;
300
301 if (!opts) {
302 return;
303 }
304
305 loc_push_none(&loc);
306 qemu_opts_loc_restore(opts);
307
308 rr = qemu_opt_get(opts, "rr");
309 if (!rr) {
310 /* Just enabling icount */
311 goto out;
312 } else if (!strcmp(rr, "record")) {
313 mode = REPLAY_MODE_RECORD;
314 } else if (!strcmp(rr, "replay")) {
315 mode = REPLAY_MODE_PLAY;
316 } else {
317 error_report("Invalid icount rr option: %s", rr);
318 exit(1);
319 }
320
321 fname = qemu_opt_get(opts, "rrfile");
322 if (!fname) {
323 error_report("File name not specified for replay");
324 exit(1);
325 }
326
327 replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot"));
328 replay_vmstate_register();
329 replay_enable(fname, mode);
330
331 out:
332 loc_pop(&loc);
333 }
334
335 void replay_start(void)
336 {
337 if (replay_mode == REPLAY_MODE_NONE) {
338 return;
339 }
340
341 if (replay_blockers) {
342 error_reportf_err(replay_blockers->data, "Record/replay: ");
343 exit(1);
344 }
345 if (!icount_enabled()) {
346 error_report("Please enable icount to use record/replay");
347 exit(1);
348 }
349
350 /* Timer for snapshotting will be set up here. */
351
352 replay_enable_events();
353 }
354
355 void replay_finish(void)
356 {
357 if (replay_mode == REPLAY_MODE_NONE) {
358 return;
359 }
360
361 replay_save_instructions();
362
363 /* finalize the file */
364 if (replay_file) {
365 if (replay_mode == REPLAY_MODE_RECORD) {
366 /*
367 * Can't do it in the signal handler, therefore
368 * add shutdown event here for the case of Ctrl-C.
369 */
370 replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL);
371 /* write end event */
372 replay_put_event(EVENT_END);
373
374 /* write header */
375 fseek(replay_file, 0, SEEK_SET);
376 replay_put_dword(REPLAY_VERSION);
377 }
378
379 fclose(replay_file);
380 replay_file = NULL;
381 }
382 if (replay_filename) {
383 g_free(replay_filename);
384 replay_filename = NULL;
385 }
386
387 g_free(replay_snapshot);
388 replay_snapshot = NULL;
389
390 replay_mode = REPLAY_MODE_NONE;
391
392 replay_finish_events();
393 }
394
395 void replay_add_blocker(Error *reason)
396 {
397 replay_blockers = g_slist_prepend(replay_blockers, reason);
398 }
399
400 const char *replay_get_filename(void)
401 {
402 return replay_filename;
403 }