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 "block/block_int.h"
  14
  15 typedef struct {
  16     int64_t length;
  17 } BDRVNullState;
  18
  19 static QemuOptsList runtime_opts = {
  20     .name = "null",
  21     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
  22     .desc = {
  23         {
  24             .name = "filename",
  25             .type = QEMU_OPT_STRING,
  26             .help = "",
  27         },
  28         {
  29             .name = BLOCK_OPT_SIZE,
  30             .type = QEMU_OPT_SIZE,
  31             .help = "size of the null block",
  32         },
  33         { /* end of list */ }
  34     },
  35 };
  36
  37 static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
  38                           Error **errp)
  39 {
  40     QemuOpts *opts;
  41     BDRVNullState *s = bs->opaque;
  42
  43     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
  44     qemu_opts_absorb_qdict(opts, options, &error_abort);
  45     s->length =
  46         qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
  47     qemu_opts_del(opts);
  48     return 0;
  49 }
  50
  51 static void null_close(BlockDriverState *bs)
  52 {
  53 }
  54
  55 static int64_t null_getlength(BlockDriverState *bs)
  56 {
  57     BDRVNullState *s = bs->opaque;
  58     return s->length;
  59 }
  60
  61 static coroutine_fn int null_co_readv(BlockDriverState *bs,
  62                                       int64_t sector_num, int nb_sectors,
  63                                       QEMUIOVector *qiov)
  64 {
  65     return 0;
  66 }
  67
  68 static coroutine_fn int null_co_writev(BlockDriverState *bs,
  69                                        int64_t sector_num, int nb_sectors,
  70                                        QEMUIOVector *qiov)
  71 {
  72     return 0;
  73 }
  74
  75 static coroutine_fn int null_co_flush(BlockDriverState *bs)
  76 {
  77     return 0;
  78 }
  79
  80 typedef struct {
  81     BlockDriverAIOCB common;
  82     QEMUBH *bh;
  83 } NullAIOCB;
  84
  85 static const AIOCBInfo null_aiocb_info = {
  86     .aiocb_size = sizeof(NullAIOCB),
  87 };
  88
  89 static void null_bh_cb(void *opaque)
  90 {
  91     NullAIOCB *acb = opaque;
  92     acb->common.cb(acb->common.opaque, 0);
  93     qemu_bh_delete(acb->bh);
  94     qemu_aio_unref(acb);
  95 }
  96
  97 static inline BlockDriverAIOCB *null_aio_common(BlockDriverState *bs,
  98                                                 BlockDriverCompletionFunc *cb,
  99                                                 void *opaque)
 100 {
 101     NullAIOCB *acb;
 102
 103     acb = qemu_aio_get(&null_aiocb_info, bs, cb, opaque);
 104     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), null_bh_cb, acb);
 105     qemu_bh_schedule(acb->bh);
 106     return &acb->common;
 107 }
 108
 109 static BlockDriverAIOCB *null_aio_readv(BlockDriverState *bs,
 110                                         int64_t sector_num, QEMUIOVector *qiov,
 111                                         int nb_sectors,
 112                                         BlockDriverCompletionFunc *cb,
 113                                         void *opaque)
 114 {
 115     return null_aio_common(bs, cb, opaque);
 116 }
 117
 118 static BlockDriverAIOCB *null_aio_writev(BlockDriverState *bs,
 119                                          int64_t sector_num, QEMUIOVector *qiov,
 120                                          int nb_sectors,
 121                                          BlockDriverCompletionFunc *cb,
 122                                          void *opaque)
 123 {
 124     return null_aio_common(bs, cb, opaque);
 125 }
 126
 127 static BlockDriverAIOCB *null_aio_flush(BlockDriverState *bs,
 128                                         BlockDriverCompletionFunc *cb,
 129                                         void *opaque)
 130 {
 131     return null_aio_common(bs, cb, opaque);
 132 }
 133
 134 static BlockDriver bdrv_null_co = {
 135     .format_name            = "null-co",
 136     .protocol_name          = "null-co",
 137     .instance_size          = sizeof(BDRVNullState),
 138
 139     .bdrv_file_open         = null_file_open,
 140     .bdrv_close             = null_close,
 141     .bdrv_getlength         = null_getlength,
 142
 143     .bdrv_co_readv          = null_co_readv,
 144     .bdrv_co_writev         = null_co_writev,
 145     .bdrv_co_flush_to_disk  = null_co_flush,
 146 };
 147
 148 static BlockDriver bdrv_null_aio = {
 149     .format_name            = "null-aio",
 150     .protocol_name          = "null-aio",
 151     .instance_size          = sizeof(BDRVNullState),
 152
 153     .bdrv_file_open         = null_file_open,
 154     .bdrv_close             = null_close,
 155     .bdrv_getlength         = null_getlength,
 156
 157     .bdrv_aio_readv         = null_aio_readv,
 158     .bdrv_aio_writev        = null_aio_writev,
 159     .bdrv_aio_flush         = null_aio_flush,
 160 };
 161
 162 static void bdrv_null_init(void)
 163 {
 164     bdrv_register(&bdrv_null_co);
 165     bdrv_register(&bdrv_null_aio);
 166 }
 167
 168 block_init(bdrv_null_init);