replay/replay-char.c

   1 /*
   2  * replay-char.c
   3  *
   4  * Copyright (c) 2010-2016 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 "chardev/char.h"
  17
  18 /* Char drivers that generate qemu_chr_be_write events
  19    that should be saved into the log. */
  20 static Chardev **char_drivers;
  21 static int drivers_count;
  22
  23 /* Char event attributes. */
  24 typedef struct CharEvent {
  25     int id;
  26     uint8_t *buf;
  27     size_t len;
  28 } CharEvent;
  29
  30 static int find_char_driver(Chardev *chr)
  31 {
  32     int i = 0;
  33     for ( ; i < drivers_count ; ++i) {
  34         if (char_drivers[i] == chr) {
  35             return i;
  36         }
  37     }
  38     return -1;
  39 }
  40
  41 void replay_register_char_driver(Chardev *chr)
  42 {
  43     if (replay_mode == REPLAY_MODE_NONE) {
  44         return;
  45     }
  46     char_drivers = g_realloc(char_drivers,
  47                              sizeof(*char_drivers) * (drivers_count + 1));
  48     char_drivers[drivers_count++] = chr;
  49 }
  50
  51 void replay_chr_be_write(Chardev *s, const uint8_t *buf, int len)
  52 {
  53     CharEvent *event = g_new0(CharEvent, 1);
  54
  55     event->id = find_char_driver(s);
  56     if (event->id < 0) {
  57         fprintf(stderr, "Replay: cannot find char driver\n");
  58         exit(1);
  59     }
  60     event->buf = g_malloc(len);
  61     memcpy(event->buf, buf, len);
  62     event->len = len;
  63
  64     replay_add_event(REPLAY_ASYNC_EVENT_CHAR_READ, event, NULL, 0);
  65 }
  66
  67 void replay_event_char_read_run(void *opaque)
  68 {
  69     CharEvent *event = (CharEvent *)opaque;
  70
  71     qemu_chr_be_write_impl(char_drivers[event->id], event->buf,
  72                            (int)event->len);
  73
  74     g_free(event->buf);
  75     g_free(event);
  76 }
  77
  78 void replay_event_char_read_save(void *opaque)
  79 {
  80     CharEvent *event = (CharEvent *)opaque;
  81
  82     replay_put_byte(event->id);
  83     replay_put_array(event->buf, event->len);
  84 }
  85
  86 void *replay_event_char_read_load(void)
  87 {
  88     CharEvent *event = g_new0(CharEvent, 1);
  89
  90     event->id = replay_get_byte();
  91     replay_get_array_alloc(&event->buf, &event->len);
  92
  93     return event;
  94 }
  95
  96 void replay_char_write_event_save(int res, int offset)
  97 {
  98     g_assert(replay_mutex_locked());
  99
 100     replay_save_instructions();
 101     replay_put_event(EVENT_CHAR_WRITE);
 102     replay_put_dword(res);
 103     replay_put_dword(offset);
 104 }
 105
 106 void replay_char_write_event_load(int *res, int *offset)
 107 {
 108     g_assert(replay_mutex_locked());
 109
 110     replay_account_executed_instructions();
 111     if (replay_next_event_is(EVENT_CHAR_WRITE)) {
 112         *res = replay_get_dword();
 113         *offset = replay_get_dword();
 114         replay_finish_event();
 115     } else {
 116         replay_sync_error("Missing character write event in the replay log");
 117     }
 118 }
 119
 120 int replay_char_read_all_load(uint8_t *buf)
 121 {
 122     g_assert(replay_mutex_locked());
 123
 124     if (replay_next_event_is(EVENT_CHAR_READ_ALL)) {
 125         size_t size;
 126         int res;
 127         replay_get_array(buf, &size);
 128         replay_finish_event();
 129         res = (int)size;
 130         assert(res >= 0);
 131         return res;
 132     } else if (replay_next_event_is(EVENT_CHAR_READ_ALL_ERROR)) {
 133         int res = replay_get_dword();
 134         replay_finish_event();
 135         return res;
 136     } else {
 137         replay_sync_error("Missing character read all event in the replay log");
 138     }
 139 }
 140
 141 void replay_char_read_all_save_error(int res)
 142 {
 143     g_assert(replay_mutex_locked());
 144     assert(res < 0);
 145     replay_save_instructions();
 146     replay_put_event(EVENT_CHAR_READ_ALL_ERROR);
 147     replay_put_dword(res);
 148 }
 149
 150 void replay_char_read_all_save_buf(uint8_t *buf, int offset)
 151 {
 152     g_assert(replay_mutex_locked());
 153     replay_save_instructions();
 154     replay_put_event(EVENT_CHAR_READ_ALL);
 155     replay_put_array(buf, offset);
 156 }