qemu

1
/*
2
 * replay-char.c
3
 *
4
 * Copyright (c) 2010-2016 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/error-report.h"
14
#include "sysemu/replay.h"
15
#include "replay-internal.h"
16
#include "chardev/char.h"
17

18
/* Char drivers that generate qemu_chr_be_write events
19
   that should be saved into the log. */
20
static Chardev **char_drivers;
21
static int drivers_count;
22

23
/* Char event attributes. */
24
typedef struct CharEvent {
25
    int id;
26
    uint8_t *buf;
27
    size_t len;
28
} CharEvent;
29

30
static int find_char_driver(Chardev *chr)
31
{
32
    int i = 0;
33
    for ( ; i < drivers_count ; ++i) {
34
        if (char_drivers[i] == chr) {
35
            return i;
36
        }
37
    }
38
    return -1;
39
}
40

41
void replay_register_char_driver(Chardev *chr)
42
{
43
    if (replay_mode == REPLAY_MODE_NONE) {
44
        return;
45
    }
46
    char_drivers = g_realloc(char_drivers,
47
                             sizeof(*char_drivers) * (drivers_count + 1));
48
    char_drivers[drivers_count++] = chr;
49
}
50

51
void replay_chr_be_write(Chardev *s, const uint8_t *buf, int len)
52
{
53
    CharEvent *event = g_new0(CharEvent, 1);
54

55
    event->id = find_char_driver(s);
56
    if (event->id < 0) {
57
        fprintf(stderr, "Replay: cannot find char driver\n");
58
        exit(1);
59
    }
60
    event->buf = g_malloc(len);
61
    memcpy(event->buf, buf, len);
62
    event->len = len;
63

64
    replay_add_event(REPLAY_ASYNC_EVENT_CHAR_READ, event, NULL, 0);
65
}
66

67
void replay_event_char_read_run(void *opaque)
68
{
69
    CharEvent *event = (CharEvent *)opaque;
70

71
    qemu_chr_be_write_impl(char_drivers[event->id], event->buf,
72
                           (int)event->len);
73

74
    g_free(event->buf);
75
    g_free(event);
76
}
77

78
void replay_event_char_read_save(void *opaque)
79
{
80
    CharEvent *event = (CharEvent *)opaque;
81

82
    replay_put_byte(event->id);
83
    replay_put_array(event->buf, event->len);
84
}
85

86
void *replay_event_char_read_load(void)
87
{
88
    CharEvent *event = g_new0(CharEvent, 1);
89

90
    event->id = replay_get_byte();
91
    replay_get_array_alloc(&event->buf, &event->len);
92

93
    return event;
94
}
95

96
void replay_char_write_event_save(int res, int offset)
97
{
98
    g_assert(replay_mutex_locked());
99

100
    replay_save_instructions();
101
    replay_put_event(EVENT_CHAR_WRITE);
102
    replay_put_dword(res);
103
    replay_put_dword(offset);
104
}
105

106
void replay_char_write_event_load(int *res, int *offset)
107
{
108
    g_assert(replay_mutex_locked());
109

110
    replay_account_executed_instructions();
111
    if (replay_next_event_is(EVENT_CHAR_WRITE)) {
112
        *res = replay_get_dword();
113
        *offset = replay_get_dword();
114
        replay_finish_event();
115
    } else {
116
        replay_sync_error("Missing character write event in the replay log");
117
    }
118
}
119

120
int replay_char_read_all_load(uint8_t *buf)
121
{
122
    g_assert(replay_mutex_locked());
123

124
    if (replay_next_event_is(EVENT_CHAR_READ_ALL)) {
125
        size_t size;
126
        int res;
127
        replay_get_array(buf, &size);
128
        replay_finish_event();
129
        res = (int)size;
130
        assert(res >= 0);
131
        return res;
132
    } else if (replay_next_event_is(EVENT_CHAR_READ_ALL_ERROR)) {
133
        int res = replay_get_dword();
134
        replay_finish_event();
135
        return res;
136
    } else {
137
        replay_sync_error("Missing character read all event in the replay log");
138
    }
139
}
140

141
void replay_char_read_all_save_error(int res)
142
{
143
    g_assert(replay_mutex_locked());
144
    assert(res < 0);
145
    replay_save_instructions();
146
    replay_put_event(EVENT_CHAR_READ_ALL_ERROR);
147
    replay_put_dword(res);
148
}
149

150
void replay_char_read_all_save_buf(uint8_t *buf, int offset)
151
{
152
    g_assert(replay_mutex_locked());
153
    replay_save_instructions();
154
    replay_put_event(EVENT_CHAR_READ_ALL);
155
    replay_put_array(buf, offset);
156
}
157