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 "qapi/qmp/qdict.h"
  16 #include "qapi/qmp/qstring.h"
  17 #include "qemu/module.h"
  18 #include "qemu/option.h"
  19 #include "block/block_int.h"
  20 #include "sysemu/replay.h"
  21
  22 #define NULL_OPT_LATENCY "latency-ns"
  23 #define NULL_OPT_ZEROES  "read-zeroes"
  24
  25 typedef struct {
  26     int64_t length;
  27     int64_t latency_ns;
  28     bool read_zeroes;
  29 } BDRVNullState;
  30
  31 static QemuOptsList runtime_opts = {
  32     .name = "null",
  33     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
  34     .desc = {
  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 void null_co_parse_filename(const char *filename, QDict *options,
  56                                    Error **errp)
  57 {
  58     /* This functions only exists so that a null-co:// filename is accepted
  59      * with the null-co driver. */
  60     if (strcmp(filename, "null-co://")) {
  61         error_setg(errp, "The only allowed filename for this driver is "
  62                          "'null-co://'");
  63         return;
  64     }
  65 }
  66
  67 static void null_aio_parse_filename(const char *filename, QDict *options,
  68                                     Error **errp)
  69 {
  70     /* This functions only exists so that a null-aio:// filename is accepted
  71      * with the null-aio driver. */
  72     if (strcmp(filename, "null-aio://")) {
  73         error_setg(errp, "The only allowed filename for this driver is "
  74                          "'null-aio://'");
  75         return;
  76     }
  77 }
  78
  79 static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
  80                           Error **errp)
  81 {
  82     QemuOpts *opts;
  83     BDRVNullState *s = bs->opaque;
  84     int ret = 0;
  85
  86     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
  87     qemu_opts_absorb_qdict(opts, options, &error_abort);
  88     s->length =
  89         qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
  90     s->latency_ns =
  91         qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0);
  92     if (s->latency_ns < 0) {
  93         error_setg(errp, "latency-ns is invalid");
  94         ret = -EINVAL;
  95     }
  96     s->read_zeroes = qemu_opt_get_bool(opts, NULL_OPT_ZEROES, false);
  97     qemu_opts_del(opts);
  98     bs->supported_write_flags = BDRV_REQ_FUA;
  99     return ret;
 100 }
 101
 102 static int64_t null_getlength(BlockDriverState *bs)
 103 {
 104     BDRVNullState *s = bs->opaque;
 105     return s->length;
 106 }
 107
 108 static coroutine_fn int null_co_common(BlockDriverState *bs)
 109 {
 110     BDRVNullState *s = bs->opaque;
 111
 112     if (s->latency_ns) {
 113         qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, s->latency_ns);
 114     }
 115     return 0;
 116 }
 117
 118 static coroutine_fn int null_co_preadv(BlockDriverState *bs,
 119                                        int64_t offset, int64_t bytes,
 120                                        QEMUIOVector *qiov,
 121                                        BdrvRequestFlags flags)
 122 {
 123     BDRVNullState *s = bs->opaque;
 124
 125     if (s->read_zeroes) {
 126         qemu_iovec_memset(qiov, 0, 0, bytes);
 127     }
 128
 129     return null_co_common(bs);
 130 }
 131
 132 static coroutine_fn int null_co_pwritev(BlockDriverState *bs,
 133                                         int64_t offset, int64_t bytes,
 134                                         QEMUIOVector *qiov,
 135                                         BdrvRequestFlags flags)
 136 {
 137     return null_co_common(bs);
 138 }
 139
 140 static coroutine_fn int null_co_flush(BlockDriverState *bs)
 141 {
 142     return null_co_common(bs);
 143 }
 144
 145 typedef struct {
 146     BlockAIOCB common;
 147     QEMUTimer timer;
 148 } NullAIOCB;
 149
 150 static const AIOCBInfo null_aiocb_info = {
 151     .aiocb_size = sizeof(NullAIOCB),
 152 };
 153
 154 static void null_bh_cb(void *opaque)
 155 {
 156     NullAIOCB *acb = opaque;
 157     acb->common.cb(acb->common.opaque, 0);
 158     qemu_aio_unref(acb);
 159 }
 160
 161 static void null_timer_cb(void *opaque)
 162 {
 163     NullAIOCB *acb = opaque;
 164     acb->common.cb(acb->common.opaque, 0);
 165     timer_deinit(&acb->timer);
 166     qemu_aio_unref(acb);
 167 }
 168
 169 static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
 170                                           BlockCompletionFunc *cb,
 171                                           void *opaque)
 172 {
 173     NullAIOCB *acb;
 174     BDRVNullState *s = bs->opaque;
 175
 176     acb = qemu_aio_get(&null_aiocb_info, bs, cb, opaque);
 177     /* Only emulate latency after vcpu is running. */
 178     if (s->latency_ns) {
 179         aio_timer_init(bdrv_get_aio_context(bs), &acb->timer,
 180                        QEMU_CLOCK_REALTIME, SCALE_NS,
 181                        null_timer_cb, acb);
 182         timer_mod_ns(&acb->timer,
 183                      qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + s->latency_ns);
 184     } else {
 185         replay_bh_schedule_oneshot_event(bdrv_get_aio_context(bs),
 186                                          null_bh_cb, acb);
 187     }
 188     return &acb->common;
 189 }
 190
 191 static BlockAIOCB *null_aio_preadv(BlockDriverState *bs,
 192                                    int64_t offset, int64_t bytes,
 193                                    QEMUIOVector *qiov, BdrvRequestFlags flags,
 194                                    BlockCompletionFunc *cb,
 195                                    void *opaque)
 196 {
 197     BDRVNullState *s = bs->opaque;
 198
 199     if (s->read_zeroes) {
 200         qemu_iovec_memset(qiov, 0, 0, bytes);
 201     }
 202
 203     return null_aio_common(bs, cb, opaque);
 204 }
 205
 206 static BlockAIOCB *null_aio_pwritev(BlockDriverState *bs,
 207                                     int64_t offset, int64_t bytes,
 208                                     QEMUIOVector *qiov, BdrvRequestFlags flags,
 209                                     BlockCompletionFunc *cb,
 210                                     void *opaque)
 211 {
 212     return null_aio_common(bs, cb, opaque);
 213 }
 214
 215 static BlockAIOCB *null_aio_flush(BlockDriverState *bs,
 216                                   BlockCompletionFunc *cb,
 217                                   void *opaque)
 218 {
 219     return null_aio_common(bs, cb, opaque);
 220 }
 221
 222 static int null_reopen_prepare(BDRVReopenState *reopen_state,
 223                                BlockReopenQueue *queue, Error **errp)
 224 {
 225     return 0;
 226 }
 227
 228 static int coroutine_fn null_co_block_status(BlockDriverState *bs,
 229                                              bool want_zero, int64_t offset,
 230                                              int64_t bytes, int64_t *pnum,
 231                                              int64_t *map,
 232                                              BlockDriverState **file)
 233 {
 234     BDRVNullState *s = bs->opaque;
 235     int ret = BDRV_BLOCK_OFFSET_VALID;
 236
 237     *pnum = bytes;
 238     *map = offset;
 239     *file = bs;
 240
 241     if (s->read_zeroes) {
 242         ret |= BDRV_BLOCK_ZERO;
 243     }
 244     return ret;
 245 }
 246
 247 static void null_refresh_filename(BlockDriverState *bs)
 248 {
 249     const QDictEntry *e;
 250
 251     for (e = qdict_first(bs->full_open_options); e;
 252          e = qdict_next(bs->full_open_options, e))
 253     {
 254         /* These options can be ignored */
 255         if (strcmp(qdict_entry_key(e), "filename") &&
 256             strcmp(qdict_entry_key(e), "driver") &&
 257             strcmp(qdict_entry_key(e), NULL_OPT_LATENCY))
 258         {
 259             return;
 260         }
 261     }
 262
 263     snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://",
 264              bs->drv->format_name);
 265 }
 266
 267 static int64_t null_allocated_file_size(BlockDriverState *bs)
 268 {
 269     return 0;
 270 }
 271
 272 static const char *const null_strong_runtime_opts[] = {
 273     BLOCK_OPT_SIZE,
 274     NULL_OPT_ZEROES,
 275
 276     NULL
 277 };
 278
 279 static BlockDriver bdrv_null_co = {
 280     .format_name            = "null-co",
 281     .protocol_name          = "null-co",
 282     .instance_size          = sizeof(BDRVNullState),
 283
 284     .bdrv_file_open         = null_file_open,
 285     .bdrv_parse_filename    = null_co_parse_filename,
 286     .bdrv_getlength         = null_getlength,
 287     .bdrv_get_allocated_file_size = null_allocated_file_size,
 288
 289     .bdrv_co_preadv         = null_co_preadv,
 290     .bdrv_co_pwritev        = null_co_pwritev,
 291     .bdrv_co_flush_to_disk  = null_co_flush,
 292     .bdrv_reopen_prepare    = null_reopen_prepare,
 293
 294     .bdrv_co_block_status   = null_co_block_status,
 295
 296     .bdrv_refresh_filename  = null_refresh_filename,
 297     .strong_runtime_opts    = null_strong_runtime_opts,
 298 };
 299
 300 static BlockDriver bdrv_null_aio = {
 301     .format_name            = "null-aio",
 302     .protocol_name          = "null-aio",
 303     .instance_size          = sizeof(BDRVNullState),
 304
 305     .bdrv_file_open         = null_file_open,
 306     .bdrv_parse_filename    = null_aio_parse_filename,
 307     .bdrv_getlength         = null_getlength,
 308     .bdrv_get_allocated_file_size = null_allocated_file_size,
 309
 310     .bdrv_aio_preadv        = null_aio_preadv,
 311     .bdrv_aio_pwritev       = null_aio_pwritev,
 312     .bdrv_aio_flush         = null_aio_flush,
 313     .bdrv_reopen_prepare    = null_reopen_prepare,
 314
 315     .bdrv_co_block_status   = null_co_block_status,
 316
 317     .bdrv_refresh_filename  = null_refresh_filename,
 318     .strong_runtime_opts    = null_strong_runtime_opts,
 319 };
 320
 321 static void bdrv_null_init(void)
 322 {
 323     bdrv_register(&bdrv_null_co);
 324     bdrv_register(&bdrv_null_aio);
 325 }
 326
 327 block_init(bdrv_null_init);