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, uint8_t *buf, int len) |
52 | { |
53 | CharEvent *event = g_malloc0(sizeof(CharEvent)); |
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_malloc0(sizeof(CharEvent)); |
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 | error_report("Missing character write event in the replay log" ); |
117 | exit(1); |
118 | } |
119 | } |
120 | |
121 | int replay_char_read_all_load(uint8_t *buf) |
122 | { |
123 | g_assert(replay_mutex_locked()); |
124 | |
125 | if (replay_next_event_is(EVENT_CHAR_READ_ALL)) { |
126 | size_t size; |
127 | int res; |
128 | replay_get_array(buf, &size); |
129 | replay_finish_event(); |
130 | res = (int)size; |
131 | assert(res >= 0); |
132 | return res; |
133 | } else if (replay_next_event_is(EVENT_CHAR_READ_ALL_ERROR)) { |
134 | int res = replay_get_dword(); |
135 | replay_finish_event(); |
136 | return res; |
137 | } else { |
138 | error_report("Missing character read all event in the replay log" ); |
139 | exit(1); |
140 | } |
141 | } |
142 | |
143 | void replay_char_read_all_save_error(int res) |
144 | { |
145 | g_assert(replay_mutex_locked()); |
146 | assert(res < 0); |
147 | replay_save_instructions(); |
148 | replay_put_event(EVENT_CHAR_READ_ALL_ERROR); |
149 | replay_put_dword(res); |
150 | } |
151 | |
152 | void replay_char_read_all_save_buf(uint8_t *buf, int offset) |
153 | { |
154 | g_assert(replay_mutex_locked()); |
155 | replay_save_instructions(); |
156 | replay_put_event(EVENT_CHAR_READ_ALL); |
157 | replay_put_array(buf, offset); |
158 | } |
159 | |