qemu

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 "sysemu/replay.h"
14
#include "sysemu/runstate.h"
15
#include "replay-internal.h"
16
#include "qemu/error-report.h"
17
#include "qemu/main-loop.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
/* Condition and queue for fair ordering of mutex lock requests. */
26
static QemuCond mutex_cond;
27
static unsigned long mutex_head, mutex_tail;
28

29
/* File for replay writing */
30
static bool write_error;
31
FILE *replay_file;
32

33
static void replay_write_error(void)
34
{
35
    if (!write_error) {
36
        error_report("replay write error");
37
        write_error = true;
38
    }
39
}
40

41
static void replay_read_error(void)
42
{
43
    error_report("error reading the replay data");
44
    exit(1);
45
}
46

47
void replay_put_byte(uint8_t byte)
48
{
49
    if (replay_file) {
50
        if (putc(byte, replay_file) == EOF) {
51
            replay_write_error();
52
        }
53
    }
54
}
55

56
void replay_put_event(uint8_t event)
57
{
58
    assert(event < EVENT_COUNT);
59
    replay_put_byte(event);
60
}
61

62

63
void replay_put_word(uint16_t word)
64
{
65
    replay_put_byte(word >> 8);
66
    replay_put_byte(word);
67
}
68

69
void replay_put_dword(uint32_t dword)
70
{
71
    replay_put_word(dword >> 16);
72
    replay_put_word(dword);
73
}
74

75
void replay_put_qword(int64_t qword)
76
{
77
    replay_put_dword(qword >> 32);
78
    replay_put_dword(qword);
79
}
80

81
void replay_put_array(const uint8_t *buf, size_t size)
82
{
83
    if (replay_file) {
84
        replay_put_dword(size);
85
        if (fwrite(buf, 1, size, replay_file) != size) {
86
            replay_write_error();
87
        }
88
    }
89
}
90

91
uint8_t replay_get_byte(void)
92
{
93
    uint8_t byte = 0;
94
    if (replay_file) {
95
        int r = getc(replay_file);
96
        if (r == EOF) {
97
            replay_read_error();
98
        }
99
        byte = r;
100
    }
101
    return byte;
102
}
103

104
uint16_t replay_get_word(void)
105
{
106
    uint16_t word = 0;
107
    if (replay_file) {
108
        word = replay_get_byte();
109
        word = (word << 8) + replay_get_byte();
110
    }
111

112
    return word;
113
}
114

115
uint32_t replay_get_dword(void)
116
{
117
    uint32_t dword = 0;
118
    if (replay_file) {
119
        dword = replay_get_word();
120
        dword = (dword << 16) + replay_get_word();
121
    }
122

123
    return dword;
124
}
125

126
int64_t replay_get_qword(void)
127
{
128
    int64_t qword = 0;
129
    if (replay_file) {
130
        qword = replay_get_dword();
131
        qword = (qword << 32) + replay_get_dword();
132
    }
133

134
    return qword;
135
}
136

137
void replay_get_array(uint8_t *buf, size_t *size)
138
{
139
    if (replay_file) {
140
        *size = replay_get_dword();
141
        if (fread(buf, 1, *size, replay_file) != *size) {
142
            replay_read_error();
143
        }
144
    }
145
}
146

147
void replay_get_array_alloc(uint8_t **buf, size_t *size)
148
{
149
    if (replay_file) {
150
        *size = replay_get_dword();
151
        *buf = g_malloc(*size);
152
        if (fread(*buf, 1, *size, replay_file) != *size) {
153
            replay_read_error();
154
        }
155
    }
156
}
157

158
void replay_check_error(void)
159
{
160
    if (replay_file) {
161
        if (feof(replay_file)) {
162
            error_report("replay file is over");
163
            qemu_system_vmstop_request_prepare();
164
            qemu_system_vmstop_request(RUN_STATE_PAUSED);
165
        } else if (ferror(replay_file)) {
166
            error_report("replay file is over or something goes wrong");
167
            qemu_system_vmstop_request_prepare();
168
            qemu_system_vmstop_request(RUN_STATE_INTERNAL_ERROR);
169
        }
170
    }
171
}
172

