Merge remote-tracking branch 'remotes/kraxel/tags/pull-vga-20170103-1' 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 "block/block_int.h"
18
19 #define NULL_OPT_LATENCY "latency-ns"
20 #define NULL_OPT_ZEROES "read-zeroes"
21
22 typedef struct {
23 int64_t length;
24 int64_t latency_ns;
25 bool read_zeroes;
26 } BDRVNullState;
27
28 static QemuOptsList runtime_opts = {
29 .name = "null",
30 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
31 .desc = {
32 {
33 .name = "filename",
34 .type = QEMU_OPT_STRING,
35 .help = "",
36 },
37 {
38 .name = BLOCK_OPT_SIZE,
39 .type = QEMU_OPT_SIZE,
40 .help = "size of the null block",
41 },
42 {
43 .name = NULL_OPT_LATENCY,
44 .type = QEMU_OPT_NUMBER,
45 .help = "nanoseconds (approximated) to wait "
46 "before completing request",
47 },
48 {
49 .name = NULL_OPT_ZEROES,
50 .type = QEMU_OPT_BOOL,
51 .help = "return zeroes when read",
52 },
53 { /* end of list */ }
54 },
55 };
56
57 static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
58 Error **errp)
59 {
60 QemuOpts *opts;
61 BDRVNullState *s = bs->opaque;
62 int ret = 0;
63
64 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
65 qemu_opts_absorb_qdict(opts, options, &error_abort);
66 s->length =
67 qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
68 s->latency_ns =
69 qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0);
70 if (s->latency_ns < 0) {
71 error_setg(errp, "latency-ns is invalid");
72 ret = -EINVAL;
73 }
74 s->read_zeroes = qemu_opt_get_bool(opts, NULL_OPT_ZEROES, false);
75 qemu_opts_del(opts);
76 return ret;
77 }
78
79 static void null_close(BlockDriverState *bs)
80 {
81 }
82
83 static int64_t null_getlength(BlockDriverState *bs)
84 {
85 BDRVNullState *s = bs->opaque;
86 return s->length;
87 }
88
89 static coroutine_fn int null_co_common(BlockDriverState *bs)
90 {
91 BDRVNullState *s = bs->opaque;
92
93 if (s->latency_ns) {
94 co_aio_sleep_ns(bdrv_get_aio_context(bs), QEMU_CLOCK_REALTIME,
95 s->latency_ns);
96 }
97 return 0;
98 }
99
100 static coroutine_fn int null_co_readv(BlockDriverState *bs,
101 int64_t sector_num, int nb_sectors,
102 QEMUIOVector *qiov)
103 {
104 BDRVNullState *s = bs->opaque;
105
106 if (s->read_zeroes) {
107 qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
108 }
109
110 return null_co_common(bs);
111 }
112
113 static coroutine_fn int null_co_writev(BlockDriverState *bs,
114 int64_t sector_num, int nb_sectors,
115 QEMUIOVector *qiov)
116 {
117 return null_co_common(bs);
118 }
119
120 static coroutine_fn int null_co_flush(BlockDriverState *bs)
121 {
122 return null_co_common(bs);
123 }
124
125 typedef struct {
126 BlockAIOCB common;
127 QEMUTimer timer;
128 } NullAIOCB;
129
130 static const AIOCBInfo null_aiocb_info = {
131 .aiocb_size = sizeof(NullAIOCB),
132 };
133
134 static void null_bh_cb(void *opaque)
135 {
136 NullAIOCB *acb = opaque;
137 acb->common.cb(acb->common.opaque, 0);
138 qemu_aio_unref(acb);
139 }
140
141 static void null_timer_cb(void *opaque)
142 {
143 NullAIOCB *acb = opaque;
144 acb->common.cb(acb->common.opaque, 0);
145 timer_deinit(&acb->timer);
146 qemu_aio_unref(acb);
147 }
148
149 static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
150 BlockCompletionFunc *cb,
151 void *opaque)
152 {
153 NullAIOCB *acb;
154 BDRVNullState *s = bs->opaque;
155
156 acb = qemu_aio_get(&null_aiocb_info, bs, cb, opaque);
157 /* Only emulate latency after vcpu is running. */
158 if (s->latency_ns) {
159 aio_timer_init(bdrv_get_aio_context(bs), &acb->timer,
160 QEMU_CLOCK_REALTIME, SCALE_NS,
161 null_timer_cb, acb);
162 timer_mod_ns(&acb->timer,
163 qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + s->latency_ns);
164 } else {
165 aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), null_bh_cb, acb);
166 }
167 return &acb->common;
168 }
169
170 static BlockAIOCB *null_aio_readv(BlockDriverState *bs,
171 int64_t sector_num, QEMUIOVector *qiov,
172 int nb_sectors,
173 BlockCompletionFunc *cb,
174 void *opaque)
175 {
176 BDRVNullState *s = bs->opaque;
177
178 if (s->read_zeroes) {
179 qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
180 }
181
182 return null_aio_common(bs, cb, opaque);
183 }
184
185 static BlockAIOCB *null_aio_writev(BlockDriverState *bs,
186 int64_t sector_num, QEMUIOVector *qiov,
187 int nb_sectors,
188 BlockCompletionFunc *cb,
189 void *opaque)
190 {
191 return null_aio_common(bs, cb, opaque);
192 }
193
194 static BlockAIOCB *null_aio_flush(BlockDriverState *bs,
195 BlockCompletionFunc *cb,
196 void *opaque)
197 {
198 return null_aio_common(bs, cb, opaque);
199 }
200
201 static int null_reopen_prepare(BDRVReopenState *reopen_state,
202 BlockReopenQueue *queue, Error **errp)
203 {
204 return 0;
205 }
206
207 static int64_t coroutine_fn null_co_get_block_status(BlockDriverState *bs,
208 int64_t sector_num,
209 int nb_sectors, int *pnum,
210 BlockDriverState **file)
211 {
212 BDRVNullState *s = bs->opaque;
213 off_t start = sector_num * BDRV_SECTOR_SIZE;
214
215 *pnum = nb_sectors;
216 *file = bs;
217
218 if (s->read_zeroes) {
219 return BDRV_BLOCK_OFFSET_VALID | start | BDRV_BLOCK_ZERO;
220 } else {
221 return BDRV_BLOCK_OFFSET_VALID | start;
222 }
223 }
224
225 static void null_refresh_filename(BlockDriverState *bs, QDict *opts)
226 {
227 QINCREF(opts);
228 qdict_del(opts, "filename");
229
230 if (!qdict_size(opts)) {
231 snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://",
232 bs->drv->format_name);
233 }
234
235 qdict_put(opts, "driver", qstring_from_str(bs->drv->format_name));
236 bs->full_open_options = opts;
237 }
238
239 static BlockDriver bdrv_null_co = {
240 .format_name = "null-co",
241 .protocol_name = "null-co",
242 .instance_size = sizeof(BDRVNullState),
243
244 .bdrv_file_open = null_file_open,
245 .bdrv_close = null_close,
246 .bdrv_getlength = null_getlength,
247
248 .bdrv_co_readv = null_co_readv,
249 .bdrv_co_writev = null_co_writev,
250 .bdrv_co_flush_to_disk = null_co_flush,
251 .bdrv_reopen_prepare = null_reopen_prepare,
252
253 .bdrv_co_get_block_status = null_co_get_block_status,
254
255 .bdrv_refresh_filename = null_refresh_filename,
256 };
257
258 static BlockDriver bdrv_null_aio = {
259 .format_name = "null-aio",
260 .protocol_name = "null-aio",
261 .instance_size = sizeof(BDRVNullState),
262
263 .bdrv_file_open = null_file_open,
264 .bdrv_close = null_close,
265 .bdrv_getlength = null_getlength,
266
267 .bdrv_aio_readv = null_aio_readv,
268 .bdrv_aio_writev = null_aio_writev,
269 .bdrv_aio_flush = null_aio_flush,
270 .bdrv_reopen_prepare = null_reopen_prepare,
271
272 .bdrv_co_get_block_status = null_co_get_block_status,
273
274 .bdrv_refresh_filename = null_refresh_filename,
275 };
276
277 static void bdrv_null_init(void)
278 {
279 bdrv_register(&bdrv_null_co);
280 bdrv_register(&bdrv_null_aio);
281 }
282
283 block_init(bdrv_null_init);