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