[mirror_qemu.git] / replay / replay-internal.h

#ifndef REPLAY_INTERNAL_H
#define REPLAY_INTERNAL_H

/*
 * replay-internal.h
 *
 * Copyright (c) 2010-2015 Institute for System Programming
 *                         of the Russian Academy of Sciences.
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 *
 */

/* Asynchronous events IDs */

typedef enum ReplayAsyncEventKind {
    REPLAY_ASYNC_EVENT_BH,
    REPLAY_ASYNC_EVENT_BH_ONESHOT,
    REPLAY_ASYNC_EVENT_INPUT,
    REPLAY_ASYNC_EVENT_INPUT_SYNC,
    REPLAY_ASYNC_EVENT_CHAR_READ,
    REPLAY_ASYNC_EVENT_BLOCK,
    REPLAY_ASYNC_EVENT_NET,
    REPLAY_ASYNC_COUNT
} ReplayAsyncEventKind;

/* Any changes to order/number of events will need to bump REPLAY_VERSION */
enum ReplayEvents {
    /* for instruction event */
    EVENT_INSTRUCTION,
    /* for software interrupt */
    EVENT_INTERRUPT,
    /* for emulated exceptions */
    EVENT_EXCEPTION,
    /* for async events */
    EVENT_ASYNC,
    EVENT_ASYNC_LAST = EVENT_ASYNC + REPLAY_ASYNC_COUNT - 1,
    /* for shutdown requests, range allows recovery of ShutdownCause */
    EVENT_SHUTDOWN,
    EVENT_SHUTDOWN_LAST = EVENT_SHUTDOWN + SHUTDOWN_CAUSE__MAX,
    /* for character device write event */
    EVENT_CHAR_WRITE,
    /* for character device read all event */
    EVENT_CHAR_READ_ALL,
    EVENT_CHAR_READ_ALL_ERROR,
    /* for audio out event */
    EVENT_AUDIO_OUT,
    /* for audio in event */
    EVENT_AUDIO_IN,
    /* for random number generator */
    EVENT_RANDOM,
    /* for clock read/writes */
    /* some of greater codes are reserved for clocks */
    EVENT_CLOCK,
    EVENT_CLOCK_LAST = EVENT_CLOCK + REPLAY_CLOCK_COUNT - 1,
    /* for checkpoint event */
    /* some of greater codes are reserved for checkpoints */
    EVENT_CHECKPOINT,
    EVENT_CHECKPOINT_LAST = EVENT_CHECKPOINT + CHECKPOINT_COUNT - 1,
    /* end of log event */
    EVENT_END,
    EVENT_COUNT
};

typedef struct ReplayState {
    /*! Cached clock values. */
    int64_t cached_clock[REPLAY_CLOCK_COUNT];
    /*! Current icount - number of processed instructions. */
    uint64_t current_icount;
    /*! Number of instructions to be executed before other events happen. */
    int instruction_count;
    /*! Type of the currently executed event. */
    unsigned int data_kind;
    /*! Flag which indicates that event is not processed yet. */
    unsigned int has_unread_data;
    /*! Temporary variable for saving current log offset. */
    uint64_t file_offset;
    /*! Next block operation id.
        This counter is global, because requests from different
        block devices should not get overlapping ids. */
    uint64_t block_request_id;
    /*! Prior value of the host clock */
    uint64_t host_clock_last;
    /*! Asynchronous event id read from the log */
    uint64_t read_event_id;
} ReplayState;
extern ReplayState replay_state;

/* File for replay writing */
extern FILE *replay_file;
/* Instruction count of the replay breakpoint */
extern uint64_t replay_break_icount;
/* Timer for the replay breakpoint callback */
extern QEMUTimer *replay_break_timer;

void replay_put_byte(uint8_t byte);
void replay_put_event(uint8_t event);
void replay_put_word(uint16_t word);
void replay_put_dword(uint32_t dword);
void replay_put_qword(int64_t qword);
void replay_put_array(const uint8_t *buf, size_t size);

uint8_t replay_get_byte(void);
uint16_t replay_get_word(void);
uint32_t replay_get_dword(void);
int64_t replay_get_qword(void);
void replay_get_array(uint8_t *buf, size_t *size);
void replay_get_array_alloc(uint8_t **buf, size_t *size);

/* Mutex functions for protecting replay log file and ensuring
 * synchronisation between vCPU and main-loop threads. */

void replay_mutex_init(void);
bool replay_mutex_locked(void);

/*! Checks error status of the file. */
void replay_check_error(void);

/*! Finishes processing of the replayed event and fetches
    the next event from the log. */
void replay_finish_event(void);
/*! Reads data type from the file and stores it in the
    data_kind variable. */
void replay_fetch_data_kind(void);

/*! Advance replay_state.current_icount to the specified value. */
void replay_advance_current_icount(uint64_t current_icount);
/*! Saves queued events (like instructions and sound). */
void replay_save_instructions(void);

/*! Skips async events until some sync event will be found.
    \return true, if event was found */
bool replay_next_event_is(int event);

/*! Reads next clock value from the file.
    If clock kind read from the file is different from the parameter,
    the value is not used. */
void replay_read_next_clock(ReplayClockKind kind);

/* Asynchronous events queue */

/*! Initializes events' processing internals */
void replay_init_events(void);
/*! Clears internal data structures for events handling */
void replay_finish_events(void);
/*! Returns true if there are any unsaved events in the queue */
bool replay_has_events(void);
/*! Saves events from queue into the file */
void replay_save_events(void);
/*! Read events from the file into the input queue */
void replay_read_events(void);
/*! Adds specified async event to the queue */
void replay_add_event(ReplayAsyncEventKind event_kind, void *opaque,
                      void *opaque2, uint64_t id);

/* Input events */

/*! Saves input event to the log */
void replay_save_input_event(InputEvent *evt);
/*! Reads input event from the log */
InputEvent *replay_read_input_event(void);
/*! Adds input event to the queue */
void replay_add_input_event(struct InputEvent *event);
/*! Adds input sync event to the queue */
void replay_add_input_sync_event(void);

/* Character devices */

/*! Called to run char device read event. */
void replay_event_char_read_run(void *opaque);
/*! Writes char read event to the file. */
void replay_event_char_read_save(void *opaque);
/*! Reads char event read from the file. */
void *replay_event_char_read_load(void);

/* Network devices */

/*! Called to run network event. */
void replay_event_net_run(void *opaque);
/*! Writes network event to the file. */
void replay_event_net_save(void *opaque);
/*! Reads network from the file. */
void *replay_event_net_load(void);

/* VMState-related functions */

/* Registers replay VMState.
   Should be called before virtual devices initialization
   to make cached timers available for post_load functions. */
void replay_vmstate_register(void);

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