linux-user: Use safe_syscall for open and openat system calls
[qemu.git] / block / raw_bsd.c
1 /* BlockDriver implementation for "raw"
2 *
3 * Copyright (C) 2010, 2013, Red Hat, Inc.
4 * Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com>
5 * Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com>
6 *
7 * Author:
8 * Laszlo Ersek <lersek@redhat.com>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to
12 * deal in the Software without restriction, including without limitation the
13 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
14 * sell copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
26 * IN THE SOFTWARE.
27 */
28
29 #include "qemu/osdep.h"
30 #include "block/block_int.h"
31 #include "qapi/error.h"
32 #include "qemu/option.h"
33
34 static QemuOptsList raw_create_opts = {
35 .name = "raw-create-opts",
36 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
37 .desc = {
38 {
39 .name = BLOCK_OPT_SIZE,
40 .type = QEMU_OPT_SIZE,
41 .help = "Virtual disk size"
42 },
43 { /* end of list */ }
44 }
45 };
46
47 static int raw_reopen_prepare(BDRVReopenState *reopen_state,
48 BlockReopenQueue *queue, Error **errp)
49 {
50 return 0;
51 }
52
53 static int coroutine_fn raw_co_readv(BlockDriverState *bs, int64_t sector_num,
54 int nb_sectors, QEMUIOVector *qiov)
55 {
56 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
57 return bdrv_co_readv(bs->file->bs, sector_num, nb_sectors, qiov);
58 }
59
60 static int coroutine_fn
61 raw_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
62 QEMUIOVector *qiov, int flags)
63 {
64 void *buf = NULL;
65 BlockDriver *drv;
66 QEMUIOVector local_qiov;
67 int ret;
68
69 if (bs->probed && sector_num == 0) {
70 /* As long as these conditions are true, we can't get partial writes to
71 * the probe buffer and can just directly check the request. */
72 QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512);
73 QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512);
74
75 if (nb_sectors == 0) {
76 /* qemu_iovec_to_buf() would fail, but we want to return success
77 * instead of -EINVAL in this case. */
78 return 0;
79 }
80
81 buf = qemu_try_blockalign(bs->file->bs, 512);
82 if (!buf) {
83 ret = -ENOMEM;
84 goto fail;
85 }
86
87 ret = qemu_iovec_to_buf(qiov, 0, buf, 512);
88 if (ret != 512) {
89 ret = -EINVAL;
90 goto fail;
91 }
92
93 drv = bdrv_probe_all(buf, 512, NULL);
94 if (drv != bs->drv) {
95 ret = -EPERM;
96 goto fail;
97 }
98
99 /* Use the checked buffer, a malicious guest might be overwriting its
100 * original buffer in the background. */
101 qemu_iovec_init(&local_qiov, qiov->niov + 1);
102 qemu_iovec_add(&local_qiov, buf, 512);
103 qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512);
104 qiov = &local_qiov;
105 }
106
107 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
108 ret = bdrv_co_pwritev(bs->file->bs, sector_num * BDRV_SECTOR_SIZE,
109 nb_sectors * BDRV_SECTOR_SIZE, qiov, flags);
110
111 fail:
112 if (qiov == &local_qiov) {
113 qemu_iovec_destroy(&local_qiov);
114 }
115 qemu_vfree(buf);
116 return ret;
117 }
118
119 static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
120 int64_t sector_num,
121 int nb_sectors, int *pnum,
122 BlockDriverState **file)
123 {
124 *pnum = nb_sectors;
125 *file = bs->file->bs;
126 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_DATA |
127 (sector_num << BDRV_SECTOR_BITS);
128 }
129
130 static int coroutine_fn raw_co_write_zeroes(BlockDriverState *bs,
131 int64_t sector_num, int nb_sectors,
132 BdrvRequestFlags flags)
133 {
134 return bdrv_co_write_zeroes(bs->file->bs, sector_num, nb_sectors, flags);
135 }
136
137 static int coroutine_fn raw_co_discard(BlockDriverState *bs,
138 int64_t sector_num, int nb_sectors)
139 {
140 return bdrv_co_discard(bs->file->bs, sector_num, nb_sectors);
141 }
142
143 static int64_t raw_getlength(BlockDriverState *bs)
144 {
145 return bdrv_getlength(bs->file->bs);
146 }
147
148 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
149 {
150 return bdrv_get_info(bs->file->bs, bdi);
151 }
152
153 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
154 {
155 bs->bl = bs->file->bs->bl;
156 }
157
158 static int raw_truncate(BlockDriverState *bs, int64_t offset)
159 {
160 return bdrv_truncate(bs->file->bs, offset);
161 }
162
163 static int raw_media_changed(BlockDriverState *bs)
164 {
165 return bdrv_media_changed(bs->file->bs);
166 }
167
168 static void raw_eject(BlockDriverState *bs, bool eject_flag)
169 {
170 bdrv_eject(bs->file->bs, eject_flag);
171 }
172
173 static void raw_lock_medium(BlockDriverState *bs, bool locked)
174 {
175 bdrv_lock_medium(bs->file->bs, locked);
176 }
177
178 static BlockAIOCB *raw_aio_ioctl(BlockDriverState *bs,
179 unsigned long int req, void *buf,
180 BlockCompletionFunc *cb,
181 void *opaque)
182 {
183 return bdrv_aio_ioctl(bs->file->bs, req, buf, cb, opaque);
184 }
185
186 static int raw_has_zero_init(BlockDriverState *bs)
187 {
188 return bdrv_has_zero_init(bs->file->bs);
189 }
190
191 static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
192 {
193 Error *local_err = NULL;
194 int ret;
195
196 ret = bdrv_create_file(filename, opts, &local_err);
197 if (local_err) {
198 error_propagate(errp, local_err);
199 }
200 return ret;
201 }
202
203 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
204 Error **errp)
205 {
206 bs->sg = bs->file->bs->sg;
207 bs->supported_write_flags = BDRV_REQ_FUA;
208 bs->supported_zero_flags = BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP;
209
210 if (bs->probed && !bdrv_is_read_only(bs)) {
211 fprintf(stderr,
212 "WARNING: Image format was not specified for '%s' and probing "
213 "guessed raw.\n"
214 " Automatically detecting the format is dangerous for "
215 "raw images, write operations on block 0 will be restricted.\n"
216 " Specify the 'raw' format explicitly to remove the "
217 "restrictions.\n",
218 bs->file->bs->filename);
219 }
220
221 return 0;
222 }
223
224 static void raw_close(BlockDriverState *bs)
225 {
226 }
227
228 static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
229 {
230 /* smallest possible positive score so that raw is used if and only if no
231 * other block driver works
232 */
233 return 1;
234 }
235
236 static int raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
237 {
238 return bdrv_probe_blocksizes(bs->file->bs, bsz);
239 }
240
241 static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
242 {
243 return bdrv_probe_geometry(bs->file->bs, geo);
244 }
245
246 BlockDriver bdrv_raw = {
247 .format_name = "raw",
248 .bdrv_probe = &raw_probe,
249 .bdrv_reopen_prepare = &raw_reopen_prepare,
250 .bdrv_open = &raw_open,
251 .bdrv_close = &raw_close,
252 .bdrv_create = &raw_create,
253 .bdrv_co_readv = &raw_co_readv,
254 .bdrv_co_writev_flags = &raw_co_writev_flags,
255 .bdrv_co_write_zeroes = &raw_co_write_zeroes,
256 .bdrv_co_discard = &raw_co_discard,
257 .bdrv_co_get_block_status = &raw_co_get_block_status,
258 .bdrv_truncate = &raw_truncate,
259 .bdrv_getlength = &raw_getlength,
260 .has_variable_length = true,
261 .bdrv_get_info = &raw_get_info,
262 .bdrv_refresh_limits = &raw_refresh_limits,
263 .bdrv_probe_blocksizes = &raw_probe_blocksizes,
264 .bdrv_probe_geometry = &raw_probe_geometry,
265 .bdrv_media_changed = &raw_media_changed,
266 .bdrv_eject = &raw_eject,
267 .bdrv_lock_medium = &raw_lock_medium,
268 .bdrv_aio_ioctl = &raw_aio_ioctl,
269 .create_opts = &raw_create_opts,
270 .bdrv_has_zero_init = &raw_has_zero_init
271 };
272
273 static void bdrv_raw_init(void)
274 {
275 bdrv_register(&bdrv_raw);
276 }
277
278 block_init(bdrv_raw_init);