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 "block/block_int.h" 15 16 #define NULL_OPT_LATENCY "latency-ns" 17 18 typedef struct { 19 int64_t length; 20 int64_t latency_ns; 21 } BDRVNullState; 22 23 static QemuOptsList runtime_opts = { 24 .name = "null", 25 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 26 .desc = { 27 { 28 .name = "filename", 29 .type = QEMU_OPT_STRING, 30 .help = "", 31 }, 32 { 33 .name = BLOCK_OPT_SIZE, 34 .type = QEMU_OPT_SIZE, 35 .help = "size of the null block", 36 }, 37 { 38 .name = NULL_OPT_LATENCY, 39 .type = QEMU_OPT_NUMBER, 40 .help = "nanoseconds (approximated) to wait " 41 "before completing request", 42 }, 43 { /* end of list */ } 44 }, 45 }; 46 47 static int null_file_open(BlockDriverState *bs, QDict *options, int flags, 48 Error **errp) 49 { 50 QemuOpts *opts; 51 BDRVNullState *s = bs->opaque; 52 int ret = 0; 53 54 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 55 qemu_opts_absorb_qdict(opts, options, &error_abort); 56 s->length = 57 qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30); 58 s->latency_ns = 59 qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0); 60 if (s->latency_ns < 0) { 61 error_setg(errp, "latency-ns is invalid"); 62 ret = -EINVAL; 63 } 64 qemu_opts_del(opts); 65 return ret; 66 } 67 68 static void null_close(BlockDriverState *bs) 69 { 70 } 71 72 static int64_t null_getlength(BlockDriverState *bs) 73 { 74 BDRVNullState *s = bs->opaque; 75 return s->length; 76 } 77 78 static coroutine_fn int null_co_common(BlockDriverState *bs) 79 { 80 BDRVNullState *s = bs->opaque; 81 82 if (s->latency_ns) { 83 co_aio_sleep_ns(bdrv_get_aio_context(bs), QEMU_CLOCK_REALTIME, 84 s->latency_ns); 85 } 86 return 0; 87 } 88 89 static coroutine_fn int null_co_readv(BlockDriverState *bs, 90 int64_t sector_num, int nb_sectors, 91 QEMUIOVector *qiov) 92 { 93 return null_co_common(bs); 94 } 95 96 static coroutine_fn int null_co_writev(BlockDriverState *bs, 97 int64_t sector_num, int nb_sectors, 98 QEMUIOVector *qiov) 99 { 100 return null_co_common(bs); 101 } 102 103 static coroutine_fn int null_co_flush(BlockDriverState *bs) 104 { 105 return null_co_common(bs); 106 } 107 108 typedef struct { 109 BlockAIOCB common; 110 QEMUBH *bh; 111 QEMUTimer timer; 112 } NullAIOCB; 113 114 static const AIOCBInfo null_aiocb_info = { 115 .aiocb_size = sizeof(NullAIOCB), 116 }; 117 118 static void null_bh_cb(void *opaque) 119 { 120 NullAIOCB *acb = opaque; 121 acb->common.cb(acb->common.opaque, 0); 122 qemu_bh_delete(acb->bh); 123 qemu_aio_unref(acb); 124 } 125 126 static void null_timer_cb(void *opaque) 127 { 128 NullAIOCB *acb = opaque; 129 acb->common.cb(acb->common.opaque, 0); 130 timer_deinit(&acb->timer); 131 qemu_aio_unref(acb); 132 } 133 134 static inline BlockAIOCB *null_aio_common(BlockDriverState *bs, 135 BlockCompletionFunc *cb, 136 void *opaque) 137 { 138 NullAIOCB *acb; 139 BDRVNullState *s = bs->opaque; 140 141 acb = qemu_aio_get(&null_aiocb_info, bs, cb, opaque); 142 /* Only emulate latency after vcpu is running. */ 143 if (s->latency_ns) { 144 aio_timer_init(bdrv_get_aio_context(bs), &acb->timer, 145 QEMU_CLOCK_REALTIME, SCALE_NS, 146 null_timer_cb, acb); 147 timer_mod_ns(&acb->timer, 148 qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + s->latency_ns); 149 } else { 150 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), null_bh_cb, acb); 151 qemu_bh_schedule(acb->bh); 152 } 153 return &acb->common; 154 } 155 156 static BlockAIOCB *null_aio_readv(BlockDriverState *bs, 157 int64_t sector_num, QEMUIOVector *qiov, 158 int nb_sectors, 159 BlockCompletionFunc *cb, 160 void *opaque) 161 { 162 return null_aio_common(bs, cb, opaque); 163 } 164 165 static BlockAIOCB *null_aio_writev(BlockDriverState *bs, 166 int64_t sector_num, QEMUIOVector *qiov, 167 int nb_sectors, 168 BlockCompletionFunc *cb, 169 void *opaque) 170 { 171 return null_aio_common(bs, cb, opaque); 172 } 173 174 static BlockAIOCB *null_aio_flush(BlockDriverState *bs, 175 BlockCompletionFunc *cb, 176 void *opaque) 177 { 178 return null_aio_common(bs, cb, opaque); 179 } 180 181 static int null_reopen_prepare(BDRVReopenState *reopen_state, 182 BlockReopenQueue *queue, Error **errp) 183 { 184 return 0; 185 } 186 187 static BlockDriver bdrv_null_co = { 188 .format_name = "null-co", 189 .protocol_name = "null-co", 190 .instance_size = sizeof(BDRVNullState), 191 192 .bdrv_file_open = null_file_open, 193 .bdrv_close = null_close, 194 .bdrv_getlength = null_getlength, 195 196 .bdrv_co_readv = null_co_readv, 197 .bdrv_co_writev = null_co_writev, 198 .bdrv_co_flush_to_disk = null_co_flush, 199 .bdrv_reopen_prepare = null_reopen_prepare, 200 }; 201 202 static BlockDriver bdrv_null_aio = { 203 .format_name = "null-aio", 204 .protocol_name = "null-aio", 205 .instance_size = sizeof(BDRVNullState), 206 207 .bdrv_file_open = null_file_open, 208 .bdrv_close = null_close, 209 .bdrv_getlength = null_getlength, 210 211 .bdrv_aio_readv = null_aio_readv, 212 .bdrv_aio_writev = null_aio_writev, 213 .bdrv_aio_flush = null_aio_flush, 214 .bdrv_reopen_prepare = null_reopen_prepare, 215 }; 216 217 static void bdrv_null_init(void) 218 { 219 bdrv_register(&bdrv_null_co); 220 bdrv_register(&bdrv_null_aio); 221 } 222 223 block_init(bdrv_null_init); 224