Add G_GNUC_PRINTF to function qemu_set_info_str and fix related issues
[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 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 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 assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);
175
176 replay_save_instructions();
177
178 if (replay_mode == REPLAY_MODE_PLAY) {
179 g_assert(replay_mutex_locked());
180 if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
181 replay_finish_event();
182 } else {
183 return false;
184 }
185 } else if (replay_mode == REPLAY_MODE_RECORD) {
186 g_assert(replay_mutex_locked());
187 replay_put_event(EVENT_CHECKPOINT + checkpoint);
188 }
189 return true;
190 }
191
192 void replay_async_events(void)
193 {
194 static bool processing = false;
195 /*
196 * If we are already processing the events, recursion may occur
197 * in case of incorrect implementation when HW event modifies timers.
198 * Timer modification may invoke the icount warp, event processing,
199 * and cause the recursion.
200 */
201 g_assert(!processing);
202 processing = true;
203
204 replay_save_instructions();
205
206 if (replay_mode == REPLAY_MODE_PLAY) {
207 g_assert(replay_mutex_locked());
208 replay_read_events();
209 } else if (replay_mode == REPLAY_MODE_RECORD) {
210 g_assert(replay_mutex_locked());
211 replay_save_events();
212 }
213 processing = false;
214 }
215
216 bool replay_has_event(void)
217 {
218 bool res = false;
219 if (replay_mode == REPLAY_MODE_PLAY) {
220 g_assert(replay_mutex_locked());
221 replay_account_executed_instructions();
222 res = EVENT_CHECKPOINT <= replay_state.data_kind
223 && replay_state.data_kind <= EVENT_CHECKPOINT_LAST;
224 res = res || (EVENT_ASYNC <= replay_state.data_kind
225 && replay_state.data_kind <= EVENT_ASYNC_LAST);
226 }
227 return res;
228 }
229
230 static void replay_enable(const char *fname, int mode)
231 {
232 const char *fmode = NULL;
233 assert(!replay_file);
234
235 switch (mode) {
236 case REPLAY_MODE_RECORD:
237 fmode = "wb";
238 break;
239 case REPLAY_MODE_PLAY:
240 fmode = "rb";
241 break;
242 default:
243 fprintf(stderr, "Replay: internal error: invalid replay mode\n");
244 exit(1);
245 }
246
247 atexit(replay_finish);
248
249 replay_file = fopen(fname, fmode);
250 if (replay_file == NULL) {
251 fprintf(stderr, "Replay: open %s: %s\n", fname, strerror(errno));
252 exit(1);
253 }
254
255 replay_filename = g_strdup(fname);
256 replay_mode = mode;
257 replay_mutex_init();
258
259 replay_state.data_kind = -1;
260 replay_state.instruction_count = 0;
261 replay_state.current_icount = 0;
262 replay_state.has_unread_data = 0;
263
264 /* skip file header for RECORD and check it for PLAY */
265 if (replay_mode == REPLAY_MODE_RECORD) {
266 fseek(replay_file, HEADER_SIZE, SEEK_SET);
267 } else if (replay_mode == REPLAY_MODE_PLAY) {
268 unsigned int version = replay_get_dword();
269 if (version != REPLAY_VERSION) {
270 fprintf(stderr, "Replay: invalid input log file version\n");
271 exit(1);
272 }
273 /* go to the beginning */
274 fseek(replay_file, HEADER_SIZE, SEEK_SET);
275 replay_fetch_data_kind();
276 }
277
278 replay_init_events();
279 }
280
281 void replay_configure(QemuOpts *opts)
282 {
283 const char *fname;
284 const char *rr;
285 ReplayMode mode = REPLAY_MODE_NONE;
286 Location loc;
287
288 if (!opts) {
289 return;
290 }
291
292 loc_push_none(&loc);
293 qemu_opts_loc_restore(opts);
294
295 rr = qemu_opt_get(opts, "rr");
296 if (!rr) {
297 /* Just enabling icount */
298 goto out;
299 } else if (!strcmp(rr, "record")) {
300 mode = REPLAY_MODE_RECORD;
301 } else if (!strcmp(rr, "replay")) {
302 mode = REPLAY_MODE_PLAY;
303 } else {
304 error_report("Invalid icount rr option: %s", rr);
305 exit(1);
306 }
307
308 fname = qemu_opt_get(opts, "rrfile");
309 if (!fname) {
310 error_report("File name not specified for replay");
311 exit(1);
312 }
313
314 replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot"));
315 replay_vmstate_register();
316 replay_enable(fname, mode);
317
318 out:
319 loc_pop(&loc);
320 }
321
322 void replay_start(void)
323 {
324 if (replay_mode == REPLAY_MODE_NONE) {
325 return;
326 }
327
328 if (replay_blockers) {
329 error_reportf_err(replay_blockers->data, "Record/replay: ");
330 exit(1);
331 }
332 if (!icount_enabled()) {
333 error_report("Please enable icount to use record/replay");
334 exit(1);
335 }
336
337 /* Timer for snapshotting will be set up here. */
338
339 replay_enable_events();
340 }
341
342 void replay_finish(void)
343 {
344 if (replay_mode == REPLAY_MODE_NONE) {
345 return;
346 }
347
348 replay_save_instructions();
349
350 /* finalize the file */
351 if (replay_file) {
352 if (replay_mode == REPLAY_MODE_RECORD) {
353 /*
354 * Can't do it in the signal handler, therefore
355 * add shutdown event here for the case of Ctrl-C.
356 */
357 replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL);
358 /* write end event */
359 replay_put_event(EVENT_END);
360
361 /* write header */
362 fseek(replay_file, 0, SEEK_SET);
363 replay_put_dword(REPLAY_VERSION);
364 }
365
366 fclose(replay_file);
367 replay_file = NULL;
368 }
369 if (replay_filename) {
370 g_free(replay_filename);
371 replay_filename = NULL;
372 }
373
374 g_free(replay_snapshot);
375 replay_snapshot = NULL;
376
377 replay_finish_events();
378 replay_mode = REPLAY_MODE_NONE;
379 }
380
381 void replay_add_blocker(Error *reason)
382 {
383 replay_blockers = g_slist_prepend(replay_blockers, reason);
384 }
385
386 const char *replay_get_filename(void)
387 {
388 return replay_filename;
389 }