Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 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 | |
Peter Maydell | d38ea87 | 2016-01-29 17:50:05 +0000 | [diff] [blame] | 12 | #include "qemu/osdep.h" |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 13 | #include "qemu/error-report.h" |
| 14 | #include "sysemu/replay.h" |
| 15 | #include "replay-internal.h" |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 16 | #include "block/aio.h" |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 17 | #include "ui/input.h" |
Pavel Dovgalyuk | 46967b1 | 2021-04-01 11:19:51 +0300 | [diff] [blame] | 18 | #include "hw/core/cpu.h" |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 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); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 30 | static bool events_enabled; |
| 31 | |
| 32 | /* Functions */ |
| 33 | |
| 34 | static void replay_run_event(Event *event) |
| 35 | { |
| 36 | switch (event->event_kind) { |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 37 | case REPLAY_ASYNC_EVENT_BH: |
| 38 | aio_bh_call(event->opaque); |
| 39 | break; |
Pavel Dovgalyuk | e4ec5ad | 2019-09-17 14:58:19 +0300 | [diff] [blame] | 40 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
| 41 | ((QEMUBHFunc *)event->opaque)(event->opaque2); |
| 42 | break; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 43 | case REPLAY_ASYNC_EVENT_INPUT: |
| 44 | qemu_input_event_send_impl(NULL, (InputEvent *)event->opaque); |
| 45 | qapi_free_InputEvent((InputEvent *)event->opaque); |
| 46 | break; |
| 47 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: |
| 48 | qemu_input_event_sync_impl(); |
| 49 | break; |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 50 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
| 51 | replay_event_char_read_run(event->opaque); |
| 52 | break; |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 53 | case REPLAY_ASYNC_EVENT_BLOCK: |
| 54 | aio_bh_call(event->opaque); |
| 55 | break; |
Pavel Dovgalyuk | 646c547 | 2016-09-26 11:08:21 +0300 | [diff] [blame] | 56 | case REPLAY_ASYNC_EVENT_NET: |
| 57 | replay_event_net_run(event->opaque); |
| 58 | break; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 59 | default: |
| 60 | error_report("Replay: invalid async event ID (%d) in the queue", |
| 61 | event->event_kind); |
| 62 | exit(1); |
| 63 | break; |
| 64 | } |
| 65 | } |
| 66 | |
| 67 | void replay_enable_events(void) |
| 68 | { |
Pavel Dovgalyuk | 1652e0c | 2018-02-27 12:52:09 +0300 | [diff] [blame] | 69 | if (replay_mode != REPLAY_MODE_NONE) { |
| 70 | events_enabled = true; |
| 71 | } |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 72 | } |
| 73 | |
| 74 | bool replay_has_events(void) |
| 75 | { |
| 76 | return !QTAILQ_EMPTY(&events_list); |
| 77 | } |
| 78 | |
| 79 | void replay_flush_events(void) |
| 80 | { |
Pavel Dovgalyuk | f9a9fb6 | 2020-10-03 20:13:37 +0300 | [diff] [blame] | 81 | if (replay_mode == REPLAY_MODE_NONE) { |
| 82 | return; |
| 83 | } |
| 84 | |
Alex Bennée | d759c95 | 2018-02-27 12:52:48 +0300 | [diff] [blame] | 85 | g_assert(replay_mutex_locked()); |
| 86 | |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 87 | while (!QTAILQ_EMPTY(&events_list)) { |
| 88 | Event *event = QTAILQ_FIRST(&events_list); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 89 | replay_run_event(event); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 90 | QTAILQ_REMOVE(&events_list, event, events); |
| 91 | g_free(event); |
| 92 | } |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 93 | } |
| 94 | |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 95 | /*! Adds specified async event to the queue */ |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 96 | void replay_add_event(ReplayAsyncEventKind event_kind, |
| 97 | void *opaque, |
| 98 | void *opaque2, uint64_t id) |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 99 | { |
| 100 | assert(event_kind < REPLAY_ASYNC_COUNT); |
| 101 | |
| 102 | if (!replay_file || replay_mode == REPLAY_MODE_NONE |
| 103 | || !events_enabled) { |
| 104 | Event e; |
| 105 | e.event_kind = event_kind; |
| 106 | e.opaque = opaque; |
| 107 | e.opaque2 = opaque2; |
| 108 | e.id = id; |
| 109 | replay_run_event(&e); |
| 110 | return; |
| 111 | } |
| 112 | |
Markus Armbruster | b21e238 | 2022-03-15 15:41:56 +0100 | [diff] [blame] | 113 | Event *event = g_new0(Event, 1); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 114 | event->event_kind = event_kind; |
| 115 | event->opaque = opaque; |
| 116 | event->opaque2 = opaque2; |
| 117 | event->id = id; |
| 118 | |
Alex Bennée | d759c95 | 2018-02-27 12:52:48 +0300 | [diff] [blame] | 119 | g_assert(replay_mutex_locked()); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 120 | QTAILQ_INSERT_TAIL(&events_list, event, events); |
Pavel Dovgalyuk | 46967b1 | 2021-04-01 11:19:51 +0300 | [diff] [blame] | 121 | qemu_cpu_kick(first_cpu); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 122 | } |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 123 | |
| 124 | void replay_bh_schedule_event(QEMUBH *bh) |
| 125 | { |
Pavel Dovgalyuk | 1652e0c | 2018-02-27 12:52:09 +0300 | [diff] [blame] | 126 | if (events_enabled) { |
Pavel Dovgalyuk | 13f2671 | 2019-07-25 11:44:43 +0300 | [diff] [blame] | 127 | uint64_t id = replay_get_current_icount(); |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 128 | replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id); |
| 129 | } else { |
| 130 | qemu_bh_schedule(bh); |
| 131 | } |
| 132 | } |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 133 | |
Pavel Dovgalyuk | e4ec5ad | 2019-09-17 14:58:19 +0300 | [diff] [blame] | 134 | void replay_bh_schedule_oneshot_event(AioContext *ctx, |
| 135 | QEMUBHFunc *cb, void *opaque) |
| 136 | { |
| 137 | if (events_enabled) { |
| 138 | uint64_t id = replay_get_current_icount(); |
| 139 | replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id); |
| 140 | } else { |
| 141 | aio_bh_schedule_oneshot(ctx, cb, opaque); |
| 142 | } |
| 143 | } |
| 144 | |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 145 | void replay_add_input_event(struct InputEvent *event) |
| 146 | { |
| 147 | replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0); |
| 148 | } |
| 149 | |
| 150 | void replay_add_input_sync_event(void) |
| 151 | { |
| 152 | replay_add_event(REPLAY_ASYNC_EVENT_INPUT_SYNC, NULL, NULL, 0); |
| 153 | } |
| 154 | |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 155 | void replay_block_event(QEMUBH *bh, uint64_t id) |
| 156 | { |
Pavel Dovgalyuk | 1652e0c | 2018-02-27 12:52:09 +0300 | [diff] [blame] | 157 | if (events_enabled) { |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 158 | replay_add_event(REPLAY_ASYNC_EVENT_BLOCK, bh, NULL, id); |
| 159 | } else { |
| 160 | qemu_bh_schedule(bh); |
| 161 | } |
| 162 | } |
| 163 | |
Pavel Dovgalyuk | 60618e2 | 2022-05-27 13:46:18 +0300 | [diff] [blame] | 164 | static void replay_save_event(Event *event) |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 165 | { |
| 166 | if (replay_mode != REPLAY_MODE_PLAY) { |
| 167 | /* put the event into the file */ |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 168 | g_assert(event->event_kind < REPLAY_ASYNC_COUNT); |
| 169 | replay_put_event(EVENT_ASYNC + event->event_kind); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 170 | |
| 171 | /* save event-specific data */ |
| 172 | switch (event->event_kind) { |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 173 | case REPLAY_ASYNC_EVENT_BH: |
Pavel Dovgalyuk | e4ec5ad | 2019-09-17 14:58:19 +0300 | [diff] [blame] | 174 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 175 | replay_put_qword(event->id); |
| 176 | break; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 177 | case REPLAY_ASYNC_EVENT_INPUT: |
| 178 | replay_save_input_event(event->opaque); |
| 179 | break; |
| 180 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: |
| 181 | break; |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 182 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
| 183 | replay_event_char_read_save(event->opaque); |
| 184 | break; |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 185 | case REPLAY_ASYNC_EVENT_BLOCK: |
| 186 | replay_put_qword(event->id); |
| 187 | break; |
Pavel Dovgalyuk | 646c547 | 2016-09-26 11:08:21 +0300 | [diff] [blame] | 188 | case REPLAY_ASYNC_EVENT_NET: |
| 189 | replay_event_net_save(event->opaque); |
| 190 | break; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 191 | default: |
Pavel Dovgalyuk | 95b4aed | 2016-03-14 10:45:04 +0300 | [diff] [blame] | 192 | error_report("Unknown ID %" PRId64 " of replay event", event->id); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 193 | exit(1); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 194 | } |
| 195 | } |
| 196 | } |
| 197 | |
| 198 | /* Called with replay mutex locked */ |
Pavel Dovgalyuk | 60618e2 | 2022-05-27 13:46:18 +0300 | [diff] [blame] | 199 | void replay_save_events(void) |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 200 | { |
Alex Bennée | d759c95 | 2018-02-27 12:52:48 +0300 | [diff] [blame] | 201 | g_assert(replay_mutex_locked()); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 202 | while (!QTAILQ_EMPTY(&events_list)) { |
| 203 | Event *event = QTAILQ_FIRST(&events_list); |
Pavel Dovgalyuk | 60618e2 | 2022-05-27 13:46:18 +0300 | [diff] [blame] | 204 | replay_save_event(event); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 205 | replay_run_event(event); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 206 | QTAILQ_REMOVE(&events_list, event, events); |
| 207 | g_free(event); |
| 208 | } |
| 209 | } |
| 210 | |
Pavel Dovgalyuk | 60618e2 | 2022-05-27 13:46:18 +0300 | [diff] [blame] | 211 | static Event *replay_read_event(void) |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 212 | { |
| 213 | Event *event; |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 214 | ReplayAsyncEventKind event_kind = replay_state.data_kind - EVENT_ASYNC; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 215 | |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 216 | /* Events that has not to be in the queue */ |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 217 | switch (event_kind) { |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 218 | case REPLAY_ASYNC_EVENT_BH: |
Pavel Dovgalyuk | e4ec5ad | 2019-09-17 14:58:19 +0300 | [diff] [blame] | 219 | case REPLAY_ASYNC_EVENT_BH_ONESHOT: |
Pavel Dovgalyuk | 0b30dc0 | 2018-02-27 12:53:22 +0300 | [diff] [blame] | 220 | if (replay_state.read_event_id == -1) { |
| 221 | replay_state.read_event_id = replay_get_qword(); |
Pavel Dovgalyuk | 8a354bd | 2015-09-17 19:24:56 +0300 | [diff] [blame] | 222 | } |
| 223 | break; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 224 | case REPLAY_ASYNC_EVENT_INPUT: |
Markus Armbruster | b21e238 | 2022-03-15 15:41:56 +0100 | [diff] [blame] | 225 | event = g_new0(Event, 1); |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 226 | event->event_kind = event_kind; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 227 | event->opaque = replay_read_input_event(); |
| 228 | return event; |
| 229 | case REPLAY_ASYNC_EVENT_INPUT_SYNC: |
Markus Armbruster | b21e238 | 2022-03-15 15:41:56 +0100 | [diff] [blame] | 230 | event = g_new0(Event, 1); |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 231 | event->event_kind = event_kind; |
Pavel Dovgalyuk | ee31299 | 2015-09-17 19:25:24 +0300 | [diff] [blame] | 232 | event->opaque = 0; |
| 233 | return event; |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 234 | case REPLAY_ASYNC_EVENT_CHAR_READ: |
Markus Armbruster | b21e238 | 2022-03-15 15:41:56 +0100 | [diff] [blame] | 235 | event = g_new0(Event, 1); |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 236 | event->event_kind = event_kind; |
Pavel Dovgalyuk | 33577b4 | 2016-03-14 10:44:36 +0300 | [diff] [blame] | 237 | event->opaque = replay_event_char_read_load(); |
| 238 | return event; |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 239 | case REPLAY_ASYNC_EVENT_BLOCK: |
Pavel Dovgalyuk | 0b30dc0 | 2018-02-27 12:53:22 +0300 | [diff] [blame] | 240 | if (replay_state.read_event_id == -1) { |
| 241 | replay_state.read_event_id = replay_get_qword(); |
Pavel Dovgalyuk | 6378567 | 2016-03-14 10:45:10 +0300 | [diff] [blame] | 242 | } |
| 243 | break; |
Pavel Dovgalyuk | 646c547 | 2016-09-26 11:08:21 +0300 | [diff] [blame] | 244 | case REPLAY_ASYNC_EVENT_NET: |
Markus Armbruster | b21e238 | 2022-03-15 15:41:56 +0100 | [diff] [blame] | 245 | event = g_new0(Event, 1); |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 246 | event->event_kind = event_kind; |
Pavel Dovgalyuk | 646c547 | 2016-09-26 11:08:21 +0300 | [diff] [blame] | 247 | event->opaque = replay_event_net_load(); |
| 248 | return event; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 249 | default: |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 250 | error_report("Unknown ID %d of replay event", event_kind); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 251 | exit(1); |
| 252 | break; |
| 253 | } |
| 254 | |
| 255 | QTAILQ_FOREACH(event, &events_list, events) { |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 256 | if (event->event_kind == event_kind |
Pavel Dovgalyuk | 0b30dc0 | 2018-02-27 12:53:22 +0300 | [diff] [blame] | 257 | && (replay_state.read_event_id == -1 |
| 258 | || replay_state.read_event_id == event->id)) { |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 259 | break; |
| 260 | } |
| 261 | } |
| 262 | |
| 263 | if (event) { |
| 264 | QTAILQ_REMOVE(&events_list, event, events); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 265 | } |
| 266 | |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 267 | return event; |
| 268 | } |
| 269 | |
| 270 | /* Called with replay mutex locked */ |
Pavel Dovgalyuk | 60618e2 | 2022-05-27 13:46:18 +0300 | [diff] [blame] | 271 | void replay_read_events(void) |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 272 | { |
Alex Bennée | d759c95 | 2018-02-27 12:52:48 +0300 | [diff] [blame] | 273 | g_assert(replay_mutex_locked()); |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 274 | while (replay_state.data_kind >= EVENT_ASYNC |
| 275 | && replay_state.data_kind <= EVENT_ASYNC_LAST) { |
Pavel Dovgalyuk | 60618e2 | 2022-05-27 13:46:18 +0300 | [diff] [blame] | 276 | Event *event = replay_read_event(); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 277 | if (!event) { |
| 278 | break; |
| 279 | } |
Pavel Dovgalyuk | 1a96e3c | 2018-02-27 12:52:03 +0300 | [diff] [blame] | 280 | replay_finish_event(); |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 281 | replay_state.read_event_id = -1; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 282 | replay_run_event(event); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 283 | |
| 284 | g_free(event); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 285 | } |
| 286 | } |
| 287 | |
| 288 | void replay_init_events(void) |
| 289 | { |
Pavel Dovgalyuk | 3e21408 | 2022-05-27 13:46:23 +0300 | [diff] [blame] | 290 | replay_state.read_event_id = -1; |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | void replay_finish_events(void) |
| 294 | { |
| 295 | events_enabled = false; |
Pavel Dovgalyuk | d873fe0 | 2018-09-12 11:18:59 +0300 | [diff] [blame] | 296 | replay_flush_events(); |
Pavel Dovgalyuk | c0c071d | 2015-09-17 19:24:22 +0300 | [diff] [blame] | 297 | } |
| 298 | |
| 299 | bool replay_events_enabled(void) |
| 300 | { |
| 301 | return events_enabled; |
| 302 | } |
Pavel Dovgalyuk | 6d0ceb8 | 2016-09-26 11:08:16 +0300 | [diff] [blame] | 303 | |
| 304 | uint64_t blkreplay_next_id(void) |
| 305 | { |
| 306 | if (replay_events_enabled()) { |
| 307 | return replay_state.block_request_id++; |
| 308 | } |
| 309 | return 0; |
| 310 | } |