]>
Commit | Line | Data |
---|---|---|
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); |