nbd: Fix trace message for disconnect
[qemu/ar7.git] / block / null.c
blobdd9c13f9ba834d1f17784612e9ad5a5f6bd9769f
1 /*
2 * Null block driver
4 * Authors:
5 * Fam Zheng <famz@redhat.com>
7 * Copyright (C) 2014 Red Hat, Inc.
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.
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"
19 #define NULL_OPT_LATENCY "latency-ns"
20 #define NULL_OPT_ZEROES "read-zeroes"
22 typedef struct {
23 int64_t length;
24 int64_t latency_ns;
25 bool read_zeroes;
26 } BDRVNullState;
28 static QemuOptsList runtime_opts = {
29 .name = "null",
30 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
31 .desc = {
33 .name = BLOCK_OPT_SIZE,
34 .type = QEMU_OPT_SIZE,
35 .help = "size of the null block",
38 .name = NULL_OPT_LATENCY,
39 .type = QEMU_OPT_NUMBER,
40 .help = "nanoseconds (approximated) to wait "
41 "before completing request",
44 .name = NULL_OPT_ZEROES,
45 .type = QEMU_OPT_BOOL,
46 .help = "return zeroes when read",
48 { /* end of list */ }
52 static void null_co_parse_filename(const char *filename, QDict *options,
53 Error **errp)
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;
64 static void null_aio_parse_filename(const char *filename, QDict *options,
65 Error **errp)
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;
76 static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
77 Error **errp)
79 QemuOpts *opts;
80 BDRVNullState *s = bs->opaque;
81 int ret = 0;
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;
93 s->read_zeroes = qemu_opt_get_bool(opts, NULL_OPT_ZEROES, false);
94 qemu_opts_del(opts);
95 return ret;
98 static void null_close(BlockDriverState *bs)
102 static int64_t null_getlength(BlockDriverState *bs)
104 BDRVNullState *s = bs->opaque;
105 return s->length;
108 static coroutine_fn int null_co_common(BlockDriverState *bs)
110 BDRVNullState *s = bs->opaque;
112 if (s->latency_ns) {
113 co_aio_sleep_ns(bdrv_get_aio_context(bs), QEMU_CLOCK_REALTIME,
114 s->latency_ns);
116 return 0;
119 static coroutine_fn int null_co_readv(BlockDriverState *bs,
120 int64_t sector_num, int nb_sectors,
121 QEMUIOVector *qiov)
123 BDRVNullState *s = bs->opaque;
125 if (s->read_zeroes) {
126 qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
129 return null_co_common(bs);
132 static coroutine_fn int null_co_writev(BlockDriverState *bs,
133 int64_t sector_num, int nb_sectors,
134 QEMUIOVector *qiov)
136 return null_co_common(bs);
139 static coroutine_fn int null_co_flush(BlockDriverState *bs)
141 return null_co_common(bs);
144 typedef struct {
145 BlockAIOCB common;
146 QEMUTimer timer;
147 } NullAIOCB;
149 static const AIOCBInfo null_aiocb_info = {
150 .aiocb_size = sizeof(NullAIOCB),
153 static void null_bh_cb(void *opaque)
155 NullAIOCB *acb = opaque;
156 acb->common.cb(acb->common.opaque, 0);
157 qemu_aio_unref(acb);
160 static void null_timer_cb(void *opaque)
162 NullAIOCB *acb = opaque;
163 acb->common.cb(acb->common.opaque, 0);
164 timer_deinit(&acb->timer);
165 qemu_aio_unref(acb);
168 static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
169 BlockCompletionFunc *cb,
170 void *opaque)
172 NullAIOCB *acb;
173 BDRVNullState *s = bs->opaque;
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);
186 return &acb->common;
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)
195 BDRVNullState *s = bs->opaque;
197 if (s->read_zeroes) {
198 qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
201 return null_aio_common(bs, cb, opaque);
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)
210 return null_aio_common(bs, cb, opaque);
213 static BlockAIOCB *null_aio_flush(BlockDriverState *bs,
214 BlockCompletionFunc *cb,
215 void *opaque)
217 return null_aio_common(bs, cb, opaque);
220 static int null_reopen_prepare(BDRVReopenState *reopen_state,
221 BlockReopenQueue *queue, Error **errp)
223 return 0;
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)
231 BDRVNullState *s = bs->opaque;
232 off_t start = sector_num * BDRV_SECTOR_SIZE;
234 *pnum = nb_sectors;
235 *file = bs;
237 if (s->read_zeroes) {
238 return BDRV_BLOCK_OFFSET_VALID | start | BDRV_BLOCK_ZERO;
239 } else {
240 return BDRV_BLOCK_OFFSET_VALID | start;
244 static void null_refresh_filename(BlockDriverState *bs, QDict *opts)
246 QINCREF(opts);
247 qdict_del(opts, "filename");
249 if (!qdict_size(opts)) {
250 snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://",
251 bs->drv->format_name);
254 qdict_put_str(opts, "driver", bs->drv->format_name);
255 bs->full_open_options = opts;
258 static BlockDriver bdrv_null_co = {
259 .format_name = "null-co",
260 .protocol_name = "null-co",
261 .instance_size = sizeof(BDRVNullState),
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,
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,
273 .bdrv_co_get_block_status = null_co_get_block_status,
275 .bdrv_refresh_filename = null_refresh_filename,
278 static BlockDriver bdrv_null_aio = {
279 .format_name = "null-aio",
280 .protocol_name = "null-aio",
281 .instance_size = sizeof(BDRVNullState),
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,
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,
293 .bdrv_co_get_block_status = null_co_get_block_status,
295 .bdrv_refresh_filename = null_refresh_filename,
298 static void bdrv_null_init(void)
300 bdrv_register(&bdrv_null_co);
301 bdrv_register(&bdrv_null_aio);
304 block_init(bdrv_null_init);