From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:34746) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XRhDU-0002PQ-NH for qemu-devel@nongnu.org; Wed, 10 Sep 2014 08:41:50 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XRhDO-0002nQ-Ba for qemu-devel@nongnu.org; Wed, 10 Sep 2014 08:41:44 -0400 Received: from lputeaux-656-01-25-125.w80-12.abo.wanadoo.fr ([80.12.84.125]:40860 helo=paradis.irqsave.net) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XRhDN-0002n9-Tn for qemu-devel@nongnu.org; Wed, 10 Sep 2014 08:41:38 -0400 Date: Wed, 10 Sep 2014 14:40:42 +0200 From: =?iso-8859-1?Q?Beno=EEt?= Canet Message-ID: <20140910124042.GC22376@irqsave.net> References: <1410336832-22160-1-git-send-email-armbru@redhat.com> <1410336832-22160-3-git-send-email-armbru@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline In-Reply-To: <1410336832-22160-3-git-send-email-armbru@redhat.com> Content-Transfer-Encoding: quoted-printable Subject: Re: [Qemu-devel] [PATCH 02/23] block: New BlockBackend List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Markus Armbruster Cc: kwolf@redhat.com, benoit.canet@irqsave.net, famz@redhat.com, qemu-devel@nongnu.org, stefanha@redhat.com The Wednesday 10 Sep 2014 =E0 10:13:31 (+0200), Markus Armbruster wrote : > A block device consists of a frontend device model and a backend. >=20 > A block backend has a tree of block drivers doing the actual work. > The tree is managed by the block layer. >=20 > We currently use a single abstraction BlockDriverState both for tree > nodes and the backend as a whole. Drawbacks: >=20 > * Its API includes both stuff that makes sense only at the block > backend level (root of the tree) and stuff that's only for use > within the block layer. This makes the API bigger and more complex > than necessary. Moreover, it's not obvious which interfaces are > meant for device models, and which really aren't. >=20 > * Since device models keep a reference to their backend, the backend > object can't just be destroyed. But for media change, we need to > replace the tree. Our solution is to make the BlockDriverState > generic, with actual driver state in a separate object, pointed to > by member opaque. That lets us replace the tree by deinitializing > and reinitializing its root. This special need of the root makes > the data structure awkward everywhere in the tree. >=20 > The general plan is to separate the APIs into "block backend", for use > by device models, monitor and whatever other code dealing with block > backends, and "block driver", for use by the block layer and whatever > other code (if any) dealing with trees and tree nodes. >=20 > Code dealing with block backends, device models in particular, should > become completely oblivious of BlockDriverState. This should let us > clean up both APIs, and the tree data structures. >=20 > This commit is a first step. It creates a minimal "block backend" > API: type BlockBackend and functions to create, destroy and find them. > BlockBackend objects are created and destroyed, but not yet used for > anything; that'll come shortly. >=20 > BlockBackend is reference-counted. Its reference count never exceeds > one so far, but that's going to change. >=20 > Signed-off-by: Markus Armbruster > --- > block/Makefile.objs | 2 +- > block/block-backend.c | 110 +++++++++++++++++++++++++++++++++= ++++++++ > blockdev.c | 10 +++- > hw/block/xen_disk.c | 11 +++++ > include/qemu/typedefs.h | 1 + > include/sysemu/block-backend.h | 26 ++++++++++ > qemu-img.c | 46 +++++++++++++++++ > qemu-io.c | 8 +++ > qemu-nbd.c | 3 +- > 9 files changed, 214 insertions(+), 3 deletions(-) > create mode 100644 block/block-backend.c > create mode 100644 include/sysemu/block-backend.h >=20 > diff --git a/block/Makefile.objs b/block/Makefile.objs > index f45f939..a70140b 100644 > --- a/block/Makefile.objs > +++ b/block/Makefile.objs > @@ -5,7 +5,7 @@ block-obj-y +=3D qed-check.o > block-obj-$(CONFIG_VHDX) +=3D vhdx.o vhdx-endian.o vhdx-log.o > block-obj-$(CONFIG_QUORUM) +=3D quorum.o > block-obj-y +=3D parallels.o blkdebug.o blkverify.o > -block-obj-y +=3D snapshot.o qapi.o > +block-obj-y +=3D block-backend.o snapshot.o qapi.o > block-obj-$(CONFIG_WIN32) +=3D raw-win32.o win32-aio.o > block-obj-$(CONFIG_POSIX) +=3D raw-posix.o > block-obj-$(CONFIG_LINUX_AIO) +=3D linux-aio.o > diff --git a/block/block-backend.c b/block/block-backend.c > new file mode 100644 > index 0000000..833f7d9 > --- /dev/null > +++ b/block/block-backend.c > @@ -0,0 +1,110 @@ > +/* > + * QEMU Block backends > + * > + * Copyright (C) 2014 Red Hat, Inc. > + * > + * Authors: > + * Markus Armbruster , > + * > + * This work is licensed under the terms of the GNU GPL, version 2 or > + * later. See the COPYING file in the top-level directory. > + */ > + > +#include "sysemu/block-backend.h" > +#include "block/block_int.h" > + > +struct BlockBackend { > + char *name; > + int refcnt; > + QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */ > +}; > + > +static QTAILQ_HEAD(, BlockBackend) blk_backends =3D > + QTAILQ_HEAD_INITIALIZER(blk_backends); > + > +/** > + * blk_new: > + * @name: name, must not be %NULL or empty > + * @errp: return location for an error to be set on failure, or %NULL > + * > + * Create a new BlockBackend, with a reference count of one. Fail if > + * @name already exists. > + * > + * Returns: the BlockBackend on success, %NULL on failure > + */ > +BlockBackend *blk_new(const char *name, Error **errp) > +{ > + BlockBackend *blk =3D g_new0(BlockBackend, 1); > + > + assert(name && name[0]); > + if (blk_by_name(name)) { > + error_setg(errp, "Device with id '%s' already exists", name); > + return NULL; > + } > + blk->name =3D g_strdup(name); > + blk->refcnt =3D 1; > + QTAILQ_INSERT_TAIL(&blk_backends, blk, link); > + return blk; > +} > + > +static void blk_delete(BlockBackend *blk) > +{ > + assert(!blk->refcnt); > + QTAILQ_REMOVE(&blk_backends, blk, link); > + g_free(blk->name); > + g_free(blk); > +} > + > +/** > + * blk_ref: > + * > + * Increment @blk's reference count. > + */ > +void blk_ref(BlockBackend *blk) > +{ > + blk->refcnt++; > +} > + > +/** > + * blk_unref: > + * > + * Decrement @blk's reference count. If this drops it to zero, > + * destroy @blk. > + */ > +void blk_unref(BlockBackend *blk) > +{ > + if (blk) { > + g_assert(blk->refcnt > 0); > + if (!--blk->refcnt) { > + blk_delete(blk); > + } > + } > +} > + > +const char *blk_name(BlockBackend *blk) > +{ > + return blk->name; > +} > + > +BlockBackend *blk_by_name(const char *name) > +{ > + BlockBackend *blk; > + > + QTAILQ_FOREACH(blk, &blk_backends, link) { > + if (!strcmp(name, blk->name)) { > + return blk; > + } > + } > + return NULL; > +} > + > +/** > + * blk_next: > + * > + * Returns: the first BlockBackend if @blk is null, else @blk's next > + * sibling, which is %NULL for the last BlockBackend > + */ > +BlockBackend *blk_next(BlockBackend *blk) > +{ > + return blk ? QTAILQ_NEXT(blk, link) : QTAILQ_FIRST(&blk_backends); > +} > diff --git a/blockdev.c b/blockdev.c > index 9fbd888..86596bc 100644 > --- a/blockdev.c > +++ b/blockdev.c > @@ -30,6 +30,7 @@ > * THE SOFTWARE. > */ > =20 > +#include "sysemu/block-backend.h" > #include "sysemu/blockdev.h" > #include "hw/block/block.h" > #include "block/blockjob.h" > @@ -221,6 +222,7 @@ void drive_del(DriveInfo *dinfo) > } > =20 > bdrv_unref(dinfo->bdrv); > + blk_unref(blk_by_name(dinfo->id)); > g_free(dinfo->id); > QTAILQ_REMOVE(&drives, dinfo, next); > g_free(dinfo->serial); > @@ -301,6 +303,7 @@ static DriveInfo *blockdev_init(const char *file, Q= Dict *bs_opts, > int ro =3D 0; > int bdrv_flags =3D 0; > int on_read_error, on_write_error; > + BlockBackend *blk; > DriveInfo *dinfo; > ThrottleConfig cfg; > int snapshot =3D 0; > @@ -456,6 +459,10 @@ static DriveInfo *blockdev_init(const char *file, = QDict *bs_opts, > } > =20 > /* init */ > + blk =3D blk_new(qemu_opts_id(opts), errp); > + if (!blk) { > + goto early_err; > + } Here you create a new block backend. And you don't attach it to anything in any way yet. So down in the code the following test will leak it: if (!file || !*file) { = =20 if (has_driver_specific_opts) { = =20 file =3D NULL; = =20 } else { = =20 QDECREF(bs_opts); = =20 qemu_opts_del(opts); = =20 return dinfo; = =20 } = =20 }=20 I am sure one of your next patchs fixes this but for this precise commit this do look like a leak. > dinfo =3D g_malloc0(sizeof(*dinfo)); > dinfo->id =3D g_strdup(qemu_opts_id(opts)); > dinfo->bdrv =3D bdrv_new_named(dinfo->id, &error); > @@ -525,6 +532,7 @@ err: > bdrv_new_err: > g_free(dinfo->id); > g_free(dinfo); > + blk_unref(blk); > early_err: > qemu_opts_del(opts); > err_no_opts: > @@ -1770,7 +1778,7 @@ int do_drive_del(Monitor *mon, const QDict *qdict= , QObject **ret_data) > */ > if (bdrv_get_attached_dev(bs)) { > bdrv_make_anon(bs); > - > + blk_unref(blk_by_name(id)); > /* Further I/O must not pause the guest */ > bdrv_set_on_error(bs, BLOCKDEV_ON_ERROR_REPORT, > BLOCKDEV_ON_ERROR_REPORT); > diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c > index 8bac7ff..730a021 100644 > --- a/hw/block/xen_disk.c > +++ b/hw/block/xen_disk.c > @@ -39,6 +39,7 @@ > #include "hw/xen/xen_backend.h" > #include "xen_blkif.h" > #include "sysemu/blockdev.h" > +#include "sysemu/block-backend.h" > =20 > /* ------------------------------------------------------------- */ > =20 > @@ -852,12 +853,18 @@ static int blk_connect(struct XenDevice *xendev) > blkdev->dinfo =3D drive_get(IF_XEN, 0, index); > if (!blkdev->dinfo) { > Error *local_err =3D NULL; > + BlockBackend *blk; > BlockDriver *drv; > =20 > /* setup via xenbus -> create new block driver instance */ > xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus set= up)\n"); > + blk =3D blk_new(blkdev->dev, NULL); > + if (!blk) { > + return -1; > + } > blkdev->bs =3D bdrv_new_named(blkdev->dev, NULL); > if (!blkdev->bs) { > + blk_unref(blk); > return -1; > } > =20 > @@ -868,6 +875,7 @@ static int blk_connect(struct XenDevice *xendev) > error_get_pretty(local_err)); > error_free(local_err); > bdrv_unref(blkdev->bs); > + blk_unref(blk); > blkdev->bs =3D NULL; > return -1; > } > @@ -983,6 +991,9 @@ static void blk_disconnect(struct XenDevice *xendev= ) > if (blkdev->bs) { > bdrv_detach_dev(blkdev->bs, blkdev); > bdrv_unref(blkdev->bs); > + if (!blkdev->dinfo) { > + blk_unref(blk_by_name(blkdev->dev)); > + } > blkdev->bs =3D NULL; > } > xen_be_unbind_evtchn(&blkdev->xendev); > diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h > index 5f20b0e..198da2e 100644 > --- a/include/qemu/typedefs.h > +++ b/include/qemu/typedefs.h > @@ -35,6 +35,7 @@ typedef struct MachineClass MachineClass; > typedef struct NICInfo NICInfo; > typedef struct HCIInfo HCIInfo; > typedef struct AudioState AudioState; > +typedef struct BlockBackend BlockBackend; > typedef struct BlockDriverState BlockDriverState; > typedef struct DriveInfo DriveInfo; > typedef struct DisplayState DisplayState; > diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-back= end.h > new file mode 100644 > index 0000000..3f8371c > --- /dev/null > +++ b/include/sysemu/block-backend.h > @@ -0,0 +1,26 @@ > +/* > + * QEMU Block backends > + * > + * Copyright (C) 2014 Red Hat, Inc. > + * > + * Authors: > + * Markus Armbruster , > + * > + * This work is licensed under the terms of the GNU GPL, version 2 or > + * later. See the COPYING file in the top-level directory. > + */ > + > +#ifndef BLOCK_BACKEND_H > +#define BLOCK_BACKEND_H > + > +#include "qemu/typedefs.h" > +#include "qapi/error.h" > + > +BlockBackend *blk_new(const char *name, Error **errp); > +void blk_ref(BlockBackend *blk); > +void blk_unref(BlockBackend *blk); > +const char *blk_name(BlockBackend *blk); > +BlockBackend *blk_by_name(const char *name); > +BlockBackend *blk_next(BlockBackend *blk); > + > +#endif > diff --git a/qemu-img.c b/qemu-img.c > index 4490a22..bad3f64 100644 > --- a/qemu-img.c > +++ b/qemu-img.c > @@ -29,6 +29,7 @@ > #include "qemu/error-report.h" > #include "qemu/osdep.h" > #include "sysemu/sysemu.h" > +#include "sysemu/block-backend.h" > #include "block/block_int.h" > #include "block/qapi.h" > #include > @@ -575,6 +576,7 @@ static int img_check(int argc, char **argv) > int c, ret; > OutputFormat output_format =3D OFORMAT_HUMAN; > const char *filename, *fmt, *output, *cache; > + BlockBackend *blk; > BlockDriverState *bs; > int fix =3D 0; > int flags =3D BDRV_O_FLAGS | BDRV_O_CHECK; > @@ -649,6 +651,7 @@ static int img_check(int argc, char **argv) > return 1; > } > =20 > + blk =3D blk_new("image", &error_abort); Hmm we are so sure this will work that we don't do if (!block) ? > bs =3D bdrv_new_open("image", filename, fmt, flags, true, quiet); > if (!bs) { > return 1; > @@ -710,6 +713,7 @@ static int img_check(int argc, char **argv) > fail: > qapi_free_ImageCheck(check); > bdrv_unref(bs); > + blk_unref(blk); > =20 > return ret; > } > @@ -718,6 +722,7 @@ static int img_commit(int argc, char **argv) > { > int c, ret, flags; > const char *filename, *fmt, *cache; > + BlockBackend *blk; > BlockDriverState *bs; > bool quiet =3D false; > =20 > @@ -756,6 +761,7 @@ static int img_commit(int argc, char **argv) > return 1; > } > =20 > + blk =3D blk_new("image", &error_abort); > bs =3D bdrv_new_open("image", filename, fmt, flags, true, quiet); > if (!bs) { > return 1; > @@ -780,6 +786,7 @@ static int img_commit(int argc, char **argv) > } > =20 > bdrv_unref(bs); > + blk_unref(blk); > if (ret) { > return 1; > } > @@ -942,6 +949,7 @@ static int check_empty_sectors(BlockDriverState *bs= , int64_t sect_num, > static int img_compare(int argc, char **argv) > { > const char *fmt1 =3D NULL, *fmt2 =3D NULL, *cache, *filename1, *fi= lename2; > + BlockBackend *blk1, *blk2; > BlockDriverState *bs1, *bs2; > int64_t total_sectors1, total_sectors2; > uint8_t *buf1 =3D NULL, *buf2 =3D NULL; > @@ -1011,6 +1019,7 @@ static int img_compare(int argc, char **argv) > goto out3; > } > =20 > + blk1 =3D blk_new("image 1", &error_abort); > bs1 =3D bdrv_new_open("image 1", filename1, fmt1, flags, true, qui= et); > if (!bs1) { > error_report("Can't open file %s", filename1); > @@ -1018,6 +1027,7 @@ static int img_compare(int argc, char **argv) > goto out3; > } > =20 > + blk2 =3D blk_new("image 2", &error_abort); > bs2 =3D bdrv_new_open("image 2", filename2, fmt2, flags, true, qui= et); > if (!bs2) { > error_report("Can't open file %s", filename2); > @@ -1184,10 +1194,12 @@ static int img_compare(int argc, char **argv) > =20 > out: > bdrv_unref(bs2); > + blk_unref(blk2); > qemu_vfree(buf1); > qemu_vfree(buf2); > out2: > bdrv_unref(bs1); > + blk_unref(blk1); > out3: > qemu_progress_end(); > return ret; > @@ -1200,6 +1212,7 @@ static int img_convert(int argc, char **argv) > int progress =3D 0, flags, src_flags; > const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_= filename; > BlockDriver *drv, *proto_drv; > + BlockBackend **blk =3D NULL, *out_blk =3D NULL; > BlockDriverState **bs =3D NULL, *out_bs =3D NULL; > int64_t total_sectors, nb_sectors, sector_num, bs_offset; > int64_t *bs_sectors =3D NULL; > @@ -1354,6 +1367,7 @@ static int img_convert(int argc, char **argv) > =20 > qemu_progress_print(0, 100); > =20 > + blk =3D g_new0(BlockBackend *, bs_n); > bs =3D g_new0(BlockDriverState *, bs_n); > bs_sectors =3D g_new(int64_t, bs_n); > =20 > @@ -1361,6 +1375,7 @@ static int img_convert(int argc, char **argv) > for (bs_i =3D 0; bs_i < bs_n; bs_i++) { > char *id =3D bs_n > 1 ? g_strdup_printf("source %d", bs_i) > : g_strdup("source"); > + blk[bs_i] =3D blk_new(id, &error_abort); > bs[bs_i] =3D bdrv_new_open(id, argv[optind + bs_i], fmt, src_f= lags, > true, quiet); > g_free(id); > @@ -1486,6 +1501,7 @@ static int img_convert(int argc, char **argv) > goto out; > } > =20 > + out_blk =3D blk_new("target", &error_abort); > out_bs =3D bdrv_new_open("target", out_filename, out_fmt, flags, t= rue, quiet); > if (!out_bs) { > ret =3D -1; > @@ -1742,6 +1758,7 @@ out: > if (out_bs) { > bdrv_unref(out_bs); > } > + blk_unref(out_blk); > if (bs) { > for (bs_i =3D 0; bs_i < bs_n; bs_i++) { > if (bs[bs_i]) { > @@ -1750,6 +1767,12 @@ out: > } > g_free(bs); > } > + if (blk) { > + for (bs_i =3D 0; bs_i < bs_n; bs_i++) { > + blk_unref(blk[bs_i]); > + } > + g_free(blk); > + } > g_free(bs_sectors); > fail_getopt: > g_free(options); > @@ -1858,6 +1881,7 @@ static ImageInfoList *collect_image_info_list(con= st char *filename, > filenames =3D g_hash_table_new_full(g_str_hash, str_equal_func, NU= LL, NULL); > =20 > while (filename) { > + BlockBackend *blk; > BlockDriverState *bs; > ImageInfo *info; > ImageInfoList *elem; > @@ -1869,6 +1893,7 @@ static ImageInfoList *collect_image_info_list(con= st char *filename, > } > g_hash_table_insert(filenames, (gpointer)filename, NULL); > =20 > + blk =3D blk_new("image", &error_abort); > bs =3D bdrv_new_open("image", filename, fmt, > BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, fa= lse); > if (!bs) { I think it misses an=20 > + blk_unref(blk); in if(!bs) branch. > @@ -1880,6 +1905,7 @@ static ImageInfoList *collect_image_info_list(con= st char *filename, > error_report("%s", error_get_pretty(err)); > error_free(err); > bdrv_unref(bs); > + blk_unref(blk); > goto err; > } > =20 > @@ -1889,6 +1915,7 @@ static ImageInfoList *collect_image_info_list(con= st char *filename, > last =3D &elem->next; > =20 > bdrv_unref(bs); > + blk_unref(blk); > =20 > filename =3D fmt =3D NULL; > if (chain) { > @@ -2082,6 +2109,7 @@ static int img_map(int argc, char **argv) > { > int c; > OutputFormat output_format =3D OFORMAT_HUMAN; > + BlockBackend *blk; > BlockDriverState *bs; > const char *filename, *fmt, *output; > int64_t length; > @@ -2130,6 +2158,7 @@ static int img_map(int argc, char **argv) > return 1; > } > =20 > + blk =3D blk_new("image", &error_abort); > bs =3D bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS, true, f= alse); > if (!bs) { > return 1; > @@ -2175,6 +2204,7 @@ static int img_map(int argc, char **argv) > =20 > out: > bdrv_unref(bs); > + blk_unref(blk); > return ret < 0; > } > =20 > @@ -2185,6 +2215,7 @@ out: > =20 > static int img_snapshot(int argc, char **argv) > { > + BlockBackend *blk; > BlockDriverState *bs; > QEMUSnapshotInfo sn; > char *filename, *snapshot_name =3D NULL; > @@ -2250,6 +2281,7 @@ static int img_snapshot(int argc, char **argv) > filename =3D argv[optind++]; > =20 > /* Open the image */ > + blk =3D blk_new("image", &error_abort); > bs =3D bdrv_new_open("image", filename, NULL, bdrv_oflags, true, q= uiet); > if (!bs) { > return 1; > @@ -2297,6 +2329,7 @@ static int img_snapshot(int argc, char **argv) > =20 > /* Cleanup */ > bdrv_unref(bs); > + blk_unref(blk); > if (ret) { > return 1; > } > @@ -2305,6 +2338,7 @@ static int img_snapshot(int argc, char **argv) > =20 > static int img_rebase(int argc, char **argv) > { > + BlockBackend *blk =3D NULL, *blk_old_backing =3D NULL, *blk_new_ba= cking =3D NULL; > BlockDriverState *bs =3D NULL, *bs_old_backing =3D NULL, *bs_new_b= acking =3D NULL; > BlockDriver *old_backing_drv, *new_backing_drv; > char *filename; > @@ -2393,6 +2427,7 @@ static int img_rebase(int argc, char **argv) > * Ignore the old backing file for unsafe rebase in case we want t= o correct > * the reference to a renamed or moved backing file. > */ > + blk =3D blk_new("image", &error_abort); > bs =3D bdrv_new_open("image", filename, fmt, flags, true, quiet); > if (!bs) { > ret =3D -1; > @@ -2425,6 +2460,7 @@ static int img_rebase(int argc, char **argv) > if (!unsafe) { > char backing_name[1024]; > =20 > + blk_old_backing =3D blk_new("old_backing", &error_abort); > bs_old_backing =3D bdrv_new_named("old_backing", &error_abort)= ; > bdrv_get_backing_filename(bs, backing_name, sizeof(backing_nam= e)); > ret =3D bdrv_open(&bs_old_backing, backing_name, NULL, NULL, s= rc_flags, > @@ -2436,6 +2472,7 @@ static int img_rebase(int argc, char **argv) > goto out; > } > if (out_baseimg[0]) { > + blk_new_backing =3D blk_new("new_backing", &error_abort); > bs_new_backing =3D bdrv_new_named("new_backing", &error_ab= ort); > ret =3D bdrv_open(&bs_new_backing, out_baseimg, NULL, NULL= , src_flags, > new_backing_drv, &local_err); > @@ -2614,12 +2651,15 @@ out: > if (bs_old_backing !=3D NULL) { > bdrv_unref(bs_old_backing); > } > + blk_unref(blk_old_backing); > if (bs_new_backing !=3D NULL) { > bdrv_unref(bs_new_backing); > } > + blk_unref(blk_new_backing); > } > =20 > bdrv_unref(bs); > + blk_unref(blk); > if (ret) { > return 1; > } > @@ -2632,6 +2672,7 @@ static int img_resize(int argc, char **argv) > const char *filename, *fmt, *size; > int64_t n, total_size; > bool quiet =3D false; > + BlockBackend *blk =3D NULL; > BlockDriverState *bs =3D NULL; > QemuOpts *param; > static QemuOptsList resize_options =3D { > @@ -2708,6 +2749,7 @@ static int img_resize(int argc, char **argv) > n =3D qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0); > qemu_opts_del(param); > =20 > + blk =3D blk_new("image", &error_abort); > bs =3D bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O= _RDWR, > true, quiet); > if (!bs) { > @@ -2745,6 +2787,7 @@ out: > if (bs) { > bdrv_unref(bs); > } > + blk_unref(blk); > if (ret) { > return 1; > } > @@ -2760,6 +2803,7 @@ static int img_amend(int argc, char **argv) > const char *fmt =3D NULL, *filename, *cache; > int flags; > bool quiet =3D false; > + BlockBackend *blk =3D NULL; > BlockDriverState *bs =3D NULL; > =20 > cache =3D BDRV_DEFAULT_CACHE; > @@ -2823,6 +2867,7 @@ static int img_amend(int argc, char **argv) > goto out; > } > =20 > + blk =3D blk_new("image", &error_abort); > bs =3D bdrv_new_open("image", filename, fmt, flags, true, quiet); > if (!bs) { > error_report("Could not open image '%s'", filename); > @@ -2856,6 +2901,7 @@ out: > if (bs) { > bdrv_unref(bs); > } > + blk_unref(blk); > qemu_opts_del(opts); > qemu_opts_free(create_opts); > g_free(options); > diff --git a/qemu-io.c b/qemu-io.c > index 44c2e1c..45e5494 100644 > --- a/qemu-io.c > +++ b/qemu-io.c > @@ -19,6 +19,7 @@ > #include "qemu/option.h" > #include "qemu/config-file.h" > #include "qemu/readline.h" > +#include "sysemu/block-backend.h" > #include "block/block_int.h" > #include "trace/control.h" > =20 > @@ -26,6 +27,7 @@ > =20 > static char *progname; > =20 > +static BlockBackend *qemuio_blk; > static BlockDriverState *qemuio_bs; > =20 > /* qemu-io commands passed using -c */ > @@ -37,7 +39,9 @@ static ReadLineState *readline_state; > static int close_f(BlockDriverState *bs, int argc, char **argv) > { > bdrv_unref(bs); > + blk_unref(qemuio_blk); > qemuio_bs =3D NULL; > + qemuio_blk =3D NULL; > return 0; > } > =20 > @@ -58,6 +62,7 @@ static int openfile(char *name, int flags, int growab= le, QDict *opts) > return 1; > } > =20 > + qemuio_blk =3D blk_new("hda", &error_abort); > qemuio_bs =3D bdrv_new_named("hda", &error_abort); I see accepting that an allocation _will_ work is the qemu tools style. > =20 > if (growable) { > @@ -70,7 +75,9 @@ static int openfile(char *name, int flags, int growab= le, QDict *opts) > error_get_pretty(local_err)); > error_free(local_err); > bdrv_unref(qemuio_bs); > + blk_unref(qemuio_blk); > qemuio_bs =3D NULL; > + qemuio_blk =3D NULL; > return 1; > } > =20 > @@ -479,6 +486,7 @@ int main(int argc, char **argv) > if (qemuio_bs) { > bdrv_unref(qemuio_bs); > } > + blk_unref(qemuio_blk); > g_free(readline_state); > return 0; > } > diff --git a/qemu-nbd.c b/qemu-nbd.c > index a56ebfc..94b9b49 100644 > --- a/qemu-nbd.c > +++ b/qemu-nbd.c > @@ -17,7 +17,7 @@ > */ > =20 > #include "qemu-common.h" > -#include "block/block.h" > +#include "sysemu/block-backend.h" > #include "block/block_int.h" > #include "block/nbd.h" > #include "qemu/main-loop.h" > @@ -687,6 +687,7 @@ int main(int argc, char **argv) > drv =3D NULL; > } > =20 > + blk_new("hda", &error_abort); > bs =3D bdrv_new_named("hda", &error_abort); > =20 > srcpath =3D argv[optind]; > --=20 > 1.9.3 >=20 >=20