The following changes since commit bf159f0bdc7b8e7aa8342dedb3829ca744c1b612:

Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2021-01-27.for-upstream' into staging (2021-01-27 17:40:25 +0000)

for you to fetch changes up to a44be0334beae3a9affb4a3a92cc6852993d7a84:

iotests: rename and move 169 and 199 tests (2021-01-27 20:53:14 +0100)

- Fix crash on write to read-only devices

- iotests: Rewrite 'check' in Python, get rid of 'groups' and allow

non-numeric test case names

Kevin Wolf (2):

block: Separate blk_is_writable() and blk_supports_write_perm()

virtio-scsi-test: Test writing to scsi-cd device

Vladimir Sementsov-Ogievskiy (6):

iotests: 146: drop extra whitespaces from .out file

iotests: add findtests.py

iotests: add testenv.py

iotests: add testrunner.py

iotests: rewrite check into python

iotests: rename and move 169 and 199 tests

docs/devel/testing.rst | 50 +-

include/sysemu/block-backend.h | 3 +-

block/block-backend.c | 19 +-

hw/block/dataplane/xen-block.c | 2 +-

hw/block/fdc.c | 9 +-

hw/block/m25p80.c | 6 +-

hw/block/nand.c | 2 +-

hw/block/nvme-ns.c | 7 +-

hw/block/onenand.c | 2 +-

hw/block/pflash_cfi01.c | 2 +-

hw/block/pflash_cfi02.c | 2 +-

hw/block/swim.c | 6 +-

hw/block/virtio-blk.c | 6 +-

hw/block/xen-block.c | 2 +-

hw/ide/core.c | 2 +-

hw/misc/sifive_u_otp.c | 2 +-

hw/ppc/pnv_pnor.c | 2 +-

hw/scsi/scsi-disk.c | 10 +-

hw/scsi/scsi-generic.c | 4 +-

hw/sd/sd.c | 6 +-

hw/usb/dev-storage.c | 4 +-

tests/qtest/virtio-scsi-test.c | 39 +

tests/qemu-iotests/findtests.py | 159 +++

tests/qemu-iotests/iotests.py | 8 +

tests/qemu-iotests/testenv.py | 281 +++++

tests/qemu-iotests/testrunner.py | 367 +++++++

Makefile | 1 -

tests/check-block.sh | 3 +-

tests/qemu-iotests/146.out | 780 +++++++-------

tests/qemu-iotests/check | 1095 +++-----------------

tests/qemu-iotests/common.env.in | 3 -

tests/qemu-iotests/group | 323 ------

tests/qemu-iotests/meson.build | 3 -

.../{199 => tests/migrate-bitmaps-postcopy-test} | 0

.../migrate-bitmaps-postcopy-test.out} | 0

.../{169 => tests/migrate-bitmaps-test} | 0

.../{169.out => tests/migrate-bitmaps-test.out} | 0

37 files changed, 1481 insertions(+), 1729 deletions(-)

create mode 100644 tests/qemu-iotests/findtests.py

create mode 100644 tests/qemu-iotests/testenv.py

create mode 100644 tests/qemu-iotests/testrunner.py

delete mode 100644 tests/qemu-iotests/common.env.in

delete mode 100644 tests/qemu-iotests/group

rename tests/qemu-iotests/{199 => tests/migrate-bitmaps-postcopy-test} (100%)

rename tests/qemu-iotests/{199.out => tests/migrate-bitmaps-postcopy-test.out} (100%)

rename tests/qemu-iotests/{169 => tests/migrate-bitmaps-test} (100%)

rename tests/qemu-iotests/{169.out => tests/migrate-bitmaps-test.out} (100%)

Currently, blk_is_read_only() tells whether a given BlockBackend can

only be used in read-only mode because its root node is read-only. Some

callers actually try to answer a slightly different question: Is the

BlockBackend configured to be writable, by taking write permissions on

the root node?

This can differ, for example, for CD-ROM devices which don't take write

permissions, but may be backed by a writable image file. scsi-cd allows

write requests to the drive if blk_is_read_only() returns false.

However, the write request will immediately run into an assertion

failure because the write permission is missing.

This patch introduces separate functions for both questions.

blk_supports_write_perm() answers the question whether the block

node/image file can support writable devices, whereas blk_is_writable()

