virtio-pci: address space translation service (ATS) support
[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 "qemu-common.h"
15 #include "sysemu/replay.h"
16 #include "replay-internal.h"
17 #include "qemu/timer.h"
18 #include "qemu/main-loop.h"
19 #include "sysemu/sysemu.h"
20 #include "qemu/error-report.h"
21
22 /* Current version of the replay mechanism.
23 Increase it when file format changes. */
24 #define REPLAY_VERSION 0xe02005
25 /* Size of replay log header */
26 #define HEADER_SIZE (sizeof(uint32_t) + sizeof(uint64_t))
27
28 ReplayMode replay_mode = REPLAY_MODE_NONE;
29
30 /* Name of replay file */
31 static char *replay_filename;
32 ReplayState replay_state;
33 static GSList *replay_blockers;
34
35 bool replay_next_event_is(int event)
36 {
37 bool res = false;
38
39 /* nothing to skip - not all instructions used */
40 if (replay_state.instructions_count != 0) {
41 assert(replay_state.data_kind == EVENT_INSTRUCTION);
42 return event == EVENT_INSTRUCTION;
43 }
44
45 while (true) {
46 if (event == replay_state.data_kind) {
47 res = true;
48 }
49 switch (replay_state.data_kind) {
50 case EVENT_SHUTDOWN:
51 replay_finish_event();
52 qemu_system_shutdown_request();
53 break;
54 default:
55 /* clock, time_t, checkpoint and other events */
56 return res;
57 }
58 }
59 return res;
60 }
61
62 uint64_t replay_get_current_step(void)
63 {
64 return cpu_get_icount_raw();
65 }
66
67 int replay_get_instructions(void)
68 {
69 int res = 0;
70 replay_mutex_lock();
71 if (replay_next_event_is(EVENT_INSTRUCTION)) {
72 res = replay_state.instructions_count;
73 }
74 replay_mutex_unlock();
75 return res;
76 }
77
78 void replay_account_executed_instructions(void)
79 {
80 if (replay_mode == REPLAY_MODE_PLAY) {
81 replay_mutex_lock();
82 if (replay_state.instructions_count > 0) {
83 int count = (int)(replay_get_current_step()
84 - replay_state.current_step);
85 replay_state.instructions_count -= count;
86 replay_state.current_step += count;
87 if (replay_state.instructions_count == 0) {
88 assert(replay_state.data_kind == EVENT_INSTRUCTION);
89 replay_finish_event();
90 /* Wake up iothread. This is required because
91 timers will not expire until clock counters
92 will be read from the log. */
93 qemu_notify_event();
94 }
95 }
96 replay_mutex_unlock();
97 }
98 }
99
100 bool replay_exception(void)
101 {
102 if (replay_mode == REPLAY_MODE_RECORD) {
103 replay_save_instructions();
104 replay_mutex_lock();
105 replay_put_event(EVENT_EXCEPTION);
106 replay_mutex_unlock();
107 return true;
108 } else if (replay_mode == REPLAY_MODE_PLAY) {
109 bool res = replay_has_exception();
110 if (res) {
111 replay_mutex_lock();
112 replay_finish_event();
113 replay_mutex_unlock();
114 }
115 return res;
116 }
117
118 return true;
119 }
120
121 bool replay_has_exception(void)
122 {
123 bool res = false;
124 if (replay_mode == REPLAY_MODE_PLAY) {
125 replay_account_executed_instructions();
126 replay_mutex_lock();
127 res = replay_next_event_is(EVENT_EXCEPTION);
128 replay_mutex_unlock();
129 }
130
131 return res;
132 }
133
134 bool replay_interrupt(void)
135 {
136 if (replay_mode == REPLAY_MODE_RECORD) {
137 replay_save_instructions();
138 replay_mutex_lock();
139 replay_put_event(EVENT_INTERRUPT);
140 replay_mutex_unlock();
141 return true;
142 } else if (replay_mode == REPLAY_MODE_PLAY) {
143 bool res = replay_has_interrupt();
144 if (res) {
145 replay_mutex_lock();
146 replay_finish_event();
147 replay_mutex_unlock();
148 }
149 return res;
150 }
151
152 return true;
153 }
154
155 bool replay_has_interrupt(void)
156 {
157 bool res = false;
158 if (replay_mode == REPLAY_MODE_PLAY) {
159 replay_account_executed_instructions();
160 replay_mutex_lock();
161 res = replay_next_event_is(EVENT_INTERRUPT);
162 replay_mutex_unlock();
163 }
164 return res;
165 }
166
167 void replay_shutdown_request(void)
168 {
169 if (replay_mode == REPLAY_MODE_RECORD) {
170 replay_mutex_lock();
171 replay_put_event(EVENT_SHUTDOWN);
172 replay_mutex_unlock();
173 }
174 }
175
176 bool replay_checkpoint(ReplayCheckpoint checkpoint)
177 {
178 bool res = false;
179 assert(EVENT_CHECKPOINT + checkpoint <= EVENT_CHECKPOINT_LAST);
180 replay_save_instructions();
181
182 if (!replay_file) {
183 return true;
184 }
185
186 replay_mutex_lock();
187
188 if (replay_mode == REPLAY_MODE_PLAY) {
189 if (replay_next_event_is(EVENT_CHECKPOINT + checkpoint)) {
190 replay_finish_event();
191 } else if (replay_state.data_kind != EVENT_ASYNC) {
192 res = false;
193 goto out;
194 }
195 replay_read_events(checkpoint);
196 /* replay_read_events may leave some unread events.
197 Return false if not all of the events associated with
198 checkpoint were processed */
199 res = replay_state.data_kind != EVENT_ASYNC;
200 } else if (replay_mode == REPLAY_MODE_RECORD) {
201 replay_put_event(EVENT_CHECKPOINT + checkpoint);
202 replay_save_events(checkpoint);
203 res = true;
204 }
205 out:
206 replay_mutex_unlock();
207 return res;
208 }
209
210 static void replay_enable(const char *fname, int mode)
211 {
212 const char *fmode = NULL;
213 assert(!replay_file);
214
215 switch (mode) {
216 case REPLAY_MODE_RECORD:
217 fmode = "wb";
218 break;
219 case REPLAY_MODE_PLAY:
220 fmode = "rb";
221 break;
222 default:
223 fprintf(stderr, "Replay: internal error: invalid replay mode\n");
224 exit(1);
225 }
226
227 atexit(replay_finish);
228
229 replay_mutex_init();
230
231 replay_file = fopen(fname, fmode);
232 if (replay_file == NULL) {
233 fprintf(stderr, "Replay: open %s: %s\n", fname, strerror(errno));
234 exit(1);
235 }
236
237 replay_filename = g_strdup(fname);
238
239 replay_mode = mode;
240 replay_state.data_kind = -1;
241 replay_state.instructions_count = 0;
242 replay_state.current_step = 0;
243 replay_state.has_unread_data = 0;
244
245 /* skip file header for RECORD and check it for PLAY */
246 if (replay_mode == REPLAY_MODE_RECORD) {
247 fseek(replay_file, HEADER_SIZE, SEEK_SET);
248 } else if (replay_mode == REPLAY_MODE_PLAY) {
249 unsigned int version = replay_get_dword();
250 if (version != REPLAY_VERSION) {
251 fprintf(stderr, "Replay: invalid input log file version\n");
252 exit(1);
253 }
254 /* go to the beginning */
255 fseek(replay_file, HEADER_SIZE, SEEK_SET);
256 replay_fetch_data_kind();
257 }
258
259 replay_init_events();
260 }
261
262 void replay_configure(QemuOpts *opts)
263 {
264 const char *fname;
265 const char *rr;
266 ReplayMode mode = REPLAY_MODE_NONE;
267 Location loc;
268
269 if (!opts) {
270 return;
271 }
272
273 loc_push_none(&loc);
274 qemu_opts_loc_restore(opts);
275
276 rr = qemu_opt_get(opts, "rr");
277 if (!rr) {
278 /* Just enabling icount */
279 goto out;
280 } else if (!strcmp(rr, "record")) {
281 mode = REPLAY_MODE_RECORD;
282 } else if (!strcmp(rr, "replay")) {
283 mode = REPLAY_MODE_PLAY;
284 } else {
285 error_report("Invalid icount rr option: %s", rr);
286 exit(1);
287 }
288
289 fname = qemu_opt_get(opts, "rrfile");
290 if (!fname) {
291 error_report("File name not specified for replay");
292 exit(1);
293 }
294
295 replay_vmstate_register();
296 replay_enable(fname, mode);
297
298 out:
299 loc_pop(&loc);
300 }
301
302 void replay_start(void)
303 {
304 if (replay_mode == REPLAY_MODE_NONE) {
305 return;
306 }
307
308 if (replay_blockers) {
309 error_reportf_err(replay_blockers->data, "Record/replay: ");
310 exit(1);
311 }
312 if (!use_icount) {
313 error_report("Please enable icount to use record/replay");
314 exit(1);
315 }
316
317 /* Timer for snapshotting will be set up here. */
318
319 replay_enable_events();
320 }
321
322 void replay_finish(void)
323 {
324 if (replay_mode == REPLAY_MODE_NONE) {
325 return;
326 }
327
328 replay_save_instructions();
329
330 /* finalize the file */
331 if (replay_file) {
332 if (replay_mode == REPLAY_MODE_RECORD) {
333 /* write end event */
334 replay_put_event(EVENT_END);
335
336 /* write header */
337 fseek(replay_file, 0, SEEK_SET);
338 replay_put_dword(REPLAY_VERSION);
339 }
340
341 fclose(replay_file);
342 replay_file = NULL;
343 }
344 if (replay_filename) {
345 g_free(replay_filename);
346 replay_filename = NULL;
347 }
348
349 replay_finish_events();
350 replay_mutex_destroy();
351 }
352
353 void replay_add_blocker(Error *reason)
354 {
355 replay_blockers = g_slist_prepend(replay_blockers, reason);
356 }