block/blkreplay.c

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