tells whether the BlockBackend is currently configured to be writable.

All calls of blk_is_read_only() are converted to one of the two new

functions.

Fixes: https://bugs.launchpad.net/bugs/1906693

Cc: qemu-stable@nongnu.org

Message-Id: <20210118123448.307825-2-kwolf@redhat.com>

Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>

include/sysemu/block-backend.h | 3 ++-

block/block-backend.c | 19 ++++++++++++++++---

hw/block/dataplane/xen-block.c | 2 +-

hw/block/fdc.c | 9 +++++----

hw/block/m25p80.c | 6 +++---

hw/block/nand.c | 2 +-

hw/block/nvme-ns.c | 7 ++++---

hw/block/onenand.c | 2 +-

hw/block/pflash_cfi01.c | 2 +-

hw/block/pflash_cfi02.c | 2 +-

hw/block/swim.c | 6 +++---

hw/block/virtio-blk.c | 6 +++---

hw/block/xen-block.c | 2 +-

hw/ide/core.c | 2 +-

hw/misc/sifive_u_otp.c | 2 +-

hw/ppc/pnv_pnor.c | 2 +-

hw/scsi/scsi-disk.c | 10 +++++-----

hw/scsi/scsi-generic.c | 4 ++--

hw/sd/sd.c | 6 +++---

hw/usb/dev-storage.c | 4 ++--

20 files changed, 57 insertions(+), 41 deletions(-)

@@ -XXX,XX +XXX,XX @@ BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,

int error);

void blk_error_action(BlockBackend *blk, BlockErrorAction action,

bool is_read, int error);

-bool blk_is_read_only(BlockBackend *blk);

+bool blk_supports_write_perm(BlockBackend *blk);

+bool blk_is_writable(BlockBackend *blk);

bool blk_is_sg(BlockBackend *blk);

bool blk_enable_write_cache(BlockBackend *blk);

void blk_set_enable_write_cache(BlockBackend *blk, bool wce);

@@ -XXX,XX +XXX,XX @@ void blk_error_action(BlockBackend *blk, BlockErrorAction action,

}

-bool blk_is_read_only(BlockBackend *blk)

+/*

+ * Returns true if the BlockBackend can support taking write permissions

+ * (because its root node is not read-only).

+ */

+bool blk_supports_write_perm(BlockBackend *blk)

{

BlockDriverState *bs = blk_bs(blk);

if (bs) {

- return bdrv_is_read_only(bs);

+ return !bdrv_is_read_only(bs);

} else {

- return blk->root_state.read_only;

+ return !blk->root_state.read_only;

}

+/*

+ * Returns true if the BlockBackend can be written to in its current

+ * configuration (i.e. if write permission have been requested)

+ */

+bool blk_is_writable(BlockBackend *blk)

+{

+ return blk->perm & BLK_PERM_WRITE;

+}

+

bool blk_is_sg(BlockBackend *blk)

{

BlockDriverState *bs = blk_bs(blk);

diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/dataplane/xen-block.c

+++ b/hw/block/dataplane/xen-block.c

@@ -XXX,XX +XXX,XX @@ static int xen_block_parse_request(XenBlockRequest *request)

};

if (request->req.operation != BLKIF_OP_READ &&

- blk_is_read_only(dataplane->blk)) {

+ !blk_is_writable(dataplane->blk)) {

error_report("error: write req for ro device");

goto err;

}

diff --git a/hw/block/fdc.c b/hw/block/fdc.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/fdc.c

+++ b/hw/block/fdc.c

@@ -XXX,XX +XXX,XX @@ static void fd_revalidate(FDrive *drv)

FLOPPY_DPRINTF("revalidate\n");

if (drv->blk != NULL) {

- drv->ro = blk_is_read_only(drv->blk);

+ drv->ro = !blk_is_writable(drv->blk);

if (!blk_is_inserted(drv->blk)) {

FLOPPY_DPRINTF("No disk in drive\n");

drv->disk = FLOPPY_DRIVE_TYPE_NONE;

@@ -XXX,XX +XXX,XX @@ static void fd_change_cb(void *opaque, bool load, Error **errp)

blk_set_perm(drive->blk, 0, BLK_PERM_ALL, &error_abort);

} else {

if (!blkconf_apply_backend_options(drive->conf,

- blk_is_read_only(drive->blk), false,

- errp)) {

+ !blk_supports_write_perm(drive->blk),

+ false, errp)) {

return;

}

}

@@ -XXX,XX +XXX,XX @@ static void floppy_drive_realize(DeviceState *qdev, Error **errp)

* read-only node later */

read_only = true;

} else {

- read_only = !blk_bs(dev->conf.blk) || blk_is_read_only(dev->conf.blk);

+ read_only = !blk_bs(dev->conf.blk) ||

+ !blk_supports_write_perm(dev->conf.blk);

}

