LXR qemu/replay/replay-internal.h

   1#ifndef REPLAY_INTERNAL_H
   2#define REPLAY_INTERNAL_H
   3
   4/*
   5 * replay-internal.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/* Any changes to order/number of events will need to bump REPLAY_VERSION */
  16enum ReplayEvents {
  17    /* for instruction event */
  18    EVENT_INSTRUCTION,
  19    /* for software interrupt */
  20    EVENT_INTERRUPT,
  21    /* for emulated exceptions */
  22    EVENT_EXCEPTION,
  23    /* for async events */
  24    EVENT_ASYNC,
  25    /* for shutdown requests, range allows recovery of ShutdownCause */
  26    EVENT_SHUTDOWN,
  27    EVENT_SHUTDOWN_LAST = EVENT_SHUTDOWN + SHUTDOWN_CAUSE__MAX,
  28    /* for character device write event */
  29    EVENT_CHAR_WRITE,
  30    /* for character device read all event */
  31    EVENT_CHAR_READ_ALL,
  32    EVENT_CHAR_READ_ALL_ERROR,
  33    /* for audio out event */
  34    EVENT_AUDIO_OUT,
  35    /* for audio in event */
  36    EVENT_AUDIO_IN,
  37    /* for random number generator */
  38    EVENT_RANDOM,
  39    /* for clock read/writes */
  40    /* some of greater codes are reserved for clocks */
  41    EVENT_CLOCK,
  42    EVENT_CLOCK_LAST = EVENT_CLOCK + REPLAY_CLOCK_COUNT - 1,
  43    /* for checkpoint event */
  44    /* some of greater codes are reserved for checkpoints */
  45    EVENT_CHECKPOINT,
  46    EVENT_CHECKPOINT_LAST = EVENT_CHECKPOINT + CHECKPOINT_COUNT - 1,
  47    /* end of log event */
  48    EVENT_END,
  49    EVENT_COUNT
  50};
  51
  52/* Asynchronous events IDs */
  53
  54enum ReplayAsyncEventKind {
  55    REPLAY_ASYNC_EVENT_BH,
  56    REPLAY_ASYNC_EVENT_BH_ONESHOT,
  57    REPLAY_ASYNC_EVENT_INPUT,
  58    REPLAY_ASYNC_EVENT_INPUT_SYNC,
  59    REPLAY_ASYNC_EVENT_CHAR_READ,
  60    REPLAY_ASYNC_EVENT_BLOCK,
  61    REPLAY_ASYNC_EVENT_NET,
  62    REPLAY_ASYNC_COUNT
  63};
  64
  65typedef enum ReplayAsyncEventKind ReplayAsyncEventKind;
  66
  67typedef struct ReplayState {
  68    /*! Cached clock values. */
  69    int64_t cached_clock[REPLAY_CLOCK_COUNT];
  70    /*! Current icount - number of processed instructions. */
  71    uint64_t current_icount;
  72    /*! Number of instructions to be executed before other events happen. */
  73    int instruction_count;
  74    /*! Type of the currently executed event. */
  75    unsigned int data_kind;
  76    /*! Flag which indicates that event is not processed yet. */
  77    unsigned int has_unread_data;
  78    /*! Temporary variable for saving current log offset. */
  79    uint64_t file_offset;
  80    /*! Next block operation id.
  81        This counter is global, because requests from different
  82        block devices should not get overlapping ids. */
  83    uint64_t block_request_id;
  84    /*! Prior value of the host clock */
  85    uint64_t host_clock_last;
  86    /*! Asynchronous event type read from the log */
  87    int32_t read_event_kind;
  88    /*! Asynchronous event id read from the log */
  89    uint64_t read_event_id;
  90    /*! Asynchronous event checkpoint id read from the log */
  91    int32_t read_event_checkpoint;
  92} ReplayState;
  93extern ReplayState replay_state;
  94
  95/* File for replay writing */
  96extern FILE *replay_file;
  97/* Instruction count of the replay breakpoint */
  98extern uint64_t replay_break_icount;
  99/* Timer for the replay breakpoint callback */
 100extern QEMUTimer *replay_break_timer;
 101
 102void replay_put_byte(uint8_t byte);
 103void replay_put_event(uint8_t event);
 104void replay_put_word(uint16_t word);
 105void replay_put_dword(uint32_t dword);
 106void replay_put_qword(int64_t qword);
 107void replay_put_array(const uint8_t *buf, size_t size);
 108
 109uint8_t replay_get_byte(void);
 110uint16_t replay_get_word(void);
 111uint32_t replay_get_dword(void);
 112int64_t replay_get_qword(void);
 113void replay_get_array(uint8_t *buf, size_t *size);
 114void replay_get_array_alloc(uint8_t **buf, size_t *size);
 115
 116/* Mutex functions for protecting replay log file and ensuring
 117 * synchronisation between vCPU and main-loop threads. */
 118
 119void replay_mutex_init(void);
 120bool replay_mutex_locked(void);
 121
 122/*! Checks error status of the file. */
 123void replay_check_error(void);
 124
 125/*! Finishes processing of the replayed event and fetches
 126    the next event from the log. */
 127void replay_finish_event(void);
 128/*! Reads data type from the file and stores it in the
 129    data_kind variable. */
 130void replay_fetch_data_kind(void);
 131
 132/*! Advance replay_state.current_icount to the specified value. */
 133void replay_advance_current_icount(uint64_t current_icount);
 134/*! Saves queued events (like instructions and sound). */
 135void replay_save_instructions(void);
 136
 137/*! Skips async events until some sync event will be found.
 138    \return true, if event was found */
 139bool replay_next_event_is(int event);
 140
 141/*! Reads next clock value from the file.
 142    If clock kind read from the file is different from the parameter,
 143    the value is not used. */
 144void replay_read_next_clock(unsigned int kind);
 145
 146/* Asynchronous events queue */
 147
 148/*! Initializes events' processing internals */
 149void replay_init_events(void);
 150/*! Clears internal data structures for events handling */
 151void replay_finish_events(void);
 152/*! Returns true if there are any unsaved events in the queue */
 153bool replay_has_events(void);
 154/*! Saves events from queue into the file */
 155void replay_save_events(int checkpoint);
 156/*! Read events from the file into the input queue */
 157void replay_read_events(int checkpoint);
 158/*! Adds specified async event to the queue */
 159void replay_add_event(ReplayAsyncEventKind event_kind, void *opaque,
 160                      void *opaque2, uint64_t id);
 161
 162/* Input events */
 163
 164/*! Saves input event to the log */
 165void replay_save_input_event(InputEvent *evt);
 166/*! Reads input event from the log */
 167InputEvent *replay_read_input_event(void);
 168/*! Adds input event to the queue */
 169void replay_add_input_event(struct InputEvent *event);
 170/*! Adds input sync event to the queue */
 171void replay_add_input_sync_event(void);
 172
 173/* Character devices */
 174
 175/*! Called to run char device read event. */
 176void replay_event_char_read_run(void *opaque);
 177/*! Writes char read event to the file. */
 178void replay_event_char_read_save(void *opaque);
 179/*! Reads char event read from the file. */
 180void *replay_event_char_read_load(void);
 181
 182/* Network devices */
 183
 184/*! Called to run network event. */
 185void replay_event_net_run(void *opaque);
 186/*! Writes network event to the file. */
 187void replay_event_net_save(void *opaque);
 188/*! Reads network from the file. */
 189void *replay_event_net_load(void);
 190
 191/* VMState-related functions */
 192
 193/* Registers replay VMState.
 194   Should be called before virtual devices initialization
 195   to make cached timers available for post_load functions. */
 196void replay_vmstate_register(void);
 197
 198#endif
 199