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