block: Fix crash on write to read-only devices
Subsystems (2)
cover block: Fix crash on write to read-only devices
Kevin Wolf (2):
block: Separate blk_is_writable() and blk_supports_write_perm()
virtio-scsi-test: Test writing to scsi-cd device
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 ++++++++++++++++++++++++++++++++++ 21 files changed, 96 insertions(+), 41 deletions(-)
Signature · 1 line
2.29.2
PATCH 1/2 block: Separate blk_is_writable() and blk_supports_write_perm()
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.
--- 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(-)
include/sysemu/block-backend.h +2 -1
@@ -191,7 +191,8 @@ 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);
block/block-backend.c +16 -3
@@ -1826,17 +1826,30 @@ 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);
hw/block/dataplane/xen-block.c +1 -1
@@ -168,7 +168,7 @@ 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; }
hw/block/fdc.c +5 -4
@@ -444,7 +444,7 @@ 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 ;
@@ -479,8 +479,8 @@ 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 ; } }
@@ -553,7 +553,8 @@ 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)) {
hw/block/m25p80.c +3 -3
@@ -506,7 +506,7 @@ 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 ; }
@@ -522,7 +522,7 @@ 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 ; }
@@ -1379,7 +1379,7 @@ 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);if (ret <0 ) {return ;
hw/block/nand.c +1 -1
@@ -400,7 +400,7 @@ 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 ; }
hw/block/nvme-ns.c +4 -3
@@ -48,13 +48,14 @@ 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 ; }
hw/block/onenand.c +1 -1
@@ -797,7 +797,7 @@ 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 ; }
hw/block/pflash_cfi01.c +1 -1
@@ -745,7 +745,7 @@ 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 ) {
hw/block/pflash_cfi02.c +1 -1
@@ -802,7 +802,7 @@ 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 ) {
hw/block/swim.c +3 -3
@@ -137,8 +137,8 @@ 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 ; } }
@@ -210,7 +210,7 @@ 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 ; }
hw/block/virtio-blk.c +3 -3
@@ -1021,7 +1021,7 @@ 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 ) {
@@ -1175,8 +1175,8 @@ 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);
hw/block/xen-block.c +1 -1
@@ -567,7 +567,7 @@ 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)
hw/ide/core.c +1 -1
@@ -2537,7 +2537,7 @@ 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 ; }
hw/misc/sifive_u_otp.c +1 -1
@@ -219,7 +219,7 @@ 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 ;
hw/ppc/pnv_pnor.c +1 -1
@@ -86,7 +86,7 @@ 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 ;
hw/scsi/scsi-disk.c +5 -5
@@ -1270,7 +1270,7 @@ 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 {
@@ -1704,7 +1704,7 @@ 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 ;
@@ -1795,7 +1795,7 @@ 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 ; }
@@ -2207,7 +2207,7 @@ 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 ; }
@@ -2380,7 +2380,7 @@ 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; }
hw/scsi/scsi-generic.c +2 -2
@@ -306,7 +306,7 @@ 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 ) {
@@ -694,7 +694,7 @@ 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 ; }
hw/sd/sd.c +3 -3
@@ -584,7 +584,7 @@ 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));
@@ -752,7 +752,7 @@ 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 ); }
@@ -2155,7 +2155,7 @@ 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 ; }
hw/usb/dev-storage.c +2 -2
@@ -613,8 +613,8 @@ 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 ; }
Signature · 1 line
2.29.2
Re: [PATCH 1/2] block: Separate blk_is_writable() and blk_supports_write_perm()
Quoted 37 lines · Kevin Wolf
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, whereasblk_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.Signed-off-by Kevin Wolf <[email protected]>--- 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 +-
Quoted 8 lines
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(-)
Re: [PATCH 1/2] block: Separate blk_is_writable() and blk_supports_write_perm()
In reply to Kevin WolfQuoted 37 lines · Kevin Wolf
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, whereasblk_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.Signed-off-by Kevin Wolf <[email protected]>--- 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 +-
Quoted 8 lines
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(-)
PATCH 2/2 virtio-scsi-test: Test writing to scsi-cd device
In reply to Kevin WolfThis 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.
--- tests/qtest/virtio-scsi-test.c | 39 ++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+)
tests/qtest/virtio-scsi-test.c +39 -0
@@ -200,6 +200,32 @@ 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) {
@@ -267,6 +293,16 @@ 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,
@@ -287,6 +323,9 @@ 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" ,
Signature · 1 line
2.29.2
Re: [PATCH 2/2] virtio-scsi-test: Test writing to scsi-cd device
Quoted 10 lines · Kevin Wolf
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.
Signed-off-by Kevin Wolf <[email protected]>--- tests/qtest/virtio-scsi-test.c | 39 ++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+)
Re: [PATCH 2/2] virtio-scsi-test: Test writing to scsi-cd device
In reply to Kevin WolfQuoted 10 lines · Kevin Wolf
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.
Signed-off-by Kevin Wolf <[email protected]>--- tests/qtest/virtio-scsi-test.c | 39 ++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+)