xref: /openbmc/qemu/block/null.c (revision d6b76d68)
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 = BLOCK_OPT_SIZE,
34             .type = QEMU_OPT_SIZE,
35             .help = "size of the null block",
36         },
37         {
38             .name = NULL_OPT_LATENCY,
39             .type = QEMU_OPT_NUMBER,
40             .help = "nanoseconds (approximated) to wait "
41                     "before completing request",
42         },
43         {
44             .name = NULL_OPT_ZEROES,
45             .type = QEMU_OPT_BOOL,
46             .help = "return zeroes when read",
47         },
48         { /* end of list */ }
49     },
50 };
51 
52 static void null_co_parse_filename(const char *filename, QDict *options,
53                                    Error **errp)
54 {
55     /* This functions only exists so that a null-co:// filename is accepted
56      * with the null-co driver. */
57     if (strcmp(filename, "null-co://")) {
58         error_setg(errp, "The only allowed filename for this driver is "
59                          "'null-co://'");
60         return;
61     }
62 }
63 
64 static void null_aio_parse_filename(const char *filename, QDict *options,
65                                     Error **errp)
66 {
67     /* This functions only exists so that a null-aio:// filename is accepted
68      * with the null-aio driver. */
69     if (strcmp(filename, "null-aio://")) {
70         error_setg(errp, "The only allowed filename for this driver is "
71                          "'null-aio://'");
72         return;
73     }
74 }
75 
76 static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
77                           Error **errp)
78 {
79     QemuOpts *opts;
80     BDRVNullState *s = bs->opaque;
81     int ret = 0;
82 
83     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
84     qemu_opts_absorb_qdict(opts, options, &error_abort);
85     s->length =
86         qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
87     s->latency_ns =
88         qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0);
89     if (s->latency_ns < 0) {
90         error_setg(errp, "latency-ns is invalid");
91         ret = -EINVAL;
92     }
93     s->read_zeroes = qemu_opt_get_bool(opts, NULL_OPT_ZEROES, false);
94     qemu_opts_del(opts);
95     return ret;
96 }
97 
98 static void null_close(BlockDriverState *bs)
99 {
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         co_aio_sleep_ns(bdrv_get_aio_context(bs), QEMU_CLOCK_REALTIME,
114                         s->latency_ns);
115     }
116     return 0;
117 }
118 
119 static coroutine_fn int null_co_readv(BlockDriverState *bs,
120                                       int64_t sector_num, int nb_sectors,
121                                       QEMUIOVector *qiov)
122 {
123     BDRVNullState *s = bs->opaque;
124 
125     if (s->read_zeroes) {
126         qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
127     }
128 
129     return null_co_common(bs);
130 }
131 
132 static coroutine_fn int null_co_writev(BlockDriverState *bs,
133                                        int64_t sector_num, int nb_sectors,
134                                        QEMUIOVector *qiov)
135 {
136     return null_co_common(bs);
137 }
138 
139 static coroutine_fn int null_co_flush(BlockDriverState *bs)
140 {
141     return null_co_common(bs);
142 }
143 
144 typedef struct {
145     BlockAIOCB common;
146     QEMUTimer timer;
147 } NullAIOCB;
148 
149 static const AIOCBInfo null_aiocb_info = {
150     .aiocb_size = sizeof(NullAIOCB),
151 };
152 
153 static void null_bh_cb(void *opaque)
154 {
155     NullAIOCB *acb = opaque;
156     acb->common.cb(acb->common.opaque, 0);
157     qemu_aio_unref(acb);
158 }
159 
160 static void null_timer_cb(void *opaque)
161 {
162     NullAIOCB *acb = opaque;
163     acb->common.cb(acb->common.opaque, 0);
164     timer_deinit(&acb->timer);
165     qemu_aio_unref(acb);
166 }
167 
168 static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
169                                           BlockCompletionFunc *cb,
170                                           void *opaque)
171 {
172     NullAIOCB *acb;
173     BDRVNullState *s = bs->opaque;
174 
175     acb = qemu_aio_get(&null_aiocb_info, bs, cb, opaque);
176     /* Only emulate latency after vcpu is running. */
177     if (s->latency_ns) {
178         aio_timer_init(bdrv_get_aio_context(bs), &acb->timer,
179                        QEMU_CLOCK_REALTIME, SCALE_NS,
180                        null_timer_cb, acb);
181         timer_mod_ns(&acb->timer,
182                      qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + s->latency_ns);
183     } else {
184         aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), null_bh_cb, acb);
185     }
186     return &acb->common;
187 }
188 
189 static BlockAIOCB *null_aio_readv(BlockDriverState *bs,
190                                   int64_t sector_num, QEMUIOVector *qiov,
191                                   int nb_sectors,
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, nb_sectors * BDRV_SECTOR_SIZE);
199     }
200 
201     return null_aio_common(bs, cb, opaque);
202 }
203 
204 static BlockAIOCB *null_aio_writev(BlockDriverState *bs,
205                                    int64_t sector_num, QEMUIOVector *qiov,
206                                    int nb_sectors,
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 int64_t coroutine_fn null_co_get_block_status(BlockDriverState *bs,
227                                                      int64_t sector_num,
228                                                      int nb_sectors, int *pnum,
229                                                      BlockDriverState **file)
230 {
231     BDRVNullState *s = bs->opaque;
232     off_t start = sector_num * BDRV_SECTOR_SIZE;
233 
234     *pnum = nb_sectors;
235     *file = bs;
236 
237     if (s->read_zeroes) {
238         return BDRV_BLOCK_OFFSET_VALID | start | BDRV_BLOCK_ZERO;
239     } else {
240         return BDRV_BLOCK_OFFSET_VALID | start;
241     }
242 }
243 
244 static void null_refresh_filename(BlockDriverState *bs, QDict *opts)
245 {
246     QINCREF(opts);
247     qdict_del(opts, "filename");
248 
249     if (!qdict_size(opts)) {
250         snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://",
251                  bs->drv->format_name);
252     }
253 
254     qdict_put_str(opts, "driver", bs->drv->format_name);
255     bs->full_open_options = opts;
256 }
257 
258 static BlockDriver bdrv_null_co = {
259     .format_name            = "null-co",
260     .protocol_name          = "null-co",
261     .instance_size          = sizeof(BDRVNullState),
262 
263     .bdrv_file_open         = null_file_open,
264     .bdrv_parse_filename    = null_co_parse_filename,
265     .bdrv_close             = null_close,
266     .bdrv_getlength         = null_getlength,
267 
268     .bdrv_co_readv          = null_co_readv,
269     .bdrv_co_writev         = null_co_writev,
270     .bdrv_co_flush_to_disk  = null_co_flush,
271     .bdrv_reopen_prepare    = null_reopen_prepare,
272 
273     .bdrv_co_get_block_status   = null_co_get_block_status,
274 
275     .bdrv_refresh_filename  = null_refresh_filename,
276 };
277 
278 static BlockDriver bdrv_null_aio = {
279     .format_name            = "null-aio",
280     .protocol_name          = "null-aio",
281     .instance_size          = sizeof(BDRVNullState),
282 
283     .bdrv_file_open         = null_file_open,
284     .bdrv_parse_filename    = null_aio_parse_filename,
285     .bdrv_close             = null_close,
286     .bdrv_getlength         = null_getlength,
287 
288     .bdrv_aio_readv         = null_aio_readv,
289     .bdrv_aio_writev        = null_aio_writev,
290     .bdrv_aio_flush         = null_aio_flush,
291     .bdrv_reopen_prepare    = null_reopen_prepare,
292 
293     .bdrv_co_get_block_status   = null_co_get_block_status,
294 
295     .bdrv_refresh_filename  = null_refresh_filename,
296 };
297 
298 static void bdrv_null_init(void)
299 {
300     bdrv_register(&bdrv_null_co);
301     bdrv_register(&bdrv_null_aio);
302 }
303 
304 block_init(bdrv_null_init);
305