LXR qemu/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. */
  20static Chardev **char_drivers;
  21static int drivers_count;
  22
  23/* Char event attributes. */
  24typedef struct CharEvent {
  25    int id;
  26    uint8_t *buf;
  27    size_t len;
  28} CharEvent;
  29
  30static 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
  41void 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
  51void replay_chr_be_write(Chardev *s, uint8_t *buf, int len)
  52{
  53    CharEvent *event = g_malloc0(sizeof(CharEvent));
  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
  67void 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
  78void 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
  86void *replay_event_char_read_load(void)
  87{
  88    CharEvent *event = g_malloc0(sizeof(CharEvent));
  89
  90    event->id = replay_get_byte();
  91    replay_get_array_alloc(&event->buf, &event->len);
  92
  93    return event;
  94}
  95
  96void 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
 106void 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        error_report("Missing character write event in the replay log");
 117        exit(1);
 118    }
 119}
 120
 121int replay_char_read_all_load(uint8_t *buf)
 122{
 123    g_assert(replay_mutex_locked());
 124
 125    if (replay_next_event_is(EVENT_CHAR_READ_ALL)) {
 126        size_t size;
 127        int res;
 128        replay_get_array(buf, &size);
 129        replay_finish_event();
 130        res = (int)size;
 131        assert(res >= 0);
 132        return res;
 133    } else if (replay_next_event_is(EVENT_CHAR_READ_ALL_ERROR)) {
 134        int res = replay_get_dword();
 135        replay_finish_event();
 136        return res;
 137    } else {
 138        error_report("Missing character read all event in the replay log");
 139        exit(1);
 140    }
 141}
 142
 143void replay_char_read_all_save_error(int res)
 144{
 145    g_assert(replay_mutex_locked());
 146    assert(res < 0);
 147    replay_save_instructions();
 148    replay_put_event(EVENT_CHAR_READ_ALL_ERROR);
 149    replay_put_dword(res);
 150}
 151
 152void replay_char_read_all_save_buf(uint8_t *buf, int offset)
 153{
 154    g_assert(replay_mutex_locked());
 155    replay_save_instructions();
 156    replay_put_event(EVENT_CHAR_READ_ALL);
 157    replay_put_array(buf, offset);
 158}
 159