xref: /qemu/block/null.c (revision abff1abf) 
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);
319