include/sysemu/replay.h

   1 #ifndef REPLAY_H
   2 #define REPLAY_H
   3
   4 /*
   5  * replay.h
   6  *
   7  * Copyright (c) 2010-2015 Institute for System Programming
   8  *                         of the Russian Academy of Sciences.
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  11  * See the COPYING file in the top-level directory.
  12  *
  13  */
  14
  15 #include "sysemu.h"
  16 #include "qapi/qapi-types-misc.h"
  17 #include "qapi/qapi-types-ui.h"
  18
  19 /* replay clock kinds */
  20 enum ReplayClockKind {
  21     /* host_clock */
  22     REPLAY_CLOCK_HOST,
  23     /* virtual_rt_clock */
  24     REPLAY_CLOCK_VIRTUAL_RT,
  25     REPLAY_CLOCK_COUNT
  26 };
  27 typedef enum ReplayClockKind ReplayClockKind;
  28
  29 /* IDs of the checkpoints */
  30 enum ReplayCheckpoint {
  31     CHECKPOINT_CLOCK_WARP_START,
  32     CHECKPOINT_CLOCK_WARP_ACCOUNT,
  33     CHECKPOINT_RESET_REQUESTED,
  34     CHECKPOINT_SUSPEND_REQUESTED,
  35     CHECKPOINT_CLOCK_VIRTUAL,
  36     CHECKPOINT_CLOCK_HOST,
  37     CHECKPOINT_CLOCK_VIRTUAL_RT,
  38     CHECKPOINT_INIT,
  39     CHECKPOINT_RESET,
  40     CHECKPOINT_COUNT
  41 };
  42 typedef enum ReplayCheckpoint ReplayCheckpoint;
  43
  44 typedef struct ReplayNetState ReplayNetState;
  45
  46 extern ReplayMode replay_mode;
  47
  48 /* Name of the initial VM snapshot */
  49 extern char *replay_snapshot;
  50
  51 /* Replay locking
  52  *
  53  * The locks are needed to protect the shared structures and log file
  54  * when doing record/replay. They also are the main sync-point between
  55  * the main-loop thread and the vCPU thread. This was a role
  56  * previously filled by the BQL which has been busy trying to reduce
  57  * its impact across the code. This ensures blocks of events stay
  58  * sequential and reproducible.
  59  */
  60
  61 void replay_mutex_lock(void);
  62 void replay_mutex_unlock(void);
  63
  64 /* Replay process control functions */
  65
  66 /*! Enables recording or saving event log with specified parameters */
  67 void replay_configure(struct QemuOpts *opts);
  68 /*! Initializes timers used for snapshotting and enables events recording */
  69 void replay_start(void);
  70 /*! Closes replay log file and frees other resources. */
  71 void replay_finish(void);
  72 /*! Adds replay blocker with the specified error description */
  73 void replay_add_blocker(Error *reason);
  74
  75 /* Processing the instructions */
  76
  77 /*! Returns number of executed instructions. */
  78 uint64_t replay_get_current_step(void);
  79 /*! Returns number of instructions to execute in replay mode. */
  80 int replay_get_instructions(void);
  81 /*! Updates instructions counter in replay mode. */
  82 void replay_account_executed_instructions(void);
  83
  84 /* Interrupts and exceptions */
  85
  86 /*! Called by exception handler to write or read
  87     exception processing events. */
  88 bool replay_exception(void);
  89 /*! Used to determine that exception is pending.
  90     Does not proceed to the next event in the log. */
  91 bool replay_has_exception(void);
  92 /*! Called by interrupt handlers to write or read
  93     interrupt processing events.
  94     \return true if interrupt should be processed */
  95 bool replay_interrupt(void);
  96 /*! Tries to read interrupt event from the file.
  97     Returns true, when interrupt request is pending */
  98 bool replay_has_interrupt(void);
  99
 100 /* Processing clocks and other time sources */
 101
 102 /*! Save the specified clock */
 103 int64_t replay_save_clock(ReplayClockKind kind, int64_t clock);
 104 /*! Read the specified clock from the log or return cached data */
 105 int64_t replay_read_clock(ReplayClockKind kind);
 106 /*! Saves or reads the clock depending on the current replay mode. */
 107 #define REPLAY_CLOCK(clock, value)                                      \
 108     (replay_mode == REPLAY_MODE_PLAY ? replay_read_clock((clock))       \
 109         : replay_mode == REPLAY_MODE_RECORD                             \
 110             ? replay_save_clock((clock), (value))                       \
 111         : (value))
 112
 113 /* Events */
 114
 115 /*! Called when qemu shutdown is requested. */
 116 void replay_shutdown_request(ShutdownCause cause);
 117 /*! Should be called at check points in the execution.
 118     These check points are skipped, if they were not met.
 119     Saves checkpoint in the SAVE mode and validates in the PLAY mode.
 120     Returns 0 in PLAY mode if checkpoint was not found.
 121     Returns 1 in all other cases. */
 122 bool replay_checkpoint(ReplayCheckpoint checkpoint);
 123 /*! Used to determine that checkpoint is pending.
 124     Does not proceed to the next event in the log. */
 125 bool replay_has_checkpoint(void);
 126
 127 /* Asynchronous events queue */
 128
 129 /*! Disables storing events in the queue */
 130 void replay_disable_events(void);
 131 /*! Enables storing events in the queue */
 132 void replay_enable_events(void);
 133 /*! Returns true when saving events is enabled */
 134 bool replay_events_enabled(void);
 135 /*! Adds bottom half event to the queue */
 136 void replay_bh_schedule_event(QEMUBH *bh);
 137 /*! Adds input event to the queue */
 138 void replay_input_event(QemuConsole *src, InputEvent *evt);
 139 /*! Adds input sync event to the queue */
 140 void replay_input_sync_event(void);
 141 /*! Adds block layer event to the queue */
 142 void replay_block_event(QEMUBH *bh, uint64_t id);
 143 /*! Returns ID for the next block event */
 144 uint64_t blkreplay_next_id(void);
 145
 146 /* Character device */
 147
 148 /*! Registers char driver to save it's events */
 149 void replay_register_char_driver(struct Chardev *chr);
 150 /*! Saves write to char device event to the log */
 151 void replay_chr_be_write(struct Chardev *s, uint8_t *buf, int len);
 152 /*! Writes char write return value to the replay log. */
 153 void replay_char_write_event_save(int res, int offset);
 154 /*! Reads char write return value from the replay log. */
 155 void replay_char_write_event_load(int *res, int *offset);
 156 /*! Reads information about read_all character event. */
 157 int replay_char_read_all_load(uint8_t *buf);
 158 /*! Writes character read_all error code into the replay log. */
 159 void replay_char_read_all_save_error(int res);
 160 /*! Writes character read_all execution result into the replay log. */
 161 void replay_char_read_all_save_buf(uint8_t *buf, int offset);
 162
 163 /* Network */
 164
 165 /*! Registers replay network filter attached to some backend. */
 166 ReplayNetState *replay_register_net(NetFilterState *nfs);
 167 /*! Unregisters replay network filter. */
 168 void replay_unregister_net(ReplayNetState *rns);
 169 /*! Called to write network packet to the replay log. */
 170 void replay_net_packet_event(ReplayNetState *rns, unsigned flags,
 171                              const struct iovec *iov, int iovcnt);
 172
 173 /* Audio */
 174
 175 /*! Saves/restores number of played samples of audio out operation. */
 176 void replay_audio_out(int *played);
 177 /*! Saves/restores recorded samples of audio in operation. */
 178 void replay_audio_in(int *recorded, void *samples, int *wpos, int size);
 179
 180 /* VM state operations */
 181
 182 /*! Called at the start of execution.
 183     Loads or saves initial vmstate depending on execution mode. */
 184 void replay_vmstate_init(void);
 185 /*! Called to ensure that replay state is consistent and VM snapshot
 186     can be created */
 187 bool replay_can_snapshot(void);
 188
 189 #endif