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