xref: /openbmc/qemu/block/blkreplay.c (revision 1f051dcb)
1 /*
2  * Block protocol for record/replay
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/module.h"
14 #include "block/block-io.h"
15 #include "block/block_int.h"
16 #include "sysemu/replay.h"
17 #include "qapi/error.h"
18 
19 typedef struct Request {
20     Coroutine *co;
21     QEMUBH *bh;
22 } Request;
23 
blkreplay_open(BlockDriverState * bs,QDict * options,int flags,Error ** errp)24 static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
25                           Error **errp)
26 {
27     int ret;
28 
29     /* Open the image file */
30     ret = bdrv_open_file_child(NULL, options, "image", bs, errp);
31     if (ret < 0) {
32         goto fail;
33     }
34 
35     bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED;
36     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED;
37 
38     ret = 0;
39 fail:
40     return ret;
41 }
42 
43 static int64_t coroutine_fn GRAPH_RDLOCK
blkreplay_co_getlength(BlockDriverState * bs)44 blkreplay_co_getlength(BlockDriverState *bs)
45 {
46     return bdrv_co_getlength(bs->file->bs);
47 }
48 
49 /* This bh is used for synchronization of return from coroutines.
50    It continues yielded coroutine which then finishes its execution.
51    BH is called adjusted to some replay checkpoint, therefore
52    record and replay will always finish coroutines deterministically.
53 */
blkreplay_bh_cb(void * opaque)54 static void blkreplay_bh_cb(void *opaque)
55 {
56     Request *req = opaque;
57     aio_co_wake(req->co);
58     qemu_bh_delete(req->bh);
59     g_free(req);
60 }
61 
block_request_create(uint64_t reqid,BlockDriverState * bs,Coroutine * co)62 static void block_request_create(uint64_t reqid, BlockDriverState *bs,
63                                  Coroutine *co)
64 {
65     Request *req = g_new(Request, 1);
66     *req = (Request) {
67         .co = co,
68         .bh = aio_bh_new(bdrv_get_aio_context(bs), blkreplay_bh_cb, req),
69     };
70     replay_block_event(req->bh, reqid);
71 }
72 
73 static int coroutine_fn GRAPH_RDLOCK
blkreplay_co_preadv(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)74 blkreplay_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
75                     QEMUIOVector *qiov, BdrvRequestFlags flags)
76 {
77     uint64_t reqid = blkreplay_next_id();
78     int ret = bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
79     block_request_create(reqid, bs, qemu_coroutine_self());
80     qemu_coroutine_yield();
81 
82     return ret;
83 }
84 
85 static int coroutine_fn GRAPH_RDLOCK
blkreplay_co_pwritev(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)86 blkreplay_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
87                      QEMUIOVector *qiov, BdrvRequestFlags flags)
88 {
89     uint64_t reqid = blkreplay_next_id();
90     int ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
91     block_request_create(reqid, bs, qemu_coroutine_self());
92     qemu_coroutine_yield();
93 
94     return ret;
95 }
96 
97 static int coroutine_fn GRAPH_RDLOCK
blkreplay_co_pwrite_zeroes(BlockDriverState * bs,int64_t offset,int64_t bytes,BdrvRequestFlags flags)98 blkreplay_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
99                            BdrvRequestFlags flags)
100 {
101     uint64_t reqid = blkreplay_next_id();
102     int ret = bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
103     block_request_create(reqid, bs, qemu_coroutine_self());
104     qemu_coroutine_yield();
105 
106     return ret;
107 }
108 
109 static int coroutine_fn GRAPH_RDLOCK
blkreplay_co_pdiscard(BlockDriverState * bs,int64_t offset,int64_t bytes)110 blkreplay_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
111 {
112     uint64_t reqid = blkreplay_next_id();
113     int ret = bdrv_co_pdiscard(bs->file, offset, bytes);
114     block_request_create(reqid, bs, qemu_coroutine_self());
115     qemu_coroutine_yield();
116 
117     return ret;
118 }
119 
blkreplay_co_flush(BlockDriverState * bs)120 static int coroutine_fn GRAPH_RDLOCK blkreplay_co_flush(BlockDriverState *bs)
121 {
122     uint64_t reqid = blkreplay_next_id();
123     int ret = bdrv_co_flush(bs->file->bs);
124     block_request_create(reqid, bs, qemu_coroutine_self());
125     qemu_coroutine_yield();
126 
127     return ret;
128 }
129 
blkreplay_snapshot_goto(BlockDriverState * bs,const char * snapshot_id)130 static int blkreplay_snapshot_goto(BlockDriverState *bs,
131                                    const char *snapshot_id)
132 {
133     BlockDriverState *file_bs;
134 
135     bdrv_graph_rdlock_main_loop();
136     file_bs = bs->file->bs;
137     bdrv_graph_rdunlock_main_loop();
138 
139     return bdrv_snapshot_goto(file_bs, snapshot_id, NULL);
140 }
141 
142 static BlockDriver bdrv_blkreplay = {
143     .format_name            = "blkreplay",
144     .instance_size          = 0,
145     .is_filter              = true,
146 
147     .bdrv_open              = blkreplay_open,
148     .bdrv_child_perm        = bdrv_default_perms,
149     .bdrv_co_getlength      = blkreplay_co_getlength,
150 
151     .bdrv_co_preadv         = blkreplay_co_preadv,
152     .bdrv_co_pwritev        = blkreplay_co_pwritev,
153 
154     .bdrv_co_pwrite_zeroes  = blkreplay_co_pwrite_zeroes,
155     .bdrv_co_pdiscard       = blkreplay_co_pdiscard,
156     .bdrv_co_flush          = blkreplay_co_flush,
157 
158     .bdrv_snapshot_goto     = blkreplay_snapshot_goto,
159 };
160 
bdrv_blkreplay_init(void)161 static void bdrv_blkreplay_init(void)
162 {
163     bdrv_register(&bdrv_blkreplay);
164 }
165 
166 block_init(bdrv_blkreplay_init);
167