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     if (replay_mode != REPLAY_MODE_NONE) {
  71         events_enabled = true;
  72     }
  73 }
  74
  75 bool replay_has_events(void)
  76 {
  77     return !QTAILQ_EMPTY(&events_list);
  78 }
  79
  80 void replay_flush_events(void)
  81 {
  82     replay_mutex_lock();
  83     while (!QTAILQ_EMPTY(&events_list)) {
  84         Event *event = QTAILQ_FIRST(&events_list);
  85         replay_mutex_unlock();
  86         replay_run_event(event);
  87         replay_mutex_lock();
  88         QTAILQ_REMOVE(&events_list, event, events);
  89         g_free(event);
  90     }
  91     replay_mutex_unlock();
  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 void replay_clear_events(void)
 104 {
 105     replay_mutex_lock();
 106     while (!QTAILQ_EMPTY(&events_list)) {
 107         Event *event = QTAILQ_FIRST(&events_list);
 108         QTAILQ_REMOVE(&events_list, event, events);
 109
 110         g_free(event);
 111     }
 112     replay_mutex_unlock();
 113 }
 114
 115 /*! Adds specified async event to the queue */
 116 void replay_add_event(ReplayAsyncEventKind event_kind,
 117                       void *opaque,
 118                       void *opaque2, uint64_t id)
 119 {
 120     assert(event_kind < REPLAY_ASYNC_COUNT);
 121
 122     if (!replay_file || replay_mode == REPLAY_MODE_NONE
 123         || !events_enabled) {
 124         Event e;
 125         e.event_kind = event_kind;
 126         e.opaque = opaque;
 127         e.opaque2 = opaque2;
 128         e.id = id;
 129         replay_run_event(&e);
 130         return;
 131     }
 132
 133     Event *event = g_malloc0(sizeof(Event));
 134     event->event_kind = event_kind;
 135     event->opaque = opaque;
 136     event->opaque2 = opaque2;
 137     event->id = id;
 138
 139     replay_mutex_lock();
 140     QTAILQ_INSERT_TAIL(&events_list, event, events);
 141     replay_mutex_unlock();
 142 }
 143
 144 void replay_bh_schedule_event(QEMUBH *bh)
 145 {
 146     if (events_enabled) {
 147         uint64_t id = replay_get_current_step();
 148         replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
 149     } else {
 150         qemu_bh_schedule(bh);
 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, int checkpoint)
 174 {
 175     if (replay_mode != REPLAY_MODE_PLAY) {
 176         /* put the event into the file */
 177         replay_put_event(EVENT_ASYNC);
 178         replay_put_byte(checkpoint);
 179         replay_put_byte(event->event_kind);
 180
 181         /* save event-specific data */
 182         switch (event->event_kind) {
 183         case REPLAY_ASYNC_EVENT_BH:
 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(int checkpoint)
 209 {
 210     while (!QTAILQ_EMPTY(&events_list)) {
 211         Event *event = QTAILQ_FIRST(&events_list);
 212         replay_save_event(event, checkpoint);
 213
 214         replay_mutex_unlock();
 215         replay_run_event(event);
 216         replay_mutex_lock();
 217         QTAILQ_REMOVE(&events_list, event, events);
 218         g_free(event);
 219     }
 220 }
 221
 222 static Event *replay_read_event(int checkpoint)
 223 {
 224     Event *event;
 225     if (read_event_kind == -1) {
 226         read_checkpoint = replay_get_byte();
 227         read_event_kind = replay_get_byte();
 228         read_id = -1;
 229         replay_check_error();
 230     }
 231
 232     if (checkpoint != read_checkpoint) {
 233         return NULL;
 234     }
 235
 236     /* Events that has not to be in the queue */
 237     switch (read_event_kind) {
 238     case REPLAY_ASYNC_EVENT_BH:
 239         if (read_id == -1) {
 240             read_id = replay_get_qword();
 241         }
 242         break;
 243     case REPLAY_ASYNC_EVENT_INPUT:
 244         event = g_malloc0(sizeof(Event));
 245         event->event_kind = 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 = 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 = read_event_kind;
 256         event->opaque = replay_event_char_read_load();
 257         return event;
 258     case REPLAY_ASYNC_EVENT_BLOCK:
 259         if (read_id == -1) {
 260             read_id = replay_get_qword();
 261         }
 262         break;
 263     case REPLAY_ASYNC_EVENT_NET:
 264         event = g_malloc0(sizeof(Event));
 265         event->event_kind = read_event_kind;
 266         event->opaque = replay_event_net_load();
 267         return event;
 268     default:
 269         error_report("Unknown ID %d of replay event", read_event_kind);
 270         exit(1);
 271         break;
 272     }
 273
 274     QTAILQ_FOREACH(event, &events_list, events) {
 275         if (event->event_kind == read_event_kind
 276             && (read_id == -1 || read_id == event->id)) {
 277             break;
 278         }
 279     }
 280
 281     if (event) {
 282         QTAILQ_REMOVE(&events_list, event, events);
 283     } else {
 284         return NULL;
 285     }
 286
 287     /* Read event-specific data */
 288
 289     return event;
 290 }
 291
 292 /* Called with replay mutex locked */
 293 void replay_read_events(int checkpoint)
 294 {
 295     while (replay_state.data_kind == EVENT_ASYNC) {
 296         Event *event = replay_read_event(checkpoint);
 297         if (!event) {
 298             break;
 299         }
 300         replay_finish_event();
 301         read_event_kind = -1;
 302         replay_mutex_unlock();
 303         replay_run_event(event);
 304         replay_mutex_lock();
 305
 306         g_free(event);
 307     }
 308 }
 309
 310 void replay_init_events(void)
 311 {
 312     read_event_kind = -1;
 313 }
 314
 315 void replay_finish_events(void)
 316 {
 317     events_enabled = false;
 318     replay_clear_events();
 319 }
 320
 321 bool replay_events_enabled(void)
 322 {
 323     return events_enabled;
 324 }
 325
 326 uint64_t blkreplay_next_id(void)
 327 {
 328     if (replay_events_enabled()) {
 329         return replay_state.block_request_id++;
 330     }
 331     return 0;
 332 }