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 } 404