jcs.org / qemu
qemu with hax to log dma reads & writes jcs.org/2018/11/12/vfio
fork atom

block: consolidate blocksize properties consistency checks

Several block device properties related to blocksize configuration must
be in certain relationship WRT each other: physical block must be no
smaller than logical block; min_io_size, opt_io_size, and
discard_granularity must be a multiple of a logical block.

To ensure these requirements are met, add corresponding consistency
checks to blkconf_blocksizes, adjusting its signature to communicate
possible error to the caller. Also remove the now redundant consistency
checks from the specific devices.

Signed-off-by: Roman Kagan <rvkagan@yandex-team.ru>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paul Durrant <paul@xen.org>
Message-Id: <20200528225516.1676602-3-rvkagan@yandex-team.ru>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>

authored by

Roman Kagan and committed by
Kevin Wolf c56ee92f 6abee260

+57 -26
+29 -1
hw/block/block.c
··· 61 61 return true; 62 62 } 63 63 64 - void blkconf_blocksizes(BlockConf *conf) 64 + bool blkconf_blocksizes(BlockConf *conf, Error **errp) 65 65 { 66 66 BlockBackend *blk = conf->blk; 67 67 BlockSizes blocksizes; ··· 83 83 conf->logical_block_size = BDRV_SECTOR_SIZE; 84 84 } 85 85 } 86 + 87 + if (conf->logical_block_size > conf->physical_block_size) { 88 + error_setg(errp, 89 + "logical_block_size > physical_block_size not supported"); 90 + return false; 91 + } 92 + 93 + if (!QEMU_IS_ALIGNED(conf->min_io_size, conf->logical_block_size)) { 94 + error_setg(errp, 95 + "min_io_size must be a multiple of logical_block_size"); 96 + return false; 97 + } 98 + 99 + if (!QEMU_IS_ALIGNED(conf->opt_io_size, conf->logical_block_size)) { 100 + error_setg(errp, 101 + "opt_io_size must be a multiple of logical_block_size"); 102 + return false; 103 + } 104 + 105 + if (conf->discard_granularity != -1 && 106 + !QEMU_IS_ALIGNED(conf->discard_granularity, 107 + conf->logical_block_size)) { 108 + error_setg(errp, "discard_granularity must be " 109 + "a multiple of logical_block_size"); 110 + return false; 111 + } 112 + 113 + return true; 86 114 } 87 115 88 116 bool blkconf_apply_backend_options(BlockConf *conf, bool readonly,
+4 -1
hw/block/fdc.c
··· 554 554 read_only = !blk_bs(dev->conf.blk) || blk_is_read_only(dev->conf.blk); 555 555 } 556 556 557 - blkconf_blocksizes(&dev->conf); 557 + if (!blkconf_blocksizes(&dev->conf, errp)) { 558 + return; 559 + } 560 + 558 561 if (dev->conf.logical_block_size != 512 || 559 562 dev->conf.physical_block_size != 512) 560 563 {
+3 -1
hw/block/nvme.c
··· 1425 1425 1426 1426 static void nvme_init_blk(NvmeCtrl *n, Error **errp) 1427 1427 { 1428 - blkconf_blocksizes(&n->conf); 1428 + if (!blkconf_blocksizes(&n->conf, errp)) { 1429 + return; 1430 + } 1429 1431 blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk), 1430 1432 false, errp); 1431 1433 }
+4 -1
hw/block/swim.c
··· 189 189 assert(ret == 0); 190 190 } 191 191 192 - blkconf_blocksizes(&dev->conf); 192 + if (!blkconf_blocksizes(&dev->conf, errp)) { 193 + return; 194 + } 195 + 193 196 if (dev->conf.logical_block_size != 512 || 194 197 dev->conf.physical_block_size != 512) 195 198 {
+1 -6
hw/block/virtio-blk.c
··· 1174 1174 return; 1175 1175 } 1176 1176 1177 - blkconf_blocksizes(&conf->conf); 1178 - 1179 - if (conf->conf.logical_block_size > 1180 - conf->conf.physical_block_size) { 1181 - error_setg(errp, 1182 - "logical_block_size > physical_block_size not supported"); 1177 + if (!blkconf_blocksizes(&conf->conf, errp)) { 1183 1178 return; 1184 1179 } 1185 1180
+1 -5
hw/block/xen-block.c
··· 239 239 return; 240 240 } 241 241 242 - blkconf_blocksizes(conf); 243 - 244 - if (conf->logical_block_size > conf->physical_block_size) { 245 - error_setg( 246 - errp, "logical_block_size > physical_block_size not supported"); 242 + if (!blkconf_blocksizes(conf, errp)) { 247 243 return; 248 244 } 249 245
+4 -1
hw/ide/qdev.c
··· 187 187 return; 188 188 } 189 189 190 - blkconf_blocksizes(&dev->conf); 190 + if (!blkconf_blocksizes(&dev->conf, errp)) { 191 + return; 192 + } 193 + 191 194 if (dev->conf.logical_block_size != 512) { 192 195 error_setg(errp, "logical_block_size must be 512 for IDE"); 193 196 return;
+5 -7
hw/scsi/scsi-disk.c
··· 2346 2346 return; 2347 2347 } 2348 2348 2349 - blkconf_blocksizes(&s->qdev.conf); 2350 - 2351 - if (s->qdev.conf.logical_block_size > 2352 - s->qdev.conf.physical_block_size) { 2353 - error_setg(errp, 2354 - "logical_block_size > physical_block_size not supported"); 2349 + if (!blkconf_blocksizes(&s->qdev.conf, errp)) { 2355 2350 return; 2356 2351 } 2357 2352 ··· 2436 2431 if (s->qdev.conf.blk) { 2437 2432 ctx = blk_get_aio_context(s->qdev.conf.blk); 2438 2433 aio_context_acquire(ctx); 2439 - blkconf_blocksizes(&s->qdev.conf); 2434 + if (!blkconf_blocksizes(&s->qdev.conf, errp)) { 2435 + goto out; 2436 + } 2440 2437 } 2441 2438 s->qdev.blocksize = s->qdev.conf.logical_block_size; 2442 2439 s->qdev.type = TYPE_DISK; ··· 2444 2441 s->product = g_strdup("QEMU HARDDISK"); 2445 2442 } 2446 2443 scsi_realize(&s->qdev, errp); 2444 + out: 2447 2445 if (ctx) { 2448 2446 aio_context_release(ctx); 2449 2447 }
+4 -1
hw/usb/dev-storage.c
··· 612 612 return; 613 613 } 614 614 615 - blkconf_blocksizes(&s->conf); 615 + if (!blkconf_blocksizes(&s->conf, errp)) { 616 + return; 617 + } 618 + 616 619 if (!blkconf_apply_backend_options(&s->conf, blk_is_read_only(blk), true, 617 620 errp)) { 618 621 return;
+1 -1
include/hw/block/block.h
··· 87 87 bool blkconf_geometry(BlockConf *conf, int *trans, 88 88 unsigned cyls_max, unsigned heads_max, unsigned secs_max, 89 89 Error **errp); 90 - void blkconf_blocksizes(BlockConf *conf); 90 + bool blkconf_blocksizes(BlockConf *conf, Error **errp); 91 91 bool blkconf_apply_backend_options(BlockConf *conf, bool readonly, 92 92 bool resizable, Error **errp); 93 93
+1 -1
tests/qemu-iotests/172.out
··· 1204 1204 drive-type = "144" 1205 1205 1206 1206 Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,logical_block_size=4096 1207 - QEMU_PROG: -device floppy,drive=none0,logical_block_size=4096: Physical and logical block size must be 512 for floppy 1207 + QEMU_PROG: -device floppy,drive=none0,logical_block_size=4096: logical_block_size > physical_block_size not supported 1208 1208 1209 1209 Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,physical_block_size=1024 1210 1210 QEMU_PROG: -device floppy,drive=none0,physical_block_size=1024: Physical and logical block size must be 512 for floppy