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/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 void replay_disable_events(void)
  96 {
  97     if (replay_mode != REPLAY_MODE_NONE) {
  98         events_enabled = false;
  99         /* Flush events queue before waiting of completion */
 100         replay_flush_events();
 101     }
 102 }
 103
 104 /*! Adds specified async event to the queue */
 105 void replay_add_event(ReplayAsyncEventKind event_kind,
 106                       void *opaque,
 107                       void *opaque2, uint64_t id)
 108 {
 109     assert(event_kind < REPLAY_ASYNC_COUNT);
 110
 111     if (!replay_file || replay_mode == REPLAY_MODE_NONE
 112         || !events_enabled) {
 113         Event e;
 114         e.event_kind = event_kind;
 115         e.opaque = opaque;
 116         e.opaque2 = opaque2;
 117         e.id = id;
 118         replay_run_event(&e);
 119         return;
 120     }
 121
 122     Event *event = g_new0(Event, 1);
 123     event->event_kind = event_kind;
 124     event->opaque = opaque;
 125     event->opaque2 = opaque2;
 126     event->id = id;
 127
 128     g_assert(replay_mutex_locked());
 129     QTAILQ_INSERT_TAIL(&events_list, event, events);
 130     qemu_cpu_kick(first_cpu);
 131 }
 132
 133 void replay_bh_schedule_event(QEMUBH *bh)
 134 {
 135     if (events_enabled) {
 136         uint64_t id = replay_get_current_icount();
 137         replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
 138     } else {
 139         qemu_bh_schedule(bh);
 140     }
 141 }
 142
 143 void replay_bh_schedule_oneshot_event(AioContext *ctx,
 144     QEMUBHFunc *cb, void *opaque)
 145 {
 146     if (events_enabled) {
 147         uint64_t id = replay_get_current_icount();
 148         replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id);
 149     } else {
 150         aio_bh_schedule_oneshot(ctx, cb, opaque);
 151     }
 152 }
 153
 154 void replay_add_input_event(struct InputEvent *event)
 155 {
 156     replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0);
 157 }
 158
 159 void replay_add_input_sync_event(void)
 160 {
 161     replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0);
 162 }
 163
 164 void replay_block_event(QEMUBH *bh, uint64_t id)
 165 {
 166     if (events_enabled) {
 167         replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
 168     } else {
 169         qemu_bh_schedule(bh);
 170     }
 171 }
 172
 173 static void replay_save_event(Event *event)
 174 {
 175     if (replay_mode != REPLAY_MODE_PLAY) {
 176         /* put the event into the file */
 177         g_assert(event->event_kind < REPLAY_ASYNC_COUNT);
 178         replay_put_event(EVENT_ASYNC + event->event_kind);
 179
 180         /* save event-specific data */
 181         switch (event->event_kind) {
 182         case REPLAY_ASYNC_EVENT_BH:
 183         case REPLAY_ASYNC_EVENT_BH_ONESHOT:
 184             replay_put_qword(event->id);
 185             break;
 186         case REPLAY_ASYNC_EVENT_INPUT:
 187             replay_save_input_event(event->opaque);
 188             break;
 189         case REPLAY_ASYNC_EVENT_INPUT_SYNC:
 190             break;
 191         case REPLAY_ASYNC_EVENT_CHAR_READ:
 192             replay_event_char_read_save(event->opaque);
 193             break;
 194         case REPLAY_ASYNC_EVENT_BLOCK:
 195             replay_put_qword(event->id);
 196             break;
 197         case REPLAY_ASYNC_EVENT_NET:
 198             replay_event_net_save(event->opaque);
 199             break;
 200         default:
 201             error_report("Unknown ID %" PRId64 " of replay event", event->id);
 202             exit(1);
 203         }
 204     }
 205 }
 206
 207 /* Called with replay mutex locked */
 208 void replay_save_events(void)
 209 {
 210     g_assert(replay_mutex_locked());
 211     while (!QTAILQ_EMPTY(&events_list)) {
 212         Event *event = QTAILQ_FIRST(&events_list);
 213         replay_save_event(event);
 214         replay_run_event(event);
 215         QTAILQ_REMOVE(&events_list, event, events);
 216         g_free(event);
 217     }
 218 }
 219
 220 static Event *replay_read_event(void)
 221 {
 222     Event *event;
 223     ReplayAsyncEventKind event_kind = replay_state.data_kind - EVENT_ASYNC;
 224
 225     /* Events that has not to be in the queue */
 226     switch (event_kind) {
 227     case REPLAY_ASYNC_EVENT_BH:
 228     case REPLAY_ASYNC_EVENT_BH_ONESHOT:
 229         if (replay_state.read_event_id == -1) {
 230             replay_state.read_event_id = replay_get_qword();
 231         }
 232         break;
 233     case REPLAY_ASYNC_EVENT_INPUT:
 234         event = g_new0(Event, 1);
 235         event->event_kind = event_kind;
 236         event->opaque = replay_read_input_event();
 237         return event;
 238     case REPLAY_ASYNC_EVENT_INPUT_SYNC:
 239         event = g_new0(Event, 1);
 240         event->event_kind = event_kind;
 241         event->opaque = 0;
 242         return event;
 243     case REPLAY_ASYNC_EVENT_CHAR_READ:
 244         event = g_new0(Event, 1);
 245         event->event_kind = event_kind;
 246         event->opaque = replay_event_char_read_load();
 247         return event;
 248     case REPLAY_ASYNC_EVENT_BLOCK:
 249         if (replay_state.read_event_id == -1) {
 250             replay_state.read_event_id = replay_get_qword();
 251         }
 252         break;
 253     case REPLAY_ASYNC_EVENT_NET:
 254         event = g_new0(Event, 1);
 255         event->event_kind = event_kind;
 256         event->opaque = replay_event_net_load();
 257         return event;
 258     default:
 259         error_report("Unknown ID %d of replay event", event_kind);
 260         exit(1);
 261         break;
 262     }
 263
 264     QTAILQ_FOREACH(event, &events_list, events) {
 265         if (event->event_kind == event_kind
 266             && (replay_state.read_event_id == -1
 267                 || replay_state.read_event_id == event->id)) {
 268             break;
 269         }
 270     }
 271
 272     if (event) {
 273         QTAILQ_REMOVE(&events_list, event, events);
 274     }
 275
 276     return event;
 277 }
 278
 279 /* Called with replay mutex locked */
 280 void replay_read_events(void)
 281 {
 282     g_assert(replay_mutex_locked());
 283     while (replay_state.data_kind >= EVENT_ASYNC
 284         && replay_state.data_kind <= EVENT_ASYNC_LAST) {
 285         Event *event = replay_read_event();
 286         if (!event) {
 287             break;
 288         }
 289         replay_finish_event();
 290         replay_state.read_event_id = -1;
 291         replay_run_event(event);
 292
 293         g_free(event);
 294     }
 295 }
 296
 297 void replay_init_events(void)
 298 {
 299     replay_state.read_event_id = -1;
 300 }
 301
 302 void replay_finish_events(void)
 303 {
 304     events_enabled = false;
 305     replay_flush_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 }