if (!blkconf_blocksizes(&dev->conf, errp)) {

diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/m25p80.c

+++ b/hw/block/m25p80.c

@@ -XXX,XX +XXX,XX @@ static void flash_sync_page(Flash *s, int page)

{

QEMUIOVector *iov;

- if (!s->blk || blk_is_read_only(s->blk)) {

+ if (!s->blk || !blk_is_writable(s->blk)) {

return;

}

@@ -XXX,XX +XXX,XX @@ static inline void flash_sync_area(Flash *s, int64_t off, int64_t len)

{

QEMUIOVector *iov;

- if (!s->blk || blk_is_read_only(s->blk)) {

+ if (!s->blk || !blk_is_writable(s->blk)) {

return;

}

@@ -XXX,XX +XXX,XX @@ static void m25p80_realize(SSIPeripheral *ss, Error **errp)

if (s->blk) {

uint64_t perm = BLK_PERM_CONSISTENT_READ |

- (blk_is_read_only(s->blk) ? 0 : BLK_PERM_WRITE);

+ (blk_supports_write_perm(s->blk) ? BLK_PERM_WRITE : 0);

ret = blk_set_perm(s->blk, perm, BLK_PERM_ALL, errp);

return;

diff --git a/hw/block/nand.c b/hw/block/nand.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/nand.c

+++ b/hw/block/nand.c

@@ -XXX,XX +XXX,XX @@ static void nand_realize(DeviceState *dev, Error **errp)

pagesize = 1 << s->oob_shift;

s->mem_oob = 1;

if (s->blk) {

- if (blk_is_read_only(s->blk)) {

+ if (!blk_supports_write_perm(s->blk)) {

error_setg(errp, "Can't use a read-only drive");

return;

}

diff --git a/hw/block/nvme-ns.c b/hw/block/nvme-ns.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/nvme-ns.c

+++ b/hw/block/nvme-ns.c

@@ -XXX,XX +XXX,XX @@ static void nvme_ns_init(NvmeNamespace *ns)

static int nvme_ns_init_blk(NvmeCtrl *n, NvmeNamespace *ns, Error **errp)

{

+ bool read_only;

+

if (!blkconf_blocksizes(&ns->blkconf, errp)) {

return -1;

}

- if (!blkconf_apply_backend_options(&ns->blkconf,

- blk_is_read_only(ns->blkconf.blk),

- false, errp)) {

+ read_only = !blk_supports_write_perm(ns->blkconf.blk);

+ if (!blkconf_apply_backend_options(&ns->blkconf, read_only, false, errp)) {

return -1;

}

diff --git a/hw/block/onenand.c b/hw/block/onenand.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/onenand.c

+++ b/hw/block/onenand.c

@@ -XXX,XX +XXX,XX @@ static void onenand_realize(DeviceState *dev, Error **errp)

s->image = memset(g_malloc(size + (size >> 5)),

0xff, size + (size >> 5));

} else {

- if (blk_is_read_only(s->blk)) {

+ if (!blk_supports_write_perm(s->blk)) {

error_setg(errp, "Can't use a read-only drive");

return;

}

diff --git a/hw/block/pflash_cfi01.c b/hw/block/pflash_cfi01.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/pflash_cfi01.c

+++ b/hw/block/pflash_cfi01.c

@@ -XXX,XX +XXX,XX @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp)

if (pfl->blk) {

uint64_t perm;

- pfl->ro = blk_is_read_only(pfl->blk);

+ pfl->ro = !blk_supports_write_perm(pfl->blk);

perm = BLK_PERM_CONSISTENT_READ | (pfl->ro ? 0 : BLK_PERM_WRITE);

ret = blk_set_perm(pfl->blk, perm, BLK_PERM_ALL, errp);

if (ret < 0) {

diff --git a/hw/block/pflash_cfi02.c b/hw/block/pflash_cfi02.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/pflash_cfi02.c

+++ b/hw/block/pflash_cfi02.c

@@ -XXX,XX +XXX,XX @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp)

if (pfl->blk) {

uint64_t perm;

- pfl->ro = blk_is_read_only(pfl->blk);

+ pfl->ro = !blk_supports_write_perm(pfl->blk);

perm = BLK_PERM_CONSISTENT_READ | (pfl->ro ? 0 : BLK_PERM_WRITE);

ret = blk_set_perm(pfl->blk, perm, BLK_PERM_ALL, errp);

if (ret < 0) {

diff --git a/hw/block/swim.c b/hw/block/swim.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/swim.c

+++ b/hw/block/swim.c

@@ -XXX,XX +XXX,XX @@ static void swim_change_cb(void *opaque, bool load, Error **errp)

blk_set_perm(drive->blk, 0, BLK_PERM_ALL, &error_abort);

} else {

if (!blkconf_apply_backend_options(drive->conf,

- blk_is_read_only(drive->blk), false,

- errp)) {

+ !blk_supports_write_perm(drive->blk),

+ false, errp)) {

return;

}

}

@@ -XXX,XX +XXX,XX @@ static void swim_drive_realize(DeviceState *qdev, Error **errp)

dev->conf.werror = BLOCKDEV_ON_ERROR_AUTO;

if (!blkconf_apply_backend_options(&dev->conf,

- blk_is_read_only(dev->conf.blk),

+ !blk_supports_write_perm(dev->conf.blk),

false, errp)) {

return;

}

diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/virtio-blk.c

+++ b/hw/block/virtio-blk.c

@@ -XXX,XX +XXX,XX @@ static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features,

virtio_has_feature(features, VIRTIO_BLK_F_CONFIG_WCE))) {

virtio_add_feature(&features, VIRTIO_BLK_F_WCE);

}

- if (blk_is_read_only(s->blk)) {

+ if (!blk_is_writable(s->blk)) {

virtio_add_feature(&features, VIRTIO_BLK_F_RO);

}

if (s->conf.num_queues > 1) {

@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)

}

if (!blkconf_apply_backend_options(&conf->conf,

- blk_is_read_only(conf->conf.blk), true,

- errp)) {

+ !blk_supports_write_perm(conf->conf.blk),

+ true, errp)) {

return;

}

s->original_wce = blk_enable_write_cache(conf->conf.blk);

diff --git a/hw/block/xen-block.c b/hw/block/xen-block.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/xen-block.c

+++ b/hw/block/xen-block.c

@@ -XXX,XX +XXX,XX @@ static void xen_disk_realize(XenBlockDevice *blockdev, Error **errp)

return;

}

- blockdev->info = blk_is_read_only(conf->blk) ? VDISK_READONLY : 0;

+ blockdev->info = blk_supports_write_perm(conf->blk) ? 0 : VDISK_READONLY;

}

static void xen_disk_class_init(ObjectClass *class, void *data)

diff --git a/hw/ide/core.c b/hw/ide/core.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/ide/core.c

+++ b/hw/ide/core.c

@@ -XXX,XX +XXX,XX @@ int ide_init_drive(IDEState *s, BlockBackend *blk, IDEDriveKind kind,

error_setg(errp, "Device needs media, but drive is empty");

return -1;

}

- if (blk_is_read_only(blk)) {

+ if (!blk_is_writable(blk)) {

error_setg(errp, "Can't use a read-only drive");

return -1;

}

diff --git a/hw/misc/sifive_u_otp.c b/hw/misc/sifive_u_otp.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/misc/sifive_u_otp.c

+++ b/hw/misc/sifive_u_otp.c

@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)

if (s->blk) {

perm = BLK_PERM_CONSISTENT_READ |

- (blk_is_read_only(s->blk) ? 0 : BLK_PERM_WRITE);

+ (blk_supports_write_perm(s->blk) ? BLK_PERM_WRITE : 0);

ret = blk_set_perm(s->blk, perm, BLK_PERM_ALL, errp);

if (ret < 0) {

return;

diff --git a/hw/ppc/pnv_pnor.c b/hw/ppc/pnv_pnor.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/ppc/pnv_pnor.c

+++ b/hw/ppc/pnv_pnor.c

@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_realize(DeviceState *dev, Error **errp)

if (s->blk) {

uint64_t perm = BLK_PERM_CONSISTENT_READ |

- (blk_is_read_only(s->blk) ? 0 : BLK_PERM_WRITE);

+ (blk_supports_write_perm(s->blk) ? BLK_PERM_WRITE : 0);

ret = blk_set_perm(s->blk, perm, BLK_PERM_ALL, errp);

if (ret < 0) {

return;

diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/scsi/scsi-disk.c

+++ b/hw/scsi/scsi-disk.c

@@ -XXX,XX +XXX,XX @@ static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf)

if (s->qdev.type == TYPE_DISK) {

dev_specific_param = s->features & (1 << SCSI_DISK_F_DPOFUA) ? 0x10 : 0;

- if (blk_is_read_only(s->qdev.conf.blk)) {

+ if (!blk_is_writable(s->qdev.conf.blk)) {

dev_specific_param |= 0x80; /* Readonly. */

}

} else {

@@ -XXX,XX +XXX,XX @@ static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf)

goto invalid_param_len;

}

- if (blk_is_read_only(s->qdev.conf.blk)) {

+ if (!blk_is_writable(s->qdev.conf.blk)) {

block_acct_invalid(blk_get_stats(s->qdev.conf.blk), BLOCK_ACCT_UNMAP);

scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED));

return;

@@ -XXX,XX +XXX,XX @@ static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf)

return;

}

- if (blk_is_read_only(s->qdev.conf.blk)) {

+ if (!blk_is_writable(s->qdev.conf.blk)) {

scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED));

return;

}

@@ -XXX,XX +XXX,XX @@ static int32_t scsi_disk_dma_command(SCSIRequest *req, uint8_t *buf)

case WRITE_VERIFY_10:

case WRITE_VERIFY_12:

case WRITE_VERIFY_16:

- if (blk_is_read_only(s->qdev.conf.blk)) {

+ if (!blk_is_writable(s->qdev.conf.blk)) {

scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED));

return 0;

}

@@ -XXX,XX +XXX,XX @@ static void scsi_realize(SCSIDevice *dev, Error **errp)

}

}

- read_only = blk_is_read_only(s->qdev.conf.blk);

+ read_only = !blk_supports_write_perm(s->qdev.conf.blk);

if (dev->type == TYPE_ROM) {

read_only = true;

}

diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/scsi/scsi-generic.c

+++ b/hw/scsi/scsi-generic.c

@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)

* readonly.

if ((s->type == TYPE_DISK || s->type == TYPE_TAPE || s->type == TYPE_ZBC) &&

- blk_is_read_only(s->conf.blk) &&

+ !blk_is_writable(s->conf.blk) &&

(r->req.cmd.buf[0] == MODE_SENSE ||

r->req.cmd.buf[0] == MODE_SENSE_10) &&

(r->req.cmd.buf[1] & 0x8) == 0) {

@@ -XXX,XX +XXX,XX @@ static void scsi_generic_realize(SCSIDevice *s, Error **errp)

return;

}

if (!blkconf_apply_backend_options(&s->conf,

- blk_is_read_only(s->conf.blk),

+ !blk_supports_write_perm(s->conf.blk),

true, errp)) {

return;

}

diff --git a/hw/sd/sd.c b/hw/sd/sd.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/sd/sd.c

+++ b/hw/sd/sd.c

@@ -XXX,XX +XXX,XX @@ static void sd_reset(DeviceState *dev)

sd_set_sdstatus(sd);

g_free(sd->wp_groups);

- sd->wp_switch = sd->blk ? blk_is_read_only(sd->blk) : false;

+ sd->wp_switch = sd->blk ? !blk_is_writable(sd->blk) : false;

sd->wpgrps_size = sect;

sd->wp_groups = bitmap_new(sd->wpgrps_size);

memset(sd->function_group, 0, sizeof(sd->function_group));

@@ -XXX,XX +XXX,XX @@ void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert)

{

sd->readonly_cb = readonly;

sd->inserted_cb = insert;

- qemu_set_irq(readonly, sd->blk ? blk_is_read_only(sd->blk) : 0);

+ qemu_set_irq(readonly, sd->blk ? !blk_is_writable(sd->blk) : 0);

qemu_set_irq(insert, sd->blk ? blk_is_inserted(sd->blk) : 0);

@@ -XXX,XX +XXX,XX @@ static void sd_realize(DeviceState *dev, Error **errp)

if (sd->blk) {

int64_t blk_size;

- if (blk_is_read_only(sd->blk)) {

+ if (!blk_supports_write_perm(sd->blk)) {

error_setg(errp, "Cannot use read-only drive as SD card");

return;

}

diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/usb/dev-storage.c

+++ b/hw/usb/dev-storage.c

@@ -XXX,XX +XXX,XX @@ static void usb_msd_storage_realize(USBDevice *dev, Error **errp)

return;

}

- if (!blkconf_apply_backend_options(&s->conf, blk_is_read_only(blk), true,

- errp)) {

+ if (!blkconf_apply_backend_options(&s->conf, !blk_supports_write_perm(blk),

+ true, errp)) {

return;

}

2.29.2

This tests that trying to write to a (read-only) scsi-cd device backed

by a read-write image file doesn't crash and results in the correct

error.

This is a regression test for https://bugs.launchpad.net/bugs/1906693.

Message-Id: <20210118123448.307825-3-kwolf@redhat.com>

Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>

tests/qtest/virtio-scsi-test.c | 39 ++++++++++++++++++++++++++++++++++

1 file changed, 39 insertions(+)

diff --git a/tests/qtest/virtio-scsi-test.c b/tests/qtest/virtio-scsi-test.c

--- a/tests/qtest/virtio-scsi-test.c

+++ b/tests/qtest/virtio-scsi-test.c

@@ -XXX,XX +XXX,XX @@ static void test_unaligned_write_same(void *obj, void *data,

qvirtio_scsi_pci_free(vs);

+static void test_write_to_cdrom(void *obj, void *data,

+ QGuestAllocator *t_alloc)

+{

+ QVirtioSCSI *scsi = obj;

+ QVirtioSCSIQueues *vs;

+ uint8_t buf[2048] = { 0 };

+ const uint8_t write_cdb[VIRTIO_SCSI_CDB_SIZE] = {

+ /* WRITE(10) to LBA 0, transfer length 1 */

+ 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00

+ };

+ struct virtio_scsi_cmd_resp resp;

+

+ alloc = t_alloc;

+ vs = qvirtio_scsi_init(scsi->vdev);

+

+ virtio_scsi_do_command(vs, write_cdb, NULL, 0, buf, 2048, &resp);

+ g_assert_cmphex(resp.response, ==, 0);

+ g_assert_cmphex(resp.status, ==, CHECK_CONDITION);

+ g_assert_cmphex(resp.sense[0], ==, 0x70);

+ g_assert_cmphex(resp.sense[2], ==, DATA_PROTECT);

+ g_assert_cmphex(resp.sense[12], ==, 0x27); /* WRITE PROTECTED */

+ g_assert_cmphex(resp.sense[13], ==, 0x00); /* WRITE PROTECTED */

+

+ qvirtio_scsi_pci_free(vs);

+}

+

static void test_iothread_attach_node(void *obj, void *data,

QGuestAllocator *t_alloc)

{

@@ -XXX,XX +XXX,XX @@ static void *virtio_scsi_setup(GString *cmd_line, void *arg)

return arg;

+static void *virtio_scsi_setup_cd(GString *cmd_line, void *arg)

+{

+ g_string_append(cmd_line,

+ " -drive file=null-co://,"

+ "file.read-zeroes=on,"

+ "if=none,id=dr1,format=raw "

+ "-device scsi-cd,drive=dr1,lun=0,scsi-id=1");

+ return arg;

+}

+

static void *virtio_scsi_setup_iothread(GString *cmd_line, void *arg)

g_string_append(cmd_line,

@@ -XXX,XX +XXX,XX @@ static void register_virtio_scsi_test(void)

qos_add_test("unaligned-write-same", "virtio-scsi",

test_unaligned_write_same, &opts);

+ opts.before = virtio_scsi_setup_cd;

+ qos_add_test("write-to-cdrom", "virtio-scsi", test_write_to_cdrom, &opts);

+

opts.before = virtio_scsi_setup_iothread;

opts.edge = (QOSGraphEdgeOptions) {

.extra_device_opts = "iothread=thread0",

2.29.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

check script will be stricter soon about whitespaces, so fix 146.out

now.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Message-Id: <20210125185056.129513-2-vsementsov@virtuozzo.com>

tests/qemu-iotests/146.out | 780 ++++++++++++++++++-------------------

1 file changed, 390 insertions(+), 390 deletions(-)

diff --git a/tests/qemu-iotests/146.out b/tests/qemu-iotests/146.out

--- a/tests/qemu-iotests/146.out

+++ b/tests/qemu-iotests/146.out

@@ -XXX,XX +XXX,XX @@ QA output created by 146

=== Testing VPC Autodetect ===

-[{ "start": 0, "length": 136363130880, "depth": 0, "zero": true, "data": false }]

+[{ "start": 0, "length": 136363130880, "depth": 0, "zero": true, "data": false}]

=== Testing VPC with current_size force ===

-[{ "start": 0, "length": 136365211648, "depth": 0, "zero": true, "data": false }]

+[{ "start": 0, "length": 136365211648, "depth": 0, "zero": true, "data": false}]

=== Testing VPC with chs force ===

-[{ "start": 0, "length": 136363130880, "depth": 0, "zero": true, "data": false }]

+[{ "start": 0, "length": 136363130880, "depth": 0, "zero": true, "data": false}]

=== Testing Hyper-V Autodetect ===

-[{ "start": 0, "length": 136365211648, "depth": 0, "zero": true, "data": false }]

+[{ "start": 0, "length": 136365211648, "depth": 0, "zero": true, "data": false}]

=== Testing Hyper-V with current_size force ===

-[{ "start": 0, "length": 136365211648, "depth": 0, "zero": true, "data": false }]

+[{ "start": 0, "length": 136365211648, "depth": 0, "zero": true, "data": false}]

=== Testing Hyper-V with chs force ===

-[{ "start": 0, "length": 136363130880, "depth": 0, "zero": true, "data": false }]

+[{ "start": 0, "length": 136363130880, "depth": 0, "zero": true, "data": false}]

=== Testing d2v Autodetect ===

-[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 2097152, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 4194304, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 6291456, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 8388608, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 10485760, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 12582912, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 14680064, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 16777216, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 18874368, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 20971520, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 23068672, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 25165824, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 27262976, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 29360128, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 31457280, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 33554432, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 35651584, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 37748736, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 39845888, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 41943040, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 44040192, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 46137344, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 48234496, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 50331648, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 52428800, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 54525952, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 56623104, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 58720256, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 60817408, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 62914560, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 65011712, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 67108864, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 69206016, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 71303168, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 73400320, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 75497472, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 77594624, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 79691776, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 81788928, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 83886080, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 85983232, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 88080384, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 90177536, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 92274688, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 94371840, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 96468992, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 98566144, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 100663296, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 102760448, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 104857600, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 106954752, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 109051904, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 111149056, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 113246208, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 115343360, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 117440512, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 119537664, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 121634816, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 123731968, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 125829120, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 127926272, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 130023424, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 132120576, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 134217728, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 136314880, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 138412032, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 140509184, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 142606336, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 144703488, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 146800640, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 148897792, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 150994944, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 153092096, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 155189248, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 157286400, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 159383552, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 161480704, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 163577856, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 165675008, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 167772160, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 169869312, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 171966464, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 174063616, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 176160768, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 178257920, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 180355072, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 182452224, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 184549376, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 186646528, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 188743680, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 190840832, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 192937984, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 195035136, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 197132288, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 199229440, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 201326592, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 203423744, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 205520896, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 207618048, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 209715200, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 211812352, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 213909504, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 216006656, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 218103808, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 220200960, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 222298112, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 224395264, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 226492416, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 228589568, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 230686720, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 232783872, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 234881024, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 236978176, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 239075328, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 241172480, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 243269632, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 245366784, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 247463936, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 249561088, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 251658240, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 253755392, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 255852544, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 257949696, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 260046848, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET },

-{ "start": 262144000, "length": 1310720, "depth": 0, "zero": false, "data": true, "offset": OFFSET }]

+[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": OFFSET},