Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 1 | /* |
| 2 | * replay-events.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 | |
Peter Maydell | d38ea87 | 2016-01-29 17:50:05 +0000 | [diff] [blame] | 12 | #include "qemu/osdep.h" |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 13 | #include "qemu-common.h" |
| 14 | #include "qemu/error-report.h" |
| 15 | #include "sysemu/replay.h" |
| 16 | #include "replay-internal.h" |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 17 | #include "block/aio.h" |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 18 | #include "ui/input.h" |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 19 | |
| 20 | typedef struct Event { |
| 21 | ReplayAsyncEventKind event_kind; |
| 22 | void *opaque; |
| 23 | void *opaque2; |
| 24 | uint64_t id; |
| 25 | |
| 26 | QTAILQ_ENTRY(Event) events; |
| 27 | } Event; |
| 28 | |
| 29 | static QTAILQ_HEAD(, Event) events_list = QTAILQ_HEAD_INITIALIZER(events_list); |
| 30 | static unsigned int read_event_kind = -1; |
| 31 | static uint64_t read_id = -1; |
| 32 | static int read_checkpoint = -1; |
| 33 | |
| 34 | static bool events_enabled; |
| 35 | |
| 36 | /* Functions */ |
| 37 | |
| 38 | static void replay_run_event(Event *event) |
| 39 | { |
| 40 | switch (event->event_kind) { |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 41 | case REPLAY_ASYNC_EVENT_BH: |
| 42 | aio_bh_call(event->opaque); |
| 43 | break; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 44 | case REPLAY_ASYNC_EVENT_INPUT: |
| 45 | qemu_input_event_send_impl(NULL, (InputEvent *)event->opaque); |
| 46 | qapi_free_InputEvent((InputEvent *)event->opaque); |
| 47 | break; |
| 48 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: |
| 49 | qemu_input_event_sync_impl(); |
| 50 | break; |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 51 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
| 52 | replay_event_char_read_run(event->opaque); |
| 53 | break; |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 54 | case REPLAY_ASYNC_EVENT_BLOCK: |
| 55 | aio_bh_call(event->opaque); |
| 56 | break; |
Pavel Dovgalyuk | 646c547 | 2016-09-26 11:08:21 +0300 | [diff] [blame] | 57 | case REPLAY_ASYNC_EVENT_NET: |
| 58 | replay_event_net_run(event->opaque); |
| 59 | break; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 60 | default: |
| 61 | error_report("Replay: invalid async event ID (%d) in the queue", |
| 62 | event->event_kind); |
| 63 | exit(1); |
| 64 | break; |
| 65 | } |
| 66 | } |
| 67 | |
| 68 | void replay_enable_events(void) |
| 69 | { |
| 70 | events_enabled = true; |
| 71 | } |
| 72 | |
| 73 | bool replay_has_events(void) |
| 74 | { |
| 75 | return !QTAILQ_EMPTY(&events_list); |
| 76 | } |
| 77 | |
| 78 | void replay_flush_events(void) |
| 79 | { |
| 80 | replay_mutex_lock(); |
| 81 | while (!QTAILQ_EMPTY(&events_list)) { |
| 82 | Event *event = QTAILQ_FIRST(&events_list); |
| 83 | replay_mutex_unlock(); |
| 84 | replay_run_event(event); |
| 85 | replay_mutex_lock(); |
| 86 | QTAILQ_REMOVE(&events_list, event, events); |
| 87 | g_free(event); |
| 88 | } |
| 89 | replay_mutex_unlock(); |
| 90 | } |
| 91 | |
| 92 | void replay_disable_events(void) |
| 93 | { |
| 94 | if (replay_mode != REPLAY_MODE_NONE) { |
| 95 | events_enabled = false; |
| 96 | /* Flush events queue before waiting of completion */ |
| 97 | replay_flush_events(); |
| 98 | } |
| 99 | } |
| 100 | |
| 101 | void replay_clear_events(void) |
| 102 | { |
| 103 | replay_mutex_lock(); |
| 104 | while (!QTAILQ_EMPTY(&events_list)) { |
| 105 | Event *event = QTAILQ_FIRST(&events_list); |
| 106 | QTAILQ_REMOVE(&events_list, event, events); |
| 107 | |
| 108 | g_free(event); |
| 109 | } |
| 110 | replay_mutex_unlock(); |
| 111 | } |
| 112 | |
| 113 | /*! Adds specified async event to the queue */ |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 114 | void replay_add_event(ReplayAsyncEventKind event_kind, |
| 115 | void *opaque, |
| 116 | void *opaque2, uint64_t id) |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 117 | { |
| 118 | assert(event_kind < REPLAY_ASYNC_COUNT); |
| 119 | |
| 120 | if (!replay_file || replay_mode == REPLAY_MODE_NONE |
| 121 | || !events_enabled) { |
| 122 | Event e; |
| 123 | e.event_kind = event_kind; |
| 124 | e.opaque = opaque; |
| 125 | e.opaque2 = opaque2; |
| 126 | e.id = id; |
| 127 | replay_run_event(&e); |
| 128 | return; |
| 129 | } |
| 130 | |
| 131 | Event *event = g_malloc0(sizeof(Event)); |
| 132 | event->event_kind = event_kind; |
| 133 | event->opaque = opaque; |
| 134 | event->opaque2 = opaque2; |
| 135 | event->id = id; |
| 136 | |
| 137 | replay_mutex_lock(); |
| 138 | QTAILQ_INSERT_TAIL(&events_list, event, events); |
| 139 | replay_mutex_unlock(); |
| 140 | } |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 141 | |
| 142 | void replay_bh_schedule_event(QEMUBH *bh) |
| 143 | { |
Pavel Dovgalyuk | 58a0067 | 2016-03-14 10:44:59 +0300 | [diff] [blame] | 144 | if (replay_mode != REPLAY_MODE_NONE && events_enabled) { |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 145 | uint64_t id = replay_get_current_step(); |
| 146 | replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id); |
| 147 | } else { |
| 148 | qemu_bh_schedule(bh); |
| 149 | } |
| 150 | } |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 151 | |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 152 | void replay_add_input_event(struct InputEvent *event) |
| 153 | { |
| 154 | replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0); |
| 155 | } |
| 156 | |
| 157 | void replay_add_input_sync_event(void) |
| 158 | { |
| 159 | replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0); |
| 160 | } |
| 161 | |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 162 | void replay_block_event(QEMUBH *bh, uint64_t id) |
| 163 | { |
| 164 | if (replay_mode != REPLAY_MODE_NONE && events_enabled) { |
| 165 | replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id); |
| 166 | } else { |
| 167 | qemu_bh_schedule(bh); |
| 168 | } |
| 169 | } |
| 170 | |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 171 | static void replay_save_event(Event *event, int checkpoint) |
| 172 | { |
| 173 | if (replay_mode != REPLAY_MODE_PLAY) { |
| 174 | /* put the event into the file */ |
| 175 | replay_put_event(EVENT_ASYNC); |
| 176 | replay_put_byte(checkpoint); |
| 177 | replay_put_byte(event->event_kind); |
| 178 | |
| 179 | /* save event-specific data */ |
| 180 | switch (event->event_kind) { |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 181 | case REPLAY_ASYNC_EVENT_BH: |
| 182 | replay_put_qword(event->id); |
| 183 | break; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 184 | case REPLAY_ASYNC_EVENT_INPUT: |
| 185 | replay_save_input_event(event->opaque); |
| 186 | break; |
| 187 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: |
| 188 | break; |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 189 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
| 190 | replay_event_char_read_save(event->opaque); |
| 191 | break; |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 192 | case REPLAY_ASYNC_EVENT_BLOCK: |
| 193 | replay_put_qword(event->id); |
| 194 | break; |
Pavel Dovgalyuk | 646c547 | 2016-09-26 11:08:21 +0300 | [diff] [blame] | 195 | case REPLAY_ASYNC_EVENT_NET: |
| 196 | replay_event_net_save(event->opaque); |
| 197 | break; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 198 | default: |
Pavel Dovgalyuk | 95b4aed | 2016-03-14 10:45:04 +0300 | [diff] [blame] | 199 | error_report("Unknown ID %" PRId64 " of replay event", event->id); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 200 | exit(1); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 201 | } |
| 202 | } |
| 203 | } |
| 204 | |
| 205 | /* Called with replay mutex locked */ |
| 206 | void replay_save_events(int checkpoint) |
| 207 | { |
| 208 | while (!QTAILQ_EMPTY(&events_list)) { |
| 209 | Event *event = QTAILQ_FIRST(&events_list); |
| 210 | replay_save_event(event, checkpoint); |
| 211 | |
| 212 | replay_mutex_unlock(); |
| 213 | replay_run_event(event); |
| 214 | replay_mutex_lock(); |
| 215 | QTAILQ_REMOVE(&events_list, event, events); |
| 216 | g_free(event); |
| 217 | } |
| 218 | } |
| 219 | |
| 220 | static Event *replay_read_event(int checkpoint) |
| 221 | { |
| 222 | Event *event; |
| 223 | if (read_event_kind == -1) { |
| 224 | read_checkpoint = replay_get_byte(); |
| 225 | read_event_kind = replay_get_byte(); |
| 226 | read_id = -1; |
| 227 | replay_check_error(); |
| 228 | } |
| 229 | |
| 230 | if (checkpoint != read_checkpoint) { |
| 231 | return NULL; |
| 232 | } |
| 233 | |
| 234 | /* Events that has not to be in the queue */ |
| 235 | switch (read_event_kind) { |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 236 | case REPLAY_ASYNC_EVENT_BH: |
| 237 | if (read_id == -1) { |
| 238 | read_id = replay_get_qword(); |
| 239 | } |
| 240 | break; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 241 | case REPLAY_ASYNC_EVENT_INPUT: |
| 242 | event = g_malloc0(sizeof(Event)); |
| 243 | event->event_kind = read_event_kind; |
| 244 | event->opaque = replay_read_input_event(); |
| 245 | return event; |
| 246 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: |
| 247 | event = g_malloc0(sizeof(Event)); |
| 248 | event->event_kind = read_event_kind; |
| 249 | event->opaque = 0; |
| 250 | return event; |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 251 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
| 252 | event = g_malloc0(sizeof(Event)); |
| 253 | event->event_kind = read_event_kind; |
| 254 | event->opaque = replay_event_char_read_load(); |
| 255 | return event; |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 256 | case REPLAY_ASYNC_EVENT_BLOCK: |
| 257 | if (read_id == -1) { |
| 258 | read_id = replay_get_qword(); |
| 259 | } |
| 260 | break; |
Pavel Dovgalyuk | 646c547 | 2016-09-26 11:08:21 +0300 | [diff] [blame] | 261 | case REPLAY_ASYNC_EVENT_NET: |
| 262 | event = g_malloc0(sizeof(Event)); |
| 263 | event->event_kind = read_event_kind; |
| 264 | event->opaque = replay_event_net_load(); |
| 265 | return event; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 266 | default: |
| 267 | error_report("Unknown ID %d of replay event", read_event_kind); |
| 268 | exit(1); |
| 269 | break; |
| 270 | } |
| 271 | |
| 272 | QTAILQ_FOREACH(event, &events_list, events) { |
| 273 | if (event->event_kind == read_event_kind |
| 274 | && (read_id == -1 || read_id == event->id)) { |
| 275 | break; |
| 276 | } |
| 277 | } |
| 278 | |
| 279 | if (event) { |
| 280 | QTAILQ_REMOVE(&events_list, event, events); |
| 281 | } else { |
| 282 | return NULL; |
| 283 | } |
| 284 | |
| 285 | /* Read event-specific data */ |
| 286 | |
| 287 | return event; |
| 288 | } |
| 289 | |
| 290 | /* Called with replay mutex locked */ |
| 291 | void replay_read_events(int checkpoint) |
| 292 | { |
Pavel Dovgalyuk | f186d64 | 2016-09-26 11:08:04 +0300 | [diff] [blame] | 293 | while (replay_state.data_kind == EVENT_ASYNC) { |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 294 | Event *event = replay_read_event(checkpoint); |
| 295 | if (!event) { |
| 296 | break; |
| 297 | } |
| 298 | replay_mutex_unlock(); |
| 299 | replay_run_event(event); |
| 300 | replay_mutex_lock(); |
| 301 | |
| 302 | g_free(event); |
| 303 | replay_finish_event(); |
| 304 | read_event_kind = -1; |
| 305 | } |
| 306 | } |
| 307 | |
| 308 | void replay_init_events(void) |
| 309 | { |
| 310 | read_event_kind = -1; |
| 311 | } |
| 312 | |
| 313 | void replay_finish_events(void) |
| 314 | { |
| 315 | events_enabled = false; |
| 316 | replay_clear_events(); |
| 317 | } |
| 318 | |
| 319 | bool replay_events_enabled(void) |
| 320 | { |
| 321 | return events_enabled; |
| 322 | } |
Pavel Dovgalyuk | 6d0ceb8 | 2016-09-26 11:08:16 +0300 | [diff] [blame] | 323 | |
| 324 | uint64_t blkreplay_next_id(void) |
| 325 | { |
| 326 | if (replay_events_enabled()) { |
| 327 | return replay_state.block_request_id++; |
| 328 | } |
| 329 | return 0; |
| 330 | } |