2 * Common code for block device models
4 * Copyright (C) 2012 Red Hat, Inc.
6 * This work is licensed under the terms of the GNU GPL, version 2 or
7 * later. See the COPYING file in the top-level directory.
10 #include "qemu/osdep.h"
11 #include "sysemu/blockdev.h"
12 #include "sysemu/block-backend.h"
13 #include "hw/block/block.h"
14 #include "qapi/error.h"
15 #include "qapi/qapi-types-block.h"
18 * Read the entire contents of @blk into @buf.
19 * @blk's contents must be @size bytes, and @size must be at most
20 * BDRV_REQUEST_MAX_BYTES.
21 * On success, return true.
22 * On failure, store an error through @errp and return false.
23 * Note that the error messages do not identify the block backend.
24 * TODO Since callers don't either, this can result in confusing
26 * This function not intended for actual block devices, which read on
27 * demand. It's for things like memory devices that (ab)use a block
28 * backend to provide persistence.
30 bool blk_check_size_and_read_all(BlockBackend
*blk
, void *buf
, hwaddr size
,
36 blk_len
= blk_getlength(blk
);
38 error_setg_errno(errp
, -blk_len
,
39 "can't get size of block backend");
42 if (blk_len
!= size
) {
43 error_setg(errp
, "device requires %" HWADDR_PRIu
" bytes, "
44 "block backend provides %" PRIu64
" bytes",
50 * We could loop for @size > BDRV_REQUEST_MAX_BYTES, but if we
51 * ever get to the point we want to read *gigabytes* here, we
52 * should probably rework the device to be more like an actual
53 * block device and read only on demand.
55 assert(size
<= BDRV_REQUEST_MAX_BYTES
);
56 ret
= blk_pread(blk
, 0, buf
, size
);
58 error_setg_errno(errp
, -ret
, "can't read block backend");
64 bool blkconf_blocksizes(BlockConf
*conf
, Error
**errp
)
66 BlockBackend
*blk
= conf
->blk
;
67 BlockSizes blocksizes
;
72 switch (conf
->backend_defaults
) {
73 case ON_OFF_AUTO_AUTO
:
74 use_blocksizes
= !blk_probe_blocksizes(blk
, &blocksizes
);
79 use_blocksizes
= !blk_probe_blocksizes(blk
, &blocksizes
);
85 use_blocksizes
= false;
93 /* fill in detected values if they are not defined via qemu command line */
94 if (!conf
->physical_block_size
) {
96 conf
->physical_block_size
= blocksizes
.phys
;
98 conf
->physical_block_size
= BDRV_SECTOR_SIZE
;
101 if (!conf
->logical_block_size
) {
102 if (use_blocksizes
) {
103 conf
->logical_block_size
= blocksizes
.log
;
105 conf
->logical_block_size
= BDRV_SECTOR_SIZE
;
109 if (!conf
->opt_io_size
) {
110 conf
->opt_io_size
= bs
->bl
.opt_transfer
;
112 if (conf
->discard_granularity
== -1) {
113 if (bs
->bl
.pdiscard_alignment
) {
114 conf
->discard_granularity
= bs
->bl
.pdiscard_alignment
;
115 } else if (bs
->bl
.request_alignment
!= 1) {
116 conf
->discard_granularity
= bs
->bl
.request_alignment
;
121 if (conf
->logical_block_size
> conf
->physical_block_size
) {
123 "logical_block_size > physical_block_size not supported");
127 if (!QEMU_IS_ALIGNED(conf
->min_io_size
, conf
->logical_block_size
)) {
129 "min_io_size must be a multiple of logical_block_size");
134 * all devices which support min_io_size (scsi and virtio-blk) expose it to
135 * the guest as a uint16_t in units of logical blocks
137 if (conf
->min_io_size
/ conf
->logical_block_size
> UINT16_MAX
) {
138 error_setg(errp
, "min_io_size must not exceed %u logical blocks",
143 if (!QEMU_IS_ALIGNED(conf
->opt_io_size
, conf
->logical_block_size
)) {
145 "opt_io_size must be a multiple of logical_block_size");
149 if (conf
->discard_granularity
!= -1 &&
150 !QEMU_IS_ALIGNED(conf
->discard_granularity
,
151 conf
->logical_block_size
)) {
152 error_setg(errp
, "discard_granularity must be "
153 "a multiple of logical_block_size");
160 bool blkconf_apply_backend_options(BlockConf
*conf
, bool readonly
,
161 bool resizable
, Error
**errp
)
163 BlockBackend
*blk
= conf
->blk
;
164 BlockdevOnError rerror
, werror
;
165 uint64_t perm
, shared_perm
;
169 perm
= BLK_PERM_CONSISTENT_READ
;
171 perm
|= BLK_PERM_WRITE
;
174 shared_perm
= BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE_UNCHANGED
|
177 shared_perm
|= BLK_PERM_RESIZE
;
179 if (conf
->share_rw
) {
180 shared_perm
|= BLK_PERM_WRITE
;
183 ret
= blk_set_perm(blk
, perm
, shared_perm
, errp
);
189 case ON_OFF_AUTO_ON
: wce
= true; break;
190 case ON_OFF_AUTO_OFF
: wce
= false; break;
191 case ON_OFF_AUTO_AUTO
: wce
= blk_enable_write_cache(blk
); break;
196 rerror
= conf
->rerror
;
197 if (rerror
== BLOCKDEV_ON_ERROR_AUTO
) {
198 rerror
= blk_get_on_error(blk
, true);
201 werror
= conf
->werror
;
202 if (werror
== BLOCKDEV_ON_ERROR_AUTO
) {
203 werror
= blk_get_on_error(blk
, false);
206 blk_set_enable_write_cache(blk
, wce
);
207 blk_set_on_error(blk
, rerror
, werror
);
212 bool blkconf_geometry(BlockConf
*conf
, int *ptrans
,
213 unsigned cyls_max
, unsigned heads_max
, unsigned secs_max
,
216 if (!conf
->cyls
&& !conf
->heads
&& !conf
->secs
) {
217 hd_geometry_guess(conf
->blk
,
218 &conf
->cyls
, &conf
->heads
, &conf
->secs
,
220 } else if (ptrans
&& *ptrans
== BIOS_ATA_TRANSLATION_AUTO
) {
221 *ptrans
= hd_bios_chs_auto_trans(conf
->cyls
, conf
->heads
, conf
->secs
);
223 if (conf
->cyls
|| conf
->heads
|| conf
->secs
) {
224 if (conf
->cyls
< 1 || conf
->cyls
> cyls_max
) {
225 error_setg(errp
, "cyls must be between 1 and %u", cyls_max
);
228 if (conf
->heads
< 1 || conf
->heads
> heads_max
) {
229 error_setg(errp
, "heads must be between 1 and %u", heads_max
);
232 if (conf
->secs
< 1 || conf
->secs
> secs_max
) {
233 error_setg(errp
, "secs must be between 1 and %u", secs_max
);