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