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