block: Add driver specific options
v2 cover block: Add driver specific options
v2:
- Fixed use after free for serial number
- Fixed id=... handling
- Fixed if=virtio overwriting opts
Kevin Wolf (8):
block: Add options QDict to .bdrv_open()
block: Add options QDict to bdrv_open() prototype Add qdict_clone_shallow()
block: Add options QDict to bdrv_open_common()
qemu-option: Add qemu_opts_absorb_qdict()
blockdev: Keep a copy of DriveInfo.serial
block: Support driver specific options in drive_init()
qcow2: Allow lazy refcounts to be enabled on the command line
block.c | 81 +++++++++++++++++++++++++++++++++++----------- block/blkverify.c | 2 +- block/bochs.c | 2 +- block/cloop.c | 2 +- block/cow.c | 2 +- block/dmg.c | 2 +- block/parallels.c | 2 +- block/qcow.c | 2 +- block/qcow2-cluster.c | 2 +- block/qcow2.c | 43 +++++++++++++++++++++++-- block/qcow2.h | 1 + block/qed.c | 4 +-- block/raw.c | 2 +- block/vdi.c | 2 +- block/vmdk.c | 4 +-- block/vpc.c | 2 +- block/vvfat.c | 2 +- blockdev.c | 82 +++++++++++++++++++++++++++++++++++++++-------- hw/xen_disk.c | 2 +- include/block/block.h | 4 +-- include/block/block_int.h | 3 +- include/qapi/qmp/qdict.h | 2 ++ include/qemu/option.h | 1 + include/sysemu/blockdev.h | 2 +- qemu-img.c | 6 ++-- qemu-io.c | 2 +- qemu-nbd.c | 2 +- qobject/qdict.c | 22 +++++++++++++ util/qemu-option.c | 34 ++++++++++++++++++++ 29 files changed, 257 insertions(+), 62 deletions(-)
Signature · 1 line
1.8.1.4
PATCH v2 1/8 block: Add options QDict to .bdrv_open()
--- block.c | 4 ++-- block/bochs.c | 2 +- block/cloop.c | 2 +- block/cow.c | 2 +- block/dmg.c | 2 +- block/parallels.c | 2 +- block/qcow.c | 2 +- block/qcow2.c | 4 ++-- block/qed.c | 4 ++-- block/raw.c | 2 +- block/vdi.c | 2 +- block/vmdk.c | 2 +- block/vpc.c | 2 +- include/block/block_int.h | 2 +- 14 files changed, 17 insertions(+), 17 deletions(-)
block.c +2 -2
@@ -710,7 +710,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, }else {assert (file !=NULL ); bs->file = file; - ret = drv->bdrv_open (bs, open_flags); + ret = drv->bdrv_open (bs,NULL , open_flags); }if (ret <0 ) {
@@ -3190,7 +3190,7 @@ int bdrv_snapshot_goto(BlockDriverState *bs,if (bs->file) { drv->bdrv_close (bs); ret =bdrv_snapshot_goto (bs->file, snapshot_id); - open_ret = drv->bdrv_open (bs, bs->open_flags); + open_ret = drv->bdrv_open (bs,NULL , bs->open_flags);if (open_ret <0 ) {bdrv_delete (bs->file); bs->drv =NULL ;
block/bochs.c +1 -1
@@ -108,7 +108,7 @@ static int bochs_probe(const uint8_t *buf, int buf_size, const char *filename)return 0 ; } -static int bochs_open (BlockDriverState *bs,int flags) +static int bochs_open (BlockDriverState *bs,QDict *options,int flags) {BDRVBochsState *s = bs->opaque;int i;
block/cloop.c +1 -1
@@ -53,7 +53,7 @@ static int cloop_probe(const uint8_t *buf, int buf_size, const char *filename)return 0 ; } -static int cloop_open (BlockDriverState *bs,int flags) +static int cloop_open (BlockDriverState *bs,QDict *options,int flags) {BDRVCloopState *s = bs->opaque;uint32_t offsets_size, max_compressed_block_size =1 , i;
block/cow.c +1 -1
@@ -58,7 +58,7 @@ static int cow_probe(const uint8_t *buf, int buf_size, const char *filename)return 0 ; } -static int cow_open (BlockDriverState *bs,int flags) +static int cow_open (BlockDriverState *bs,QDict *options,int flags) {BDRVCowState *s = bs->opaque;struct cow_header_v2 cow_header;
block/dmg.c +1 -1
@@ -85,7 +85,7 @@ static int read_uint32(BlockDriverState *bs, int64_t offset, uint32_t *result)return 0 ; } -static int dmg_open (BlockDriverState *bs,int flags) +static int dmg_open (BlockDriverState *bs,QDict *options,int flags) {BDRVDMGState *s = bs->opaque;uint64_t info_begin,info_end,last_in_offset,last_out_offset;
block/parallels.c +1 -1
@@ -68,7 +68,7 @@ static int parallels_probe(const uint8_t *buf, int buf_size, const char *filenamreturn 0 ; } -static int parallels_open (BlockDriverState *bs,int flags) +static int parallels_open (BlockDriverState *bs,QDict *options,int flags) {BDRVParallelsState *s = bs->opaque;int i;
block/qcow.c +1 -1
@@ -92,7 +92,7 @@ static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)return 0 ; } -static int qcow_open (BlockDriverState *bs,int flags) +static int qcow_open (BlockDriverState *bs,QDict *options,int flags) {BDRVQcowState *s = bs->opaque;int len, i, shift, ret;
block/qcow2.c +2 -2
@@ -285,7 +285,7 @@ static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result,return ret; } -static int qcow2_open (BlockDriverState *bs,int flags) +static int qcow2_open (BlockDriverState *bs,QDict *options,int flags) {BDRVQcowState *s = bs->opaque;int len, i, ret =0 ;
@@ -912,7 +912,7 @@ static void qcow2_invalidate_cache(BlockDriverState *bs)qcow2_close (bs);memset (s,0 ,sizeof (BDRVQcowState)); -qcow2_open (bs, flags); +qcow2_open (bs,NULL , flags);if (crypt_method) { s->crypt_method = crypt_method;
block/qed.c +2 -2
@@ -373,7 +373,7 @@ static void bdrv_qed_rebind(BlockDriverState *bs) s->bs = bs; } -static int bdrv_qed_open (BlockDriverState *bs,int flags) +static int bdrv_qed_open (BlockDriverState *bs,QDict *options,int flags) {BDRVQEDState *s = bs->opaque;QEDHeader le_header;
@@ -1526,7 +1526,7 @@ static void bdrv_qed_invalidate_cache(BlockDriverState *bs)bdrv_qed_close (bs);memset (s,0 ,sizeof (BDRVQEDState)); -bdrv_qed_open (bs, bs->open_flags); +bdrv_qed_open (bs,NULL , bs->open_flags); } static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result,
block/raw.c +1 -1
@@ -3,7 +3,7 @@#include "block/block_int.h" #include "qemu/module.h" -static int raw_open (BlockDriverState *bs,int flags) +static int raw_open (BlockDriverState *bs,QDict *options,int flags) { bs->sg = bs->file->sg;return 0 ;
block/vdi.c +1 -1
@@ -364,7 +364,7 @@ static int vdi_probe(const uint8_t *buf, int buf_size, const char *filename)return result; } -static int vdi_open (BlockDriverState *bs,int flags) +static int vdi_open (BlockDriverState *bs,QDict *options,int flags) {BDRVVdiState *s = bs->opaque;VdiHeader header;
block/vmdk.c +1 -1
@@ -723,7 +723,7 @@ static int vmdk_open_desc_file(BlockDriverState *bs, int flags,return vmdk_parse_extents (buf, bs, bs->file->filename); } -static int vmdk_open (BlockDriverState *bs,int flags) +static int vmdk_open (BlockDriverState *bs,QDict *options,int flags) {int ret;BDRVVmdkState *s = bs->opaque;
block/vpc.c +1 -1
@@ -155,7 +155,7 @@ static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)return 0 ; } -static int vpc_open (BlockDriverState *bs,int flags) +static int vpc_open (BlockDriverState *bs,QDict *options,int flags) {BDRVVPCState *s = bs->opaque;int i;
include/block/block_int.h +1 -1
@@ -82,7 +82,7 @@ struct BlockDriver {void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state);void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state); -int (*bdrv_open)(BlockDriverState *bs,int flags); +int (*bdrv_open)(BlockDriverState *bs,QDict *options,int flags);int (*bdrv_file_open)(BlockDriverState *bs,const char *filename,int flags);int (*bdrv_read)(BlockDriverState *bs,int64_t sector_num,uint8_t *buf,int nb_sectors);
Signature · 1 line
1.8.1.4
PATCH v2 2/8 block: Add options QDict to bdrv_open() prototype
In reply to Kevin WolfIt doesn't do anything yet except storing the options QDict in the BlockDriverState.
--- block.c | 47 +++++++++++++++++++++++++++++++++++------------ block/blkverify.c | 2 +- block/qcow2.c | 2 +- block/vmdk.c | 2 +- block/vvfat.c | 2 +- blockdev.c | 10 ++++++---- hw/xen_disk.c | 2 +- include/block/block.h | 4 ++-- include/block/block_int.h | 1 + qemu-img.c | 6 +++--- qemu-io.c | 2 +- qemu-nbd.c | 2 +- 12 files changed, 54 insertions(+), 28 deletions(-)
block.c +35 -12
@@ -788,7 +788,8 @@ int bdrv_open_backing_file(BlockDriverState *bs)/* backing files always opened read-only */ back_flags = bs->open_flags & ~(BDRV_O_RDWR |BDRV_O_SNAPSHOT ); - ret =bdrv_open (bs->backing_hd, backing_filename, back_flags, back_drv); + ret =bdrv_open (bs->backing_hd, backing_filename,NULL , + back_flags, back_drv);if (ret <0 ) {bdrv_delete (bs->backing_hd); bs->backing_hd =NULL ;
@@ -800,15 +801,28 @@ int bdrv_open_backing_file(BlockDriverState *bs)/* * Opens a disk image (raw, qcow2, vmdk, ...) +* +* options is a QDict of options to pass to the block drivers, or NULL for an +* empty set of options. The reference to the QDict belongs to the block layer +* after the call (even on failure), so if the caller intends to reuse the +* dictionary, it needs to use QINCREF() before calling bdrv_open. */ -int bdrv_open (BlockDriverState *bs,const char *filename,int flags, -BlockDriver *drv) +int bdrv_open (BlockDriverState *bs,const char *filename,QDict *options, +int flags,BlockDriver *drv) {int ret;/* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ char tmp_filename[PATH_MAX +1 ];BlockDriverState *file =NULL ; +/* NULL means an empty set of options */ +if (options ==NULL ) { + options =qdict_new (); + } + + bs->options = options; + +/* For snapshot=on, create a temporary qcow2 overlay */ if (flags &BDRV_O_SNAPSHOT ) {BlockDriverState *bs1;int64_t total_size;
@@ -822,10 +836,10 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags,/* if there is a backing file, use it */ bs1 =bdrv_new ("" ); - ret =bdrv_open (bs1, filename,0 , drv); + ret =bdrv_open (bs1, filename,NULL ,0 , drv);if (ret <0 ) {bdrv_delete (bs1); -return ret; + goto fail; } total_size =bdrv_getlength (bs1) &BDRV_SECTOR_MASK ;
@@ -836,15 +850,17 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags, ret =get_tmp_filename (tmp_filename,sizeof (tmp_filename));if (ret <0 ) { -return ret; + goto fail; }/* Real path is meaningless for protocols */ -if (is_protocol) +if (is_protocol) {snprintf (backing_filename,sizeof (backing_filename),"%s" , filename); -else if (!realpath (filename, backing_filename)) -return -errno; + }else if (!realpath (filename, backing_filename)) { + ret = -errno; + goto fail; + } bdrv_qcow2 =bdrv_find_format ("qcow2" ); options =parse_option_parameters ("" , bdrv_qcow2->create_options,NULL );
@@ -859,7 +875,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags, ret =bdrv_create (bdrv_qcow2, tmp_filename, options);free_option_parameters (options);if (ret <0 ) { -return ret; + goto fail; } filename = tmp_filename;
@@ -874,7 +890,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags, ret =bdrv_file_open (&file, filename,bdrv_open_flags (bs, flags));if (ret <0 ) { -return ret; + goto fail; }/* Find the right image format driver */
@@ -924,6 +940,10 @@ unlink_and_fail:if (bs->is_temporary) {unlink (filename); } +fail: +QDECREF (bs->options); + bs->options =NULL ; +return ret; }
@@ -1193,6 +1213,8 @@ void bdrv_close(BlockDriverState *bs) bs->valid_key =0 ; bs->sg =0 ; bs->growable =0 ; +QDECREF (bs->options); + bs->options =NULL ;if (bs->file !=NULL ) {bdrv_delete (bs->file);
@@ -4594,7 +4616,8 @@ void bdrv_img_create(const char *filename, const char *fmt, bs =bdrv_new ("" ); - ret =bdrv_open (bs, backing_file->value.s, back_flags, backing_drv); + ret =bdrv_open (bs, backing_file->value.s,NULL , back_flags, + backing_drv);if (ret <0 ) {error_setg_errno (errp, -ret,"Could not open '%s'" , backing_file->value.s);
block/blkverify.c +1 -1
@@ -98,7 +98,7 @@ static int blkverify_open(BlockDriverState *bs, const char *filename, int flags)/* Open the test file */ s->test_file =bdrv_new ("" ); - ret =bdrv_open (s->test_file, filename, flags,NULL ); + ret =bdrv_open (s->test_file, filename,NULL , flags,NULL );if (ret <0 ) {bdrv_delete (s->test_file); s->test_file =NULL ;
block/qcow2.c +1 -1
@@ -1265,7 +1265,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,*/ BlockDriver * drv =bdrv_find_format ("qcow2" );assert (drv !=NULL ); - ret =bdrv_open (bs, filename, + ret =bdrv_open (bs, filename,NULL ,BDRV_O_RDWR |BDRV_O_CACHE_WB |BDRV_O_NO_FLUSH , drv);if (ret <0 ) { goto out;
block/vmdk.c +1 -1
@@ -1527,7 +1527,7 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options)if (backing_file) {char parent_filename[PATH_MAX ];BlockDriverState *bs =bdrv_new ("" ); - ret =bdrv_open (bs, backing_file,0 ,NULL ); + ret =bdrv_open (bs, backing_file,NULL ,0 ,NULL );if (ret !=0 ) {bdrv_delete (bs);return ret;
block/vvfat.c +1 -1
@@ -2830,7 +2830,7 @@ static int enable_write_target(BDRVVVFATState *s)return -1 ; } - ret =bdrv_open (s->qcow, s->qcow_filename, + ret =bdrv_open (s->qcow, s->qcow_filename,NULL ,BDRV_O_RDWR |BDRV_O_CACHE_WB |BDRV_O_NO_FLUSH , bdrv_qcow);if (ret <0 ) {return ret;
blockdev.c +6 -4
@@ -635,7 +635,7 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type)error_report ("warning: disabling copy_on_read on readonly drive" ); } - ret =bdrv_open (dinfo->bdrv, file, bdrv_flags, drv); + ret =bdrv_open (dinfo->bdrv, file,NULL , bdrv_flags, drv);if (ret <0 ) {if (ret == -EMEDIUMTYPE ) { error_report("could not open disk image %s: not in %s format",
@@ -820,7 +820,9 @@ void qmp_transaction(BlockdevActionList *dev_list, Error **errp)/* We will manually add the backing_hd field to the bs later */ states->new_bs =bdrv_new ("" ); - ret =bdrv_open (states->new_bs, new_image_file, +/* TODO Inherit bs->options or only take explicit options with an +* extended QMP command? */ + ret =bdrv_open (states->new_bs, new_image_file,NULL , flags |BDRV_O_NO_BACKING , drv);if (ret !=0 ) {error_set (errp,QERR_OPEN_FILE_FAILED , new_image_file);
@@ -921,7 +923,7 @@ static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename, int bdrv_flags, BlockDriver *drv, const char *password, Error **errp) { - if (bdrv_open(bs, filename, bdrv_flags, drv) < 0) { + if (bdrv_open(bs, filename, NULL, bdrv_flags, drv) < 0) {error_set (errp ,QERR_OPEN_FILE_FAILED ,filename );return ; }
@@ -1330,7 +1332,7 @@ void qmp_drive_mirror(const char *device, const char *target,* file. */ target_bs =bdrv_new ("" ); - ret =bdrv_open (target_bs, target, flags |BDRV_O_NO_BACKING , drv); + ret =bdrv_open (target_bs, target,NULL , flags |BDRV_O_NO_BACKING , drv);if (ret <0 ) {bdrv_delete (target_bs);
hw/xen_disk.c +1 -1
@@ -763,7 +763,7 @@ static int blk_init(struct XenDevice *xendev)xen_be_printf (&blkdev->xendev,2 ,"create new bdrv (xenbus setup)\n" ); blkdev->bs =bdrv_new (blkdev->dev);if (blkdev->bs) { -if (bdrv_open (blkdev->bs, blkdev->filename, qflags, +if (bdrv_open (blkdev->bs, blkdev->filename,NULL , qflags,bdrv_find_whitelisted_format (blkdev->fileproto)) !=0 ) {bdrv_delete (blkdev->bs); blkdev->bs =NULL ;
include/block/block.h +2 -2
@@ -137,8 +137,8 @@ int bdrv_parse_cache_flags(const char *mode, int *flags);int bdrv_parse_discard_flags (const char *mode,int *flags);int bdrv_file_open (BlockDriverState **pbs,const char *filename,int flags);int bdrv_open_backing_file (BlockDriverState *bs); -int bdrv_open (BlockDriverState *bs,const char *filename,int flags, -BlockDriver *drv); +int bdrv_open (BlockDriverState *bs,const char *filename,QDict *options, +int flags,BlockDriver *drv);BlockReopenQueue *bdrv_reopen_queue (BlockReopenQueue *bs_queue,BlockDriverState *bs,int flags);int bdrv_reopen_multiple (BlockReopenQueue *bs_queue,Error **errp);
include/block/block_int.h +1 -0
@@ -286,6 +286,7 @@ struct BlockDriverState {/* long-running background operation */ BlockJob *job; +QDict *options; };int get_tmp_filename (char *filename,int size);
qemu-img.c +3 -3
@@ -276,7 +276,7 @@ static BlockDriverState *bdrv_new_open(const char *filename, drv =NULL ; } - ret =bdrv_open (bs, filename, flags, drv); + ret =bdrv_open (bs, filename,NULL , flags, drv);if (ret <0 ) {error_report ("Could not open '%s': %s" , filename,strerror (-ret)); goto fail;
@@ -2156,7 +2156,7 @@ static int img_rebase(int argc, char **argv) bs_old_backing =bdrv_new ("old_backing" );bdrv_get_backing_filename (bs, backing_name,sizeof (backing_name)); - ret =bdrv_open (bs_old_backing, backing_name,BDRV_O_FLAGS , + ret =bdrv_open (bs_old_backing, backing_name,NULL ,BDRV_O_FLAGS , old_backing_drv);if (ret) {error_report ("Could not open old backing file '%s'" , backing_name);
@@ -2164,7 +2164,7 @@ static int img_rebase(int argc, char **argv) }if (out_baseimg[0 ]) { bs_new_backing =bdrv_new ("new_backing" ); - ret =bdrv_open (bs_new_backing, out_baseimg,BDRV_O_FLAGS , + ret =bdrv_open (bs_new_backing, out_baseimg,NULL ,BDRV_O_FLAGS , new_backing_drv);if (ret) { error_report("Could not open new backing file '%s'",
qemu-io.c +1 -1
@@ -1773,7 +1773,7 @@ static int openfile(char *name, int flags, int growable) }else { bs =bdrv_new ("hda" ); -if (bdrv_open (bs, name, flags,NULL ) <0 ) { +if (bdrv_open (bs, name,NULL , flags,NULL ) <0 ) {fprintf (stderr,"%s: can't open device %s\n" , progname, name);bdrv_delete (bs); bs =NULL ;
qemu-nbd.c +1 -1
@@ -557,7 +557,7 @@ int main(int argc, char **argv) bs =bdrv_new ("hda" ); srcpath = argv[optind]; -if ((ret =bdrv_open (bs, srcpath, flags,NULL )) <0 ) { +if ((ret =bdrv_open (bs, srcpath,NULL , flags,NULL )) <0 ) { errno = -ret;err (EXIT_FAILURE ,"Failed to bdrv_open '%s'" , argv[optind]); }
Signature · 1 line
1.8.1.4
PATCH v2 3/8 Add qdict_clone_shallow()
In reply to Kevin Wolf--- include/qapi/qmp/qdict.h | 2 ++ qobject/qdict.c | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+)
include/qapi/qmp/qdict.h +2 -0
@@ -64,4 +64,6 @@ int64_t qdict_get_try_int(const QDict *qdict, const char *key,int qdict_get_try_bool (const QDict *qdict,const char *key,int def_value);const char *qdict_get_try_str (const QDict *qdict,const char *key); +QDict *qdict_clone_shallow (const QDict *src); +#endif /* QDICT_H */
qobject/qdict.c +22 -0
@@ -401,6 +401,28 @@ const QDictEntry *qdict_next(const QDict *qdict, const QDictEntry *entry) }/** +* qdict_clone_shallow(): Clones a given QDict. Its entries are not copied, but +* another reference is added. +*/ +QDict *qdict_clone_shallow (const QDict *src) +{ +QDict *dest; +QDictEntry *entry; +int i; + + dest =qdict_new (); + +for (i =0 ; i <QDICT_BUCKET_MAX ; i++) { + QLIST_FOREACH(entry, &src->table[i], next) { +qobject_incref (entry->value); +qdict_put_obj (dest, entry->key, entry->value); + } + } + +return dest; +} + +/** * qentry_destroy(): Free all the memory allocated by a QDictEntry */ static void qentry_destroy (QDictEntry *e)
Signature · 1 line
1.8.1.4
PATCH v2 4/8 block: Add options QDict to bdrv_open_common()
In reply to Kevin WolfThe options are passed down to the block drivers, which are supposed to remove all options they have processed. Anything that is left over in the end is an unknown option and results in an error.
--- block.c | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-)
block.c +26 -6
@@ -665,15 +665,18 @@ static int bdrv_open_flags(BlockDriverState *bs, int flags)/* * Common part for opening disk images and files +* +* Removes all processed options from *options. */ static int bdrv_open_common (BlockDriverState *bs,BlockDriverState *file, -const char *filename, +const char *filename,QDict *options,int flags,BlockDriver *drv) {int ret, open_flags;assert (drv !=NULL );assert (bs->file ==NULL ); +assert (options ==NULL || bs->options != options);trace_bdrv_open_common (bs, filename, flags, drv->format_name);
@@ -710,7 +713,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, }else {assert (file !=NULL ); bs->file = file; - ret = drv->bdrv_open (bs,NULL , open_flags); + ret = drv->bdrv_open (bs, options, open_flags); }if (ret <0 ) {
@@ -752,7 +755,7 @@ int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags) } bs =bdrv_new ("" ); - ret =bdrv_open_common (bs,NULL , filename, flags, drv); + ret =bdrv_open_common (bs,NULL , filename,NULL , flags, drv);if (ret <0 ) {bdrv_delete (bs);return ret;
@@ -821,6 +824,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, } bs->options = options; + options =qdict_clone_shallow (options);/* For snapshot=on, create a temporary qcow2 overlay */ if (flags &BDRV_O_SNAPSHOT ) {
@@ -903,7 +907,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, }/* Open the image */ - ret =bdrv_open_common (bs, file, filename, flags, drv); + ret =bdrv_open_common (bs, file, filename, options, flags, drv);if (ret <0 ) { goto unlink_and_fail; }
@@ -917,11 +921,22 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options,if ((flags &BDRV_O_NO_BACKING ) ==0 ) { ret =bdrv_open_backing_file (bs);if (ret <0 ) { -bdrv_close (bs); -return ret; + goto close_and_fail; } } +/* Check if any unknown options were used */ +if (qdict_size (options) !=0 ) { +const QDictEntry *entry =qdict_first (options); +qerror_report (ERROR_CLASS_GENERIC_ERROR ,"Block format '%s' used by " +"device '%s' doesn't support the option '%s'" , + drv->format_name, bs->device_name, entry->key); + + ret = -EINVAL ; + goto close_and_fail; + } +QDECREF (options); +if (!bdrv_key_required (bs)) {bdrv_dev_change_media_cb (bs, true); }
@@ -942,8 +957,13 @@ unlink_and_fail: } fail:QDECREF (bs->options); +QDECREF (options); bs->options =NULL ; +return ret; +close_and_fail: +bdrv_close (bs); +QDECREF (options);return ret; }
Signature · 1 line
1.8.1.4
PATCH v2 5/8 qemu-option: Add qemu_opts_absorb_qdict()
In reply to Kevin WolfThis adds a function that adds all entries of a QDict to a QemuOpts if the keys are known, and leaves only the rest in the QDict.
This way a single QDict of -drive options can be processed in multiple places (generic block layer, block driver, backing file block driver, etc.), where each part picks the options it knows. If at the end of the process the QDict isn't empty, the user specified an invalid option.
--- include/qemu/option.h | 1 + util/qemu-option.c | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+)
include/qemu/option.h +1 -0
@@ -149,6 +149,7 @@ void qemu_opts_set_defaults(QemuOptsList *list, const char *params,QemuOpts *qemu_opts_from_qdict (QemuOptsList *list,const QDict *qdict,Error **errp);QDict *qemu_opts_to_qdict (QemuOpts *opts,QDict *qdict); +void qemu_opts_absorb_qdict (QemuOpts *opts,QDict *qdict,Error **errp);typedef int (*qemu_opts_loopfunc )(QemuOpts *opts,void *opaque);int qemu_opts_print (QemuOpts *opts,void *dummy);
util/qemu-option.c +34 -0
@@ -1067,6 +1067,40 @@ QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict, }/* +* Adds all QDict entries to the QemuOpts that can be added and removes them +* from the QDict. When this function returns, the QDict contains only those +* entries that couldn't be added to the QemuOpts. +*/ +void qemu_opts_absorb_qdict (QemuOpts *opts,QDict *qdict,Error **errp) +{ +const QDictEntry *entry, *next; + + entry =qdict_first (qdict); + +while (entry !=NULL ) { +Error *local_err =NULL ; +OptsFromQDictState state = { + .errp = &local_err, + .opts = opts, + }; + + next =qdict_next (qdict, entry); + +if (find_desc_by_name (opts->list->desc, entry->key)) { +qemu_opts_from_qdict_1 (entry->key, entry->value, &state); +if (error_is_set (&local_err)) { +error_propagate (errp, local_err); +return ; + }else { +qdict_del (qdict, entry->key); + } + } + + entry = next; + } +} + +/* * Convert from QemuOpts to QDict. * The QDict values are of type QString. * TODO We'll want to use types appropriate for opt->desc->type, but
Signature · 1 line
1.8.1.4
PATCH v2 6/8 blockdev: Keep a copy of DriveInfo.serial
In reply to Kevin WolfPointing to a QemuOpts element is surprising and can lead to subtle use-after-free errors when the QemuOpts is freed after all options are parsed.
--- blockdev.c | 5 ++++- include/sysemu/blockdev.h | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-)
blockdev.c +4 -1
@@ -191,6 +191,7 @@ static void drive_uninit(DriveInfo *dinfo)bdrv_delete (dinfo->bdrv);g_free (dinfo->id);QTAILQ_REMOVE (&drives, dinfo, next); +g_free (dinfo->serial);g_free (dinfo); }
@@ -566,7 +567,9 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type) dinfo->trans = translation; dinfo->opts = opts; dinfo->refcount =1 ; - dinfo->serial = serial; +if (serial !=NULL ) { + dinfo->serial =g_strdup (serial); + }QTAILQ_INSERT_TAIL (&drives, dinfo, next);bdrv_set_on_error (dinfo->bdrv, on_read_error, on_write_error);
include/sysemu/blockdev.h +1 -1
@@ -40,7 +40,7 @@ struct DriveInfo {int media_cd;int cyls, heads, secs, trans;QemuOpts *opts; -const char *serial; +char *serial;QTAILQ_ENTRY (DriveInfo) next;int refcount; };
Signature · 1 line
1.8.1.4
PATCH v2 7/8 block: Support driver specific options in drive_init()
In reply to Kevin WolfAny non-default -drive options are now passed down to the block drivers.
--- blockdev.c | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 59 insertions(+), 10 deletions(-)
blockdev.c +59 -10
@@ -22,6 +22,7 @@#include "sysemu/arch_init.h" static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives); +extern QemuOptsList qemu_common_drive_opts;static const char *const if_name[IF_COUNT ] = { [IF_NONE ] ="none" ,
@@ -288,7 +289,7 @@ static bool do_check_io_limits(BlockIOLimit *io_limits, Error **errp)return true; } -DriveInfo *drive_init (QemuOpts *opts,BlockInterfaceType block_default_type) +DriveInfo *drive_init (QemuOpts *all_opts,BlockInterfaceType block_default_type) {const char *buf;const char *file =NULL ;
@@ -311,10 +312,36 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type)bool copy_on_read;int ret;Error *error =NULL ; +QemuOpts *opts; +QDict *bs_opts; +const char *id; translation =BIOS_ATA_TRANSLATION_AUTO ; media =MEDIA_DISK ; +/* Check common options by copying from all_opts to opts, all other options +* are stored in bs_opts. */ + id =qemu_opts_id (all_opts); + opts =qemu_opts_create (&qemu_common_drive_opts, id,1 , &error); +if (error_is_set (&error)) { +qerror_report_err (error); +error_free (error); +return NULL ; + } + + bs_opts =qdict_new (); +qemu_opts_to_qdict (all_opts, bs_opts); +qemu_opts_absorb_qdict (opts, bs_opts, &error); +if (error_is_set (&error)) { +qerror_report_err (error); +error_free (error); +return NULL ; + } + +if (id) { +qdict_del (bs_opts,"id" ); + } +/* extract parameters */ bus_id =qemu_opt_get_number (opts,"bus" ,0 ); unit_id =qemu_opt_get_number (opts,"unit" ,-1 );
@@ -565,7 +592,7 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type) dinfo->heads = heads; dinfo->secs = secs; dinfo->trans = translation; - dinfo->opts = opts; + dinfo->opts = all_opts; dinfo->refcount =1 ;if (serial !=NULL ) { dinfo->serial =g_strdup (serial);
@@ -590,17 +617,20 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type)case IF_MTD :break ;case IF_VIRTIO : + {/* add virtio block device */ - opts =qemu_opts_create_nofail (qemu_find_opts ("device" )); +QemuOpts *devopts; + devopts =qemu_opts_create_nofail (qemu_find_opts ("device" ));if (arch_type ==QEMU_ARCH_S390X ) { -qemu_opt_set (opts,"driver" ,"virtio-blk-s390" ); +qemu_opt_set (devopts,"driver" ,"virtio-blk-s390" ); }else { -qemu_opt_set (opts,"driver" ,"virtio-blk-pci" ); +qemu_opt_set (devopts,"driver" ,"virtio-blk-pci" ); } -qemu_opt_set (opts,"drive" , dinfo->id); +qemu_opt_set (devopts,"drive" , dinfo->id);if (devaddr) -qemu_opt_set (opts,"addr" , devaddr); +qemu_opt_set (devopts,"addr" , devaddr);break ; + }default :abort (); }
@@ -638,7 +668,9 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type)error_report ("warning: disabling copy_on_read on readonly drive" ); } - ret =bdrv_open (dinfo->bdrv, file,NULL , bdrv_flags, drv); + ret =bdrv_open (dinfo->bdrv, file, bs_opts, bdrv_flags, drv); + bs_opts =NULL ; +if (ret <0 ) {if (ret == -EMEDIUMTYPE ) { error_report("could not open disk image %s: not in %s format",
@@ -652,9 +684,14 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type)if (bdrv_key_required (dinfo->bdrv)) autostart =0 ; + +qemu_opts_del (opts); +return dinfo; err: +qemu_opts_del (opts); +QDECREF (bs_opts);bdrv_delete (dinfo->bdrv);g_free (dinfo->id);QTAILQ_REMOVE (&drives, dinfo, next);
@@ -1464,9 +1501,9 @@ BlockJobInfoList *qmp_query_block_jobs(Error **errp)return dummy.next; } -QemuOptsList qemu_drive_opts = { +QemuOptsList qemu_common_drive_opts = { .name ="drive" , - .head =QTAILQ_HEAD_INITIALIZER (qemu_drive_opts.head), + .head =QTAILQ_HEAD_INITIALIZER (qemu_common_drive_opts.head), .desc = { { .name ="bus" ,
@@ -1585,3 +1622,15 @@ QemuOptsList qemu_drive_opts = { {/* end of list */ } }, }; + +QemuOptsList qemu_drive_opts = { + .name ="drive" , + .head =QTAILQ_HEAD_INITIALIZER (qemu_drive_opts.head), + .desc = { +/* +* no elements => accept any params +* validation will happen later +*/ + {/* end of list */ } + }, +};
Signature · 1 line
1.8.1.4
PATCH v2 8/8 qcow2: Allow lazy refcounts to be enabled on the command line
In reply to Kevin Wolfqcow2 images now accept a boolean lazy_refcounts options. Use it like this:
-drive file=test.qcow2,lazy_refcounts=on
If the option is specified on the command line, it overrides the default specified by the qcow2 header flags that were set when creating the image.
--- block/qcow2-cluster.c | 2 +- block/qcow2.c | 37 +++++++++++++++++++++++++++++++++++++ block/qcow2.h | 1 + 3 files changed, 39 insertions(+), 1 deletion(-)
block/qcow2-cluster.c +1 -1
@@ -668,7 +668,7 @@ int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m) }/* Update L2 table. */ -if (s->compatible_features &QCOW2_COMPAT_LAZY_REFCOUNTS ) { +if (s->use_lazy_refcounts) {qcow2_mark_dirty (bs); }if (qcow2_need_accurate_refcounts (s)) {
block/qcow2.c +37 -0
@@ -285,11 +285,26 @@ static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result,return ret; } +static QemuOptsList qcow2_runtime_opts = { + .name ="qcow2" , + .head =QTAILQ_HEAD_INITIALIZER (qcow2_runtime_opts.head), + .desc = { + { + .name ="lazy_refcounts" , + .type =QEMU_OPT_BOOL , + .help ="Postpone refcount updates" , + }, + {/* end of list */ } + }, +}; +static int qcow2_open (BlockDriverState *bs,QDict *options,int flags) {BDRVQcowState *s = bs->opaque;int len, i, ret =0 ;QCowHeader header; +QemuOpts *opts; +Error *local_err =NULL ;uint64_t ext_end; ret =bdrv_pread (bs->file,0 , &header,sizeof (header));
@@ -495,6 +510,28 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags) } } +/* Enable lazy_refcounts according to image and command line options */ + opts =qemu_opts_create_nofail (&qcow2_runtime_opts); +qemu_opts_absorb_qdict (opts, options, &local_err); +if (error_is_set (&local_err)) { +qerror_report_err (local_err); +error_free (local_err); + ret = -EINVAL ; + goto fail; + } + + s->use_lazy_refcounts =qemu_opt_get_bool (opts,"lazy_refcounts" , + (s->compatible_features &QCOW2_COMPAT_LAZY_REFCOUNTS )); + +qemu_opts_del (opts); + +if (s->use_lazy_refcounts && s->qcow_version <3 ) { +qerror_report (ERROR_CLASS_GENERIC_ERROR ,"Lazy refcounts require " +"a qcow2 image with at least qemu 1.1 compatibility level" ); + ret = -EINVAL ; + goto fail; + } +#ifdef DEBUG_ALLOC {BdrvCheckResult result = {0 };
block/qcow2.h +1 -0
@@ -173,6 +173,7 @@ typedef struct BDRVQcowState {int flags;int qcow_version; +bool use_lazy_refcounts;uint64_t incompatible_features;uint64_t compatible_features;
Signature · 1 line
1.8.1.4
Stefan Hajnoczi
AppliedQuoted 37 lines · Kevin Wolf
v2:
- Fixed use after free for serial number
- Fixed id=... handling
- Fixed if=virtio overwriting optsKevin Wolf (8):
block: Add options QDict to .bdrv_open()
block: Add options QDict tobdrv_open()prototype Addqdict_clone_shallow()
block: Add options QDict tobdrv_open_common()
qemu-option: Addqemu_opts_absorb_qdict()
blockdev: Keep a copy of DriveInfo.serial
block: Support driver specific options indrive_init()
qcow2: Allow lazy refcounts to be enabled on the command lineblock.c | 81 +++++++++++++++++++++++++++++++++++----------- block/blkverify.c | 2 +- block/bochs.c | 2 +- block/cloop.c | 2 +- block/cow.c | 2 +- block/dmg.c | 2 +- block/parallels.c | 2 +- block/qcow.c | 2 +- block/qcow2-cluster.c | 2 +- block/qcow2.c | 43 +++++++++++++++++++++++-- block/qcow2.h | 1 + block/qed.c | 4 +-- block/raw.c | 2 +- block/vdi.c | 2 +- block/vmdk.c | 4 +-- block/vpc.c | 2 +- block/vvfat.c | 2 +- blockdev.c | 82 +++++++++++++++++++++++++++++++++++++++-------- hw/xen_disk.c | 2 +- include/block/block.h | 4 +-- include/block/block_int.h | 3 +- include/qapi/qmp/qdict.h | 2 ++
Quoted 13 lines
include/qemu/option.h | 1 + include/sysemu/blockdev.h | 2 +- qemu-img.c | 6 ++-- qemu-io.c | 2 +- qemu-nbd.c | 2 +- qobject/qdict.c | 22 +++++++++++++ util/qemu-option.c | 34 ++++++++++++++++++++ 29 files changed, 257 insertions(+), 62 deletions(-)Signature · 1 line
1.8.1.4
Thanks, applied to my block tree:
https://github.com/stefanha/qemu/commits/block
Stefan