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