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