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