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
  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 bool events_enabled;
  30
  31 /* Functions */
  32
  33 static void replay_run_event(Event *event)
  34 {
  35     switch (event->event_kind) {
  36     case REPLAY_ASYNC_EVENT_BH:
  37         aio_bh_call(event->opaque);
  38         break;
  39     case REPLAY_ASYNC_EVENT_BH_ONESHOT:
  40         ((QEMUBHFunc *)event->opaque)(event->opaque2);
  41         break;
  42     case REPLAY_ASYNC_EVENT_INPUT:
  43         qemu_input_event_send_impl(NULL, (InputEvent *)event->opaque);
  44         qapi_free_InputEvent((InputEvent *)event->opaque);
  45         break;
  46     case REPLAY_ASYNC_EVENT_INPUT_SYNC:
  47         qemu_input_event_sync_impl();
  48         break;
  49     case REPLAY_ASYNC_EVENT_CHAR_READ:
  50         replay_event_char_read_run(event->opaque);
  51         break;
  52     case REPLAY_ASYNC_EVENT_BLOCK:
  53         aio_bh_call(event->opaque);
  54         break;
  55     case REPLAY_ASYNC_EVENT_NET:
  56         replay_event_net_run(event->opaque);
  57         break;
  58     default:
  59         error_report("Replay: invalid async event ID (%d) in the queue",
  60                     event->event_kind);
  61         exit(1);
  62         break;
  63     }
  64 }
  65
  66 void replay_enable_events(void)
  67 {
  68     if (replay_mode != REPLAY_MODE_NONE) {
  69         events_enabled = true;
  70     }
  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     if (replay_mode == REPLAY_MODE_NONE) {
  81         return;
  82     }
  83
  84     g_assert(replay_mutex_locked());
  85
  86     while (!QTAILQ_EMPTY(&events_list)) {
  87         Event *event = QTAILQ_FIRST(&events_list);
  88         replay_run_event(event);
  89         QTAILQ_REMOVE(&events_list, event, events);
  90         g_free(event);
  91     }
  92 }
  93
  94 void replay_disable_events(void)
  95 {
  96     if (replay_mode != REPLAY_MODE_NONE) {
  97         events_enabled = false;
  98         /* Flush events queue before waiting of completion */
  99         replay_flush_events();
 100     }
 101 }
 102
 103 /*! Adds specified async event to the queue */
 104 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     g_assert(replay_mutex_locked());
 128     QTAILQ_INSERT_TAIL(&events_list, event, events);
 129 }
 130
 131 void replay_bh_schedule_event(QEMUBH *bh)
 132 {
 133     if (events_enabled) {
 134         uint64_t id = replay_get_current_icount();
 135         replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
 136     } else {
 137         qemu_bh_schedule(bh);
 138     }
 139 }
 140
 141 void replay_bh_schedule_oneshot_event(AioContext *ctx,
 142     QEMUBHFunc *cb, void *opaque)
 143 {
 144     if (events_enabled) {
 145         uint64_t id = replay_get_current_icount();
 146         replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id);
 147     } else {
 148         aio_bh_schedule_oneshot(ctx, cb, opaque);
 149     }
 150 }
 151
 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
 162 void replay_block_event(QEMUBH *bh, uint64_t id)
 163 {
 164     if (events_enabled) {
 165         replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id);
 166     } else {
 167         qemu_bh_schedule(bh);
 168     }
 169 }
 170
 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) {
 181         case REPLAY_ASYNC_EVENT_BH:
 182         case REPLAY_ASYNC_EVENT_BH_ONESHOT:
 183             replay_put_qword(event->id);
 184             break;
 185         case REPLAY_ASYNC_EVENT_INPUT:
 186             replay_save_input_event(event->opaque);
 187             break;
 188         case REPLAY_ASYNC_EVENT_INPUT_SYNC:
 189             break;
 190         case REPLAY_ASYNC_EVENT_CHAR_READ:
 191             replay_event_char_read_save(event->opaque);
 192             break;
 193         case REPLAY_ASYNC_EVENT_BLOCK:
 194             replay_put_qword(event->id);
 195             break;
 196         case REPLAY_ASYNC_EVENT_NET:
 197             replay_event_net_save(event->opaque);
 198             break;
 199         default:
 200             error_report("Unknown ID %" PRId64 " of replay event", event->id);
 201             exit(1);
 202         }
 203     }
 204 }
 205
 206 /* Called with replay mutex locked */
 207 void replay_save_events(int checkpoint)
 208 {
 209     g_assert(replay_mutex_locked());
 210     g_assert(checkpoint != CHECKPOINT_CLOCK_WARP_START);
 211     g_assert(checkpoint != CHECKPOINT_CLOCK_VIRTUAL);
 212     while (!QTAILQ_EMPTY(&events_list)) {
 213         Event *event = QTAILQ_FIRST(&events_list);
 214         replay_save_event(event, checkpoint);
 215         replay_run_event(event);
 216         QTAILQ_REMOVE(&events_list, event, events);
 217         g_free(event);
 218     }
 219 }
 220
 221 static Event *replay_read_event(int checkpoint)
 222 {
 223     Event *event;
 224     if (replay_state.read_event_kind == -1) {
 225         replay_state.read_event_checkpoint = replay_get_byte();
 226         replay_state.read_event_kind = replay_get_byte();
 227         replay_state.read_event_id = -1;
 228         replay_check_error();
 229     }
 230
 231     if (checkpoint != replay_state.read_event_checkpoint) {
 232         return NULL;
 233     }
 234
 235     /* Events that has not to be in the queue */
 236     switch (replay_state.read_event_kind) {
 237     case REPLAY_ASYNC_EVENT_BH:
 238     case REPLAY_ASYNC_EVENT_BH_ONESHOT:
 239         if (replay_state.read_event_id == -1) {
 240             replay_state.read_event_id = replay_get_qword();
 241         }
 242         break;
 243     case REPLAY_ASYNC_EVENT_INPUT:
 244         event = g_malloc0(sizeof(Event));
 245         event->event_kind = replay_state.read_event_kind;
 246         event->opaque = replay_read_input_event();
 247         return event;
 248     case REPLAY_ASYNC_EVENT_INPUT_SYNC:
 249         event = g_malloc0(sizeof(Event));
 250         event->event_kind = replay_state.read_event_kind;
 251         event->opaque = 0;
 252         return event;
 253     case REPLAY_ASYNC_EVENT_CHAR_READ:
 254         event = g_malloc0(sizeof(Event));
 255         event->event_kind = replay_state.read_event_kind;
 256         event->opaque = replay_event_char_read_load();
 257         return event;
 258     case REPLAY_ASYNC_EVENT_BLOCK:
 259         if (replay_state.read_event_id == -1) {
 260             replay_state.read_event_id = replay_get_qword();
 261         }
 262         break;
 263     case REPLAY_ASYNC_EVENT_NET:
 264         event = g_malloc0(sizeof(Event));
 265         event->event_kind = replay_state.read_event_kind;
 266         event->opaque = replay_event_net_load();
 267         return event;
 268     default:
 269         error_report("Unknown ID %d of replay event",
 270             replay_state.read_event_kind);
 271         exit(1);
 272         break;
 273     }
 274
 275     QTAILQ_FOREACH(event, &events_list, events) {
 276         if (event->event_kind == replay_state.read_event_kind
 277             && (replay_state.read_event_id == -1
 278                 || replay_state.read_event_id == event->id)) {
 279             break;
 280         }
 281     }
 282
 283     if (event) {
 284         QTAILQ_REMOVE(&events_list, event, events);
 285     } else {
 286         return NULL;
 287     }
 288
 289     /* Read event-specific data */
 290
 291     return event;
 292 }
 293
 294 /* Called with replay mutex locked */
 295 void replay_read_events(int checkpoint)
 296 {
 297     g_assert(replay_mutex_locked());
 298     while (replay_state.data_kind == EVENT_ASYNC) {
 299         Event *event = replay_read_event(checkpoint);
 300         if (!event) {
 301             break;
 302         }
 303         replay_finish_event();
 304         replay_state.read_event_kind = -1;
 305         replay_run_event(event);
 306
 307         g_free(event);
 308     }
 309 }
 310
 311 void replay_init_events(void)
 312 {
 313     replay_state.read_event_kind = -1;
 314 }
 315
 316 void replay_finish_events(void)
 317 {
 318     events_enabled = false;
 319     replay_flush_events();
 320 }
 321
 322 bool replay_events_enabled(void)
 323 {
 324     return events_enabled;
 325 }
 326
 327 uint64_t blkreplay_next_id(void)
 328 {
 329     if (replay_events_enabled()) {
 330         return replay_state.block_request_id++;
 331     }
 332     return 0;
 333 }