/src/qemu/block/raw-format.c
Line | Count | Source |
1 | | /* BlockDriver implementation for "raw" format driver |
2 | | * |
3 | | * Copyright (C) 2010-2016 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-io.h" |
31 | | #include "block/block_int.h" |
32 | | #include "qapi/error.h" |
33 | | #include "qemu/module.h" |
34 | | #include "qemu/option.h" |
35 | | #include "qemu/memalign.h" |
36 | | |
37 | | typedef struct BDRVRawState { |
38 | | uint64_t offset; |
39 | | uint64_t size; |
40 | | bool has_size; |
41 | | } BDRVRawState; |
42 | | |
43 | | static const char *const mutable_opts[] = { "offset", "size", NULL }; |
44 | | |
45 | | static QemuOptsList raw_runtime_opts = { |
46 | | .name = "raw", |
47 | | .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head), |
48 | | .desc = { |
49 | | { |
50 | | .name = "offset", |
51 | | .type = QEMU_OPT_SIZE, |
52 | | .help = "offset in the disk where the image starts", |
53 | | }, |
54 | | { |
55 | | .name = "size", |
56 | | .type = QEMU_OPT_SIZE, |
57 | | .help = "virtual disk size", |
58 | | }, |
59 | | { /* end of list */ } |
60 | | }, |
61 | | }; |
62 | | |
63 | | static QemuOptsList raw_create_opts = { |
64 | | .name = "raw-create-opts", |
65 | | .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head), |
66 | | .desc = { |
67 | | { |
68 | | .name = BLOCK_OPT_SIZE, |
69 | | .type = QEMU_OPT_SIZE, |
70 | | .help = "Virtual disk size" |
71 | | }, |
72 | | { /* end of list */ } |
73 | | } |
74 | | }; |
75 | | |
76 | | static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size, |
77 | | uint64_t *size, Error **errp) |
78 | 15 | { |
79 | 15 | QemuOpts *opts = NULL; |
80 | 15 | int ret; |
81 | | |
82 | 15 | opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort); |
83 | 15 | if (!qemu_opts_absorb_qdict(opts, options, errp)) { |
84 | 0 | ret = -EINVAL; |
85 | 0 | goto end; |
86 | 0 | } |
87 | | |
88 | 15 | *offset = qemu_opt_get_size(opts, "offset", 0); |
89 | 15 | *has_size = qemu_opt_find(opts, "size"); |
90 | 15 | *size = qemu_opt_get_size(opts, "size", 0); |
91 | | |
92 | 15 | ret = 0; |
93 | 15 | end: |
94 | 15 | qemu_opts_del(opts); |
95 | 15 | return ret; |
96 | 15 | } |
97 | | |
98 | | static int GRAPH_RDLOCK |
99 | | raw_apply_options(BlockDriverState *bs, BDRVRawState *s, uint64_t offset, |
100 | | bool has_size, uint64_t size, Error **errp) |
101 | 15 | { |
102 | 15 | int64_t real_size = 0; |
103 | | |
104 | 15 | real_size = bdrv_getlength(bs->file->bs); |
105 | 15 | if (real_size < 0) { |
106 | 0 | error_setg_errno(errp, -real_size, "Could not get image size"); |
107 | 0 | return real_size; |
108 | 0 | } |
109 | | |
110 | | /* Check size and offset */ |
111 | 15 | if (offset > real_size) { |
112 | 0 | error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than " |
113 | 0 | "size of the containing file (%" PRId64 ")", |
114 | 0 | offset, real_size); |
115 | 0 | return -EINVAL; |
116 | 0 | } |
117 | | |
118 | 15 | if (has_size && (real_size - offset) < size) { |
119 | 0 | error_setg(errp, "The sum of offset (%" PRIu64 ") and size " |
120 | 0 | "(%" PRIu64 ") has to be smaller or equal to the " |
121 | 0 | " actual size of the containing file (%" PRId64 ")", |
122 | 0 | offset, size, real_size); |
123 | 0 | return -EINVAL; |
124 | 0 | } |
125 | | |
126 | | /* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding |
127 | | * up and leaking out of the specified area. */ |
128 | 15 | if (has_size && !QEMU_IS_ALIGNED(size, BDRV_SECTOR_SIZE)) { |
129 | 0 | error_setg(errp, "Specified size is not multiple of %llu", |
130 | 0 | BDRV_SECTOR_SIZE); |
131 | 0 | return -EINVAL; |
132 | 0 | } |
133 | | |
134 | 15 | s->offset = offset; |
135 | 15 | s->has_size = has_size; |
136 | 15 | s->size = has_size ? size : real_size - offset; |
137 | | |
138 | 15 | return 0; |
139 | 15 | } |
140 | | |
141 | | static int raw_reopen_prepare(BDRVReopenState *reopen_state, |
142 | | BlockReopenQueue *queue, Error **errp) |
143 | 0 | { |
144 | 0 | bool has_size; |
145 | 0 | uint64_t offset, size; |
146 | 0 | int ret; |
147 | |
|
148 | 0 | GLOBAL_STATE_CODE(); |
149 | 0 | GRAPH_RDLOCK_GUARD_MAINLOOP(); |
150 | |
|
151 | 0 | assert(reopen_state != NULL); |
152 | 0 | assert(reopen_state->bs != NULL); |
153 | |
|
154 | 0 | reopen_state->opaque = g_new0(BDRVRawState, 1); |
155 | |
|
156 | 0 | ret = raw_read_options(reopen_state->options, &offset, &has_size, &size, |
157 | 0 | errp); |
158 | 0 | if (ret < 0) { |
159 | 0 | return ret; |
160 | 0 | } |
161 | | |
162 | 0 | ret = raw_apply_options(reopen_state->bs, reopen_state->opaque, |
163 | 0 | offset, has_size, size, errp); |
164 | 0 | if (ret < 0) { |
165 | 0 | return ret; |
166 | 0 | } |
167 | | |
168 | 0 | return 0; |
169 | 0 | } |
170 | | |
171 | | static void raw_reopen_commit(BDRVReopenState *state) |
172 | 0 | { |
173 | 0 | BDRVRawState *new_s = state->opaque; |
174 | 0 | BDRVRawState *s = state->bs->opaque; |
175 | |
|
176 | 0 | memcpy(s, new_s, sizeof(BDRVRawState)); |
177 | |
|
178 | 0 | g_free(state->opaque); |
179 | 0 | state->opaque = NULL; |
180 | 0 | } |
181 | | |
182 | | static void raw_reopen_abort(BDRVReopenState *state) |
183 | 0 | { |
184 | 0 | g_free(state->opaque); |
185 | 0 | state->opaque = NULL; |
186 | 0 | } |
187 | | |
188 | | /* Check and adjust the offset, against 'offset' and 'size' options. */ |
189 | | static inline int raw_adjust_offset(BlockDriverState *bs, int64_t *offset, |
190 | | int64_t bytes, bool is_write) |
191 | 20.1M | { |
192 | 20.1M | BDRVRawState *s = bs->opaque; |
193 | | |
194 | 20.1M | if (s->has_size && (*offset > s->size || bytes > (s->size - *offset))) { |
195 | | /* There's not enough space for the write, or the read request is |
196 | | * out-of-range. Don't read/write anything to prevent leaking out of |
197 | | * the size specified in options. */ |
198 | 0 | return is_write ? -ENOSPC : -EINVAL; |
199 | 0 | } |
200 | | |
201 | 20.1M | if (*offset > INT64_MAX - s->offset) { |
202 | 0 | return -EINVAL; |
203 | 0 | } |
204 | 20.1M | *offset += s->offset; |
205 | | |
206 | 20.1M | return 0; |
207 | 20.1M | } |
208 | | |
209 | | static int coroutine_fn GRAPH_RDLOCK |
210 | | raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes, |
211 | | QEMUIOVector *qiov, BdrvRequestFlags flags) |
212 | 19.3M | { |
213 | 19.3M | int ret; |
214 | | |
215 | 19.3M | ret = raw_adjust_offset(bs, &offset, bytes, false); |
216 | 19.3M | if (ret) { |
217 | 0 | return ret; |
218 | 0 | } |
219 | | |
220 | 19.3M | BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO); |
221 | 19.3M | return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags); |
222 | 19.3M | } |
223 | | |
224 | | static int coroutine_fn GRAPH_RDLOCK |
225 | | raw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes, |
226 | | QEMUIOVector *qiov, BdrvRequestFlags flags) |
227 | 808k | { |
228 | 808k | void *buf = NULL; |
229 | 808k | BlockDriver *drv; |
230 | 808k | QEMUIOVector local_qiov; |
231 | 808k | int ret; |
232 | | |
233 | 808k | if (bs->probed && offset < BLOCK_PROBE_BUF_SIZE && bytes) { |
234 | | /* Handling partial writes would be a pain - so we just |
235 | | * require that guests have 512-byte request alignment if |
236 | | * probing occurred */ |
237 | 0 | QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512); |
238 | 0 | QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512); |
239 | 0 | assert(offset == 0 && bytes >= BLOCK_PROBE_BUF_SIZE); |
240 | |
|
241 | 0 | buf = qemu_try_blockalign(bs->file->bs, 512); |
242 | 0 | if (!buf) { |
243 | 0 | ret = -ENOMEM; |
244 | 0 | goto fail; |
245 | 0 | } |
246 | | |
247 | 0 | ret = qemu_iovec_to_buf(qiov, 0, buf, 512); |
248 | 0 | if (ret != 512) { |
249 | 0 | ret = -EINVAL; |
250 | 0 | goto fail; |
251 | 0 | } |
252 | | |
253 | 0 | drv = bdrv_probe_all(buf, 512, NULL); |
254 | 0 | if (drv != bs->drv) { |
255 | 0 | ret = -EPERM; |
256 | 0 | goto fail; |
257 | 0 | } |
258 | | |
259 | | /* Use the checked buffer, a malicious guest might be overwriting its |
260 | | * original buffer in the background. */ |
261 | 0 | qemu_iovec_init(&local_qiov, qiov->niov + 1); |
262 | 0 | qemu_iovec_add(&local_qiov, buf, 512); |
263 | 0 | qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512); |
264 | 0 | qiov = &local_qiov; |
265 | |
|
266 | 0 | flags &= ~BDRV_REQ_REGISTERED_BUF; |
267 | 0 | } |
268 | | |
269 | 808k | ret = raw_adjust_offset(bs, &offset, bytes, true); |
270 | 808k | if (ret) { |
271 | 0 | goto fail; |
272 | 0 | } |
273 | | |
274 | 808k | BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO); |
275 | 808k | ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags); |
276 | | |
277 | 808k | fail: |
278 | 808k | if (qiov == &local_qiov) { |
279 | 0 | qemu_iovec_destroy(&local_qiov); |
280 | 0 | } |
281 | 808k | qemu_vfree(buf); |
282 | 808k | return ret; |
283 | 808k | } |
284 | | |
285 | | static int coroutine_fn GRAPH_RDLOCK |
286 | | raw_co_block_status(BlockDriverState *bs, unsigned int mode, |
287 | | int64_t offset, int64_t bytes, int64_t *pnum, int64_t *map, |
288 | | BlockDriverState **file) |
289 | 0 | { |
290 | 0 | BDRVRawState *s = bs->opaque; |
291 | 0 | *pnum = bytes; |
292 | 0 | *file = bs->file->bs; |
293 | 0 | *map = offset + s->offset; |
294 | 0 | return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID; |
295 | 0 | } |
296 | | |
297 | | static int coroutine_fn GRAPH_RDLOCK |
298 | | raw_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes, |
299 | | BdrvRequestFlags flags) |
300 | 466 | { |
301 | 466 | int ret; |
302 | | |
303 | 466 | ret = raw_adjust_offset(bs, &offset, bytes, true); |
304 | 466 | if (ret) { |
305 | 0 | return ret; |
306 | 0 | } |
307 | 466 | return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags); |
308 | 466 | } |
309 | | |
310 | | static int coroutine_fn GRAPH_RDLOCK |
311 | | raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes) |
312 | 0 | { |
313 | 0 | int ret; |
314 | |
|
315 | 0 | ret = raw_adjust_offset(bs, &offset, bytes, true); |
316 | 0 | if (ret) { |
317 | 0 | return ret; |
318 | 0 | } |
319 | 0 | return bdrv_co_pdiscard(bs->file, offset, bytes); |
320 | 0 | } |
321 | | |
322 | | static int coroutine_fn GRAPH_RDLOCK |
323 | | raw_co_zone_report(BlockDriverState *bs, int64_t offset, |
324 | | unsigned int *nr_zones, |
325 | | BlockZoneDescriptor *zones) |
326 | 0 | { |
327 | 0 | return bdrv_co_zone_report(bs->file->bs, offset, nr_zones, zones); |
328 | 0 | } |
329 | | |
330 | | static int coroutine_fn GRAPH_RDLOCK |
331 | | raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op, |
332 | | int64_t offset, int64_t len) |
333 | 0 | { |
334 | 0 | return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len); |
335 | 0 | } |
336 | | |
337 | | static int coroutine_fn GRAPH_RDLOCK |
338 | | raw_co_zone_append(BlockDriverState *bs,int64_t *offset, QEMUIOVector *qiov, |
339 | | BdrvRequestFlags flags) |
340 | 0 | { |
341 | 0 | return bdrv_co_zone_append(bs->file->bs, offset, qiov, flags); |
342 | 0 | } |
343 | | |
344 | | static int64_t coroutine_fn GRAPH_RDLOCK |
345 | | raw_co_getlength(BlockDriverState *bs) |
346 | 15 | { |
347 | 15 | int64_t len; |
348 | 15 | BDRVRawState *s = bs->opaque; |
349 | | |
350 | | /* Update size. It should not change unless the file was externally |
351 | | * modified. */ |
352 | 15 | len = bdrv_co_getlength(bs->file->bs); |
353 | 15 | if (len < 0) { |
354 | 0 | return len; |
355 | 0 | } |
356 | | |
357 | 15 | if (len < s->offset) { |
358 | 0 | s->size = 0; |
359 | 15 | } else { |
360 | 15 | if (s->has_size) { |
361 | | /* Try to honour the size */ |
362 | 0 | s->size = MIN(s->size, len - s->offset); |
363 | 15 | } else { |
364 | 15 | s->size = len - s->offset; |
365 | 15 | } |
366 | 15 | } |
367 | | |
368 | 15 | return s->size; |
369 | 15 | } |
370 | | |
371 | | static BlockMeasureInfo *raw_measure(QemuOpts *opts, BlockDriverState *in_bs, |
372 | | Error **errp) |
373 | 0 | { |
374 | 0 | BlockMeasureInfo *info; |
375 | 0 | int64_t required; |
376 | |
|
377 | 0 | if (in_bs) { |
378 | 0 | required = bdrv_getlength(in_bs); |
379 | 0 | if (required < 0) { |
380 | 0 | error_setg_errno(errp, -required, "Unable to get image size"); |
381 | 0 | return NULL; |
382 | 0 | } |
383 | 0 | } else { |
384 | 0 | required = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), |
385 | 0 | BDRV_SECTOR_SIZE); |
386 | 0 | } |
387 | | |
388 | 0 | info = g_new0(BlockMeasureInfo, 1); |
389 | 0 | info->required = required; |
390 | | |
391 | | /* Unallocated sectors count towards the file size in raw images */ |
392 | 0 | info->fully_allocated = info->required; |
393 | 0 | return info; |
394 | 0 | } |
395 | | |
396 | | static int coroutine_fn GRAPH_RDLOCK |
397 | | raw_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) |
398 | 0 | { |
399 | 0 | return bdrv_co_get_info(bs->file->bs, bdi); |
400 | 0 | } |
401 | | |
402 | | static void GRAPH_RDLOCK raw_refresh_limits(BlockDriverState *bs, Error **errp) |
403 | 15 | { |
404 | 15 | bs->bl.has_variable_length = bs->file->bs->bl.has_variable_length; |
405 | | |
406 | 15 | if (bs->probed) { |
407 | | /* To make it easier to protect the first sector, any probed |
408 | | * image is restricted to read-modify-write on sub-sector |
409 | | * operations. */ |
410 | 0 | bs->bl.request_alignment = BDRV_SECTOR_SIZE; |
411 | 0 | } |
412 | 15 | } |
413 | | |
414 | | static int coroutine_fn GRAPH_RDLOCK |
415 | | raw_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, |
416 | | PreallocMode prealloc, BdrvRequestFlags flags, Error **errp) |
417 | 0 | { |
418 | 0 | BDRVRawState *s = bs->opaque; |
419 | |
|
420 | 0 | if (s->has_size) { |
421 | 0 | error_setg(errp, "Cannot resize fixed-size raw disks"); |
422 | 0 | return -ENOTSUP; |
423 | 0 | } |
424 | | |
425 | 0 | if (INT64_MAX - offset < s->offset) { |
426 | 0 | error_setg(errp, "Disk size too large for the chosen offset"); |
427 | 0 | return -EINVAL; |
428 | 0 | } |
429 | | |
430 | 0 | s->size = offset; |
431 | 0 | offset += s->offset; |
432 | 0 | return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp); |
433 | 0 | } |
434 | | |
435 | | static void coroutine_fn GRAPH_RDLOCK |
436 | | raw_co_eject(BlockDriverState *bs, bool eject_flag) |
437 | 0 | { |
438 | 0 | bdrv_co_eject(bs->file->bs, eject_flag); |
439 | 0 | } |
440 | | |
441 | | static void coroutine_fn GRAPH_RDLOCK |
442 | | raw_co_lock_medium(BlockDriverState *bs, bool locked) |
443 | 29 | { |
444 | 29 | bdrv_co_lock_medium(bs->file->bs, locked); |
445 | 29 | } |
446 | | |
447 | | static int coroutine_fn GRAPH_RDLOCK |
448 | | raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) |
449 | 0 | { |
450 | 0 | BDRVRawState *s = bs->opaque; |
451 | 0 | if (s->offset || s->has_size) { |
452 | 0 | return -ENOTSUP; |
453 | 0 | } |
454 | 0 | return bdrv_co_ioctl(bs->file->bs, req, buf); |
455 | 0 | } |
456 | | |
457 | | static int GRAPH_RDLOCK raw_has_zero_init(BlockDriverState *bs) |
458 | 0 | { |
459 | 0 | return bdrv_has_zero_init(bs->file->bs); |
460 | 0 | } |
461 | | |
462 | | static int coroutine_fn GRAPH_UNLOCKED |
463 | | raw_co_create_opts(BlockDriver *drv, const char *filename, |
464 | | QemuOpts *opts, Error **errp) |
465 | 0 | { |
466 | 0 | return bdrv_co_create_file(filename, opts, true, errp); |
467 | 0 | } |
468 | | |
469 | | static int raw_open(BlockDriverState *bs, QDict *options, int flags, |
470 | | Error **errp) |
471 | 15 | { |
472 | 15 | BDRVRawState *s = bs->opaque; |
473 | 15 | bool has_size; |
474 | 15 | uint64_t offset, size; |
475 | 15 | BdrvChildRole file_role; |
476 | 15 | int ret; |
477 | | |
478 | 15 | GLOBAL_STATE_CODE(); |
479 | | |
480 | 15 | ret = raw_read_options(options, &offset, &has_size, &size, errp); |
481 | 15 | if (ret < 0) { |
482 | 0 | return ret; |
483 | 0 | } |
484 | | |
485 | | /* |
486 | | * Without offset and a size limit, this driver behaves very much |
487 | | * like a filter. With any such limit, it does not. |
488 | | */ |
489 | 15 | if (offset || has_size) { |
490 | 0 | file_role = BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY; |
491 | 15 | } else { |
492 | 15 | file_role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY; |
493 | 15 | } |
494 | | |
495 | 15 | bdrv_open_child(NULL, options, "file", bs, &child_of_bds, |
496 | 15 | file_role, false, errp); |
497 | | |
498 | 15 | GRAPH_RDLOCK_GUARD_MAINLOOP(); |
499 | 15 | if (!bs->file) { |
500 | 0 | return -EINVAL; |
501 | 0 | } |
502 | | |
503 | 15 | bs->sg = bdrv_is_sg(bs->file->bs); |
504 | 15 | bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED | |
505 | 15 | (BDRV_REQ_FUA & bs->file->bs->supported_write_flags); |
506 | 15 | bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED | |
507 | 15 | ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) & |
508 | 15 | bs->file->bs->supported_zero_flags); |
509 | 15 | bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags & |
510 | 15 | BDRV_REQ_ZERO_WRITE; |
511 | | |
512 | 15 | if (bs->probed && !bdrv_is_read_only(bs)) { |
513 | 0 | bdrv_refresh_filename(bs->file->bs); |
514 | 0 | fprintf(stderr, |
515 | 0 | "WARNING: Image format was not specified for '%s' and probing " |
516 | 0 | "guessed raw.\n" |
517 | 0 | " Automatically detecting the format is dangerous for " |
518 | 0 | "raw images, write operations on block 0 will be restricted.\n" |
519 | 0 | " Specify the 'raw' format explicitly to remove the " |
520 | 0 | "restrictions.\n", |
521 | 0 | bs->file->bs->filename); |
522 | 0 | } |
523 | | |
524 | 15 | ret = raw_apply_options(bs, s, offset, has_size, size, errp); |
525 | 15 | if (ret < 0) { |
526 | 0 | return ret; |
527 | 0 | } |
528 | | |
529 | 15 | if (bdrv_is_sg(bs) && (s->offset || s->has_size)) { |
530 | 0 | error_setg(errp, "Cannot use offset/size with SCSI generic devices"); |
531 | 0 | return -EINVAL; |
532 | 0 | } |
533 | | |
534 | 15 | return 0; |
535 | 15 | } |
536 | | |
537 | | static int raw_probe(const uint8_t *buf, int buf_size, const char *filename) |
538 | 0 | { |
539 | | /* smallest possible positive score so that raw is used if and only if no |
540 | | * other block driver works |
541 | | */ |
542 | 0 | return 1; |
543 | 0 | } |
544 | | |
545 | | static int GRAPH_RDLOCK |
546 | | raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) |
547 | 20 | { |
548 | 20 | BDRVRawState *s = bs->opaque; |
549 | 20 | int ret; |
550 | | |
551 | 20 | ret = bdrv_probe_blocksizes(bs->file->bs, bsz); |
552 | 20 | if (ret < 0) { |
553 | 20 | return ret; |
554 | 20 | } |
555 | | |
556 | 0 | if (!QEMU_IS_ALIGNED(s->offset, MAX(bsz->log, bsz->phys))) { |
557 | 0 | return -ENOTSUP; |
558 | 0 | } |
559 | | |
560 | 0 | return 0; |
561 | 0 | } |
562 | | |
563 | | static int GRAPH_RDLOCK |
564 | | raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo) |
565 | 10 | { |
566 | 10 | BDRVRawState *s = bs->opaque; |
567 | 10 | if (s->offset || s->has_size) { |
568 | 0 | return -ENOTSUP; |
569 | 0 | } |
570 | 10 | return bdrv_probe_geometry(bs->file->bs, geo); |
571 | 10 | } |
572 | | |
573 | | static int coroutine_fn GRAPH_RDLOCK |
574 | | raw_co_copy_range_from(BlockDriverState *bs, |
575 | | BdrvChild *src, int64_t src_offset, |
576 | | BdrvChild *dst, int64_t dst_offset, |
577 | | int64_t bytes, BdrvRequestFlags read_flags, |
578 | | BdrvRequestFlags write_flags) |
579 | 0 | { |
580 | 0 | int ret; |
581 | |
|
582 | 0 | ret = raw_adjust_offset(bs, &src_offset, bytes, false); |
583 | 0 | if (ret) { |
584 | 0 | return ret; |
585 | 0 | } |
586 | 0 | return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset, |
587 | 0 | bytes, read_flags, write_flags); |
588 | 0 | } |
589 | | |
590 | | static int coroutine_fn GRAPH_RDLOCK |
591 | | raw_co_copy_range_to(BlockDriverState *bs, |
592 | | BdrvChild *src, int64_t src_offset, |
593 | | BdrvChild *dst, int64_t dst_offset, |
594 | | int64_t bytes, BdrvRequestFlags read_flags, |
595 | | BdrvRequestFlags write_flags) |
596 | 0 | { |
597 | 0 | int ret; |
598 | |
|
599 | 0 | ret = raw_adjust_offset(bs, &dst_offset, bytes, true); |
600 | 0 | if (ret) { |
601 | 0 | return ret; |
602 | 0 | } |
603 | 0 | return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes, |
604 | 0 | read_flags, write_flags); |
605 | 0 | } |
606 | | |
607 | | static const char *const raw_strong_runtime_opts[] = { |
608 | | "offset", |
609 | | "size", |
610 | | |
611 | | NULL |
612 | | }; |
613 | | |
614 | | static void GRAPH_RDLOCK raw_cancel_in_flight(BlockDriverState *bs) |
615 | 0 | { |
616 | 0 | bdrv_cancel_in_flight(bs->file->bs); |
617 | 0 | } |
618 | | |
619 | | static void raw_child_perm(BlockDriverState *bs, BdrvChild *c, |
620 | | BdrvChildRole role, |
621 | | BlockReopenQueue *reopen_queue, |
622 | | uint64_t parent_perm, uint64_t parent_shared, |
623 | | uint64_t *nperm, uint64_t *nshared) |
624 | 62 | { |
625 | 62 | bdrv_default_perms(bs, c, role, reopen_queue, parent_perm, |
626 | 62 | parent_shared, nperm, nshared); |
627 | | |
628 | | /* |
629 | | * bdrv_default_perms() may add WRITE and/or RESIZE (see comment in |
630 | | * bdrv_default_perms_for_storage() for an explanation) but we only need |
631 | | * them if they are in parent_perm. Drop WRITE and RESIZE whenever possible |
632 | | * to avoid permission conflicts. |
633 | | */ |
634 | 62 | *nperm &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE); |
635 | 62 | *nperm |= parent_perm & (BLK_PERM_WRITE | BLK_PERM_RESIZE); |
636 | 62 | } |
637 | | |
638 | | BlockDriver bdrv_raw = { |
639 | | .format_name = "raw", |
640 | | .instance_size = sizeof(BDRVRawState), |
641 | | .supports_zoned_children = true, |
642 | | .bdrv_probe = &raw_probe, |
643 | | .bdrv_reopen_prepare = &raw_reopen_prepare, |
644 | | .bdrv_reopen_commit = &raw_reopen_commit, |
645 | | .bdrv_reopen_abort = &raw_reopen_abort, |
646 | | .bdrv_open = &raw_open, |
647 | | .bdrv_child_perm = raw_child_perm, |
648 | | .bdrv_co_create_opts = &raw_co_create_opts, |
649 | | .bdrv_co_preadv = &raw_co_preadv, |
650 | | .bdrv_co_pwritev = &raw_co_pwritev, |
651 | | .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes, |
652 | | .bdrv_co_pdiscard = &raw_co_pdiscard, |
653 | | .bdrv_co_zone_report = &raw_co_zone_report, |
654 | | .bdrv_co_zone_mgmt = &raw_co_zone_mgmt, |
655 | | .bdrv_co_zone_append = &raw_co_zone_append, |
656 | | .bdrv_co_block_status = &raw_co_block_status, |
657 | | .bdrv_co_copy_range_from = &raw_co_copy_range_from, |
658 | | .bdrv_co_copy_range_to = &raw_co_copy_range_to, |
659 | | .bdrv_co_truncate = &raw_co_truncate, |
660 | | .bdrv_co_getlength = &raw_co_getlength, |
661 | | .is_format = true, |
662 | | .bdrv_measure = &raw_measure, |
663 | | .bdrv_co_get_info = &raw_co_get_info, |
664 | | .bdrv_refresh_limits = &raw_refresh_limits, |
665 | | .bdrv_probe_blocksizes = &raw_probe_blocksizes, |
666 | | .bdrv_probe_geometry = &raw_probe_geometry, |
667 | | .bdrv_co_eject = &raw_co_eject, |
668 | | .bdrv_co_lock_medium = &raw_co_lock_medium, |
669 | | .bdrv_co_ioctl = &raw_co_ioctl, |
670 | | .create_opts = &raw_create_opts, |
671 | | .bdrv_has_zero_init = &raw_has_zero_init, |
672 | | .strong_runtime_opts = raw_strong_runtime_opts, |
673 | | .mutable_opts = mutable_opts, |
674 | | .bdrv_cancel_in_flight = raw_cancel_in_flight, |
675 | | }; |
676 | | |
677 | | static void bdrv_raw_init(void) |
678 | 63 | { |
679 | 63 | bdrv_register(&bdrv_raw); |
680 | 63 | } |
681 | | |
682 | | block_init(bdrv_raw_init); |