virtio-pci: address space translation service (ATS) support
[qemu.git] / replay / replay-internal.c
1 /*
2 * replay-internal.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 "qemu-common.h"
14 #include "sysemu/replay.h"
15 #include "replay-internal.h"
16 #include "qemu/error-report.h"
17 #include "sysemu/sysemu.h"
18
19 /* Mutex to protect reading and writing events to the log.
20 data_kind and has_unread_data are also protected
21 by this mutex.
22 It also protects replay events queue which stores events to be
23 written or read to the log. */
24 static QemuMutex lock;
25
26 /* File for replay writing */
27 FILE *replay_file;
28
29 void replay_put_byte(uint8_t byte)
30 {
31 if (replay_file) {
32 putc(byte, replay_file);
33 }
34 }
35
36 void replay_put_event(uint8_t event)
37 {
38 assert(event < EVENT_COUNT);
39 replay_put_byte(event);
40 }
41
42
43 void replay_put_word(uint16_t word)
44 {
45 replay_put_byte(word >> 8);
46 replay_put_byte(word);
47 }
48
49 void replay_put_dword(uint32_t dword)
50 {
51 replay_put_word(dword >> 16);
52 replay_put_word(dword);
53 }
54
55 void replay_put_qword(int64_t qword)
56 {
57 replay_put_dword(qword >> 32);
58 replay_put_dword(qword);
59 }
60
61 void replay_put_array(const uint8_t *buf, size_t size)
62 {
63 if (replay_file) {
64 replay_put_dword(size);
65 fwrite(buf, 1, size, replay_file);
66 }
67 }
68
69 uint8_t replay_get_byte(void)
70 {
71 uint8_t byte = 0;
72 if (replay_file) {
73 byte = getc(replay_file);
74 }
75 return byte;
76 }
77
78 uint16_t replay_get_word(void)
79 {
80 uint16_t word = 0;
81 if (replay_file) {
82 word = replay_get_byte();
83 word = (word << 8) + replay_get_byte();
84 }
85
86 return word;
87 }
88
89 uint32_t replay_get_dword(void)
90 {
91 uint32_t dword = 0;
92 if (replay_file) {
93 dword = replay_get_word();
94 dword = (dword << 16) + replay_get_word();
95 }
96
97 return dword;
98 }
99
100 int64_t replay_get_qword(void)
101 {
102 int64_t qword = 0;
103 if (replay_file) {
104 qword = replay_get_dword();
105 qword = (qword << 32) + replay_get_dword();
106 }
107
108 return qword;
109 }
110
111 void replay_get_array(uint8_t *buf, size_t *size)
112 {
113 if (replay_file) {
114 *size = replay_get_dword();
115 if (fread(buf, 1, *size, replay_file) != *size) {
116 error_report("replay read error");
117 }
118 }
119 }
120
121 void replay_get_array_alloc(uint8_t **buf, size_t *size)
122 {
123 if (replay_file) {
124 *size = replay_get_dword();
125 *buf = g_malloc(*size);
126 if (fread(*buf, 1, *size, replay_file) != *size) {
127 error_report("replay read error");
128 }
129 }
130 }
131
132 void replay_check_error(void)
133 {
134 if (replay_file) {
135 if (feof(replay_file)) {
136 error_report("replay file is over");
137 qemu_system_vmstop_request_prepare();
138 qemu_system_vmstop_request(RUN_STATE_PAUSED);
139 } else if (ferror(replay_file)) {
140 error_report("replay file is over or something goes wrong");
141 qemu_system_vmstop_request_prepare();
142 qemu_system_vmstop_request(RUN_STATE_INTERNAL_ERROR);
143 }
144 }
145 }
146
147 void replay_fetch_data_kind(void)
148 {
149 if (replay_file) {
150 if (!replay_state.has_unread_data) {
151 replay_state.data_kind = replay_get_byte();
152 if (replay_state.data_kind == EVENT_INSTRUCTION) {
153 replay_state.instructions_count = replay_get_dword();
154 }
155 replay_check_error();
156 replay_state.has_unread_data = 1;
157 if (replay_state.data_kind >= EVENT_COUNT) {
158 error_report("Replay: unknown event kind %d",
159 replay_state.data_kind);
160 exit(1);
161 }
162 }
163 }
164 }
165
166 void replay_finish_event(void)
167 {
168 replay_state.has_unread_data = 0;
169 replay_fetch_data_kind();
170 }
171
172 void replay_mutex_init(void)
173 {
174 qemu_mutex_init(&lock);
175 }
176
177 void replay_mutex_destroy(void)
178 {
179 qemu_mutex_destroy(&lock);
180 }
181
182 void replay_mutex_lock(void)
183 {
184 qemu_mutex_lock(&lock);
185 }
186
187 void replay_mutex_unlock(void)
188 {
189 qemu_mutex_unlock(&lock);
190 }
191
192 /*! Saves cached instructions. */
193 void replay_save_instructions(void)
194 {
195 if (replay_file && replay_mode == REPLAY_MODE_RECORD) {
196 replay_mutex_lock();
197 int diff = (int)(replay_get_current_step() - replay_state.current_step);
198 if (diff > 0) {
199 replay_put_event(EVENT_INSTRUCTION);
200 replay_put_dword(diff);
201 replay_state.current_step += diff;
202 }
203 replay_mutex_unlock();
204 }
205 }