linux-user: Use safe_syscall for open and openat system calls
[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 "block/block_int.h"
16
17 #define NULL_OPT_LATENCY "latency-ns"
18 #define NULL_OPT_ZEROES "read-zeroes"
19
20 typedef struct {
21 int64_t length;
22 int64_t latency_ns;
23 bool read_zeroes;
24 } BDRVNullState;
25
26 static QemuOptsList runtime_opts = {
27 .name = "null",
28 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
29 .desc = {
30 {
31 .name = "filename",
32 .type = QEMU_OPT_STRING,
33 .help = "",
34 },
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 int null_file_open(BlockDriverState *bs, QDict *options, int flags,
56 Error **errp)
57 {
58 QemuOpts *opts;
59 BDRVNullState *s = bs->opaque;
60 int ret = 0;
61
62 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
63 qemu_opts_absorb_qdict(opts, options, &error_abort);
64 s->length =
65 qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
66 s->latency_ns =
67 qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0);
68 if (s->latency_ns < 0) {
69 error_setg(errp, "latency-ns is invalid");
70 ret = -EINVAL;
71 }
72 s->read_zeroes = qemu_opt_get_bool(opts, NULL_OPT_ZEROES, false);
73 qemu_opts_del(opts);
74 return ret;
75 }
76
77 static void null_close(BlockDriverState *bs)
78 {
79 }
80
81 static int64_t null_getlength(BlockDriverState *bs)
82 {
83 BDRVNullState *s = bs->opaque;
84 return s->length;
85 }
86
87 static coroutine_fn int null_co_common(BlockDriverState *bs)
88 {
89 BDRVNullState *s = bs->opaque;
90
91 if (s->latency_ns) {
92 co_aio_sleep_ns(bdrv_get_aio_context(bs), QEMU_CLOCK_REALTIME,
93 s->latency_ns);
94 }
95 return 0;
96 }
97
98 static coroutine_fn int null_co_readv(BlockDriverState *bs,
99 int64_t sector_num, int nb_sectors,
100 QEMUIOVector *qiov)
101 {
102 BDRVNullState *s = bs->opaque;
103
104 if (s->read_zeroes) {
105 qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
106 }
107
108 return null_co_common(bs);
109 }
110
111 static coroutine_fn int null_co_writev(BlockDriverState *bs,
112 int64_t sector_num, int nb_sectors,
113 QEMUIOVector *qiov)
114 {
115 return null_co_common(bs);
116 }
117
118 static coroutine_fn int null_co_flush(BlockDriverState *bs)
119 {
120 return null_co_common(bs);
121 }
122
123 typedef struct {
124 BlockAIOCB common;
125 QEMUBH *bh;
126 QEMUTimer timer;
127 } NullAIOCB;
128
129 static const AIOCBInfo null_aiocb_info = {
130 .aiocb_size = sizeof(NullAIOCB),
131 };
132
133 static void null_bh_cb(void *opaque)
134 {
135 NullAIOCB *acb = opaque;
136 acb->common.cb(acb->common.opaque, 0);
137 qemu_bh_delete(acb->bh);
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 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), null_bh_cb, acb);
166 qemu_bh_schedule(acb->bh);
167 }
168 return &acb->common;
169 }
170
171 static BlockAIOCB *null_aio_readv(BlockDriverState *bs,
172 int64_t sector_num, QEMUIOVector *qiov,
173 int nb_sectors,
174 BlockCompletionFunc *cb,
175 void *opaque)
176 {
177 BDRVNullState *s = bs->opaque;
178
179 if (s->read_zeroes) {
180 qemu_iovec_memset(qiov, 0, 0, nb_sectors * BDRV_SECTOR_SIZE);
181 }
182
183 return null_aio_common(bs, cb, opaque);
184 }
185
186 static BlockAIOCB *null_aio_writev(BlockDriverState *bs,
187 int64_t sector_num, QEMUIOVector *qiov,
188 int nb_sectors,
189 BlockCompletionFunc *cb,
190 void *opaque)
191 {
192 return null_aio_common(bs, cb, opaque);
193 }
194
195 static BlockAIOCB *null_aio_flush(BlockDriverState *bs,
196 BlockCompletionFunc *cb,
197 void *opaque)
198 {
199 return null_aio_common(bs, cb, opaque);
200 }
201
202 static int null_reopen_prepare(BDRVReopenState *reopen_state,
203 BlockReopenQueue *queue, Error **errp)
204 {
205 return 0;
206 }
207
208 static int64_t coroutine_fn null_co_get_block_status(BlockDriverState *bs,
209 int64_t sector_num,
210 int nb_sectors, int *pnum,
211 BlockDriverState **file)
212 {
213 BDRVNullState *s = bs->opaque;
214 off_t start = sector_num * BDRV_SECTOR_SIZE;
215
216 *pnum = nb_sectors;
217 *file = bs;
218
219 if (s->read_zeroes) {
220 return BDRV_BLOCK_OFFSET_VALID | start | BDRV_BLOCK_ZERO;
221 } else {
222 return BDRV_BLOCK_OFFSET_VALID | start;
223 }
224 }
225
226 static BlockDriver bdrv_null_co = {
227 .format_name = "null-co",
228 .protocol_name = "null-co",
229 .instance_size = sizeof(BDRVNullState),
230
231 .bdrv_file_open = null_file_open,
232 .bdrv_close = null_close,
233 .bdrv_getlength = null_getlength,
234
235 .bdrv_co_readv = null_co_readv,
236 .bdrv_co_writev = null_co_writev,
237 .bdrv_co_flush_to_disk = null_co_flush,
238 .bdrv_reopen_prepare = null_reopen_prepare,
239
240 .bdrv_co_get_block_status = null_co_get_block_status,
241 };
242
243 static BlockDriver bdrv_null_aio = {
244 .format_name = "null-aio",
245 .protocol_name = "null-aio",
246 .instance_size = sizeof(BDRVNullState),
247
248 .bdrv_file_open = null_file_open,
249 .bdrv_close = null_close,
250 .bdrv_getlength = null_getlength,
251
252 .bdrv_aio_readv = null_aio_readv,
253 .bdrv_aio_writev = null_aio_writev,
254 .bdrv_aio_flush = null_aio_flush,
255 .bdrv_reopen_prepare = null_reopen_prepare,
256
257 .bdrv_co_get_block_status = null_co_get_block_status,
258 };
259
260 static void bdrv_null_init(void)
261 {
262 bdrv_register(&bdrv_null_co);
263 bdrv_register(&bdrv_null_aio);
264 }
265
266 block_init(bdrv_null_init);