virtio-pci: address space translation service (ATS) support
[qemu.git] / 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. */
21 static CharDriverState **char_drivers;
22 static int drivers_count;
23
24 /* Char event attributes. */
25 typedef struct CharEvent {
26 int id;
27 uint8_t *buf;
28 size_t len;
29 } CharEvent;
30
31 static 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
42 void 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
52 void 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
68 void 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
79 void 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
87 void *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
97 void 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
107 void 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
123 int 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
147 void 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
157 void 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 }