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 replay_init_events(); 389 } 390 391 void replay_configure(QemuOpts *opts) 392 { 393 const char *fname; 394 const char *rr; 395 ReplayMode mode = REPLAY_MODE_NONE; 396 Location loc; 397 398 if (!opts) { 399 return; 400 } 401 402 loc_push_none(&loc); 403 qemu_opts_loc_restore(opts); 404 405 rr = qemu_opt_get(opts, "rr"); 406 if (!rr) { 407 /* Just enabling icount */ 408 goto out; 409 } else if (!strcmp(rr, "record")) { 410 mode = REPLAY_MODE_RECORD; 411 } else if (!strcmp(rr, "replay")) { 412 mode = REPLAY_MODE_PLAY; 413 } else { 414 error_report("Invalid icount rr option: %s", rr); 415 exit(1); 416 } 417 418 fname = qemu_opt_get(opts, "rrfile"); 419 if (!fname) { 420 error_report("File name not specified for replay"); 421 exit(1); 422 } 423 424 replay_snapshot = g_strdup(qemu_opt_get(opts, "rrsnapshot")); 425 replay_vmstate_register(); 426 replay_enable(fname, mode); 427 428 out: 429 loc_pop(&loc); 430 } 431 432 void replay_start(void) 433 { 434 if (replay_mode == REPLAY_MODE_NONE) { 435 return; 436 } 437 438 if (replay_blockers) { 439 error_reportf_err(replay_blockers->data, "Record/replay: "); 440 exit(1); 441 } 442 if (!icount_enabled()) { 443 error_report("Please enable icount to use record/replay"); 444 exit(1); 445 } 446 447 /* Timer for snapshotting will be set up here. */ 448 449 replay_enable_events(); 450 } 451 452 /* 453 * For none/record the answer is yes. 454 */ 455 bool replay_can_wait(void) 456 { 457 if (replay_mode == REPLAY_MODE_PLAY) { 458 /* 459 * For playback we shouldn't ever be at a point we wait. If 460 * the instruction count has reached zero and we have an 461 * unconsumed event we should go around again and consume it. 462 */ 463 if (replay_state.instruction_count == 0 && replay_state.has_unread_data) { 464 return false; 465 } else { 466 replay_sync_error("Playback shouldn't have to iowait"); 467 } 468 } 469 return true; 470 } 471 472 473 void replay_finish(void) 474 { 475 if (replay_mode == REPLAY_MODE_NONE) { 476 return; 477 } 478 479 replay_save_instructions(); 480 481 /* finalize the file */ 482 if (replay_file) { 483 if (replay_mode == REPLAY_MODE_RECORD) { 484 /* 485 * Can't do it in the signal handler, therefore 486 * add shutdown event here for the case of Ctrl-C. 487 */ 488 replay_shutdown_request(SHUTDOWN_CAUSE_HOST_SIGNAL); 489 /* write end event */ 490 replay_put_event(EVENT_END); 491 492 /* write header */ 493 fseek(replay_file, 0, SEEK_SET); 494 replay_put_dword(REPLAY_VERSION); 495 } 496 497 fclose(replay_file); 498 replay_file = NULL; 499 } 500 g_free(replay_filename); 501 replay_filename = NULL; 502 503 g_free(replay_snapshot); 504 replay_snapshot = NULL; 505 506 replay_finish_events(); 507 replay_mode = REPLAY_MODE_NONE; 508 } 509 510 void replay_add_blocker(const char *feature) 511 { 512 Error *reason = NULL; 513 514 error_setg(&reason, "Record/replay is not supported with %s", 515 feature); 516 replay_blockers = g_slist_prepend(replay_blockers, reason); 517 } 518 519 const char *replay_get_filename(void) 520 { 521 return replay_filename; 522 } 523