173
void replay_fetch_data_kind(void)
174
{
175
    if (replay_file) {
176
        if (!replay_state.has_unread_data) {
177
            replay_state.data_kind = replay_get_byte();
178
            replay_state.current_event++;
179
            if (replay_state.data_kind == EVENT_INSTRUCTION) {
180
                replay_state.instruction_count = replay_get_dword();
181
            }
182
            replay_check_error();
183
            replay_state.has_unread_data = true;
184
            if (replay_state.data_kind >= EVENT_COUNT) {
185
                error_report("Replay: unknown event kind %d",
186
                             replay_state.data_kind);
187
                exit(1);
188
            }
189
        }
190
    }
191
}
192

193
void replay_finish_event(void)
194
{
195
    replay_state.has_unread_data = false;
196
    replay_fetch_data_kind();
197
}
198

199
static __thread bool replay_locked;
200

201
void replay_mutex_init(void)
202
{
203
    qemu_mutex_init(&lock);
204
    qemu_cond_init(&mutex_cond);
205
    /* Hold the mutex while we start-up */
206
    replay_locked = true;
207
    ++mutex_tail;
208
}
209

210
bool replay_mutex_locked(void)
211
{
212
    return replay_locked;
213
}
214

215
/* Ordering constraints, replay_lock must be taken before BQL */
216
void replay_mutex_lock(void)
217
{
218
    if (replay_mode != REPLAY_MODE_NONE) {
219
        unsigned long id;
220
        g_assert(!bql_locked());
221
        g_assert(!replay_mutex_locked());
222
        qemu_mutex_lock(&lock);
223
        id = mutex_tail++;
224
        while (id != mutex_head) {
225
            qemu_cond_wait(&mutex_cond, &lock);
226
        }
227
        replay_locked = true;
228
        qemu_mutex_unlock(&lock);
229
    }
230
}
231

232
void replay_mutex_unlock(void)
233
{
234
    if (replay_mode != REPLAY_MODE_NONE) {
235
        g_assert(replay_mutex_locked());
236
        qemu_mutex_lock(&lock);
237
        ++mutex_head;
238
        replay_locked = false;
239
        qemu_cond_broadcast(&mutex_cond);
240
        qemu_mutex_unlock(&lock);
241
    }
242
}
243

244
void replay_advance_current_icount(uint64_t current_icount)
245
{
246
    int diff = (int)(current_icount - replay_state.current_icount);
247

248
    /* Time can only go forward */
249
    assert(diff >= 0);
250

251
    if (replay_mode == REPLAY_MODE_RECORD) {
252
        if (diff > 0) {
253
            replay_put_event(EVENT_INSTRUCTION);
254
            replay_put_dword(diff);
255
            replay_state.current_icount += diff;
256
        }
257
    } else if (replay_mode == REPLAY_MODE_PLAY) {
258
        if (diff > 0) {
259
            replay_state.instruction_count -= diff;
260
            replay_state.current_icount += diff;
261
            if (replay_state.instruction_count == 0) {
262
                assert(replay_state.data_kind == EVENT_INSTRUCTION);
263
                replay_finish_event();
264
                /* Wake up iothread. This is required because
265
                    timers will not expire until clock counters
266
                    will be read from the log. */
267
                qemu_notify_event();
268
            }
269
        }
270
        /* Execution reached the break step */
271
        if (replay_break_icount == replay_state.current_icount) {
272
            /* Cannot make callback directly from the vCPU thread */
273
            timer_mod_ns(replay_break_timer,
274
                qemu_clock_get_ns(QEMU_CLOCK_REALTIME));
275
        }
276
    }
277
}
278

279
/*! Saves cached instructions. */
280
void replay_save_instructions(void)
281
{
282
    if (replay_file && replay_mode == REPLAY_MODE_RECORD) {
283
        g_assert(replay_mutex_locked());
284
        replay_advance_current_icount(replay_get_current_icount());
285
    }
286
}
287