1 /* BlockDriver implementation for "raw" format driver
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>
8 * Laszlo Ersek <lersek@redhat.com>
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:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
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
29 #include "qemu/osdep.h"
30 #include "block/block_int.h"
31 #include "qapi/error.h"
32 #include "qemu/module.h"
33 #include "qemu/option.h"
35 typedef struct BDRVRawState
{
41 static const char *const mutable_opts
[] = { "offset", "size", NULL
};
43 static QemuOptsList raw_runtime_opts
= {
45 .head
= QTAILQ_HEAD_INITIALIZER(raw_runtime_opts
.head
),
49 .type
= QEMU_OPT_SIZE
,
50 .help
= "offset in the disk where the image starts",
54 .type
= QEMU_OPT_SIZE
,
55 .help
= "virtual disk size",
61 static QemuOptsList raw_create_opts
= {
62 .name
= "raw-create-opts",
63 .head
= QTAILQ_HEAD_INITIALIZER(raw_create_opts
.head
),
66 .name
= BLOCK_OPT_SIZE
,
67 .type
= QEMU_OPT_SIZE
,
68 .help
= "Virtual disk size"
74 static int raw_read_options(QDict
*options
, uint64_t *offset
, bool *has_size
,
75 uint64_t *size
, Error
**errp
)
77 Error
*local_err
= NULL
;
78 QemuOpts
*opts
= NULL
;
81 opts
= qemu_opts_create(&raw_runtime_opts
, NULL
, 0, &error_abort
);
82 if (!qemu_opts_absorb_qdict(opts
, options
, &local_err
)) {
83 error_propagate(errp
, local_err
);
88 *offset
= qemu_opt_get_size(opts
, "offset", 0);
89 *has_size
= qemu_opt_find(opts
, "size");
90 *size
= qemu_opt_get_size(opts
, "size", 0);
98 static int raw_apply_options(BlockDriverState
*bs
, BDRVRawState
*s
,
99 uint64_t offset
, bool has_size
, uint64_t size
,
102 int64_t real_size
= 0;
104 real_size
= bdrv_getlength(bs
->file
->bs
);
106 error_setg_errno(errp
, -real_size
, "Could not get image size");
110 /* Check size and offset */
111 if (offset
> real_size
) {
112 error_setg(errp
, "Offset (%" PRIu64
") cannot be greater than "
113 "size of the containing file (%" PRId64
")",
114 s
->offset
, real_size
);
118 if (has_size
&& (real_size
- offset
) < size
) {
119 error_setg(errp
, "The sum of offset (%" PRIu64
") and size "
120 "(%" PRIu64
") has to be smaller or equal to the "
121 " actual size of the containing file (%" PRId64
")",
122 s
->offset
, s
->size
, real_size
);
126 /* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding
127 * up and leaking out of the specified area. */
128 if (has_size
&& !QEMU_IS_ALIGNED(size
, BDRV_SECTOR_SIZE
)) {
129 error_setg(errp
, "Specified size is not multiple of %llu",
135 s
->has_size
= has_size
;
136 s
->size
= has_size
? size
: real_size
- offset
;
141 static int raw_reopen_prepare(BDRVReopenState
*reopen_state
,
142 BlockReopenQueue
*queue
, Error
**errp
)
145 uint64_t offset
, size
;
148 assert(reopen_state
!= NULL
);
149 assert(reopen_state
->bs
!= NULL
);
151 reopen_state
->opaque
= g_new0(BDRVRawState
, 1);
153 ret
= raw_read_options(reopen_state
->options
, &offset
, &has_size
, &size
,
159 ret
= raw_apply_options(reopen_state
->bs
, reopen_state
->opaque
,
160 offset
, has_size
, size
, errp
);
168 static void raw_reopen_commit(BDRVReopenState
*state
)
170 BDRVRawState
*new_s
= state
->opaque
;
171 BDRVRawState
*s
= state
->bs
->opaque
;
173 memcpy(s
, new_s
, sizeof(BDRVRawState
));
175 g_free(state
->opaque
);
176 state
->opaque
= NULL
;
179 static void raw_reopen_abort(BDRVReopenState
*state
)
181 g_free(state
->opaque
);
182 state
->opaque
= NULL
;
185 /* Check and adjust the offset, against 'offset' and 'size' options. */
186 static inline int raw_adjust_offset(BlockDriverState
*bs
, uint64_t *offset
,
187 uint64_t bytes
, bool is_write
)
189 BDRVRawState
*s
= bs
->opaque
;
191 if (s
->has_size
&& (*offset
> s
->size
|| bytes
> (s
->size
- *offset
))) {
192 /* There's not enough space for the write, or the read request is
193 * out-of-range. Don't read/write anything to prevent leaking out of
194 * the size specified in options. */
195 return is_write
? -ENOSPC
: -EINVAL
;
198 if (*offset
> INT64_MAX
- s
->offset
) {
201 *offset
+= s
->offset
;
206 static int coroutine_fn
raw_co_preadv(BlockDriverState
*bs
, uint64_t offset
,
207 uint64_t bytes
, QEMUIOVector
*qiov
,
212 ret
= raw_adjust_offset(bs
, &offset
, bytes
, false);
217 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
218 return bdrv_co_preadv(bs
->file
, offset
, bytes
, qiov
, flags
);
221 static int coroutine_fn
raw_co_pwritev(BlockDriverState
*bs
, uint64_t offset
,
222 uint64_t bytes
, QEMUIOVector
*qiov
,
227 QEMUIOVector local_qiov
;
230 if (bs
->probed
&& offset
< BLOCK_PROBE_BUF_SIZE
&& bytes
) {
231 /* Handling partial writes would be a pain - so we just
232 * require that guests have 512-byte request alignment if
233 * probing occurred */
234 QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE
!= 512);
235 QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE
!= 512);
236 assert(offset
== 0 && bytes
>= BLOCK_PROBE_BUF_SIZE
);
238 buf
= qemu_try_blockalign(bs
->file
->bs
, 512);
244 ret
= qemu_iovec_to_buf(qiov
, 0, buf
, 512);
250 drv
= bdrv_probe_all(buf
, 512, NULL
);
251 if (drv
!= bs
->drv
) {
256 /* Use the checked buffer, a malicious guest might be overwriting its
257 * original buffer in the background. */
258 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
259 qemu_iovec_add(&local_qiov
, buf
, 512);
260 qemu_iovec_concat(&local_qiov
, qiov
, 512, qiov
->size
- 512);
264 ret
= raw_adjust_offset(bs
, &offset
, bytes
, true);
269 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
270 ret
= bdrv_co_pwritev(bs
->file
, offset
, bytes
, qiov
, flags
);
273 if (qiov
== &local_qiov
) {
274 qemu_iovec_destroy(&local_qiov
);
280 static int coroutine_fn
raw_co_block_status(BlockDriverState
*bs
,
281 bool want_zero
, int64_t offset
,
282 int64_t bytes
, int64_t *pnum
,
284 BlockDriverState
**file
)
286 BDRVRawState
*s
= bs
->opaque
;
288 *file
= bs
->file
->bs
;
289 *map
= offset
+ s
->offset
;
290 return BDRV_BLOCK_RAW
| BDRV_BLOCK_OFFSET_VALID
;
293 static int coroutine_fn
raw_co_pwrite_zeroes(BlockDriverState
*bs
,
294 int64_t offset
, int bytes
,
295 BdrvRequestFlags flags
)
299 ret
= raw_adjust_offset(bs
, (uint64_t *)&offset
, bytes
, true);
303 return bdrv_co_pwrite_zeroes(bs
->file
, offset
, bytes
, flags
);
306 static int coroutine_fn
raw_co_pdiscard(BlockDriverState
*bs
,
307 int64_t offset
, int bytes
)
311 ret
= raw_adjust_offset(bs
, (uint64_t *)&offset
, bytes
, true);
315 return bdrv_co_pdiscard(bs
->file
, offset
, bytes
);
318 static int64_t raw_getlength(BlockDriverState
*bs
)
321 BDRVRawState
*s
= bs
->opaque
;
323 /* Update size. It should not change unless the file was externally
325 len
= bdrv_getlength(bs
->file
->bs
);
330 if (len
< s
->offset
) {
334 /* Try to honour the size */
335 s
->size
= MIN(s
->size
, len
- s
->offset
);
337 s
->size
= len
- s
->offset
;
344 static BlockMeasureInfo
*raw_measure(QemuOpts
*opts
, BlockDriverState
*in_bs
,
347 BlockMeasureInfo
*info
;
351 required
= bdrv_getlength(in_bs
);
353 error_setg_errno(errp
, -required
, "Unable to get image size");
357 required
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
361 info
= g_new0(BlockMeasureInfo
, 1);
362 info
->required
= required
;
364 /* Unallocated sectors count towards the file size in raw images */
365 info
->fully_allocated
= info
->required
;
369 static int raw_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
371 return bdrv_get_info(bs
->file
->bs
, bdi
);
374 static void raw_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
377 /* To make it easier to protect the first sector, any probed
378 * image is restricted to read-modify-write on sub-sector
380 bs
->bl
.request_alignment
= BDRV_SECTOR_SIZE
;
384 static int coroutine_fn
raw_co_truncate(BlockDriverState
*bs
, int64_t offset
,
385 bool exact
, PreallocMode prealloc
,
386 BdrvRequestFlags flags
, Error
**errp
)
388 BDRVRawState
*s
= bs
->opaque
;
391 error_setg(errp
, "Cannot resize fixed-size raw disks");
395 if (INT64_MAX
- offset
< s
->offset
) {
396 error_setg(errp
, "Disk size too large for the chosen offset");
402 return bdrv_co_truncate(bs
->file
, offset
, exact
, prealloc
, flags
, errp
);
405 static void raw_eject(BlockDriverState
*bs
, bool eject_flag
)
407 bdrv_eject(bs
->file
->bs
, eject_flag
);
410 static void raw_lock_medium(BlockDriverState
*bs
, bool locked
)
412 bdrv_lock_medium(bs
->file
->bs
, locked
);
415 static int raw_co_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
417 BDRVRawState
*s
= bs
->opaque
;
418 if (s
->offset
|| s
->has_size
) {
421 return bdrv_co_ioctl(bs
->file
->bs
, req
, buf
);
424 static int raw_has_zero_init(BlockDriverState
*bs
)
426 return bdrv_has_zero_init(bs
->file
->bs
);
429 static int coroutine_fn
raw_co_create_opts(BlockDriver
*drv
,
430 const char *filename
,
434 return bdrv_create_file(filename
, opts
, errp
);
437 static int raw_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
440 BDRVRawState
*s
= bs
->opaque
;
442 uint64_t offset
, size
;
443 BdrvChildRole file_role
;
446 ret
= raw_read_options(options
, &offset
, &has_size
, &size
, errp
);
452 * Without offset and a size limit, this driver behaves very much
453 * like a filter. With any such limit, it does not.
455 if (offset
|| has_size
) {
456 file_role
= BDRV_CHILD_DATA
| BDRV_CHILD_PRIMARY
;
458 file_role
= BDRV_CHILD_FILTERED
| BDRV_CHILD_PRIMARY
;
461 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_of_bds
,
462 file_role
, false, errp
);
467 bs
->sg
= bs
->file
->bs
->sg
;
468 bs
->supported_write_flags
= BDRV_REQ_WRITE_UNCHANGED
|
469 (BDRV_REQ_FUA
& bs
->file
->bs
->supported_write_flags
);
470 bs
->supported_zero_flags
= BDRV_REQ_WRITE_UNCHANGED
|
471 ((BDRV_REQ_FUA
| BDRV_REQ_MAY_UNMAP
| BDRV_REQ_NO_FALLBACK
) &
472 bs
->file
->bs
->supported_zero_flags
);
473 bs
->supported_truncate_flags
= bs
->file
->bs
->supported_truncate_flags
&
476 if (bs
->probed
&& !bdrv_is_read_only(bs
)) {
477 bdrv_refresh_filename(bs
->file
->bs
);
479 "WARNING: Image format was not specified for '%s' and probing "
481 " Automatically detecting the format is dangerous for "
482 "raw images, write operations on block 0 will be restricted.\n"
483 " Specify the 'raw' format explicitly to remove the "
485 bs
->file
->bs
->filename
);
488 ret
= raw_apply_options(bs
, s
, offset
, has_size
, size
, errp
);
493 if (bs
->sg
&& (s
->offset
|| s
->has_size
)) {
494 error_setg(errp
, "Cannot use offset/size with SCSI generic devices");
501 static int raw_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
503 /* smallest possible positive score so that raw is used if and only if no
504 * other block driver works
509 static int raw_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
511 BDRVRawState
*s
= bs
->opaque
;
514 ret
= bdrv_probe_blocksizes(bs
->file
->bs
, bsz
);
519 if (!QEMU_IS_ALIGNED(s
->offset
, MAX(bsz
->log
, bsz
->phys
))) {
526 static int raw_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
528 BDRVRawState
*s
= bs
->opaque
;
529 if (s
->offset
|| s
->has_size
) {
532 return bdrv_probe_geometry(bs
->file
->bs
, geo
);
535 static int coroutine_fn
raw_co_copy_range_from(BlockDriverState
*bs
,
541 BdrvRequestFlags read_flags
,
542 BdrvRequestFlags write_flags
)
546 ret
= raw_adjust_offset(bs
, &src_offset
, bytes
, false);
550 return bdrv_co_copy_range_from(bs
->file
, src_offset
, dst
, dst_offset
,
551 bytes
, read_flags
, write_flags
);
554 static int coroutine_fn
raw_co_copy_range_to(BlockDriverState
*bs
,
560 BdrvRequestFlags read_flags
,
561 BdrvRequestFlags write_flags
)
565 ret
= raw_adjust_offset(bs
, &dst_offset
, bytes
, true);
569 return bdrv_co_copy_range_to(src
, src_offset
, bs
->file
, dst_offset
, bytes
,
570 read_flags
, write_flags
);
573 static const char *const raw_strong_runtime_opts
[] = {
580 BlockDriver bdrv_raw
= {
581 .format_name
= "raw",
582 .instance_size
= sizeof(BDRVRawState
),
583 .bdrv_probe
= &raw_probe
,
584 .bdrv_reopen_prepare
= &raw_reopen_prepare
,
585 .bdrv_reopen_commit
= &raw_reopen_commit
,
586 .bdrv_reopen_abort
= &raw_reopen_abort
,
587 .bdrv_open
= &raw_open
,
588 .bdrv_child_perm
= bdrv_default_perms
,
589 .bdrv_co_create_opts
= &raw_co_create_opts
,
590 .bdrv_co_preadv
= &raw_co_preadv
,
591 .bdrv_co_pwritev
= &raw_co_pwritev
,
592 .bdrv_co_pwrite_zeroes
= &raw_co_pwrite_zeroes
,
593 .bdrv_co_pdiscard
= &raw_co_pdiscard
,
594 .bdrv_co_block_status
= &raw_co_block_status
,
595 .bdrv_co_copy_range_from
= &raw_co_copy_range_from
,
596 .bdrv_co_copy_range_to
= &raw_co_copy_range_to
,
597 .bdrv_co_truncate
= &raw_co_truncate
,
598 .bdrv_getlength
= &raw_getlength
,
600 .has_variable_length
= true,
601 .bdrv_measure
= &raw_measure
,
602 .bdrv_get_info
= &raw_get_info
,
603 .bdrv_refresh_limits
= &raw_refresh_limits
,
604 .bdrv_probe_blocksizes
= &raw_probe_blocksizes
,
605 .bdrv_probe_geometry
= &raw_probe_geometry
,
606 .bdrv_eject
= &raw_eject
,
607 .bdrv_lock_medium
= &raw_lock_medium
,
608 .bdrv_co_ioctl
= &raw_co_ioctl
,
609 .create_opts
= &raw_create_opts
,
610 .bdrv_has_zero_init
= &raw_has_zero_init
,
611 .strong_runtime_opts
= raw_strong_runtime_opts
,
612 .mutable_opts
= mutable_opts
,
615 static void bdrv_raw_init(void)
617 bdrv_register(&bdrv_raw
);
620 block_init(bdrv_raw_init
);