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