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