block/null.c

   1 /*
   2  * Null block driver
   3  *
   4  * Authors:
   5  *  Fam Zheng <famz@redhat.com>
   6  *
   7  * Copyright (C) 2014 Red Hat, Inc.
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qapi/error.h"
  15 #include "block/block_int.h"
  16
  17 #define NULL_OPT_LATENCY "latency-ns"
  18 #define NULL_OPT_ZEROES  "read-zeroes"
  19
  20 typedef struct {
  21     int64_t length;
  22     int64_t latency_ns;
  23     bool read_zeroes;
  24 } BDRVNullState;
  25
  26 static QemuOptsList runtime_opts = {
  27     .name = "null",
  28     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
  29     .desc = {
  30         {
  31             .name = "filename",
  32             .type = QEMU_OPT_STRING,
  33             .help = "",
  34         },
  35         {
  36             .name = BLOCK_OPT_SIZE,
  37             .type = QEMU_OPT_SIZE,
  38             .help = "size of the null block",
  39         },
  40         {
  41             .name = NULL_OPT_LATENCY,
  42             .type = QEMU_OPT_NUMBER,
  43             .help = "nanoseconds (approximated) to wait "
  44                     "before completing request",
  45         },
  46         {
  47             .name = NULL_OPT_ZEROES,
  48             .type = QEMU_OPT_BOOL,
  49             .help = "return zeroes when read",
  50         },
  51         { /* end of list */ }
  52     },
  53 };
  54
  55 static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
  56                           Error **errp)
  57 {
  58     QemuOpts *opts;
  59     BDRVNullState *s = bs->opaque;
  60     int ret = 0;
  61
  62     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
  63     qemu_opts_absorb_qdict(opts, options, &error_abort);
  64     s->length =
  65         qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
  66     s->latency_ns =
  67         qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0);
  68     if (s->latency_ns < 0) {
  69         error_setg(errp, "latency-ns is invalid");
  70         ret = -EINVAL;
  71     }
  72     s->read_zeroes = qemu_opt_get_bool(opts, NULL_OPT_ZEROES, false);
  73     qemu_opts_del(opts);
  74     return ret;
  75 }
  76
  77 static void null_close(BlockDriverState *bs)
  78 {
  79 }
  80
  81 static int64_t null_getlength(BlockDriverState *bs)
  82 {
  83     BDRVNullState *s = bs->opaque;
  84     return s->length;
  85 }
  86
  87 static coroutine_fn int null_co_common(BlockDriverState *bs)
  88 {
  89     BDRVNullState *s = bs->opaque;
  90
  91     if (s->latency_ns) {
  92         co_aio_sleep_ns(bdrv_get_aio_context(bs), QEMU_CLOCK_REALTIME,
  93                         s->latency_ns);
  94     }
  95     return 0;
  96 }
  97
  98 static coroutine_fn int null_co_readv(BlockDriverState *bs,
  99                                       int64_t sector_num, int nb_sectors,
 100                                       QEMUIOVector *qiov)
 101 {
 102     BDRVNullState *s = bs->opaque;
 103
 104     if (s->read_zeroes) {
 105         qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
 106     }
 107
 108     return null_co_common(bs);
 109 }
 110
 111 static coroutine_fn int null_co_writev(BlockDriverState *bs,
 112                                        int64_t sector_num, int nb_sectors,
 113                                        QEMUIOVector *qiov)
 114 {
 115     return null_co_common(bs);
 116 }
 117
 118 static coroutine_fn int null_co_flush(BlockDriverState *bs)
 119 {
 120     return null_co_common(bs);
 121 }
 122
 123 typedef struct {
 124     BlockAIOCB common;
 125     QEMUBH *bh;
 126     QEMUTimer timer;
 127 } NullAIOCB;
 128
 129 static const AIOCBInfo null_aiocb_info = {
 130     .aiocb_size = sizeof(NullAIOCB),
 131 };
 132
 133 static void null_bh_cb(void *opaque)
 134 {
 135     NullAIOCB *acb = opaque;
 136     acb->common.cb(acb->common.opaque, 0);
 137     qemu_bh_delete(acb->bh);
 138     qemu_aio_unref(acb);
 139 }
 140
 141 static void null_timer_cb(void *opaque)
 142 {
 143     NullAIOCB *acb = opaque;
 144     acb->common.cb(acb->common.opaque, 0);
 145     timer_deinit(&acb->timer);
 146     qemu_aio_unref(acb);
 147 }
 148
 149 static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
 150                                           BlockCompletionFunc *cb,
 151                                           void *opaque)
 152 {
 153     NullAIOCB *acb;
 154     BDRVNullState *s = bs->opaque;
 155
 156     acb = qemu_aio_get(&null_aiocb_info, bs, cb, opaque);
 157     /* Only emulate latency after vcpu is running. */
 158     if (s->latency_ns) {
 159         aio_timer_init(bdrv_get_aio_context(bs), &acb->timer,
 160                        QEMU_CLOCK_REALTIME, SCALE_NS,
 161                        null_timer_cb, acb);
 162         timer_mod_ns(&acb->timer,
 163                      qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + s->latency_ns);
 164     } else {
 165         acb->bh = aio_bh_new(bdrv_get_aio_context(bs), null_bh_cb, acb);
 166         qemu_bh_schedule(acb->bh);
 167     }
 168     return &acb->common;
 169 }
 170
 171 static BlockAIOCB *null_aio_readv(BlockDriverState *bs,
 172                                   int64_t sector_num, QEMUIOVector *qiov,
 173                                   int nb_sectors,
 174                                   BlockCompletionFunc *cb,
 175                                   void *opaque)
 176 {
 177     BDRVNullState *s = bs->opaque;
 178
 179     if (s->read_zeroes) {
 180         qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
 181     }
 182
 183     return null_aio_common(bs, cb, opaque);
 184 }
 185
 186 static BlockAIOCB *null_aio_writev(BlockDriverState *bs,
 187                                    int64_t sector_num, QEMUIOVector *qiov,
 188                                    int nb_sectors,
 189                                    BlockCompletionFunc *cb,
 190                                    void *opaque)
 191 {
 192     return null_aio_common(bs, cb, opaque);
 193 }
 194
 195 static BlockAIOCB *null_aio_flush(BlockDriverState *bs,
 196                                   BlockCompletionFunc *cb,
 197                                   void *opaque)
 198 {
 199     return null_aio_common(bs, cb, opaque);
 200 }
 201
 202 static int null_reopen_prepare(BDRVReopenState *reopen_state,
 203                                BlockReopenQueue *queue, Error **errp)
 204 {
 205     return 0;
 206 }
 207
 208 static int64_t coroutine_fn null_co_get_block_status(BlockDriverState *bs,
 209                                                      int64_t sector_num,
 210                                                      int nb_sectors, int *pnum,
 211                                                      BlockDriverState **file)
 212 {
 213     BDRVNullState *s = bs->opaque;
 214     off_t start = sector_num * BDRV_SECTOR_SIZE;
 215
 216     *pnum = nb_sectors;
 217     *file = bs;
 218
 219     if (s->read_zeroes) {
 220         return BDRV_BLOCK_OFFSET_VALID | start | BDRV_BLOCK_ZERO;
 221     } else {
 222         return BDRV_BLOCK_OFFSET_VALID | start;
 223     }
 224 }
 225
 226 static BlockDriver bdrv_null_co = {
 227     .format_name            = "null-co",
 228     .protocol_name          = "null-co",
 229     .instance_size          = sizeof(BDRVNullState),
 230
 231     .bdrv_file_open         = null_file_open,
 232     .bdrv_close             = null_close,
 233     .bdrv_getlength         = null_getlength,
 234
 235     .bdrv_co_readv          = null_co_readv,
 236     .bdrv_co_writev         = null_co_writev,
 237     .bdrv_co_flush_to_disk  = null_co_flush,
 238     .bdrv_reopen_prepare    = null_reopen_prepare,
 239
 240     .bdrv_co_get_block_status   = null_co_get_block_status,
 241 };
 242
 243 static BlockDriver bdrv_null_aio = {
 244     .format_name            = "null-aio",
 245     .protocol_name          = "null-aio",
 246     .instance_size          = sizeof(BDRVNullState),
 247
 248     .bdrv_file_open         = null_file_open,
 249     .bdrv_close             = null_close,
 250     .bdrv_getlength         = null_getlength,
 251
 252     .bdrv_aio_readv         = null_aio_readv,
 253     .bdrv_aio_writev        = null_aio_writev,
 254     .bdrv_aio_flush         = null_aio_flush,
 255     .bdrv_reopen_prepare    = null_reopen_prepare,
 256
 257     .bdrv_co_get_block_status   = null_co_get_block_status,
 258 };
 259
 260 static void bdrv_null_init(void)
 261 {
 262     bdrv_register(&bdrv_null_co);
 263     bdrv_register(&bdrv_null_aio);
 264 }
 265
 266 block_init(bdrv_null_init);