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