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