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
  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 request */
  26    EVENT_SHUTDOWN,
  27    /* for character device write event */
  28    EVENT_CHAR_WRITE,
  29    /* for character device read all event */
  30    EVENT_CHAR_READ_ALL,
  31    EVENT_CHAR_READ_ALL_ERROR,
  32    /* for clock read/writes */
  33    /* some of greater codes are reserved for clocks */
  34    EVENT_CLOCK,
  35    EVENT_CLOCK_LAST = EVENT_CLOCK + REPLAY_CLOCK_COUNT - 1,
  36    /* for checkpoint event */
  37    /* some of greater codes are reserved for checkpoints */
  38    EVENT_CHECKPOINT,
  39    EVENT_CHECKPOINT_LAST = EVENT_CHECKPOINT + CHECKPOINT_COUNT - 1,
  40    /* end of log event */
  41    EVENT_END,
  42    EVENT_COUNT
  43};
  44
  45/* Asynchronous events IDs */
  46
  47enum ReplayAsyncEventKind {
  48    REPLAY_ASYNC_EVENT_BH,
  49    REPLAY_ASYNC_EVENT_INPUT,
  50    REPLAY_ASYNC_EVENT_INPUT_SYNC,
  51    REPLAY_ASYNC_EVENT_CHAR_READ,
  52    REPLAY_ASYNC_EVENT_BLOCK,
  53    REPLAY_ASYNC_COUNT
  54};
  55
  56typedef enum ReplayAsyncEventKind ReplayAsyncEventKind;
  57
  58typedef struct ReplayState {
  59    /*! Cached clock values. */
  60    int64_t cached_clock[REPLAY_CLOCK_COUNT];
  61    /*! Current step - number of processed instructions and timer events. */
  62    uint64_t current_step;
  63    /*! Number of instructions to be executed before other events happen. */
  64    int instructions_count;
  65} ReplayState;
  66extern ReplayState replay_state;
  67
  68extern unsigned int replay_data_kind;
  69
  70/* File for replay writing */
  71extern FILE *replay_file;
  72
  73void replay_put_byte(uint8_t byte);
  74void replay_put_event(uint8_t event);
  75void replay_put_word(uint16_t word);
  76void replay_put_dword(uint32_t dword);
  77void replay_put_qword(int64_t qword);
  78void replay_put_array(const uint8_t *buf, size_t size);
  79
  80uint8_t replay_get_byte(void);
  81uint16_t replay_get_word(void);
  82uint32_t replay_get_dword(void);
  83int64_t replay_get_qword(void);
  84void replay_get_array(uint8_t *buf, size_t *size);
  85void replay_get_array_alloc(uint8_t **buf, size_t *size);
  86
  87/* Mutex functions for protecting replay log file */
  88
  89void replay_mutex_init(void);
  90void replay_mutex_destroy(void);
  91void replay_mutex_lock(void);
  92void replay_mutex_unlock(void);
  93
  94/*! Checks error status of the file. */
  95void replay_check_error(void);
  96
  97/*! Finishes processing of the replayed event and fetches
  98    the next event from the log. */
  99void replay_finish_event(void);
 100/*! Reads data type from the file and stores it in the
 101    replay_data_kind variable. */
 102void replay_fetch_data_kind(void);
 103
 104/*! Saves queued events (like instructions and sound). */
 105void replay_save_instructions(void);
 106
 107/*! Skips async events until some sync event will be found.
 108    \return true, if event was found */
 109bool replay_next_event_is(int event);
 110
 111/*! Reads next clock value from the file.
 112    If clock kind read from the file is different from the parameter,
 113    the value is not used. */
 114void replay_read_next_clock(unsigned int kind);
 115
 116/* Asynchronous events queue */
 117
 118/*! Initializes events' processing internals */
 119void replay_init_events(void);
 120/*! Clears internal data structures for events handling */
 121void replay_finish_events(void);
 122/*! Enables storing events in the queue */
 123void replay_enable_events(void);
 124/*! Flushes events queue */
 125void replay_flush_events(void);
 126/*! Clears events list before loading new VM state */
 127void replay_clear_events(void);
 128/*! Returns true if there are any unsaved events in the queue */
 129bool replay_has_events(void);
 130/*! Saves events from queue into the file */
 131void replay_save_events(int checkpoint);
 132/*! Read events from the file into the input queue */
 133void replay_read_events(int checkpoint);
 134/*! Adds specified async event to the queue */
 135void replay_add_event(ReplayAsyncEventKind event_kind, void *opaque,
 136                      void *opaque2, uint64_t id);
 137
 138/* Input events */
 139
 140/*! Saves input event to the log */
 141void replay_save_input_event(InputEvent *evt);
 142/*! Reads input event from the log */
 143InputEvent *replay_read_input_event(void);
 144/*! Adds input event to the queue */
 145void replay_add_input_event(struct InputEvent *event);
 146/*! Adds input sync event to the queue */
 147void replay_add_input_sync_event(void);
 148
 149/* Character devices */
 150
 151/*! Called to run char device read event. */
 152void replay_event_char_read_run(void *opaque);
 153/*! Writes char read event to the file. */
 154void replay_event_char_read_save(void *opaque);
 155/*! Reads char event read from the file. */
 156void *replay_event_char_read_load(void);
 157
 158#endif
 159