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