replay/replay-events.c

   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-common.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
  19 typedef struct Event {
  20     ReplayAsyncEventKind event_kind;
  21     void *opaque;
  22     void *opaque2;
  23     uint64_t id;
  24
  25     QTAILQ_ENTRY(Event) events;
  26 } Event;
  27
  28 static QTAILQ_HEAD(, Event) events_list = QTAILQ_HEAD_INITIALIZER(events_list);
  29 static unsigned int read_event_kind = -1;
  30 static uint64_t read_id = -1;
  31 static int read_checkpoint = -1;
  32
  33 static bool events_enabled;
  34
  35 /* Functions */
  36
  37 static void replay_run_event(Event *event)
  38 {
  39     switch (event->event_kind) {
  40     case REPLAY_ASYNC_EVENT_BH:
  41         aio_bh_call(event->opaque);
  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     default:
  51         error_report("Replay: invalid async event ID (%d) in the queue",
  52                     event->event_kind);
  53         exit(1);
  54         break;
  55     }
  56 }
  57
  58 void replay_enable_events(void)
  59 {
  60     events_enabled = true;
  61 }
  62
  63 bool replay_has_events(void)
  64 {
  65     return !QTAILQ_EMPTY(&events_list);
  66 }
  67
  68 void replay_flush_events(void)
  69 {
  70     replay_mutex_lock();
  71     while (!QTAILQ_EMPTY(&events_list)) {
  72         Event *event = QTAILQ_FIRST(&events_list);
  73         replay_mutex_unlock();
  74         replay_run_event(event);
  75         replay_mutex_lock();
  76         QTAILQ_REMOVE(&events_list, event, events);
  77         g_free(event);
  78     }
  79     replay_mutex_unlock();
  80 }
  81
  82 void replay_disable_events(void)
  83 {
  84     if (replay_mode != REPLAY_MODE_NONE) {
  85         events_enabled = false;
  86         /* Flush events queue before waiting of completion */
  87         replay_flush_events();
  88     }
  89 }
  90
  91 void replay_clear_events(void)
  92 {
  93     replay_mutex_lock();
  94     while (!QTAILQ_EMPTY(&events_list)) {
  95         Event *event = QTAILQ_FIRST(&events_list);
  96         QTAILQ_REMOVE(&events_list, event, events);
  97
  98         g_free(event);
  99     }
 100     replay_mutex_unlock();
 101 }
 102
 103 /*! Adds specified async event to the queue */
 104 static void replay_add_event(ReplayAsyncEventKind event_kind,
 105                              void *opaque,
 106                              void *opaque2, uint64_t id)
 107 {
 108     assert(event_kind < REPLAY_ASYNC_COUNT);
 109
 110     if (!replay_file || replay_mode == REPLAY_MODE_NONE
 111         || !events_enabled) {
 112         Event e;
 113         e.event_kind = event_kind;
 114         e.opaque = opaque;
 115         e.opaque2 = opaque2;
 116         e.id = id;
 117         replay_run_event(&e);
 118         return;
 119     }
 120
 121     Event *event = g_malloc0(sizeof(Event));
 122     event->event_kind = event_kind;
 123     event->opaque = opaque;
 124     event->opaque2 = opaque2;
 125     event->id = id;
 126
 127     replay_mutex_lock();
 128     QTAILQ_INSERT_TAIL(&events_list, event, events);
 129     replay_mutex_unlock();
 130 }
 131
 132 void replay_bh_schedule_event(QEMUBH *bh)
 133 {
 134     if (replay_mode != REPLAY_MODE_NONE) {
 135         uint64_t id = replay_get_current_step();
 136         replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
 137     } else {
 138         qemu_bh_schedule(bh);
 139     }
 140 }
 141
 142 void replay_add_input_event(struct InputEvent *event)
 143 {
 144     replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0);
 145 }
 146
 147 void replay_add_input_sync_event(void)
 148 {
 149     replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0);
 150 }
 151
 152 static void replay_save_event(Event *event, int checkpoint)
 153 {
 154     if (replay_mode != REPLAY_MODE_PLAY) {
 155         /* put the event into the file */
 156         replay_put_event(EVENT_ASYNC);
 157         replay_put_byte(checkpoint);
 158         replay_put_byte(event->event_kind);
 159
 160         /* save event-specific data */
 161         switch (event->event_kind) {
 162         case REPLAY_ASYNC_EVENT_BH:
 163             replay_put_qword(event->id);
 164             break;
 165         case REPLAY_ASYNC_EVENT_INPUT:
 166             replay_save_input_event(event->opaque);
 167             break;
 168         case REPLAY_ASYNC_EVENT_INPUT_SYNC:
 169             break;
 170         default:
 171             error_report("Unknown ID %d of replay event", read_event_kind);
 172             exit(1);
 173         }
 174     }
 175 }
 176
 177 /* Called with replay mutex locked */
 178 void replay_save_events(int checkpoint)
 179 {
 180     while (!QTAILQ_EMPTY(&events_list)) {
 181         Event *event = QTAILQ_FIRST(&events_list);
 182         replay_save_event(event, checkpoint);
 183
 184         replay_mutex_unlock();
 185         replay_run_event(event);
 186         replay_mutex_lock();
 187         QTAILQ_REMOVE(&events_list, event, events);
 188         g_free(event);
 189     }
 190 }
 191
 192 static Event *replay_read_event(int checkpoint)
 193 {
 194     Event *event;
 195     if (read_event_kind == -1) {
 196         read_checkpoint = replay_get_byte();
 197         read_event_kind = replay_get_byte();
 198         read_id = -1;
 199         replay_check_error();
 200     }
 201
 202     if (checkpoint != read_checkpoint) {
 203         return NULL;
 204     }
 205
 206     /* Events that has not to be in the queue */
 207     switch (read_event_kind) {
 208     case REPLAY_ASYNC_EVENT_BH:
 209         if (read_id == -1) {
 210             read_id = replay_get_qword();
 211         }
 212         break;
 213     case REPLAY_ASYNC_EVENT_INPUT:
 214         event = g_malloc0(sizeof(Event));
 215         event->event_kind = read_event_kind;
 216         event->opaque = replay_read_input_event();
 217         return event;
 218     case REPLAY_ASYNC_EVENT_INPUT_SYNC:
 219         event = g_malloc0(sizeof(Event));
 220         event->event_kind = read_event_kind;
 221         event->opaque = 0;
 222         return event;
 223     default:
 224         error_report("Unknown ID %d of replay event", read_event_kind);
 225         exit(1);
 226         break;
 227     }
 228
 229     QTAILQ_FOREACH(event, &events_list, events) {
 230         if (event->event_kind == read_event_kind
 231             && (read_id == -1 || read_id == event->id)) {
 232             break;
 233         }
 234     }
 235
 236     if (event) {
 237         QTAILQ_REMOVE(&events_list, event, events);
 238     } else {
 239         return NULL;
 240     }
 241
 242     /* Read event-specific data */
 243
 244     return event;
 245 }
 246
 247 /* Called with replay mutex locked */
 248 void replay_read_events(int checkpoint)
 249 {
 250     while (replay_data_kind == EVENT_ASYNC) {
 251         Event *event = replay_read_event(checkpoint);
 252         if (!event) {
 253             break;
 254         }
 255         replay_mutex_unlock();
 256         replay_run_event(event);
 257         replay_mutex_lock();
 258
 259         g_free(event);
 260         replay_finish_event();
 261         read_event_kind = -1;
 262     }
 263 }
 264
 265 void replay_init_events(void)
 266 {
 267     read_event_kind = -1;
 268 }
 269
 270 void replay_finish_events(void)
 271 {
 272     events_enabled = false;
 273     replay_clear_events();
 274 }
 275
 276 bool replay_events_enabled(void)
 277 {
 278     return events_enabled;
 279 }