From d8bb71b6227366c188595b91c24a58c9b06e46dd Mon Sep 17 00:00:00 2001 From: Zhang Haoyu Date: Sat, 11 Oct 2014 16:35:43 +0800 Subject: [PATCH 01/28] qcow2: fix leak of Qcow2DiscardRegion in update_refcount_discard When the Qcow2DiscardRegion is adjacent to another one referenced by "d", free this Qcow2DiscardRegion metadata referenced by "p" after it was removed from s->discards queue. Signed-off-by: Zhang Haoyu Signed-off-by: Kevin Wolf --- block/qcow2-refcount.c | 1 + 1 file changed, 1 insertion(+) diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c index 2bcaaf9b98..c31d85a840 100644 --- a/block/qcow2-refcount.c +++ b/block/qcow2-refcount.c @@ -524,6 +524,7 @@ found: QTAILQ_REMOVE(&s->discards, p, next); d->offset = MIN(d->offset, p->offset); d->bytes += p->bytes; + g_free(p); } } From 38c4d0aea3e1264c86e282d99560330adf2b6e25 Mon Sep 17 00:00:00 2001 From: Tony Breeds Date: Fri, 26 Sep 2014 09:14:11 +1000 Subject: [PATCH 02/28] block/raw-posix: Fix disk corruption in try_fiemap MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Using fiemap without FIEMAP_FLAG_SYNC is a known corrupter. Add the FIEMAP_FLAG_SYNC flag to the FS_IOC_FIEMAP ioctl. This has the downside of significantly reducing performance. Reported-By: Michael Steffens Signed-off-by: Tony Breeds Cc: Kevin Wolf Cc: Markus Armbruster Cc: Stefan Hajnoczi Cc: Max Reitz Cc: Pádraig Brady Cc: Eric Blake Reviewed-by: Eric Blake Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block/raw-posix.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/block/raw-posix.c b/block/raw-posix.c index 86ce4f2607..d672c739c8 100644 --- a/block/raw-posix.c +++ b/block/raw-posix.c @@ -1482,7 +1482,7 @@ static int64_t try_fiemap(BlockDriverState *bs, off_t start, off_t *data, f.fm.fm_start = start; f.fm.fm_length = (int64_t)nb_sectors * BDRV_SECTOR_SIZE; - f.fm.fm_flags = 0; + f.fm.fm_flags = FIEMAP_FLAG_SYNC; f.fm.fm_extent_count = 1; f.fm.fm_reserved = 0; if (ioctl(s->fd, FS_IOC_FIEMAP, &f) == -1) { From 7c15903789953ead14a417882657d52dc0c19a24 Mon Sep 17 00:00:00 2001 From: Tony Breeds Date: Fri, 26 Sep 2014 09:14:12 +1000 Subject: [PATCH 03/28] block/raw-posix: use seek_hole ahead of fiemap MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit try_fiemap() uses FIEMAP_FLAG_SYNC which has a significant performance impact. Prefer seek_hole() over fiemap() to avoid this impact where possible. seek_hole is more widely used and, arguably, has potential to be optimised in the kernel. Reported-By: Michael Steffens Signed-off-by: Tony Breeds Cc: Kevin Wolf Cc: Markus Armbruster Cc: Stefan Hajnoczi Cc: Max Reitz Cc: Pádraig Brady Cc: Eric Blake Reviewed-by: Eric Blake Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block/raw-posix.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/block/raw-posix.c b/block/raw-posix.c index d672c739c8..eb76f0e233 100644 --- a/block/raw-posix.c +++ b/block/raw-posix.c @@ -1571,9 +1571,9 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs, start = sector_num * BDRV_SECTOR_SIZE; - ret = try_fiemap(bs, start, &data, &hole, nb_sectors, pnum); + ret = try_seek_hole(bs, start, &data, &hole, pnum); if (ret < 0) { - ret = try_seek_hole(bs, start, &data, &hole, pnum); + ret = try_fiemap(bs, start, &data, &hole, nb_sectors, pnum); if (ret < 0) { /* Assume everything is allocated. */ data = 0; From ec0de76874462c745a1600911bd81ee0253c0c23 Mon Sep 17 00:00:00 2001 From: Max Reitz Date: Wed, 8 Oct 2014 19:55:15 +0200 Subject: [PATCH 04/28] nbd: Fix filename generation Export names may be used with nbd+unix, too, fix nbd_refresh_filename() accordingly. Also, for nbd+tcp, the documented path schema is "nbd://host[:port]/export", so use it. Furthermore, as can be seen from that schema, the port is optional. That makes six single cases for how the filename can be formatted; it is not easy to generalize these cases without the resulting statement being completely unreadable, thus there is simply one snprintf() per case. Finally, taking the options from BDRVNBDState::socket_opts is wrong, because those will not contain the export name. Just use BlockDriverState::options instead. Reported-by: Stefan Hajnoczi Signed-off-by: Max Reitz Reviewed-by: Paolo Bonzini Signed-off-by: Kevin Wolf --- block/nbd.c | 46 ++++++++++++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 16 deletions(-) diff --git a/block/nbd.c b/block/nbd.c index 89775e1e2b..04cc845076 100644 --- a/block/nbd.c +++ b/block/nbd.c @@ -342,30 +342,44 @@ static void nbd_attach_aio_context(BlockDriverState *bs, static void nbd_refresh_filename(BlockDriverState *bs) { - BDRVNBDState *s = bs->opaque; QDict *opts = qdict_new(); - const char *path = qemu_opt_get(s->socket_opts, "path"); - const char *host = qemu_opt_get(s->socket_opts, "host"); - const char *port = qemu_opt_get(s->socket_opts, "port"); - const char *export = qemu_opt_get(s->socket_opts, "export"); + const char *path = qdict_get_try_str(bs->options, "path"); + const char *host = qdict_get_try_str(bs->options, "host"); + const char *port = qdict_get_try_str(bs->options, "port"); + const char *export = qdict_get_try_str(bs->options, "export"); qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("nbd"))); + if (path && export) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nbd+unix:///%s?socket=%s", export, path); + } else if (path && !export) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nbd+unix://?socket=%s", path); + } else if (!path && export && port) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nbd://%s:%s/%s", host, port, export); + } else if (!path && export && !port) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nbd://%s/%s", host, export); + } else if (!path && !export && port) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nbd://%s:%s", host, port); + } else if (!path && !export && !port) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nbd://%s", host); + } + if (path) { - snprintf(bs->exact_filename, sizeof(bs->exact_filename), - "nbd+unix:%s", path); qdict_put_obj(opts, "path", QOBJECT(qstring_from_str(path))); - } else if (export) { - snprintf(bs->exact_filename, sizeof(bs->exact_filename), - "nbd:%s:%s/%s", host, port, export); - qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host))); - qdict_put_obj(opts, "port", QOBJECT(qstring_from_str(port))); - qdict_put_obj(opts, "export", QOBJECT(qstring_from_str(export))); - } else { - snprintf(bs->exact_filename, sizeof(bs->exact_filename), - "nbd:%s:%s", host, port); + } else if (port) { qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host))); qdict_put_obj(opts, "port", QOBJECT(qstring_from_str(port))); + } else { + qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host))); + } + if (export) { + qdict_put_obj(opts, "export", QOBJECT(qstring_from_str(export))); } bs->full_open_options = opts; From e4e9986b1caebebdbe53d6f9ad5b03d5ba83f4c3 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:03 +0200 Subject: [PATCH 05/28] block: Split bdrv_new_root() off bdrv_new() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Creating an anonymous BDS can't fail. Make that obvious. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Reviewed-by: Benoît Canet Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- block.c | 28 +++++++++++++++++++--------- block/iscsi.c | 2 +- block/vvfat.c | 2 +- blockdev.c | 2 +- hw/block/xen_disk.c | 2 +- include/block/block.h | 3 ++- qemu-img.c | 6 +++--- qemu-io.c | 2 +- qemu-nbd.c | 2 +- 9 files changed, 30 insertions(+), 19 deletions(-) diff --git a/block.c b/block.c index 27533f3a81..42659ecc71 100644 --- a/block.c +++ b/block.c @@ -336,10 +336,11 @@ void bdrv_register(BlockDriver *bdrv) } /* create a new block device (by default it is empty) */ -BlockDriverState *bdrv_new(const char *device_name, Error **errp) +BlockDriverState *bdrv_new_root(const char *device_name, Error **errp) { BlockDriverState *bs; - int i; + + assert(*device_name); if (*device_name && !id_wellformed(device_name)) { error_setg(errp, "Invalid device name"); @@ -358,12 +359,21 @@ BlockDriverState *bdrv_new(const char *device_name, Error **errp) return NULL; } + bs = bdrv_new(); + + pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); + QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list); + + return bs; +} + +BlockDriverState *bdrv_new(void) +{ + BlockDriverState *bs; + int i; + bs = g_new0(BlockDriverState, 1); QLIST_INIT(&bs->dirty_bitmaps); - pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); - if (device_name[0] != '\0') { - QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list); - } for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { QLIST_INIT(&bs->op_blockers[i]); } @@ -1224,7 +1234,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) goto free_exit; } - backing_hd = bdrv_new("", errp); + backing_hd = bdrv_new(); if (bs->backing_format[0] != '\0') { back_drv = bdrv_find_format(bs->backing_format); @@ -1353,7 +1363,7 @@ int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp) qdict_put(snapshot_options, "file.filename", qstring_from_str(tmp_filename)); - bs_snapshot = bdrv_new("", &error_abort); + bs_snapshot = bdrv_new(); ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options, flags, bdrv_qcow2, &local_err); @@ -1424,7 +1434,7 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, if (*pbs) { bs = *pbs; } else { - bs = bdrv_new("", &error_abort); + bs = bdrv_new(); } /* NULL means an empty set of options */ diff --git a/block/iscsi.c b/block/iscsi.c index 3a01de0edb..a7fb764e4d 100644 --- a/block/iscsi.c +++ b/block/iscsi.c @@ -1519,7 +1519,7 @@ static int iscsi_create(const char *filename, QemuOpts *opts, Error **errp) IscsiLun *iscsilun = NULL; QDict *bs_options; - bs = bdrv_new("", &error_abort); + bs = bdrv_new(); /* Read out options */ total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), diff --git a/block/vvfat.c b/block/vvfat.c index 731e591ec1..6c9fde017b 100644 --- a/block/vvfat.c +++ b/block/vvfat.c @@ -2939,7 +2939,7 @@ static int enable_write_target(BDRVVVFATState *s, Error **errp) unlink(s->qcow_filename); #endif - bdrv_set_backing_hd(s->bs, bdrv_new("", &error_abort)); + bdrv_set_backing_hd(s->bs, bdrv_new()); s->bs->backing_hd->drv = &vvfat_write_target; s->bs->backing_hd->opaque = g_new(void *, 1); *(void**)s->bs->backing_hd->opaque = s; diff --git a/blockdev.c b/blockdev.c index e595910476..7608f469ef 100644 --- a/blockdev.c +++ b/blockdev.c @@ -523,7 +523,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, } /* init */ - bs = bdrv_new(qemu_opts_id(opts), errp); + bs = bdrv_new_root(qemu_opts_id(opts), errp); if (!bs) { goto early_err; } diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index 0d27ab16a7..7f0f66bc46 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -858,7 +858,7 @@ static int blk_connect(struct XenDevice *xendev) /* setup via xenbus -> create new block driver instance */ xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); - blkdev->bs = bdrv_new(blkdev->dev, NULL); + blkdev->bs = bdrv_new_root(blkdev->dev, NULL); if (!blkdev->bs) { return -1; } diff --git a/include/block/block.h b/include/block/block.h index 3318f0dfbe..a3039ce6f7 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -204,7 +204,8 @@ BlockDriver *bdrv_find_whitelisted_format(const char *format_name, int bdrv_create(BlockDriver *drv, const char* filename, QemuOpts *opts, Error **errp); int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp); -BlockDriverState *bdrv_new(const char *device_name, Error **errp); +BlockDriverState *bdrv_new_root(const char *device_name, Error **errp); +BlockDriverState *bdrv_new(void); void bdrv_make_anon(BlockDriverState *bs); void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old); void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top); diff --git a/qemu-img.c b/qemu-img.c index 27b85dbda4..9c77dcc927 100644 --- a/qemu-img.c +++ b/qemu-img.c @@ -296,7 +296,7 @@ static BlockDriverState *bdrv_new_open(const char *id, Error *local_err = NULL; int ret; - bs = bdrv_new(id, &error_abort); + bs = bdrv_new_root(id, &error_abort); if (fmt) { drv = bdrv_find_format(fmt); @@ -2423,7 +2423,7 @@ static int img_rebase(int argc, char **argv) if (!unsafe) { char backing_name[1024]; - bs_old_backing = bdrv_new("old_backing", &error_abort); + bs_old_backing = bdrv_new_root("old_backing", &error_abort); bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); ret = bdrv_open(&bs_old_backing, backing_name, NULL, NULL, src_flags, old_backing_drv, &local_err); @@ -2434,7 +2434,7 @@ static int img_rebase(int argc, char **argv) goto out; } if (out_baseimg[0]) { - bs_new_backing = bdrv_new("new_backing", &error_abort); + bs_new_backing = bdrv_new_root("new_backing", &error_abort); ret = bdrv_open(&bs_new_backing, out_baseimg, NULL, NULL, src_flags, new_backing_drv, &local_err); if (ret) { diff --git a/qemu-io.c b/qemu-io.c index 66cf3ef4be..d131dc5baa 100644 --- a/qemu-io.c +++ b/qemu-io.c @@ -58,7 +58,7 @@ static int openfile(char *name, int flags, int growable, QDict *opts) return 1; } - qemuio_bs = bdrv_new("hda", &error_abort); + qemuio_bs = bdrv_new_root("hda", &error_abort); if (growable) { flags |= BDRV_O_PROTOCOL; diff --git a/qemu-nbd.c b/qemu-nbd.c index b524b3420f..d9f1749def 100644 --- a/qemu-nbd.c +++ b/qemu-nbd.c @@ -691,7 +691,7 @@ int main(int argc, char **argv) drv = NULL; } - bs = bdrv_new("hda", &error_abort); + bs = bdrv_new_root("hda", &error_abort); srcpath = argv[optind]; ret = bdrv_open(&bs, srcpath, NULL, NULL, flags, drv, &local_err); From 26f54e9a3cfe62fca61baf83a06b269935d6b9a4 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:04 +0200 Subject: [PATCH 06/28] block: New BlockBackend A block device consists of a frontend device model and a backend. A block backend has a tree of block drivers doing the actual work. The tree is managed by the block layer. We currently use a single abstraction BlockDriverState both for tree nodes and the backend as a whole. Drawbacks: * 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. * 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. 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. 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. 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 exactly when root BlockDriverState objects are created and destroyed. "Root" in the sense of "in bdrv_states". They're not yet used for anything; that'll come shortly. A root BlockDriverState is created with bdrv_new_root(), so where to create a BlockBackend is obvious. Where these roots get destroyed isn't always as obvious. It is obvious in qemu-img.c, qemu-io.c and qemu-nbd.c, and in error paths of blockdev_init(), blk_connect(). That leaves destruction of objects successfully created by blockdev_init() and blk_connect(). blockdev_init() is used only by drive_new() and qmp_blockdev_add(). Objects created by the latter are currently indestructible (see commit 48f364d "blockdev: Refuse to drive_del something added with blockdev-add" and commit 2d246f0 "blockdev: Introduce DriveInfo.enable_auto_del"). Objects created by the former get destroyed by drive_del(). Objects created by blk_connect() get destroyed by blk_disconnect(). BlockBackend is reference-counted. Its reference count never exceeds one so far, but that's going to change. In drive_del(), the BB's reference count is surely one now. The BDS's reference count is greater than one when something else is holding a reference, such as a block job. In this case, the BB is destroyed right away, but the BDS lives on until all extra references get dropped. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block/Makefile.objs | 2 +- block/block-backend.c | 120 +++++++++++++++++++++++++++++++++ blockdev.c | 13 +++- hw/block/xen_disk.c | 11 +++ include/qemu/typedefs.h | 1 + include/sysemu/block-backend.h | 26 +++++++ qemu-img.c | 70 ++++++++++++++++--- qemu-io.c | 8 +++ qemu-nbd.c | 5 +- 9 files changed, 245 insertions(+), 11 deletions(-) create mode 100644 block/block-backend.c create mode 100644 include/sysemu/block-backend.h diff --git a/block/Makefile.objs b/block/Makefile.objs index a833ed5745..27911b6b88 100644 --- a/block/Makefile.objs +++ b/block/Makefile.objs @@ -5,7 +5,7 @@ block-obj-y += qed-check.o block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o vhdx-log.o block-obj-$(CONFIG_QUORUM) += quorum.o block-obj-y += parallels.o blkdebug.o blkverify.o -block-obj-y += snapshot.o qapi.o +block-obj-y += block-backend.o snapshot.o qapi.o block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o block-obj-$(CONFIG_POSIX) += raw-posix.o block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o diff --git a/block/block-backend.c b/block/block-backend.c new file mode 100644 index 0000000000..e89caa9611 --- /dev/null +++ b/block/block-backend.c @@ -0,0 +1,120 @@ +/* + * QEMU Block backends + * + * Copyright (C) 2014 Red Hat, Inc. + * + * Authors: + * Markus Armbruster , + * + * This work is licensed under the terms of the GNU LGPL, version 2.1 + * or later. See the COPYING.LIB 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 */ +}; + +/* All the BlockBackends */ +static QTAILQ_HEAD(, BlockBackend) blk_backends = + QTAILQ_HEAD_INITIALIZER(blk_backends); + +/* + * Create a new BlockBackend with @name, with a reference count of one. + * @name must not be null or empty. + * Fail if a BlockBackend with this name already exists. + * Store an error through @errp on failure, unless it's null. + * Return the new BlockBackend on success, null on failure. + */ +BlockBackend *blk_new(const char *name, Error **errp) +{ + BlockBackend *blk; + + assert(name && name[0]); + if (blk_by_name(name)) { + error_setg(errp, "Device with id '%s' already exists", name); + return NULL; + } + + blk = g_new0(BlockBackend, 1); + blk->name = g_strdup(name); + blk->refcnt = 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); +} + +/* + * Increment @blk's reference count. + * @blk must not be null. + */ +void blk_ref(BlockBackend *blk) +{ + blk->refcnt++; +} + +/* + * Decrement @blk's reference count. + * If this drops it to zero, destroy @blk. + * For convenience, do nothing if @blk is null. + */ +void blk_unref(BlockBackend *blk) +{ + if (blk) { + assert(blk->refcnt > 0); + if (!--blk->refcnt) { + blk_delete(blk); + } + } +} + +/* + * Return the BlockBackend after @blk. + * If @blk is null, return the first one. + * Else, return @blk's next sibling, which may be null. + * + * To iterate over all BlockBackends, do + * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { + * ... + * } + */ +BlockBackend *blk_next(BlockBackend *blk) +{ + return blk ? QTAILQ_NEXT(blk, link) : QTAILQ_FIRST(&blk_backends); +} + +/* + * Return @blk's name, a non-null, non-empty string. + */ +const char *blk_name(BlockBackend *blk) +{ + return blk->name; +} + +/* + * Return the BlockBackend with name @name if it exists, else null. + * @name must not be null. + */ +BlockBackend *blk_by_name(const char *name) +{ + BlockBackend *blk; + + assert(name); + QTAILQ_FOREACH(blk, &blk_backends, link) { + if (!strcmp(name, blk->name)) { + return blk; + } + } + return NULL; +} diff --git a/blockdev.c b/blockdev.c index 7608f469ef..508188ea9f 100644 --- a/blockdev.c +++ b/blockdev.c @@ -30,6 +30,7 @@ * THE SOFTWARE. */ +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/block/block.h" #include "block/blockjob.h" @@ -278,7 +279,10 @@ static void bdrv_format_print(void *opaque, const char *name) void drive_del(DriveInfo *dinfo) { + BlockBackend *blk = blk_by_name(dinfo->id); + bdrv_unref(dinfo->bdrv); + blk_unref(blk); } void drive_info_del(DriveInfo *dinfo) @@ -367,6 +371,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, int ro = 0; int bdrv_flags = 0; int on_read_error, on_write_error; + BlockBackend *blk; BlockDriverState *bs; DriveInfo *dinfo; ThrottleConfig cfg; @@ -523,9 +528,13 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, } /* init */ + blk = blk_new(qemu_opts_id(opts), errp); + if (!blk) { + goto early_err; + } bs = bdrv_new_root(qemu_opts_id(opts), errp); if (!bs) { - goto early_err; + goto bdrv_new_err; } bs->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0; bs->read_only = ro; @@ -591,6 +600,8 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, err: bdrv_unref(bs); +bdrv_new_err: + blk_unref(blk); early_err: qemu_opts_del(opts); err_no_opts: diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index 7f0f66bc46..265cf13aa9 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" /* ------------------------------------------------------------- */ @@ -854,12 +855,18 @@ static int blk_connect(struct XenDevice *xendev) blkdev->dinfo = drive_get(IF_XEN, 0, index); if (!blkdev->dinfo) { Error *local_err = NULL; + BlockBackend *blk; BlockDriver *drv; /* setup via xenbus -> create new block driver instance */ xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); + blk = blk_new(blkdev->dev, NULL); + if (!blk) { + return -1; + } blkdev->bs = bdrv_new_root(blkdev->dev, NULL); if (!blkdev->bs) { + blk_unref(blk); return -1; } @@ -870,6 +877,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 = NULL; return -1; } @@ -985,6 +993,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 = NULL; } xen_be_unbind_evtchn(&blkdev->xendev); diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h index 168a4086d8..34751778a3 100644 --- a/include/qemu/typedefs.h +++ b/include/qemu/typedefs.h @@ -36,6 +36,7 @@ typedef struct MachineState MachineState; 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-backend.h new file mode 100644 index 0000000000..198062a00e --- /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 LGPL, version 2.1 + * or later. See the COPYING.LIB 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 9c77dcc927..bdb95a4a3f 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,10 +576,11 @@ static int img_check(int argc, char **argv) int c, ret; OutputFormat output_format = OFORMAT_HUMAN; const char *filename, *fmt, *output, *cache; + BlockBackend *blk; BlockDriverState *bs; int fix = 0; int flags = BDRV_O_FLAGS | BDRV_O_CHECK; - ImageCheck *check; + ImageCheck *check = NULL; bool quiet = false; fmt = NULL; @@ -649,9 +651,11 @@ static int img_check(int argc, char **argv) return 1; } + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); if (!bs) { - return 1; + ret = 1; + goto fail; } check = g_new0(ImageCheck, 1); @@ -710,6 +714,7 @@ static int img_check(int argc, char **argv) fail: qapi_free_ImageCheck(check); bdrv_unref(bs); + blk_unref(blk); return ret; } @@ -718,6 +723,7 @@ static int img_commit(int argc, char **argv) { int c, ret, flags; const char *filename, *fmt, *cache; + BlockBackend *blk; BlockDriverState *bs; bool quiet = false; @@ -756,9 +762,11 @@ static int img_commit(int argc, char **argv) return 1; } + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); if (!bs) { - return 1; + ret = -1; + goto out; } ret = bdrv_commit(bs); switch(ret) { @@ -779,7 +787,9 @@ static int img_commit(int argc, char **argv) break; } +out: bdrv_unref(bs); + blk_unref(blk); if (ret) { return 1; } @@ -942,6 +952,7 @@ static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num, static int img_compare(int argc, char **argv) { const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2; + BlockBackend *blk1, *blk2; BlockDriverState *bs1, *bs2; int64_t total_sectors1, total_sectors2; uint8_t *buf1 = NULL, *buf2 = NULL; @@ -1011,18 +1022,20 @@ static int img_compare(int argc, char **argv) goto out3; } + blk1 = blk_new("image_1", &error_abort); bs1 = bdrv_new_open("image_1", filename1, fmt1, flags, true, quiet); if (!bs1) { error_report("Can't open file %s", filename1); ret = 2; - goto out3; + goto out2; } + blk2 = blk_new("image_2", &error_abort); bs2 = bdrv_new_open("image_2", filename2, fmt2, flags, true, quiet); if (!bs2) { error_report("Can't open file %s", filename2); ret = 2; - goto out2; + goto out1; } buf1 = qemu_blockalign(bs1, IO_BUF_SIZE); @@ -1183,11 +1196,14 @@ static int img_compare(int argc, char **argv) ret = 0; out: - bdrv_unref(bs2); qemu_vfree(buf1); qemu_vfree(buf2); +out1: + bdrv_unref(bs2); + blk_unref(blk2); out2: bdrv_unref(bs1); + blk_unref(blk1); out3: qemu_progress_end(); return ret; @@ -1200,6 +1216,7 @@ static int img_convert(int argc, char **argv) int progress = 0, flags, src_flags; const char *fmt, *out_fmt, *cache, *src_cache, *out_baseimg, *out_filename; BlockDriver *drv, *proto_drv; + BlockBackend **blk = NULL, *out_blk = NULL; BlockDriverState **bs = NULL, *out_bs = NULL; int64_t total_sectors, nb_sectors, sector_num, bs_offset; int64_t *bs_sectors = NULL; @@ -1354,6 +1371,7 @@ static int img_convert(int argc, char **argv) qemu_progress_print(0, 100); + blk = g_new0(BlockBackend *, bs_n); bs = g_new0(BlockDriverState *, bs_n); bs_sectors = g_new(int64_t, bs_n); @@ -1361,6 +1379,7 @@ static int img_convert(int argc, char **argv) for (bs_i = 0; bs_i < bs_n; bs_i++) { char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i) : g_strdup("source"); + blk[bs_i] = blk_new(id, &error_abort); bs[bs_i] = bdrv_new_open(id, argv[optind + bs_i], fmt, src_flags, true, quiet); g_free(id); @@ -1486,6 +1505,7 @@ static int img_convert(int argc, char **argv) goto out; } + out_blk = blk_new("target", &error_abort); out_bs = bdrv_new_open("target", out_filename, out_fmt, flags, true, quiet); if (!out_bs) { ret = -1; @@ -1740,6 +1760,7 @@ out: if (out_bs) { bdrv_unref(out_bs); } + blk_unref(out_blk); if (bs) { for (bs_i = 0; bs_i < bs_n; bs_i++) { if (bs[bs_i]) { @@ -1748,6 +1769,12 @@ out: } g_free(bs); } + if (blk) { + for (bs_i = 0; bs_i < bs_n; bs_i++) { + blk_unref(blk[bs_i]); + } + g_free(blk); + } g_free(bs_sectors); fail_getopt: g_free(options); @@ -1856,6 +1883,7 @@ static ImageInfoList *collect_image_info_list(const char *filename, filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL); while (filename) { + BlockBackend *blk; BlockDriverState *bs; ImageInfo *info; ImageInfoList *elem; @@ -1867,9 +1895,11 @@ static ImageInfoList *collect_image_info_list(const char *filename, } g_hash_table_insert(filenames, (gpointer)filename, NULL); + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false); if (!bs) { + blk_unref(blk); goto err; } @@ -1878,6 +1908,7 @@ static ImageInfoList *collect_image_info_list(const char *filename, error_report("%s", error_get_pretty(err)); error_free(err); bdrv_unref(bs); + blk_unref(blk); goto err; } @@ -1887,6 +1918,7 @@ static ImageInfoList *collect_image_info_list(const char *filename, last = &elem->next; bdrv_unref(bs); + blk_unref(blk); filename = fmt = NULL; if (chain) { @@ -2080,6 +2112,7 @@ static int img_map(int argc, char **argv) { int c; OutputFormat output_format = OFORMAT_HUMAN; + BlockBackend *blk; BlockDriverState *bs; const char *filename, *fmt, *output; int64_t length; @@ -2128,9 +2161,11 @@ static int img_map(int argc, char **argv) return 1; } + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS, true, false); if (!bs) { - return 1; + ret = -1; + goto out; } if (output_format == OFORMAT_HUMAN) { @@ -2173,6 +2208,7 @@ static int img_map(int argc, char **argv) out: bdrv_unref(bs); + blk_unref(blk); return ret < 0; } @@ -2183,6 +2219,7 @@ out: static int img_snapshot(int argc, char **argv) { + BlockBackend *blk; BlockDriverState *bs; QEMUSnapshotInfo sn; char *filename, *snapshot_name = NULL; @@ -2248,9 +2285,11 @@ static int img_snapshot(int argc, char **argv) filename = argv[optind++]; /* Open the image */ + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, NULL, bdrv_oflags, true, quiet); if (!bs) { - return 1; + ret = -1; + goto out; } /* Perform the requested action */ @@ -2294,7 +2333,9 @@ static int img_snapshot(int argc, char **argv) } /* Cleanup */ +out: bdrv_unref(bs); + blk_unref(blk); if (ret) { return 1; } @@ -2303,6 +2344,7 @@ static int img_snapshot(int argc, char **argv) static int img_rebase(int argc, char **argv) { + BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL; BlockDriverState *bs = NULL, *bs_old_backing = NULL, *bs_new_backing = NULL; BlockDriver *old_backing_drv, *new_backing_drv; char *filename; @@ -2391,6 +2433,7 @@ static int img_rebase(int argc, char **argv) * Ignore the old backing file for unsafe rebase in case we want to correct * the reference to a renamed or moved backing file. */ + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); if (!bs) { ret = -1; @@ -2423,6 +2466,7 @@ static int img_rebase(int argc, char **argv) if (!unsafe) { char backing_name[1024]; + blk_old_backing = blk_new("old_backing", &error_abort); bs_old_backing = bdrv_new_root("old_backing", &error_abort); bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); ret = bdrv_open(&bs_old_backing, backing_name, NULL, NULL, src_flags, @@ -2434,6 +2478,7 @@ static int img_rebase(int argc, char **argv) goto out; } if (out_baseimg[0]) { + blk_new_backing = blk_new("new_backing", &error_abort); bs_new_backing = bdrv_new_root("new_backing", &error_abort); ret = bdrv_open(&bs_new_backing, out_baseimg, NULL, NULL, src_flags, new_backing_drv, &local_err); @@ -2612,12 +2657,15 @@ out: if (bs_old_backing != NULL) { bdrv_unref(bs_old_backing); } + blk_unref(blk_old_backing); if (bs_new_backing != NULL) { bdrv_unref(bs_new_backing); } + blk_unref(blk_new_backing); } bdrv_unref(bs); + blk_unref(blk); if (ret) { return 1; } @@ -2630,6 +2678,7 @@ static int img_resize(int argc, char **argv) const char *filename, *fmt, *size; int64_t n, total_size; bool quiet = false; + BlockBackend *blk = NULL; BlockDriverState *bs = NULL; QemuOpts *param; static QemuOptsList resize_options = { @@ -2706,6 +2755,7 @@ static int img_resize(int argc, char **argv) n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0); qemu_opts_del(param); + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet); if (!bs) { @@ -2743,6 +2793,7 @@ out: if (bs) { bdrv_unref(bs); } + blk_unref(blk); if (ret) { return 1; } @@ -2758,6 +2809,7 @@ static int img_amend(int argc, char **argv) const char *fmt = NULL, *filename, *cache; int flags; bool quiet = false; + BlockBackend *blk = NULL; BlockDriverState *bs = NULL; cache = BDRV_DEFAULT_CACHE; @@ -2821,6 +2873,7 @@ static int img_amend(int argc, char **argv) goto out; } + blk = blk_new("image", &error_abort); bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); if (!bs) { error_report("Could not open image '%s'", filename); @@ -2854,6 +2907,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 d131dc5baa..a8dc973ab7 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" @@ -26,6 +27,7 @@ static char *progname; +static BlockBackend *qemuio_blk; static BlockDriverState *qemuio_bs; /* 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 = NULL; + qemuio_blk = NULL; return 0; } @@ -58,6 +62,7 @@ static int openfile(char *name, int flags, int growable, QDict *opts) return 1; } + qemuio_blk = blk_new("hda", &error_abort); qemuio_bs = bdrv_new_root("hda", &error_abort); if (growable) { @@ -70,7 +75,9 @@ static int openfile(char *name, int flags, int growable, QDict *opts) error_get_pretty(local_err)); error_free(local_err); bdrv_unref(qemuio_bs); + blk_unref(qemuio_blk); qemuio_bs = NULL; + qemuio_blk = NULL; return 1; } @@ -484,6 +491,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 d9f1749def..634ba11260 100644 --- a/qemu-nbd.c +++ b/qemu-nbd.c @@ -17,7 +17,7 @@ */ #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" @@ -384,6 +384,7 @@ static void nbd_accept(void *opaque) int main(int argc, char **argv) { + BlockBackend *blk; BlockDriverState *bs; BlockDriver *drv; off_t dev_offset = 0; @@ -691,6 +692,7 @@ int main(int argc, char **argv) drv = NULL; } + blk = blk_new("hda", &error_abort); bs = bdrv_new_root("hda", &error_abort); srcpath = argv[optind]; @@ -774,6 +776,7 @@ int main(int argc, char **argv) } while (state != TERMINATED); bdrv_unref(bs); + blk_unref(blk); if (sockpath) { unlink(sockpath); } From 7e7d56d9e05b340290669442cfa05f5869204572 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:05 +0200 Subject: [PATCH 07/28] block: Connect BlockBackend to BlockDriverState Convenience function blk_new_with_bs() creates a BlockBackend with its BlockDriverState. Callers have to unref both. The commit after next will relieve them of the need to unref the BlockDriverState. Complication: due to the silly way drive_del works, we need a way to hide a BlockBackend, just like bdrv_make_anon(). To emphasize its "special" status, give the function a suitably off-putting name: blk_hide_on_behalf_of_do_drive_del(). Unfortunately, hiding turns the BlockBackend's name into the empty string. Can't avoid that without breaking the blk->bs->device_name equals blk->name invariant. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block.c | 12 ++- block/block-backend.c | 71 +++++++++++++++++- blockdev.c | 19 ++--- hw/block/xen_disk.c | 8 +- include/block/block_int.h | 2 + include/sysemu/block-backend.h | 5 ++ qemu-img.c | 131 ++++++++++++++++----------------- qemu-io.c | 4 +- qemu-nbd.c | 4 +- 9 files changed, 159 insertions(+), 97 deletions(-) diff --git a/block.c b/block.c index 42659ecc71..e11a3ec275 100644 --- a/block.c +++ b/block.c @@ -2025,6 +2025,8 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name), bs_src->device_name); bs_dest->device_list = bs_src->device_list; + bs_dest->blk = bs_src->blk; + memcpy(bs_dest->op_blockers, bs_src->op_blockers, sizeof(bs_dest->op_blockers)); } @@ -2037,7 +2039,7 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, * This will modify the BlockDriverState fields, and swap contents * between bs_new and bs_old. Both bs_new and bs_old are modified. * - * bs_new is required to be anonymous. + * bs_new must be nameless and not attached to a BlockBackend. * * This function does not create any image files. */ @@ -2056,8 +2058,9 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list); } - /* bs_new must be anonymous and shouldn't have anything fancy enabled */ + /* bs_new must be nameless and shouldn't have anything fancy enabled */ assert(bs_new->device_name[0] == '\0'); + assert(!bs_new->blk); assert(QLIST_EMPTY(&bs_new->dirty_bitmaps)); assert(bs_new->job == NULL); assert(bs_new->dev == NULL); @@ -2073,8 +2076,9 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) bdrv_move_feature_fields(bs_old, bs_new); bdrv_move_feature_fields(bs_new, &tmp); - /* bs_new shouldn't be in bdrv_states even after the swap! */ + /* bs_new must remain nameless and unattached */ assert(bs_new->device_name[0] == '\0'); + assert(!bs_new->blk); /* Check a few fields that should remain attached to the device */ assert(bs_new->dev == NULL); @@ -2101,7 +2105,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) * This will modify the BlockDriverState fields, and swap contents * between bs_new and bs_top. Both bs_new and bs_top are modified. * - * bs_new is required to be anonymous. + * bs_new must be nameless and not attached to a BlockBackend. * * This function does not create any image files. */ diff --git a/block/block-backend.c b/block/block-backend.c index e89caa9611..a12215a546 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -16,10 +16,11 @@ struct BlockBackend { char *name; int refcnt; + BlockDriverState *bs; QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */ }; -/* All the BlockBackends */ +/* All the BlockBackends (except for hidden ones) */ static QTAILQ_HEAD(, BlockBackend) blk_backends = QTAILQ_HEAD_INITIALIZER(blk_backends); @@ -47,10 +48,44 @@ BlockBackend *blk_new(const char *name, Error **errp) return blk; } +/* + * Create a new BlockBackend with a new BlockDriverState attached. + * Both have a reference count of one. Caller owns *both* references. + * TODO Let caller own only the BlockBackend reference + * Otherwise just like blk_new(), which see. + */ +BlockBackend *blk_new_with_bs(const char *name, Error **errp) +{ + BlockBackend *blk; + BlockDriverState *bs; + + blk = blk_new(name, errp); + if (!blk) { + return NULL; + } + + bs = bdrv_new_root(name, errp); + if (!bs) { + blk_unref(blk); + return NULL; + } + + blk->bs = bs; + bs->blk = blk; + return blk; +} + static void blk_delete(BlockBackend *blk) { assert(!blk->refcnt); - QTAILQ_REMOVE(&blk_backends, blk, link); + if (blk->bs) { + blk->bs->blk = NULL; + blk->bs = NULL; + } + /* Avoid double-remove after blk_hide_on_behalf_of_do_drive_del() */ + if (blk->name[0]) { + QTAILQ_REMOVE(&blk_backends, blk, link); + } g_free(blk->name); g_free(blk); } @@ -68,6 +103,8 @@ void blk_ref(BlockBackend *blk) * Decrement @blk's reference count. * If this drops it to zero, destroy @blk. * For convenience, do nothing if @blk is null. + * Does *not* touch the attached BlockDriverState's reference count. + * TODO Decrement it! */ void blk_unref(BlockBackend *blk) { @@ -95,7 +132,9 @@ BlockBackend *blk_next(BlockBackend *blk) } /* - * Return @blk's name, a non-null, non-empty string. + * Return @blk's name, a non-null string. + * Wart: the name is empty iff @blk has been hidden with + * blk_hide_on_behalf_of_do_drive_del(). */ const char *blk_name(BlockBackend *blk) { @@ -118,3 +157,29 @@ BlockBackend *blk_by_name(const char *name) } return NULL; } + +/* + * Return the BlockDriverState attached to @blk if any, else null. + */ +BlockDriverState *blk_bs(BlockBackend *blk) +{ + return blk->bs; +} + +/* + * Hide @blk. + * @blk must not have been hidden already. + * Make attached BlockDriverState, if any, anonymous. + * Once hidden, @blk is invisible to all functions that don't receive + * it as argument. For example, blk_by_name() won't return it. + * Strictly for use by do_drive_del(). + * TODO get rid of it! + */ +void blk_hide_on_behalf_of_do_drive_del(BlockBackend *blk) +{ + QTAILQ_REMOVE(&blk_backends, blk, link); + blk->name[0] = 0; + if (blk->bs) { + bdrv_make_anon(blk->bs); + } +} diff --git a/blockdev.c b/blockdev.c index 508188ea9f..12fabcc8d9 100644 --- a/blockdev.c +++ b/blockdev.c @@ -279,7 +279,7 @@ static void bdrv_format_print(void *opaque, const char *name) void drive_del(DriveInfo *dinfo) { - BlockBackend *blk = blk_by_name(dinfo->id); + BlockBackend *blk = dinfo->bdrv->blk; bdrv_unref(dinfo->bdrv); blk_unref(blk); @@ -528,14 +528,11 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, } /* init */ - blk = blk_new(qemu_opts_id(opts), errp); + blk = blk_new_with_bs(qemu_opts_id(opts), errp); if (!blk) { goto early_err; } - bs = bdrv_new_root(qemu_opts_id(opts), errp); - if (!bs) { - goto bdrv_new_err; - } + bs = blk_bs(blk); bs->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0; bs->read_only = ro; bs->detect_zeroes = detect_zeroes; @@ -600,7 +597,6 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, err: bdrv_unref(bs); -bdrv_new_err: blk_unref(blk); early_err: qemu_opts_del(opts); @@ -1840,16 +1836,18 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) { const char *id = qdict_get_str(qdict, "id"); + BlockBackend *blk; BlockDriverState *bs; DriveInfo *dinfo; AioContext *aio_context; Error *local_err = NULL; - bs = bdrv_find(id); - if (!bs) { + blk = blk_by_name(id); + if (!blk) { error_report("Device '%s' not found", id); return -1; } + bs = blk_bs(blk); dinfo = drive_get_by_blockdev(bs); if (dinfo && !dinfo->enable_auto_del) { @@ -1879,8 +1877,7 @@ int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) * then we can just get rid of the block driver state right here. */ if (bdrv_get_attached_dev(bs)) { - bdrv_make_anon(bs); - + blk_hide_on_behalf_of_do_drive_del(blk); /* 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 265cf13aa9..00220837e0 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -860,15 +860,11 @@ static int blk_connect(struct XenDevice *xendev) /* setup via xenbus -> create new block driver instance */ xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); - blk = blk_new(blkdev->dev, NULL); + blk = blk_new_with_bs(blkdev->dev, NULL); if (!blk) { return -1; } - blkdev->bs = bdrv_new_root(blkdev->dev, NULL); - if (!blkdev->bs) { - blk_unref(blk); - return -1; - } + blkdev->bs = blk_bs(blk); drv = bdrv_find_whitelisted_format(blkdev->fileproto, readonly); if (bdrv_open(&blkdev->bs, blkdev->filename, NULL, NULL, qflags, diff --git a/include/block/block_int.h b/include/block/block_int.h index 8d86a6c1eb..14e0b7c053 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -324,6 +324,8 @@ struct BlockDriverState { BlockDriver *drv; /* NULL means no media */ void *opaque; + BlockBackend *blk; /* owning backend, if any */ + void *dev; /* attached device model, if any */ /* TODO change to DeviceState when all users are qdevified */ const BlockDevOps *dev_ops; diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h index 198062a00e..b97a794e45 100644 --- a/include/sysemu/block-backend.h +++ b/include/sysemu/block-backend.h @@ -17,10 +17,15 @@ #include "qapi/error.h" BlockBackend *blk_new(const char *name, Error **errp); +BlockBackend *blk_new_with_bs(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); +BlockDriverState *blk_bs(BlockBackend *blk); + +void blk_hide_on_behalf_of_do_drive_del(BlockBackend *blk); + #endif diff --git a/qemu-img.c b/qemu-img.c index bdb95a4a3f..5548637444 100644 --- a/qemu-img.c +++ b/qemu-img.c @@ -284,20 +284,19 @@ static int print_block_option_help(const char *filename, const char *fmt) return 0; } -static BlockDriverState *bdrv_new_open(const char *id, - const char *filename, - const char *fmt, - int flags, - bool require_io, - bool quiet) +static BlockBackend *img_open(const char *id, const char *filename, + const char *fmt, int flags, + bool require_io, bool quiet) { + BlockBackend *blk; BlockDriverState *bs; BlockDriver *drv; char password[256]; Error *local_err = NULL; int ret; - bs = bdrv_new_root(id, &error_abort); + blk = blk_new_with_bs(id, &error_abort); + bs = blk_bs(blk); if (fmt) { drv = bdrv_find_format(fmt); @@ -328,9 +327,10 @@ static BlockDriverState *bdrv_new_open(const char *id, goto fail; } } - return bs; + return blk; fail: bdrv_unref(bs); + blk_unref(blk); return NULL; } @@ -580,7 +580,7 @@ static int img_check(int argc, char **argv) BlockDriverState *bs; int fix = 0; int flags = BDRV_O_FLAGS | BDRV_O_CHECK; - ImageCheck *check = NULL; + ImageCheck *check; bool quiet = false; fmt = NULL; @@ -651,12 +651,11 @@ static int img_check(int argc, char **argv) return 1; } - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); - if (!bs) { - ret = 1; - goto fail; + blk = img_open("image", filename, fmt, flags, true, quiet); + if (!blk) { + return 1; } + bs = blk_bs(blk); check = g_new0(ImageCheck, 1); ret = collect_image_check(bs, check, filename, fmt, fix); @@ -762,12 +761,12 @@ static int img_commit(int argc, char **argv) return 1; } - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); - if (!bs) { - ret = -1; - goto out; + blk = img_open("image", filename, fmt, flags, true, quiet); + if (!blk) { + return 1; } + bs = blk_bs(blk); + ret = bdrv_commit(bs); switch(ret) { case 0: @@ -787,7 +786,6 @@ static int img_commit(int argc, char **argv) break; } -out: bdrv_unref(bs); blk_unref(blk); if (ret) { @@ -1022,21 +1020,21 @@ static int img_compare(int argc, char **argv) goto out3; } - blk1 = blk_new("image_1", &error_abort); - bs1 = bdrv_new_open("image_1", filename1, fmt1, flags, true, quiet); - if (!bs1) { + blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet); + if (!blk1) { error_report("Can't open file %s", filename1); ret = 2; + goto out3; + } + bs1 = blk_bs(blk1); + + blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet); + if (!blk2) { + error_report("Can't open file %s", filename2); + ret = 2; goto out2; } - - blk2 = blk_new("image_2", &error_abort); - bs2 = bdrv_new_open("image_2", filename2, fmt2, flags, true, quiet); - if (!bs2) { - error_report("Can't open file %s", filename2); - ret = 2; - goto out1; - } + bs2 = blk_bs(blk2); buf1 = qemu_blockalign(bs1, IO_BUF_SIZE); buf2 = qemu_blockalign(bs2, IO_BUF_SIZE); @@ -1198,7 +1196,6 @@ static int img_compare(int argc, char **argv) out: qemu_vfree(buf1); qemu_vfree(buf2); -out1: bdrv_unref(bs2); blk_unref(blk2); out2: @@ -1379,15 +1376,15 @@ static int img_convert(int argc, char **argv) for (bs_i = 0; bs_i < bs_n; bs_i++) { char *id = bs_n > 1 ? g_strdup_printf("source_%d", bs_i) : g_strdup("source"); - blk[bs_i] = blk_new(id, &error_abort); - bs[bs_i] = bdrv_new_open(id, argv[optind + bs_i], fmt, src_flags, - true, quiet); + blk[bs_i] = img_open(id, argv[optind + bs_i], fmt, src_flags, + true, quiet); g_free(id); - if (!bs[bs_i]) { + if (!blk[bs_i]) { error_report("Could not open '%s'", argv[optind + bs_i]); ret = -1; goto out; } + bs[bs_i] = blk_bs(blk[bs_i]); bs_sectors[bs_i] = bdrv_nb_sectors(bs[bs_i]); if (bs_sectors[bs_i] < 0) { error_report("Could not get size of %s: %s", @@ -1505,12 +1502,12 @@ static int img_convert(int argc, char **argv) goto out; } - out_blk = blk_new("target", &error_abort); - out_bs = bdrv_new_open("target", out_filename, out_fmt, flags, true, quiet); - if (!out_bs) { + out_blk = img_open("target", out_filename, out_fmt, flags, true, quiet); + if (!out_blk) { ret = -1; goto out; } + out_bs = blk_bs(out_blk); bs_i = 0; bs_offset = 0; @@ -1895,13 +1892,12 @@ static ImageInfoList *collect_image_info_list(const char *filename, } g_hash_table_insert(filenames, (gpointer)filename, NULL); - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, fmt, - BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false); - if (!bs) { - blk_unref(blk); + blk = img_open("image", filename, fmt, + BDRV_O_FLAGS | BDRV_O_NO_BACKING, false, false); + if (!blk) { goto err; } + bs = blk_bs(blk); bdrv_query_image_info(bs, &info, &err); if (err) { @@ -2161,12 +2157,11 @@ static int img_map(int argc, char **argv) return 1; } - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS, true, false); - if (!bs) { - ret = -1; - goto out; + blk = img_open("image", filename, fmt, BDRV_O_FLAGS, true, false); + if (!blk) { + return 1; } + bs = blk_bs(blk); if (output_format == OFORMAT_HUMAN) { printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File"); @@ -2285,12 +2280,11 @@ static int img_snapshot(int argc, char **argv) filename = argv[optind++]; /* Open the image */ - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, NULL, bdrv_oflags, true, quiet); - if (!bs) { - ret = -1; - goto out; + blk = img_open("image", filename, NULL, bdrv_oflags, true, quiet); + if (!blk) { + return 1; } + bs = blk_bs(blk); /* Perform the requested action */ switch(action) { @@ -2333,7 +2327,6 @@ static int img_snapshot(int argc, char **argv) } /* Cleanup */ -out: bdrv_unref(bs); blk_unref(blk); if (ret) { @@ -2433,12 +2426,12 @@ static int img_rebase(int argc, char **argv) * Ignore the old backing file for unsafe rebase in case we want to correct * the reference to a renamed or moved backing file. */ - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); - if (!bs) { + blk = img_open("image", filename, fmt, flags, true, quiet); + if (!blk) { ret = -1; goto out; } + bs = blk_bs(blk); /* Find the right drivers for the backing files */ old_backing_drv = NULL; @@ -2466,8 +2459,8 @@ static int img_rebase(int argc, char **argv) if (!unsafe) { char backing_name[1024]; - blk_old_backing = blk_new("old_backing", &error_abort); - bs_old_backing = bdrv_new_root("old_backing", &error_abort); + blk_old_backing = blk_new_with_bs("old_backing", &error_abort); + bs_old_backing = blk_bs(blk_old_backing); bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); ret = bdrv_open(&bs_old_backing, backing_name, NULL, NULL, src_flags, old_backing_drv, &local_err); @@ -2478,8 +2471,8 @@ static int img_rebase(int argc, char **argv) goto out; } if (out_baseimg[0]) { - blk_new_backing = blk_new("new_backing", &error_abort); - bs_new_backing = bdrv_new_root("new_backing", &error_abort); + blk_new_backing = blk_new_with_bs("new_backing", &error_abort); + bs_new_backing = blk_bs(blk_new_backing); ret = bdrv_open(&bs_new_backing, out_baseimg, NULL, NULL, src_flags, new_backing_drv, &local_err); if (ret) { @@ -2755,13 +2748,13 @@ static int img_resize(int argc, char **argv) n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0); qemu_opts_del(param); - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, - true, quiet); - if (!bs) { + blk = img_open("image", filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, + true, quiet); + if (!blk) { ret = -1; goto out; } + bs = blk_bs(blk); if (relative) { total_size = bdrv_getlength(bs) + n * relative; @@ -2873,13 +2866,13 @@ static int img_amend(int argc, char **argv) goto out; } - blk = blk_new("image", &error_abort); - bs = bdrv_new_open("image", filename, fmt, flags, true, quiet); - if (!bs) { + blk = img_open("image", filename, fmt, flags, true, quiet); + if (!blk) { error_report("Could not open image '%s'", filename); ret = -1; goto out; } + bs = blk_bs(blk); fmt = bs->drv->format_name; diff --git a/qemu-io.c b/qemu-io.c index a8dc973ab7..8380734b08 100644 --- a/qemu-io.c +++ b/qemu-io.c @@ -62,8 +62,8 @@ static int openfile(char *name, int flags, int growable, QDict *opts) return 1; } - qemuio_blk = blk_new("hda", &error_abort); - qemuio_bs = bdrv_new_root("hda", &error_abort); + qemuio_blk = blk_new_with_bs("hda", &error_abort); + qemuio_bs = blk_bs(qemuio_blk); if (growable) { flags |= BDRV_O_PROTOCOL; diff --git a/qemu-nbd.c b/qemu-nbd.c index 634ba11260..f741973687 100644 --- a/qemu-nbd.c +++ b/qemu-nbd.c @@ -692,8 +692,8 @@ int main(int argc, char **argv) drv = NULL; } - blk = blk_new("hda", &error_abort); - bs = bdrv_new_root("hda", &error_abort); + blk = blk_new_with_bs("hda", &error_abort); + bs = blk_bs(blk); srcpath = argv[optind]; ret = bdrv_open(&bs, srcpath, NULL, NULL, flags, drv, &local_err); From 18e46a033d67060c1430740cf8084b702955ae8f Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:06 +0200 Subject: [PATCH 08/28] block: Connect BlockBackend and DriveInfo Make the BlockBackend own the DriveInfo. Change blockdev_init() to return the BlockBackend instead of the DriveInfo. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block.c | 2 -- block/block-backend.c | 38 ++++++++++++++++++++ blockdev.c | 73 ++++++++++++++++++++------------------- include/sysemu/blockdev.h | 4 +++ 4 files changed, 79 insertions(+), 38 deletions(-) diff --git a/block.c b/block.c index e11a3ec275..c210315085 100644 --- a/block.c +++ b/block.c @@ -29,7 +29,6 @@ #include "qemu/module.h" #include "qapi/qmp/qjson.h" #include "sysemu/sysemu.h" -#include "sysemu/blockdev.h" /* FIXME layering violation */ #include "qemu/notify.h" #include "block/coroutine.h" #include "block/qapi.h" @@ -2131,7 +2130,6 @@ static void bdrv_delete(BlockDriverState *bs) /* remove from list, if necessary */ bdrv_make_anon(bs); - drive_info_del(drive_get_by_blockdev(bs)); g_free(bs); } diff --git a/block/block-backend.c b/block/block-backend.c index a12215a546..edaf73c1d7 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -12,11 +12,13 @@ #include "sysemu/block-backend.h" #include "block/block_int.h" +#include "sysemu/blockdev.h" struct BlockBackend { char *name; int refcnt; BlockDriverState *bs; + DriveInfo *legacy_dinfo; QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */ }; @@ -87,6 +89,7 @@ static void blk_delete(BlockBackend *blk) QTAILQ_REMOVE(&blk_backends, blk, link); } g_free(blk->name); + drive_info_del(blk->legacy_dinfo); g_free(blk); } @@ -166,6 +169,41 @@ BlockDriverState *blk_bs(BlockBackend *blk) return blk->bs; } +/* + * Return @blk's DriveInfo if any, else null. + */ +DriveInfo *blk_legacy_dinfo(BlockBackend *blk) +{ + return blk->legacy_dinfo; +} + +/* + * Set @blk's DriveInfo to @dinfo, and return it. + * @blk must not have a DriveInfo set already. + * No other BlockBackend may have the same DriveInfo set. + */ +DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo) +{ + assert(!blk->legacy_dinfo); + return blk->legacy_dinfo = dinfo; +} + +/* + * Return the BlockBackend with DriveInfo @dinfo. + * It must exist. + */ +BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo) +{ + BlockBackend *blk; + + QTAILQ_FOREACH(blk, &blk_backends, link) { + if (blk->legacy_dinfo == dinfo) { + return blk; + } + } + abort(); +} + /* * Hide @blk. * @blk must not have been hidden already. diff --git a/blockdev.c b/blockdev.c index 12fabcc8d9..24d40f95b1 100644 --- a/blockdev.c +++ b/blockdev.c @@ -47,8 +47,6 @@ #include "trace.h" #include "sysemu/arch_init.h" -static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives); - static const char *const if_name[IF_COUNT] = { [IF_NONE] = "none", [IF_IDE] = "ide", @@ -86,13 +84,15 @@ static int if_max_devs[IF_COUNT] = { */ void override_max_devs(BlockInterfaceType type, int max_devs) { + BlockBackend *blk; DriveInfo *dinfo; if (max_devs <= 0) { return; } - QTAILQ_FOREACH(dinfo, &drives, next) { + for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { + dinfo = blk_legacy_dinfo(blk); if (dinfo->type == type) { fprintf(stderr, "Cannot override units-per-bus property of" " the %s interface, because a drive of that type has" @@ -113,7 +113,8 @@ void override_max_devs(BlockInterfaceType type, int max_devs) */ void blockdev_mark_auto_del(BlockDriverState *bs) { - DriveInfo *dinfo = drive_get_by_blockdev(bs); + BlockBackend *blk = bs->blk; + DriveInfo *dinfo = blk_legacy_dinfo(blk); if (dinfo && !dinfo->enable_auto_del) { return; @@ -129,7 +130,8 @@ void blockdev_mark_auto_del(BlockDriverState *bs) void blockdev_auto_del(BlockDriverState *bs) { - DriveInfo *dinfo = drive_get_by_blockdev(bs); + BlockBackend *blk = bs->blk; + DriveInfo *dinfo = blk_legacy_dinfo(blk); if (dinfo && dinfo->auto_del) { drive_del(dinfo); @@ -194,15 +196,15 @@ QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file, DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) { + BlockBackend *blk; DriveInfo *dinfo; - /* seek interface, bus and unit */ - - QTAILQ_FOREACH(dinfo, &drives, next) { - if (dinfo->type == type && - dinfo->bus == bus && - dinfo->unit == unit) + for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { + dinfo = blk_legacy_dinfo(blk); + if (dinfo && dinfo->type == type + && dinfo->bus == bus && dinfo->unit == unit) { return dinfo; + } } return NULL; @@ -210,10 +212,12 @@ DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) bool drive_check_orphaned(void) { + BlockBackend *blk; DriveInfo *dinfo; bool rs = false; - QTAILQ_FOREACH(dinfo, &drives, next) { + for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { + dinfo = blk_legacy_dinfo(blk); /* If dinfo->bdrv->dev is NULL, it has no device attached. */ /* Unless this is a default drive, this may be an oversight. */ if (!dinfo->bdrv->dev && !dinfo->is_default && @@ -239,13 +243,15 @@ DriveInfo *drive_get_by_index(BlockInterfaceType type, int index) int drive_get_max_bus(BlockInterfaceType type) { int max_bus; + BlockBackend *blk; DriveInfo *dinfo; max_bus = -1; - QTAILQ_FOREACH(dinfo, &drives, next) { - if(dinfo->type == type && - dinfo->bus > max_bus) + for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { + dinfo = blk_legacy_dinfo(blk); + if (dinfo && dinfo->type == type && dinfo->bus > max_bus) { max_bus = dinfo->bus; + } } return max_bus; } @@ -262,14 +268,7 @@ DriveInfo *drive_get_next(BlockInterfaceType type) DriveInfo *drive_get_by_blockdev(BlockDriverState *bs) { - DriveInfo *dinfo; - - QTAILQ_FOREACH(dinfo, &drives, next) { - if (dinfo->bdrv == bs) { - return dinfo; - } - } - return NULL; + return bs->blk ? blk_legacy_dinfo(bs->blk) : NULL; } static void bdrv_format_print(void *opaque, const char *name) @@ -292,7 +291,6 @@ void drive_info_del(DriveInfo *dinfo) } qemu_opts_del(dinfo->opts); g_free(dinfo->id); - QTAILQ_REMOVE(&drives, dinfo, next); g_free(dinfo->serial); g_free(dinfo); } @@ -364,8 +362,8 @@ static bool check_throttle_config(ThrottleConfig *cfg, Error **errp) typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType; /* Takes the ownership of bs_opts */ -static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, - Error **errp) +static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, + Error **errp) { const char *buf; int ro = 0; @@ -548,7 +546,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, dinfo = g_malloc0(sizeof(*dinfo)); dinfo->id = g_strdup(qemu_opts_id(opts)); dinfo->bdrv = bs; - QTAILQ_INSERT_TAIL(&drives, dinfo, next); + blk_set_legacy_dinfo(blk, dinfo); if (!file || !*file) { if (has_driver_specific_opts) { @@ -556,7 +554,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, } else { QDECREF(bs_opts); qemu_opts_del(opts); - return dinfo; + return blk; } } if (snapshot) { @@ -593,7 +591,7 @@ static DriveInfo *blockdev_init(const char *file, QDict *bs_opts, QDECREF(bs_opts); qemu_opts_del(opts); - return dinfo; + return blk; err: bdrv_unref(bs); @@ -710,6 +708,7 @@ QemuOptsList qemu_legacy_drive_opts = { DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type) { const char *value; + BlockBackend *blk; DriveInfo *dinfo = NULL; QDict *bs_opts; QemuOpts *legacy_opts; @@ -1007,9 +1006,9 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type) } /* Actual block device init: Functionality shared with blockdev-add */ - dinfo = blockdev_init(filename, bs_opts, &local_err); + blk = blockdev_init(filename, bs_opts, &local_err); bs_opts = NULL; - if (dinfo == NULL) { + if (!blk) { if (local_err) { error_report("%s", error_get_pretty(local_err)); error_free(local_err); @@ -1020,6 +1019,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type) } /* Set legacy DriveInfo fields */ + dinfo = blk_legacy_dinfo(blk); dinfo->enable_auto_del = true; dinfo->opts = all_opts; @@ -1849,7 +1849,7 @@ int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) } bs = blk_bs(blk); - dinfo = drive_get_by_blockdev(bs); + dinfo = blk_legacy_dinfo(blk); if (dinfo && !dinfo->enable_auto_del) { error_report("Deleting device added with blockdev-add" " is not supported"); @@ -2574,7 +2574,7 @@ void qmp_change_backing_file(const char *device, void qmp_blockdev_add(BlockdevOptions *options, Error **errp) { QmpOutputVisitor *ov = qmp_output_visitor_new(); - DriveInfo *dinfo; + BlockBackend *blk; QObject *obj; QDict *qdict; Error *local_err = NULL; @@ -2612,14 +2612,15 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp) qdict_flatten(qdict); - dinfo = blockdev_init(NULL, qdict, &local_err); + blk = blockdev_init(NULL, qdict, &local_err); if (local_err) { error_propagate(errp, local_err); goto fail; } - if (bdrv_key_required(dinfo->bdrv)) { - drive_del(dinfo); + if (bdrv_key_required(blk_bs(blk))) { + bdrv_unref(blk_bs(blk)); + blk_unref(blk); error_setg(errp, "blockdev-add doesn't support encrypted devices"); goto fail; } diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h index 09716de809..c814a90be5 100644 --- a/include/sysemu/blockdev.h +++ b/include/sysemu/blockdev.h @@ -46,6 +46,10 @@ struct DriveInfo { QTAILQ_ENTRY(DriveInfo) next; }; +DriveInfo *blk_legacy_dinfo(BlockBackend *blk); +DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo); +BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo); + void override_max_devs(BlockInterfaceType type, int max_devs); DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit); From 8fb3c76c949f34f29c5252ee339fbe1cbfcc3234 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:07 +0200 Subject: [PATCH 09/28] block: Code motion to get rid of stubs/blockdev.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- block/block-backend.c | 13 +++++++++++++ blockdev.c | 11 ----------- include/sysemu/blockdev.h | 1 - stubs/Makefile.objs | 1 - stubs/blockdev.c | 12 ------------ 5 files changed, 13 insertions(+), 25 deletions(-) delete mode 100644 stubs/blockdev.c diff --git a/block/block-backend.c b/block/block-backend.c index edaf73c1d7..d4bdd48e03 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -22,6 +22,8 @@ struct BlockBackend { QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */ }; +static void drive_info_del(DriveInfo *dinfo); + /* All the BlockBackends (except for hidden ones) */ static QTAILQ_HEAD(, BlockBackend) blk_backends = QTAILQ_HEAD_INITIALIZER(blk_backends); @@ -93,6 +95,17 @@ static void blk_delete(BlockBackend *blk) g_free(blk); } +static void drive_info_del(DriveInfo *dinfo) +{ + if (!dinfo) { + return; + } + qemu_opts_del(dinfo->opts); + g_free(dinfo->id); + g_free(dinfo->serial); + g_free(dinfo); +} + /* * Increment @blk's reference count. * @blk must not be null. diff --git a/blockdev.c b/blockdev.c index 24d40f95b1..a00461df7b 100644 --- a/blockdev.c +++ b/blockdev.c @@ -284,17 +284,6 @@ void drive_del(DriveInfo *dinfo) blk_unref(blk); } -void drive_info_del(DriveInfo *dinfo) -{ - if (!dinfo) { - return; - } - qemu_opts_del(dinfo->opts); - g_free(dinfo->id); - g_free(dinfo->serial); - g_free(dinfo); -} - typedef struct { QEMUBH *bh; BlockDriverState *bs; diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h index c814a90be5..ccd4bf487e 100644 --- a/include/sysemu/blockdev.h +++ b/include/sysemu/blockdev.h @@ -65,7 +65,6 @@ QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file, const char *optstr); DriveInfo *drive_new(QemuOpts *arg, BlockInterfaceType block_default_type); void drive_del(DriveInfo *dinfo); -void drive_info_del(DriveInfo *dinfo); /* device-hotplug */ diff --git a/stubs/Makefile.objs b/stubs/Makefile.objs index c0b1f6a320..5e347d04bd 100644 --- a/stubs/Makefile.objs +++ b/stubs/Makefile.objs @@ -1,6 +1,5 @@ stub-obj-y += arch-query-cpu-def.o stub-obj-y += bdrv-commit-all.o -stub-obj-y += blockdev.o stub-obj-y += chr-baum-init.o stub-obj-y += chr-msmouse.o stub-obj-y += chr-testdev.o diff --git a/stubs/blockdev.c b/stubs/blockdev.c deleted file mode 100644 index 5d0a79c3a6..0000000000 --- a/stubs/blockdev.c +++ /dev/null @@ -1,12 +0,0 @@ -#include -#include "sysemu/blockdev.h" - -DriveInfo *drive_get_by_blockdev(BlockDriverState *bs) -{ - return NULL; -} - -void drive_info_del(DriveInfo *dinfo) -{ - assert(!dinfo); -} From 9ba10c95a4a63ef453893ba16bf1c8e11a1d3c39 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:08 +0200 Subject: [PATCH 10/28] block: Make BlockBackend own its BlockDriverState On BlockBackend destruction, unref its BlockDriverState. Replaces the callers' unrefs. This turns the pointer from BlockBackend to BlockDriverState into a strong reference, managed with bdrv_ref() / bdrv_unref(). The back-pointer remains weak. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- block/block-backend.c | 6 ++---- blockdev.c | 7 +------ hw/block/xen_disk.c | 6 +++--- qemu-img.c | 35 +---------------------------------- qemu-io.c | 5 ----- qemu-nbd.c | 1 - 6 files changed, 7 insertions(+), 53 deletions(-) diff --git a/block/block-backend.c b/block/block-backend.c index d4bdd48e03..6236b5b96d 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -54,8 +54,6 @@ BlockBackend *blk_new(const char *name, Error **errp) /* * Create a new BlockBackend with a new BlockDriverState attached. - * Both have a reference count of one. Caller owns *both* references. - * TODO Let caller own only the BlockBackend reference * Otherwise just like blk_new(), which see. */ BlockBackend *blk_new_with_bs(const char *name, Error **errp) @@ -83,7 +81,9 @@ static void blk_delete(BlockBackend *blk) { assert(!blk->refcnt); if (blk->bs) { + assert(blk->bs->blk == blk); blk->bs->blk = NULL; + bdrv_unref(blk->bs); blk->bs = NULL; } /* Avoid double-remove after blk_hide_on_behalf_of_do_drive_del() */ @@ -119,8 +119,6 @@ void blk_ref(BlockBackend *blk) * Decrement @blk's reference count. * If this drops it to zero, destroy @blk. * For convenience, do nothing if @blk is null. - * Does *not* touch the attached BlockDriverState's reference count. - * TODO Decrement it! */ void blk_unref(BlockBackend *blk) { diff --git a/blockdev.c b/blockdev.c index a00461df7b..63f797b417 100644 --- a/blockdev.c +++ b/blockdev.c @@ -278,10 +278,7 @@ static void bdrv_format_print(void *opaque, const char *name) void drive_del(DriveInfo *dinfo) { - BlockBackend *blk = dinfo->bdrv->blk; - - bdrv_unref(dinfo->bdrv); - blk_unref(blk); + blk_unref(dinfo->bdrv->blk); } typedef struct { @@ -583,7 +580,6 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, return blk; err: - bdrv_unref(bs); blk_unref(blk); early_err: qemu_opts_del(opts); @@ -2608,7 +2604,6 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp) } if (bdrv_key_required(blk_bs(blk))) { - bdrv_unref(blk_bs(blk)); blk_unref(blk); error_setg(errp, "blockdev-add doesn't support encrypted devices"); goto fail; diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index 00220837e0..feb227fe3a 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -872,7 +872,6 @@ static int blk_connect(struct XenDevice *xendev) xen_be_printf(&blkdev->xendev, 0, "error: %s\n", error_get_pretty(local_err)); error_free(local_err); - bdrv_unref(blkdev->bs); blk_unref(blk); blkdev->bs = NULL; return -1; @@ -888,7 +887,9 @@ static int blk_connect(struct XenDevice *xendev) } /* blkdev->bs is not create by us, we get a reference * so we can bdrv_unref() unconditionally */ - bdrv_ref(blkdev->bs); + /* Except we don't bdrv_unref() anymore, we blk_unref(). + * Conditionally, because we can't easily blk_ref() here. + * TODO Clean this up! */ } bdrv_attach_dev_nofail(blkdev->bs, blkdev); blkdev->file_size = bdrv_getlength(blkdev->bs); @@ -988,7 +989,6 @@ 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)); } diff --git a/qemu-img.c b/qemu-img.c index 5548637444..09e7e72f5a 100644 --- a/qemu-img.c +++ b/qemu-img.c @@ -329,7 +329,6 @@ static BlockBackend *img_open(const char *id, const char *filename, } return blk; fail: - bdrv_unref(bs); blk_unref(blk); return NULL; } @@ -712,9 +711,7 @@ static int img_check(int argc, char **argv) fail: qapi_free_ImageCheck(check); - bdrv_unref(bs); blk_unref(blk); - return ret; } @@ -786,7 +783,6 @@ static int img_commit(int argc, char **argv) break; } - bdrv_unref(bs); blk_unref(blk); if (ret) { return 1; @@ -1196,10 +1192,8 @@ static int img_compare(int argc, char **argv) out: qemu_vfree(buf1); qemu_vfree(buf2); - bdrv_unref(bs2); blk_unref(blk2); out2: - bdrv_unref(bs1); blk_unref(blk1); out3: qemu_progress_end(); @@ -1754,18 +1748,8 @@ out: qemu_opts_free(create_opts); qemu_vfree(buf); qemu_opts_del(sn_opts); - if (out_bs) { - bdrv_unref(out_bs); - } blk_unref(out_blk); - if (bs) { - for (bs_i = 0; bs_i < bs_n; bs_i++) { - if (bs[bs_i]) { - bdrv_unref(bs[bs_i]); - } - } - g_free(bs); - } + g_free(bs); if (blk) { for (bs_i = 0; bs_i < bs_n; bs_i++) { blk_unref(blk[bs_i]); @@ -1903,7 +1887,6 @@ static ImageInfoList *collect_image_info_list(const char *filename, if (err) { error_report("%s", error_get_pretty(err)); error_free(err); - bdrv_unref(bs); blk_unref(blk); goto err; } @@ -1913,7 +1896,6 @@ static ImageInfoList *collect_image_info_list(const char *filename, *last = elem; last = &elem->next; - bdrv_unref(bs); blk_unref(blk); filename = fmt = NULL; @@ -2202,7 +2184,6 @@ static int img_map(int argc, char **argv) dump_map_entry(output_format, &curr, NULL); out: - bdrv_unref(bs); blk_unref(blk); return ret < 0; } @@ -2327,7 +2308,6 @@ static int img_snapshot(int argc, char **argv) } /* Cleanup */ - bdrv_unref(bs); blk_unref(blk); if (ret) { return 1; @@ -2647,17 +2627,10 @@ out: qemu_progress_end(); /* Cleanup */ if (!unsafe) { - if (bs_old_backing != NULL) { - bdrv_unref(bs_old_backing); - } blk_unref(blk_old_backing); - if (bs_new_backing != NULL) { - bdrv_unref(bs_new_backing); - } blk_unref(blk_new_backing); } - bdrv_unref(bs); blk_unref(blk); if (ret) { return 1; @@ -2783,9 +2756,6 @@ static int img_resize(int argc, char **argv) break; } out: - if (bs) { - bdrv_unref(bs); - } blk_unref(blk); if (ret) { return 1; @@ -2897,9 +2867,6 @@ static int img_amend(int argc, char **argv) } out: - if (bs) { - bdrv_unref(bs); - } blk_unref(blk); qemu_opts_del(opts); qemu_opts_free(create_opts); diff --git a/qemu-io.c b/qemu-io.c index 8380734b08..60f84dd72a 100644 --- a/qemu-io.c +++ b/qemu-io.c @@ -38,7 +38,6 @@ static ReadLineState *readline_state; static int close_f(BlockDriverState *bs, int argc, char **argv) { - bdrv_unref(bs); blk_unref(qemuio_blk); qemuio_bs = NULL; qemuio_blk = NULL; @@ -74,7 +73,6 @@ static int openfile(char *name, int flags, int growable, QDict *opts) name ? " device " : "", name ?: "", error_get_pretty(local_err)); error_free(local_err); - bdrv_unref(qemuio_bs); blk_unref(qemuio_blk); qemuio_bs = NULL; qemuio_blk = NULL; @@ -488,9 +486,6 @@ int main(int argc, char **argv) */ bdrv_drain_all(); - 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 f741973687..5cd6c6d187 100644 --- a/qemu-nbd.c +++ b/qemu-nbd.c @@ -775,7 +775,6 @@ int main(int argc, char **argv) } } while (state != TERMINATED); - bdrv_unref(bs); blk_unref(blk); if (sockpath) { unlink(sockpath); From b9fe8a7a12f18adebba5616a3e9f44143a78c07e Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:09 +0200 Subject: [PATCH 11/28] blockdev: Eliminate drive_del() drive_del() has become a trivial wrapper around blk_unref(). Get rid of it. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- blockdev.c | 9 ++------- device-hotplug.c | 3 ++- hw/ide/piix.c | 4 +++- include/sysemu/blockdev.h | 1 - 4 files changed, 7 insertions(+), 10 deletions(-) diff --git a/blockdev.c b/blockdev.c index 63f797b417..30382031b8 100644 --- a/blockdev.c +++ b/blockdev.c @@ -134,7 +134,7 @@ void blockdev_auto_del(BlockDriverState *bs) DriveInfo *dinfo = blk_legacy_dinfo(blk); if (dinfo && dinfo->auto_del) { - drive_del(dinfo); + blk_unref(blk); } } @@ -276,11 +276,6 @@ static void bdrv_format_print(void *opaque, const char *name) error_printf(" %s", name); } -void drive_del(DriveInfo *dinfo) -{ - blk_unref(dinfo->bdrv->blk); -} - typedef struct { QEMUBH *bh; BlockDriverState *bs; @@ -1867,7 +1862,7 @@ int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) bdrv_set_on_error(bs, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT); } else { - drive_del(dinfo); + blk_unref(blk); } aio_context_release(aio_context); diff --git a/device-hotplug.c b/device-hotplug.c index e6a1ffb9fa..9e38cc4808 100644 --- a/device-hotplug.c +++ b/device-hotplug.c @@ -24,6 +24,7 @@ #include "hw/hw.h" #include "hw/boards.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "qemu/config-file.h" #include "sysemu/sysemu.h" @@ -76,6 +77,6 @@ void drive_hot_add(Monitor *mon, const QDict *qdict) err: if (dinfo) { - drive_del(dinfo); + blk_unref(blk_by_legacy_dinfo(dinfo)); } } diff --git a/hw/ide/piix.c b/hw/ide/piix.c index 49e78a738a..ec93977e53 100644 --- a/hw/ide/piix.c +++ b/hw/ide/piix.c @@ -27,6 +27,7 @@ #include #include #include +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/sysemu.h" #include "sysemu/dma.h" @@ -178,12 +179,13 @@ int pci_piix3_xen_ide_unplug(DeviceState *dev) for (; i < 3; i++) { di = drive_get_by_index(IF_IDE, i); if (di != NULL && !di->media_cd) { + BlockBackend *blk = blk_by_legacy_dinfo(di); DeviceState *ds = bdrv_get_attached_dev(di->bdrv); if (ds) { bdrv_detach_dev(di->bdrv, ds); } pci_ide->bus[di->bus].ifs[di->unit].bs = NULL; - drive_del(di); + blk_unref(blk); } } qdev_reset_all(DEVICE(dev)); diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h index ccd4bf487e..439844d6dd 100644 --- a/include/sysemu/blockdev.h +++ b/include/sysemu/blockdev.h @@ -64,7 +64,6 @@ QemuOpts *drive_def(const char *optstr); QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file, const char *optstr); DriveInfo *drive_new(QemuOpts *arg, BlockInterfaceType block_default_type); -void drive_del(DriveInfo *dinfo); /* device-hotplug */ From fea68bb6e9fa65c7cc6caa6adda810d1d0fdbde4 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:10 +0200 Subject: [PATCH 12/28] block: Eliminate bdrv_iterate(), use bdrv_next() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- block-migration.c | 30 +++++++++++++++--------------- block.c | 9 --------- blockdev.c | 31 +++++++++++++------------------ include/block/block.h | 2 -- monitor.c | 32 +++++++++----------------------- 5 files changed, 37 insertions(+), 67 deletions(-) diff --git a/block-migration.c b/block-migration.c index 3ad31a2c70..cb3e16c9d9 100644 --- a/block-migration.c +++ b/block-migration.c @@ -343,12 +343,25 @@ static void unset_dirty_tracking(void) } } -static void init_blk_migration_it(void *opaque, BlockDriverState *bs) +static void init_blk_migration(QEMUFile *f) { + BlockDriverState *bs; BlkMigDevState *bmds; int64_t sectors; - if (!bdrv_is_read_only(bs)) { + block_mig_state.submitted = 0; + block_mig_state.read_done = 0; + block_mig_state.transferred = 0; + block_mig_state.total_sector_sum = 0; + block_mig_state.prev_progress = -1; + block_mig_state.bulk_completed = 0; + block_mig_state.zero_blocks = migrate_zero_blocks(); + + for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) { + if (bdrv_is_read_only(bs)) { + continue; + } + sectors = bdrv_nb_sectors(bs); if (sectors <= 0) { return; @@ -378,19 +391,6 @@ static void init_blk_migration_it(void *opaque, BlockDriverState *bs) } } -static void init_blk_migration(QEMUFile *f) -{ - block_mig_state.submitted = 0; - block_mig_state.read_done = 0; - block_mig_state.transferred = 0; - block_mig_state.total_sector_sum = 0; - block_mig_state.prev_progress = -1; - block_mig_state.bulk_completed = 0; - block_mig_state.zero_blocks = migrate_zero_blocks(); - - bdrv_iterate(init_blk_migration_it, NULL); -} - /* Called with no lock taken. */ static int blk_mig_save_bulked_block(QEMUFile *f) diff --git a/block.c b/block.c index c210315085..d13d29b7b8 100644 --- a/block.c +++ b/block.c @@ -3906,15 +3906,6 @@ BlockDriverState *bdrv_next(BlockDriverState *bs) return QTAILQ_NEXT(bs, device_list); } -void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque) -{ - BlockDriverState *bs; - - QTAILQ_FOREACH(bs, &bdrv_states, device_list) { - it(opaque, bs); - } -} - const char *bdrv_get_device_name(BlockDriverState *bs) { return bs->device_name; diff --git a/blockdev.c b/blockdev.c index 30382031b8..c99df8f3f1 100644 --- a/blockdev.c +++ b/blockdev.c @@ -2608,26 +2608,21 @@ fail: qmp_output_visitor_cleanup(ov); } -static void do_qmp_query_block_jobs_one(void *opaque, BlockDriverState *bs) -{ - BlockJobInfoList **prev = opaque; - BlockJob *job = bs->job; - - if (job) { - BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1); - elem->value = block_job_query(bs->job); - (*prev)->next = elem; - *prev = elem; - } -} - BlockJobInfoList *qmp_query_block_jobs(Error **errp) { - /* Dummy is a fake list element for holding the head pointer */ - BlockJobInfoList dummy = {}; - BlockJobInfoList *prev = &dummy; - bdrv_iterate(do_qmp_query_block_jobs_one, &prev); - return dummy.next; + BlockJobInfoList *head = NULL, **p_next = &head; + BlockDriverState *bs; + + for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) { + if (bs->job) { + BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1); + elem->value = block_job_query(bs->job); + *p_next = elem; + p_next = &elem->next; + } + } + + return head; } QemuOptsList qemu_common_drive_opts = { diff --git a/include/block/block.h b/include/block/block.h index a3039ce6f7..6c97dd44a3 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -411,8 +411,6 @@ BlockDriverState *bdrv_lookup_bs(const char *device, Error **errp); bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base); BlockDriverState *bdrv_next(BlockDriverState *bs); -void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), - void *opaque); int bdrv_is_encrypted(BlockDriverState *bs); int bdrv_key_required(BlockDriverState *bs); int bdrv_set_key(BlockDriverState *bs, const char *key); diff --git a/monitor.c b/monitor.c index 2d14f394d6..412e63fdd9 100644 --- a/monitor.c +++ b/monitor.c @@ -4216,24 +4216,6 @@ static void file_completion(Monitor *mon, const char *input) closedir(ffs); } -typedef struct MonitorBlockComplete { - Monitor *mon; - const char *input; -} MonitorBlockComplete; - -static void block_completion_it(void *opaque, BlockDriverState *bs) -{ - const char *name = bdrv_get_device_name(bs); - MonitorBlockComplete *mbc = opaque; - Monitor *mon = mbc->mon; - const char *input = mbc->input; - - if (input[0] == '\0' || - !strncmp(name, (char *)input, strlen(input))) { - readline_add_completion(mon->rs, name); - } -} - static const char *next_arg_type(const char *typestr) { const char *p = strchr(typestr, ':'); @@ -4671,9 +4653,9 @@ static void monitor_find_completion_by_table(Monitor *mon, { const char *cmdname; int i; - const char *ptype, *str; + const char *ptype, *str, *name; const mon_cmd_t *cmd; - MonitorBlockComplete mbs; + BlockDriverState *bs; if (nb_args <= 1) { /* command completion */ @@ -4725,10 +4707,14 @@ static void monitor_find_completion_by_table(Monitor *mon, break; case 'B': /* block device name completion */ - mbs.mon = mon; - mbs.input = str; readline_set_completion_index(mon->rs, strlen(str)); - bdrv_iterate(block_completion_it, &mbs); + for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) { + name = bdrv_get_device_name(bs); + if (str[0] == '\0' || + !strncmp(name, str, strlen(str))) { + readline_add_completion(mon->rs, name); + } + } break; case 's': case 'S': From bfb197e0d998bea8741c65492b2b42f443729249 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:11 +0200 Subject: [PATCH 13/28] block: Eliminate BlockDriverState member device_name[] device_name[] can become non-empty only in bdrv_new_root() and bdrv_move_feature_fields(). The latter is used only to undo damage done by bdrv_swap(). The former is called only by blk_new_with_bs(). Therefore, when a BlockDriverState's device_name[] is non-empty, then it's been created with a BlockBackend, and vice versa. Furthermore, blk_new_with_bs() keeps the two names equal. Therefore, device_name[] is redundant. Eliminate it. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block-migration.c | 12 ++++++---- block.c | 49 +++++++++++++++++++++------------------ block/mirror.c | 3 ++- block/qapi.c | 6 ++--- block/qcow.c | 4 ++-- block/qcow2.c | 4 ++-- block/qed.c | 2 +- block/quorum.c | 4 ++-- block/vdi.c | 2 +- block/vhdx.c | 2 +- block/vmdk.c | 4 ++-- block/vpc.c | 2 +- block/vvfat.c | 2 +- blockjob.c | 3 ++- include/block/block.h | 2 +- include/block/block_int.h | 2 -- 16 files changed, 55 insertions(+), 48 deletions(-) diff --git a/block-migration.c b/block-migration.c index cb3e16c9d9..da30e93158 100644 --- a/block-migration.c +++ b/block-migration.c @@ -14,7 +14,9 @@ */ #include "qemu-common.h" -#include "block/block_int.h" +#include "block/block.h" +#include "qemu/error-report.h" +#include "qemu/main-loop.h" #include "hw/hw.h" #include "qemu/queue.h" #include "qemu/timer.h" @@ -130,9 +132,9 @@ static void blk_send(QEMUFile *f, BlkMigBlock * blk) | flags); /* device name */ - len = strlen(blk->bmds->bs->device_name); + len = strlen(bdrv_get_device_name(blk->bmds->bs)); qemu_put_byte(f, len); - qemu_put_buffer(f, (uint8_t *)blk->bmds->bs->device_name, len); + qemu_put_buffer(f, (uint8_t *)bdrv_get_device_name(blk->bmds->bs), len); /* if a block is zero we need to flush here since the network * bandwidth is now a lot higher than the storage device bandwidth. @@ -382,9 +384,9 @@ static void init_blk_migration(QEMUFile *f) if (bmds->shared_base) { DPRINTF("Start migration for %s with shared base image\n", - bs->device_name); + bdrv_get_device_name(bs)); } else { - DPRINTF("Start full migration for %s\n", bs->device_name); + DPRINTF("Start full migration for %s\n", bdrv_get_device_name(bs)); } QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry); diff --git a/block.c b/block.c index d13d29b7b8..5c37970a4a 100644 --- a/block.c +++ b/block.c @@ -28,6 +28,7 @@ #include "block/blockjob.h" #include "qemu/module.h" #include "qapi/qmp/qjson.h" +#include "sysemu/block-backend.h" #include "sysemu/sysemu.h" #include "qemu/notify.h" #include "block/coroutine.h" @@ -360,9 +361,7 @@ BlockDriverState *bdrv_new_root(const char *device_name, Error **errp) bs = bdrv_new(); - pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list); - return bs; } @@ -1168,7 +1167,7 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd) } else if (backing_hd) { error_setg(&bs->backing_blocker, "device is used as backing hd of '%s'", - bs->device_name); + bdrv_get_device_name(bs)); } bs->backing_hd = backing_hd; @@ -1542,7 +1541,7 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, } else { error_setg(errp, "Block format '%s' used by device '%s' doesn't " "support the option '%s'", drv->format_name, - bs->device_name, entry->key); + bdrv_get_device_name(bs), entry->key); } ret = -EINVAL; @@ -1749,7 +1748,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) && reopen_state->flags & BDRV_O_RDWR) { error_set(errp, QERR_DEVICE_IS_READ_ONLY, - reopen_state->bs->device_name); + bdrv_get_device_name(reopen_state->bs)); goto error; } @@ -1776,7 +1775,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, /* It is currently mandatory to have a bdrv_reopen_prepare() * handler for each supported drv. */ error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - drv->format_name, reopen_state->bs->device_name, + drv->format_name, bdrv_get_device_name(reopen_state->bs), "reopening of file"); ret = -1; goto error; @@ -1964,10 +1963,17 @@ void bdrv_drain_all(void) Also, NULL terminate the device_name to prevent double remove */ void bdrv_make_anon(BlockDriverState *bs) { - if (bs->device_name[0] != '\0') { + /* + * Take care to remove bs from bdrv_states only when it's actually + * in it. Note that bs->device_list.tqe_prev is initially null, + * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish + * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by + * resetting it to null on remove. + */ + if (bs->device_list.tqe_prev) { QTAILQ_REMOVE(&bdrv_states, bs, device_list); + bs->device_list.tqe_prev = NULL; } - bs->device_name[0] = '\0'; if (bs->node_name[0] != '\0') { QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list); } @@ -2021,8 +2027,6 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, bs_dest->job = bs_src->job; /* keep the same entry in bdrv_states */ - pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name), - bs_src->device_name); bs_dest->device_list = bs_src->device_list; bs_dest->blk = bs_src->blk; @@ -2038,7 +2042,7 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, * This will modify the BlockDriverState fields, and swap contents * between bs_new and bs_old. Both bs_new and bs_old are modified. * - * bs_new must be nameless and not attached to a BlockBackend. + * bs_new must not be attached to a BlockBackend. * * This function does not create any image files. */ @@ -2057,8 +2061,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list); } - /* bs_new must be nameless and shouldn't have anything fancy enabled */ - assert(bs_new->device_name[0] == '\0'); + /* bs_new must be unattached and shouldn't have anything fancy enabled */ assert(!bs_new->blk); assert(QLIST_EMPTY(&bs_new->dirty_bitmaps)); assert(bs_new->job == NULL); @@ -2075,8 +2078,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) bdrv_move_feature_fields(bs_old, bs_new); bdrv_move_feature_fields(bs_new, &tmp); - /* bs_new must remain nameless and unattached */ - assert(bs_new->device_name[0] == '\0'); + /* bs_new must remain unattached */ assert(!bs_new->blk); /* Check a few fields that should remain attached to the device */ @@ -2104,7 +2106,7 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) * This will modify the BlockDriverState fields, and swap contents * between bs_new and bs_top. Both bs_new and bs_top are modified. * - * bs_new must be nameless and not attached to a BlockBackend. + * bs_new must not be attached to a BlockBackend. * * This function does not create any image files. */ @@ -3820,7 +3822,7 @@ BlockDriverState *bdrv_find(const char *name) BlockDriverState *bs; QTAILQ_FOREACH(bs, &bdrv_states, device_list) { - if (!strcmp(name, bs->device_name)) { + if (!strcmp(name, bdrv_get_device_name(bs))) { return bs; } } @@ -3906,9 +3908,9 @@ BlockDriverState *bdrv_next(BlockDriverState *bs) return QTAILQ_NEXT(bs, device_list); } -const char *bdrv_get_device_name(BlockDriverState *bs) +const char *bdrv_get_device_name(const BlockDriverState *bs) { - return bs->device_name; + return bs->blk ? blk_name(bs->blk) : ""; } int bdrv_get_flags(BlockDriverState *bs) @@ -5262,13 +5264,15 @@ int bdrv_media_changed(BlockDriverState *bs) void bdrv_eject(BlockDriverState *bs, bool eject_flag) { BlockDriver *drv = bs->drv; + const char *device_name; if (drv && drv->bdrv_eject) { drv->bdrv_eject(bs, eject_flag); } - if (bs->device_name[0] != '\0') { - qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), + device_name = bdrv_get_device_name(bs); + if (device_name[0] != '\0') { + qapi_event_send_device_tray_moved(device_name, eject_flag, &error_abort); } } @@ -5478,7 +5482,8 @@ bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) blocker = QLIST_FIRST(&bs->op_blockers[op]); if (errp) { error_setg(errp, "Device '%s' is busy: %s", - bs->device_name, error_get_pretty(blocker->reason)); + bdrv_get_device_name(bs), + error_get_pretty(blocker->reason)); } return true; } diff --git a/block/mirror.c b/block/mirror.c index 18b18e0353..829be2f88a 100644 --- a/block/mirror.c +++ b/block/mirror.c @@ -567,7 +567,8 @@ static void mirror_complete(BlockJob *job, Error **errp) return; } if (!s->synced) { - error_set(errp, QERR_BLOCK_JOB_NOT_READY, job->bs->device_name); + error_set(errp, QERR_BLOCK_JOB_NOT_READY, + bdrv_get_device_name(job->bs)); return; } diff --git a/block/qapi.c b/block/qapi.c index 9733ebd328..d071ee564e 100644 --- a/block/qapi.c +++ b/block/qapi.c @@ -272,7 +272,7 @@ void bdrv_query_info(BlockDriverState *bs, BlockDriverState *bs0; ImageInfo **p_image_info; Error *local_err = NULL; - info->device = g_strdup(bs->device_name); + info->device = g_strdup(bdrv_get_device_name(bs)); info->type = g_strdup("unknown"); info->locked = bdrv_dev_is_medium_locked(bs); info->removable = bdrv_dev_has_removable_media(bs); @@ -327,9 +327,9 @@ static BlockStats *bdrv_query_stats(const BlockDriverState *bs) s = g_malloc0(sizeof(*s)); - if (bs->device_name[0]) { + if (bdrv_get_device_name(bs)[0]) { s->has_device = true; - s->device = g_strdup(bs->device_name); + s->device = g_strdup(bdrv_get_device_name(bs)); } s->stats = g_malloc0(sizeof(*s->stats)); diff --git a/block/qcow.c b/block/qcow.c index a87bd692f0..ece22697a6 100644 --- a/block/qcow.c +++ b/block/qcow.c @@ -124,7 +124,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags, snprintf(version, sizeof(version), "QCOW version %" PRIu32, header.version); error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, - bs->device_name, "qcow", version); + bdrv_get_device_name(bs), "qcow", version); ret = -ENOTSUP; goto fail; } @@ -231,7 +231,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags, /* Disable migration when qcow images are used */ error_set(&s->migration_blocker, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - "qcow", bs->device_name, "live migration"); + "qcow", bdrv_get_device_name(bs), "live migration"); migrate_add_blocker(s->migration_blocker); qemu_co_mutex_init(&s->lock); diff --git a/block/qcow2.c b/block/qcow2.c index fb28493c02..156a219993 100644 --- a/block/qcow2.c +++ b/block/qcow2.c @@ -206,8 +206,8 @@ static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState *bs, vsnprintf(msg, sizeof(msg), fmt, ap); va_end(ap); - error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, bs->device_name, "qcow2", - msg); + error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, + bdrv_get_device_name(bs), "qcow2", msg); } static void report_unsupported_feature(BlockDriverState *bs, diff --git a/block/qed.c b/block/qed.c index e2316d7ff0..7f03c26227 100644 --- a/block/qed.c +++ b/block/qed.c @@ -408,7 +408,7 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags, snprintf(buf, sizeof(buf), "%" PRIx64, s->header.features & ~QED_FEATURE_MASK); error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, - bs->device_name, "QED", buf); + bdrv_get_device_name(bs), "QED", buf); return -ENOTSUP; } if (!qed_is_cluster_size_valid(s->header.cluster_size)) { diff --git a/block/quorum.c b/block/quorum.c index 7687466733..6ce5904824 100644 --- a/block/quorum.c +++ b/block/quorum.c @@ -226,8 +226,8 @@ static void quorum_report_bad(QuorumAIOCB *acb, char *node_name, int ret) static void quorum_report_failure(QuorumAIOCB *acb) { - const char *reference = acb->common.bs->device_name[0] ? - acb->common.bs->device_name : + const char *reference = bdrv_get_device_name(acb->common.bs)[0] ? + bdrv_get_device_name(acb->common.bs) : acb->common.bs->node_name; qapi_event_send_quorum_failure(reference, acb->sector_num, diff --git a/block/vdi.c b/block/vdi.c index cfa08b0b93..9604721476 100644 --- a/block/vdi.c +++ b/block/vdi.c @@ -490,7 +490,7 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags, /* Disable migration when vdi images are used */ error_set(&s->migration_blocker, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - "vdi", bs->device_name, "live migration"); + "vdi", bdrv_get_device_name(bs), "live migration"); migrate_add_blocker(s->migration_blocker); return 0; diff --git a/block/vhdx.c b/block/vhdx.c index b0464487a5..12bfe75e51 100644 --- a/block/vhdx.c +++ b/block/vhdx.c @@ -1004,7 +1004,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, /* Disable migration when VHDX images are used */ error_set(&s->migration_blocker, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - "vhdx", bs->device_name, "live migration"); + "vhdx", bdrv_get_device_name(bs), "live migration"); migrate_add_blocker(s->migration_blocker); return 0; diff --git a/block/vmdk.c b/block/vmdk.c index 4ae6c75310..673d3f5fb4 100644 --- a/block/vmdk.c +++ b/block/vmdk.c @@ -657,7 +657,7 @@ static int vmdk_open_vmdk4(BlockDriverState *bs, snprintf(buf, sizeof(buf), "VMDK version %" PRId32, le32_to_cpu(header.version)); error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, - bs->device_name, "vmdk", buf); + bdrv_get_device_name(bs), "vmdk", buf); return -ENOTSUP; } else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) { /* VMware KB 2064959 explains that version 3 added support for @@ -939,7 +939,7 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags, /* Disable migration when VMDK images are used */ error_set(&s->migration_blocker, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - "vmdk", bs->device_name, "live migration"); + "vmdk", bdrv_get_device_name(bs), "live migration"); migrate_add_blocker(s->migration_blocker); g_free(buf); return 0; diff --git a/block/vpc.c b/block/vpc.c index e08144a76e..38c4f02fff 100644 --- a/block/vpc.c +++ b/block/vpc.c @@ -320,7 +320,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags, /* Disable migration when VHD images are used */ error_set(&s->migration_blocker, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - "vpc", bs->device_name, "live migration"); + "vpc", bdrv_get_device_name(bs), "live migration"); migrate_add_blocker(s->migration_blocker); return 0; diff --git a/block/vvfat.c b/block/vvfat.c index 6c9fde017b..cefe3a4f79 100644 --- a/block/vvfat.c +++ b/block/vvfat.c @@ -1182,7 +1182,7 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags, if (s->qcow) { error_set(&s->migration_blocker, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, - "vvfat (rw)", bs->device_name, "live migration"); + "vvfat (rw)", bdrv_get_device_name(bs), "live migration"); migrate_add_blocker(s->migration_blocker); } diff --git a/blockjob.c b/blockjob.c index 0689fdd2b5..3af0f6c863 100644 --- a/blockjob.c +++ b/blockjob.c @@ -107,7 +107,8 @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) void block_job_complete(BlockJob *job, Error **errp) { if (job->paused || job->cancelled || !job->driver->complete) { - error_set(errp, QERR_BLOCK_JOB_NOT_READY, job->bs->device_name); + error_set(errp, QERR_BLOCK_JOB_NOT_READY, + bdrv_get_device_name(job->bs)); return; } diff --git a/include/block/block.h b/include/block/block.h index 6c97dd44a3..3880e05f77 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -417,7 +417,7 @@ int bdrv_set_key(BlockDriverState *bs, const char *key); int bdrv_query_missing_keys(void); void bdrv_iterate_format(void (*it)(void *opaque, const char *name), void *opaque); -const char *bdrv_get_device_name(BlockDriverState *bs); +const char *bdrv_get_device_name(const BlockDriverState *bs); int bdrv_get_flags(BlockDriverState *bs); int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors); diff --git a/include/block/block_int.h b/include/block/block_int.h index 14e0b7c053..da00aa5cfc 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -392,8 +392,6 @@ struct BlockDriverState { char node_name[32]; /* element of the list of named nodes building the graph */ QTAILQ_ENTRY(BlockDriverState) node_list; - /* Device name is the name associated with the "drive" the guest sees */ - char device_name[32]; /* element of the list of "drives" the guest sees */ QTAILQ_ENTRY(BlockDriverState) device_list; QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps; From 7f06d47eff9d26cca87855273f20786502f8c57e Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:12 +0200 Subject: [PATCH 14/28] block: Merge BlockBackend and BlockDriverState name spaces BlockBackend's name space is separate only to keep the initial patches simple. Time to merge the two. Retain bdrv_find() and bdrv_get_device_name() for now, to keep this series manageable. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block.c | 48 +++++++++++-------------------------------- block/block-backend.c | 17 +++++++++------ include/block/block.h | 2 +- 3 files changed, 24 insertions(+), 43 deletions(-) diff --git a/block.c b/block.c index 5c37970a4a..2d80d6a588 100644 --- a/block.c +++ b/block.c @@ -335,31 +335,9 @@ void bdrv_register(BlockDriver *bdrv) QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); } -/* create a new block device (by default it is empty) */ -BlockDriverState *bdrv_new_root(const char *device_name, Error **errp) +BlockDriverState *bdrv_new_root(void) { - BlockDriverState *bs; - - assert(*device_name); - - if (*device_name && !id_wellformed(device_name)) { - error_setg(errp, "Invalid device name"); - return NULL; - } - - if (bdrv_find(device_name)) { - error_setg(errp, "Device with id '%s' already exists", - device_name); - return NULL; - } - if (bdrv_find_node(device_name)) { - error_setg(errp, - "Device name '%s' conflicts with an existing node name", - device_name); - return NULL; - } - - bs = bdrv_new(); + BlockDriverState *bs = bdrv_new(); QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list); return bs; @@ -883,7 +861,7 @@ static void bdrv_assign_node_name(BlockDriverState *bs, } /* takes care of avoiding namespaces collisions */ - if (bdrv_find(node_name)) { + if (blk_by_name(node_name)) { error_setg(errp, "node-name=%s is conflicting with a device id", node_name); return; @@ -3817,16 +3795,12 @@ void bdrv_iterate_format(void (*it)(void *opaque, const char *name), } /* This function is to find block backend bs */ +/* TODO convert callers to blk_by_name(), then remove */ BlockDriverState *bdrv_find(const char *name) { - BlockDriverState *bs; + BlockBackend *blk = blk_by_name(name); - QTAILQ_FOREACH(bs, &bdrv_states, device_list) { - if (!strcmp(name, bdrv_get_device_name(bs))) { - return bs; - } - } - return NULL; + return blk ? blk_bs(blk) : NULL; } /* This function is to find a node in the bs graph */ @@ -3865,13 +3839,14 @@ BlockDriverState *bdrv_lookup_bs(const char *device, const char *node_name, Error **errp) { - BlockDriverState *bs = NULL; + BlockBackend *blk; + BlockDriverState *bs; if (device) { - bs = bdrv_find(device); + blk = blk_by_name(device); - if (bs) { - return bs; + if (blk) { + return blk_bs(blk); } } @@ -3908,6 +3883,7 @@ BlockDriverState *bdrv_next(BlockDriverState *bs) return QTAILQ_NEXT(bs, device_list); } +/* TODO check what callers really want: bs->node_name or blk_name() */ const char *bdrv_get_device_name(const BlockDriverState *bs) { return bs->blk ? blk_name(bs->blk) : ""; diff --git a/block/block-backend.c b/block/block-backend.c index 6236b5b96d..fb91680f03 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -40,10 +40,20 @@ BlockBackend *blk_new(const char *name, Error **errp) BlockBackend *blk; assert(name && name[0]); + if (!id_wellformed(name)) { + error_setg(errp, "Invalid device name"); + return NULL; + } if (blk_by_name(name)) { error_setg(errp, "Device with id '%s' already exists", name); return NULL; } + if (bdrv_find_node(name)) { + error_setg(errp, + "Device name '%s' conflicts with an existing node name", + name); + return NULL; + } blk = g_new0(BlockBackend, 1); blk->name = g_strdup(name); @@ -66,12 +76,7 @@ BlockBackend *blk_new_with_bs(const char *name, Error **errp) return NULL; } - bs = bdrv_new_root(name, errp); - if (!bs) { - blk_unref(blk); - return NULL; - } - + bs = bdrv_new_root(); blk->bs = bs; bs->blk = blk; return blk; diff --git a/include/block/block.h b/include/block/block.h index 3880e05f77..3dc7c56037 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -204,7 +204,7 @@ BlockDriver *bdrv_find_whitelisted_format(const char *format_name, int bdrv_create(BlockDriver *drv, const char* filename, QemuOpts *opts, Error **errp); int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp); -BlockDriverState *bdrv_new_root(const char *device_name, Error **errp); +BlockDriverState *bdrv_new_root(void); BlockDriverState *bdrv_new(void); void bdrv_make_anon(BlockDriverState *bs); void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old); From fa1d36df7466ebbef0331b79d0ce3c5e140695c9 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:13 +0200 Subject: [PATCH 15/28] block: Eliminate DriveInfo member bdrv, use blk_by_legacy_dinfo() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The patch is big, but all it really does is replacing dinfo->bdrv by blk_bs(blk_by_legacy_dinfo(dinfo)) The replacement is repetitive, but the conversion of device models to BlockBackend is imminent, and will shorten it to just blk_legacy_dinfo(dinfo). Line wrapping muddies the waters a bit. I also omit tests whether dinfo->bdrv is null, because it never is. Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- blockdev.c | 7 +++---- hw/arm/collie.c | 9 +++++---- hw/arm/gumstix.c | 5 +++-- hw/arm/mainstone.c | 8 ++++---- hw/arm/musicpal.c | 11 ++++++----- hw/arm/nseries.c | 6 ++++-- hw/arm/omap1.c | 4 +++- hw/arm/omap2.c | 4 +++- hw/arm/omap_sx1.c | 9 +++++---- hw/arm/pxa2xx.c | 7 +++++-- hw/arm/spitz.c | 4 +++- hw/arm/versatilepb.c | 4 +++- hw/arm/vexpress.c | 4 +++- hw/arm/virt.c | 4 +++- hw/arm/xilinx_zynq.c | 4 +++- hw/arm/z2.c | 7 ++++--- hw/block/fdc.c | 16 ++++++++++----- hw/block/m25p80.c | 5 +++-- hw/block/xen_disk.c | 2 +- hw/cris/axis_dev88.c | 3 ++- hw/display/tc6393xb.c | 4 +++- hw/i386/pc_sysfw.c | 3 ++- hw/ide/piix.c | 5 +++-- hw/ide/qdev.c | 4 +++- hw/isa/pc87312.c | 7 +++++-- hw/lm32/lm32_boards.c | 13 ++++++------ hw/lm32/milkymist.c | 7 ++++--- hw/microblaze/petalogix_ml605_mmu.c | 5 +++-- hw/microblaze/petalogix_s3adsp1800_mmu.c | 5 +++-- hw/mips/mips_malta.c | 4 +++- hw/mips/mips_r4k.c | 5 +++-- hw/pci/pci-hotplug-old.c | 10 +++++++--- hw/ppc/ppc405_boards.c | 25 +++++++++++++++--------- hw/ppc/spapr.c | 4 +++- hw/ppc/virtex_ml507.c | 5 +++-- hw/scsi/scsi-bus.c | 5 +++-- hw/sd/milkymist-memcard.c | 7 +++++-- hw/sd/pl181.c | 3 ++- hw/sd/sdhci.c | 3 ++- hw/sd/ssi-sd.c | 3 ++- hw/sh4/r2d.c | 5 +++-- hw/usb/dev-storage.c | 4 +++- hw/xtensa/xtfpga.c | 4 +++- include/sysemu/blockdev.h | 1 - 44 files changed, 168 insertions(+), 96 deletions(-) diff --git a/blockdev.c b/blockdev.c index c99df8f3f1..aa37dbc541 100644 --- a/blockdev.c +++ b/blockdev.c @@ -220,11 +220,11 @@ bool drive_check_orphaned(void) dinfo = blk_legacy_dinfo(blk); /* If dinfo->bdrv->dev is NULL, it has no device attached. */ /* Unless this is a default drive, this may be an oversight. */ - if (!dinfo->bdrv->dev && !dinfo->is_default && + if (!blk_bs(blk)->dev && !dinfo->is_default && dinfo->type != IF_NONE) { fprintf(stderr, "Warning: Orphaned drive without device: " "id=%s,file=%s,if=%s,bus=%d,unit=%d\n", - dinfo->id, dinfo->bdrv->filename, if_name[dinfo->type], + dinfo->id, blk_bs(blk)->filename, if_name[dinfo->type], dinfo->bus, dinfo->unit); rs = true; } @@ -526,7 +526,6 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, dinfo = g_malloc0(sizeof(*dinfo)); dinfo->id = g_strdup(qemu_opts_id(opts)); - dinfo->bdrv = bs; blk_set_legacy_dinfo(blk, dinfo); if (!file || !*file) { @@ -556,7 +555,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, QINCREF(bs_opts); ret = bdrv_open(&bs, file, NULL, bs_opts, bdrv_flags, drv, &error); - assert(bs == dinfo->bdrv); + assert(bs == blk_bs(blk)); if (ret < 0) { error_setg(errp, "could not open disk image %s: %s", diff --git a/hw/arm/collie.c b/hw/arm/collie.c index ed7851fe06..024729042e 100644 --- a/hw/arm/collie.c +++ b/hw/arm/collie.c @@ -15,6 +15,7 @@ #include "strongarm.h" #include "hw/arm/arm.h" #include "hw/block/flash.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" @@ -41,13 +42,13 @@ static void collie_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi01_register(SA_CS0, NULL, "collie.fl1", 0x02000000, - dinfo ? dinfo->bdrv : NULL, (64 * 1024), - 512, 4, 0x00, 0x00, 0x00, 0x00, 0); + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + (64 * 1024), 512, 4, 0x00, 0x00, 0x00, 0x00, 0); dinfo = drive_get(IF_PFLASH, 0, 1); pflash_cfi01_register(SA_CS1, NULL, "collie.fl2", 0x02000000, - dinfo ? dinfo->bdrv : NULL, (64 * 1024), - 512, 4, 0x00, 0x00, 0x00, 0x00, 0); + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + (64 * 1024), 512, 4, 0x00, 0x00, 0x00, 0x00, 0); sysbus_create_simple("scoop", 0x40800000, NULL); diff --git a/hw/arm/gumstix.c b/hw/arm/gumstix.c index 3f8465ebc0..49f9339e6a 100644 --- a/hw/arm/gumstix.c +++ b/hw/arm/gumstix.c @@ -40,6 +40,7 @@ #include "hw/block/flash.h" #include "hw/devices.h" #include "hw/boards.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" @@ -71,7 +72,7 @@ static void connex_init(MachineState *machine) be = 0; #endif if (!pflash_cfi01_register(0x00000000, NULL, "connext.rom", connex_rom, - dinfo ? dinfo->bdrv : NULL, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, sector_len, connex_rom / sector_len, 2, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); @@ -109,7 +110,7 @@ static void verdex_init(MachineState *machine) be = 0; #endif if (!pflash_cfi01_register(0x00000000, NULL, "verdex.rom", verdex_rom, - dinfo ? dinfo->bdrv : NULL, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, sector_len, verdex_rom / sector_len, 2, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); diff --git a/hw/arm/mainstone.c b/hw/arm/mainstone.c index 2f1d61809d..a4a25b5c10 100644 --- a/hw/arm/mainstone.c +++ b/hw/arm/mainstone.c @@ -18,7 +18,7 @@ #include "hw/devices.h" #include "hw/boards.h" #include "hw/block/flash.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/sysbus.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" @@ -149,9 +149,9 @@ static void mainstone_common_init(MemoryRegion *address_space_mem, if (!pflash_cfi01_register(mainstone_flash_base[i], NULL, i ? "mainstone.flash1" : "mainstone.flash0", MAINSTONE_FLASH, - dinfo->bdrv, sector_len, - MAINSTONE_FLASH / sector_len, 4, 0, 0, 0, 0, - be)) { + blk_bs(blk_by_legacy_dinfo(dinfo)), + sector_len, MAINSTONE_FLASH / sector_len, + 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); exit(1); } diff --git a/hw/arm/musicpal.c b/hw/arm/musicpal.c index c541455452..77ad4eb1fd 100644 --- a/hw/arm/musicpal.c +++ b/hw/arm/musicpal.c @@ -22,6 +22,7 @@ #include "hw/block/flash.h" #include "ui/console.h" #include "hw/i2c/i2c.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "ui/pixel_ops.h" @@ -1632,7 +1633,9 @@ static void musicpal_init(MachineState *machine) /* Register flash */ dinfo = drive_get(IF_PFLASH, 0, 0); if (dinfo) { - flash_size = bdrv_getlength(dinfo->bdrv); + BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + + flash_size = bdrv_getlength(bs); if (flash_size != 8*1024*1024 && flash_size != 16*1024*1024 && flash_size != 32*1024*1024) { fprintf(stderr, "Invalid flash image size\n"); @@ -1647,16 +1650,14 @@ static void musicpal_init(MachineState *machine) #ifdef TARGET_WORDS_BIGENDIAN pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL, "musicpal.flash", flash_size, - dinfo->bdrv, 0x10000, - (flash_size + 0xffff) >> 16, + bs, 0x10000, (flash_size + 0xffff) >> 16, MP_FLASH_SIZE_MAX / flash_size, 2, 0x00BF, 0x236D, 0x0000, 0x0000, 0x5555, 0x2AAA, 1); #else pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL, "musicpal.flash", flash_size, - dinfo->bdrv, 0x10000, - (flash_size + 0xffff) >> 16, + bs, 0x10000, (flash_size + 0xffff) >> 16, MP_FLASH_SIZE_MAX / flash_size, 2, 0x00BF, 0x236D, 0x0000, 0x0000, 0x5555, 0x2AAA, 0); diff --git a/hw/arm/nseries.c b/hw/arm/nseries.c index 4f092d6446..253607826c 100644 --- a/hw/arm/nseries.c +++ b/hw/arm/nseries.c @@ -31,6 +31,7 @@ #include "hw/hw.h" #include "hw/bt.h" #include "hw/loader.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/sysbus.h" #include "exec/address-spaces.h" @@ -172,8 +173,9 @@ static void n8x0_nand_setup(struct n800_s *s) qdev_prop_set_uint16(s->nand, "version_id", 0); qdev_prop_set_int32(s->nand, "shift", 1); dinfo = drive_get(IF_MTD, 0, 0); - if (dinfo && dinfo->bdrv) { - qdev_prop_set_drive_nofail(s->nand, "drive", dinfo->bdrv); + if (dinfo) { + qdev_prop_set_drive_nofail(s->nand, "drive", + blk_bs(blk_by_legacy_dinfo(dinfo))); } qdev_init_nofail(s->nand); sysbus_connect_irq(SYS_BUS_DEVICE(s->nand), 0, diff --git a/hw/arm/omap1.c b/hw/arm/omap1.c index 306cf17b32..74dac49fbe 100644 --- a/hw/arm/omap1.c +++ b/hw/arm/omap1.c @@ -21,6 +21,7 @@ #include "hw/arm/omap.h" #include "sysemu/sysemu.h" #include "hw/arm/soc_dma.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "qemu/range.h" #include "hw/sysbus.h" @@ -3978,7 +3979,8 @@ struct omap_mpu_state_s *omap310_mpu_init(MemoryRegion *system_memory, fprintf(stderr, "qemu: missing SecureDigital device\n"); exit(1); } - s->mmc = omap_mmc_init(0xfffb7800, system_memory, dinfo->bdrv, + s->mmc = omap_mmc_init(0xfffb7800, system_memory, + blk_bs(blk_by_legacy_dinfo(dinfo)), qdev_get_gpio_in(s->ih[1], OMAP_INT_OQN), &s->drq[OMAP_DMA_MMC_TX], omap_findclk(s, "mmc_ck")); diff --git a/hw/arm/omap2.c b/hw/arm/omap2.c index d6e19ae6b2..0b6a95e75a 100644 --- a/hw/arm/omap2.c +++ b/hw/arm/omap2.c @@ -18,6 +18,7 @@ * with this program; if not, see . */ +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/hw.h" #include "hw/arm/arm.h" @@ -2461,7 +2462,8 @@ struct omap_mpu_state_s *omap2420_mpu_init(MemoryRegion *sysmem, fprintf(stderr, "qemu: missing SecureDigital device\n"); exit(1); } - s->mmc = omap2_mmc_init(omap_l4tao(s->l4, 9), dinfo->bdrv, + s->mmc = omap2_mmc_init(omap_l4tao(s->l4, 9), + blk_bs(blk_by_legacy_dinfo(dinfo)), qdev_get_gpio_in(s->ih[0], OMAP_INT_24XX_MMC_IRQ), &s->drq[OMAP24XX_DMA_MMC1_TX], omap_findclk(s, "mmc_fclk"), omap_findclk(s, "mmc_iclk")); diff --git a/hw/arm/omap_sx1.c b/hw/arm/omap_sx1.c index 320b39c51b..0a4e7405a5 100644 --- a/hw/arm/omap_sx1.c +++ b/hw/arm/omap_sx1.c @@ -31,6 +31,7 @@ #include "hw/boards.h" #include "hw/arm/arm.h" #include "hw/block/flash.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/qtest.h" #include "exec/address-spaces.h" @@ -154,8 +155,8 @@ static void sx1_init(MachineState *machine, const int version) if ((dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) { if (!pflash_cfi01_register(OMAP_CS0_BASE, NULL, "omap_sx1.flash0-1", flash_size, - dinfo->bdrv, sector_size, - flash_size / sector_size, + blk_bs(blk_by_legacy_dinfo(dinfo)), + sector_size, flash_size / sector_size, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory %d.\n", fl_idx); @@ -178,8 +179,8 @@ static void sx1_init(MachineState *machine, const int version) if (!pflash_cfi01_register(OMAP_CS1_BASE, NULL, "omap_sx1.flash1-1", flash1_size, - dinfo->bdrv, sector_size, - flash1_size / sector_size, + blk_bs(blk_by_legacy_dinfo(dinfo)), + sector_size, flash1_size / sector_size, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory %d.\n", fl_idx); diff --git a/hw/arm/pxa2xx.c b/hw/arm/pxa2xx.c index 7d306fb1b7..6b7abe134a 100644 --- a/hw/arm/pxa2xx.c +++ b/hw/arm/pxa2xx.c @@ -14,6 +14,7 @@ #include "hw/i2c/i2c.h" #include "hw/ssi.h" #include "sysemu/char.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" static struct { @@ -2085,7 +2086,8 @@ PXA2xxState *pxa270_init(MemoryRegion *address_space, fprintf(stderr, "qemu: missing SecureDigital device\n"); exit(1); } - s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, dinfo->bdrv, + s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, + blk_bs(blk_by_legacy_dinfo(dinfo)), qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC), qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI), qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI)); @@ -2217,7 +2219,8 @@ PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size) fprintf(stderr, "qemu: missing SecureDigital device\n"); exit(1); } - s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, dinfo->bdrv, + s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, + blk_bs(blk_by_legacy_dinfo(dinfo)), qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC), qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI), qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI)); diff --git a/hw/arm/spitz.c b/hw/arm/spitz.c index 9260896424..ff12f9b219 100644 --- a/hw/arm/spitz.c +++ b/hw/arm/spitz.c @@ -25,6 +25,7 @@ #include "block/block.h" #include "audio/audio.h" #include "hw/boards.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/sysbus.h" #include "exec/address-spaces.h" @@ -170,7 +171,8 @@ static int sl_nand_init(SysBusDevice *dev) s->ctl = 0; nand = drive_get(IF_MTD, 0, 0); - s->nand = nand_init(nand ? nand->bdrv : NULL, s->manf_id, s->chip_id); + s->nand = nand_init(nand ? blk_bs(blk_by_legacy_dinfo(nand)) : NULL, + s->manf_id, s->chip_id); memory_region_init_io(&s->iomem, OBJECT(s), &sl_ops, s, "sl", 0x40); sysbus_init_mmio(dev, &s->iomem); diff --git a/hw/arm/versatilepb.c b/hw/arm/versatilepb.c index 7696be182d..2ff46b048d 100644 --- a/hw/arm/versatilepb.c +++ b/hw/arm/versatilepb.c @@ -15,6 +15,7 @@ #include "hw/pci/pci.h" #include "hw/i2c/i2c.h" #include "hw/boards.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "hw/block/flash.h" @@ -338,7 +339,8 @@ static void versatile_init(MachineState *machine, int board_id) dinfo = drive_get(IF_PFLASH, 0, 0); if (!pflash_cfi01_register(VERSATILE_FLASH_ADDR, NULL, "versatile.flash", - VERSATILE_FLASH_SIZE, dinfo ? dinfo->bdrv : NULL, + VERSATILE_FLASH_SIZE, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, VERSATILE_FLASH_SECT_SIZE, VERSATILE_FLASH_SIZE / VERSATILE_FLASH_SECT_SIZE, 4, 0x0089, 0x0018, 0x0000, 0x0, 0)) { diff --git a/hw/arm/vexpress.c b/hw/arm/vexpress.c index aed218f01b..828228c748 100644 --- a/hw/arm/vexpress.c +++ b/hw/arm/vexpress.c @@ -30,6 +30,7 @@ #include "hw/boards.h" #include "hw/loader.h" #include "exec/address-spaces.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/block/flash.h" #include "sysemu/device_tree.h" @@ -491,7 +492,8 @@ static pflash_t *ve_pflash_cfi01_register(hwaddr base, const char *name, { DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); - if (di && qdev_prop_set_drive(dev, "drive", di->bdrv)) { + if (di && qdev_prop_set_drive(dev, "drive", + blk_bs(blk_by_legacy_dinfo(di)))) { abort(); } diff --git a/hw/arm/virt.c b/hw/arm/virt.c index 8c6b171414..e5fce2ad06 100644 --- a/hw/arm/virt.c +++ b/hw/arm/virt.c @@ -33,6 +33,7 @@ #include "hw/arm/primecell.h" #include "hw/devices.h" #include "net/net.h" +#include "sysemu/block-backend.h" #include "sysemu/device_tree.h" #include "sysemu/sysemu.h" #include "sysemu/kvm.h" @@ -450,7 +451,8 @@ static void create_one_flash(const char *name, hwaddr flashbase, DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); const uint64_t sectorlength = 256 * 1024; - if (dinfo && qdev_prop_set_drive(dev, "drive", dinfo->bdrv)) { + if (dinfo && qdev_prop_set_drive(dev, "drive", + blk_bs(blk_by_legacy_dinfo(dinfo)))) { abort(); } diff --git a/hw/arm/xilinx_zynq.c b/hw/arm/xilinx_zynq.c index ad85c7af2e..415344fc5e 100644 --- a/hw/arm/xilinx_zynq.c +++ b/hw/arm/xilinx_zynq.c @@ -22,6 +22,7 @@ #include "sysemu/sysemu.h" #include "hw/boards.h" #include "hw/block/flash.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/loader.h" #include "hw/ssi.h" @@ -164,7 +165,8 @@ static void zynq_init(MachineState *machine) /* AMD */ pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE, - dinfo ? dinfo->bdrv : NULL, FLASH_SECTOR_SIZE, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + FLASH_SECTOR_SIZE, FLASH_SIZE/FLASH_SECTOR_SIZE, 1, 1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa, 0); diff --git a/hw/arm/z2.c b/hw/arm/z2.c index 36b3b504f4..9b38a2bc01 100644 --- a/hw/arm/z2.c +++ b/hw/arm/z2.c @@ -20,6 +20,7 @@ #include "hw/boards.h" #include "sysemu/sysemu.h" #include "hw/block/flash.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "ui/console.h" #include "audio/audio.h" @@ -336,9 +337,9 @@ static void z2_init(MachineState *machine) if (!pflash_cfi01_register(Z2_FLASH_BASE, NULL, "z2.flash0", Z2_FLASH_SIZE, - dinfo ? dinfo->bdrv : NULL, sector_len, - Z2_FLASH_SIZE / sector_len, 4, 0, 0, 0, 0, - be)) { + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + sector_len, Z2_FLASH_SIZE / sector_len, + 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); exit(1); } diff --git a/hw/block/fdc.c b/hw/block/fdc.c index 34c1d8f1c9..c25d7676d2 100644 --- a/hw/block/fdc.c +++ b/hw/block/fdc.c @@ -33,6 +33,7 @@ #include "qemu/timer.h" #include "hw/isa/isa.h" #include "hw/sysbus.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/sysemu.h" #include "qemu/log.h" @@ -2107,10 +2108,12 @@ ISADevice *fdctrl_init_isa(ISABus *bus, DriveInfo **fds) dev = DEVICE(isadev); if (fds[0]) { - qdev_prop_set_drive_nofail(dev, "driveA", fds[0]->bdrv); + qdev_prop_set_drive_nofail(dev, "driveA", + blk_bs(blk_by_legacy_dinfo(fds[0]))); } if (fds[1]) { - qdev_prop_set_drive_nofail(dev, "driveB", fds[1]->bdrv); + qdev_prop_set_drive_nofail(dev, "driveB", + blk_bs(blk_by_legacy_dinfo(fds[1]))); } qdev_init_nofail(dev); @@ -2130,10 +2133,12 @@ void fdctrl_init_sysbus(qemu_irq irq, int dma_chann, fdctrl = &sys->state; fdctrl->dma_chann = dma_chann; /* FIXME */ if (fds[0]) { - qdev_prop_set_drive_nofail(dev, "driveA", fds[0]->bdrv); + qdev_prop_set_drive_nofail(dev, "driveA", + blk_bs(blk_by_legacy_dinfo(fds[0]))); } if (fds[1]) { - qdev_prop_set_drive_nofail(dev, "driveB", fds[1]->bdrv); + qdev_prop_set_drive_nofail(dev, "driveB", + blk_bs(blk_by_legacy_dinfo(fds[1]))); } qdev_init_nofail(dev); sbd = SYS_BUS_DEVICE(dev); @@ -2149,7 +2154,8 @@ void sun4m_fdctrl_init(qemu_irq irq, hwaddr io_base, dev = qdev_create(NULL, "SUNW,fdtwo"); if (fds[0]) { - qdev_prop_set_drive_nofail(dev, "drive", fds[0]->bdrv); + qdev_prop_set_drive_nofail(dev, "drive", + blk_bs(blk_by_legacy_dinfo(fds[0]))); } qdev_init_nofail(dev); sys = SYSBUS_FDC(dev); diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c index 5893773f0c..78280a881a 100644 --- a/hw/block/m25p80.c +++ b/hw/block/m25p80.c @@ -22,6 +22,7 @@ */ #include "hw/hw.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/ssi.h" @@ -624,9 +625,9 @@ static int m25p80_init(SSISlave *ss) dinfo = drive_get_next(IF_MTD); - if (dinfo && dinfo->bdrv) { + if (dinfo) { DB_PRINT_L(0, "Binding to IF_MTD drive\n"); - s->bdrv = dinfo->bdrv; + s->bdrv = blk_bs(blk_by_legacy_dinfo(dinfo)); /* FIXME: Move to late init */ if (bdrv_read(s->bdrv, 0, s->storage, DIV_ROUND_UP(s->size, diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index feb227fe3a..ca4f855c5d 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -879,7 +879,7 @@ static int blk_connect(struct XenDevice *xendev) } else { /* setup via qemu cmdline -> already setup for us */ xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n"); - blkdev->bs = blkdev->dinfo->bdrv; + blkdev->bs = blk_bs(blk_by_legacy_dinfo(blkdev->dinfo)); if (bdrv_is_read_only(blkdev->bs) && !readonly) { xen_be_printf(&blkdev->xendev, 0, "Unexpected read-only drive"); blkdev->bs = NULL; diff --git a/hw/cris/axis_dev88.c b/hw/cris/axis_dev88.c index 2fb3aa81da..417702aced 100644 --- a/hw/cris/axis_dev88.c +++ b/hw/cris/axis_dev88.c @@ -30,6 +30,7 @@ #include "hw/loader.h" #include "elf.h" #include "boot.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" @@ -284,7 +285,7 @@ void axisdev88_init(MachineState *machine) /* Attach a NAND flash to CS1. */ nand = drive_get(IF_MTD, 0, 0); - nand_state.nand = nand_init(nand ? nand->bdrv : NULL, + nand_state.nand = nand_init(nand ? blk_bs(blk_by_legacy_dinfo(nand)) : NULL, NAND_MFR_STMICRO, 0x39); memory_region_init_io(&nand_state.iomem, NULL, &nand_ops, &nand_state, "nand", 0x05000000); diff --git a/hw/display/tc6393xb.c b/hw/display/tc6393xb.c index c19c055d7c..576f319d12 100644 --- a/hw/display/tc6393xb.c +++ b/hw/display/tc6393xb.c @@ -15,6 +15,7 @@ #include "hw/block/flash.h" #include "ui/console.h" #include "ui/pixel_ops.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #define IRQ_TC6393_NAND 0 @@ -576,7 +577,8 @@ TC6393xbState *tc6393xb_init(MemoryRegion *sysmem, uint32_t base, qemu_irq irq) s->sub_irqs = qemu_allocate_irqs(tc6393xb_sub_irq, s, TC6393XB_NR_IRQS); nand = drive_get(IF_MTD, 0, 0); - s->flash = nand_init(nand ? nand->bdrv : NULL, NAND_MFR_TOSHIBA, 0x76); + s->flash = nand_init(nand ? blk_bs(blk_by_legacy_dinfo(nand)) : NULL, + NAND_MFR_TOSHIBA, 0x76); memory_region_init_io(&s->iomem, NULL, &tc6393xb_ops, s, "tc6393xb", 0x10000); memory_region_add_subregion(sysmem, base, &s->iomem); diff --git a/hw/i386/pc_sysfw.c b/hw/i386/pc_sysfw.c index bbe367a49f..9bf22b6a47 100644 --- a/hw/i386/pc_sysfw.c +++ b/hw/i386/pc_sysfw.c @@ -23,6 +23,7 @@ * THE SOFTWARE. */ +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "qemu/error-report.h" #include "hw/sysbus.h" @@ -119,7 +120,7 @@ static void pc_system_flash_init(MemoryRegion *rom_memory) (unit < FLASH_MAP_UNIT_MAX && (pflash_drv = drive_get(IF_PFLASH, 0, unit)) != NULL); ++unit) { - bdrv = pflash_drv->bdrv; + bdrv = blk_bs(blk_by_legacy_dinfo(pflash_drv)); size = bdrv_getlength(bdrv); if (size < 0) { fatal_errmsg = g_strdup_printf("failed to get backing file size"); diff --git a/hw/ide/piix.c b/hw/ide/piix.c index ec93977e53..0e87e51148 100644 --- a/hw/ide/piix.c +++ b/hw/ide/piix.c @@ -180,9 +180,10 @@ int pci_piix3_xen_ide_unplug(DeviceState *dev) di = drive_get_by_index(IF_IDE, i); if (di != NULL && !di->media_cd) { BlockBackend *blk = blk_by_legacy_dinfo(di); - DeviceState *ds = bdrv_get_attached_dev(di->bdrv); + BlockDriverState *bs = blk_bs(blk); + DeviceState *ds = bdrv_get_attached_dev(bs); if (ds) { - bdrv_detach_dev(di->bdrv, ds); + bdrv_detach_dev(bs, ds); } pci_ide->bus[di->bus].ifs[di->unit].bs = NULL; blk_unref(blk); diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c index 9814ef0d24..816167b99b 100644 --- a/hw/ide/qdev.c +++ b/hw/ide/qdev.c @@ -20,6 +20,7 @@ #include "sysemu/dma.h" #include "qemu/error-report.h" #include +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/block/block.h" #include "sysemu/sysemu.h" @@ -117,7 +118,8 @@ IDEDevice *ide_create_drive(IDEBus *bus, int unit, DriveInfo *drive) dev = qdev_create(&bus->qbus, drive->media_cd ? "ide-cd" : "ide-hd"); qdev_prop_set_uint32(dev, "unit", unit); - qdev_prop_set_drive_nofail(dev, "drive", drive->bdrv); + qdev_prop_set_drive_nofail(dev, "drive", + blk_bs(blk_by_legacy_dinfo(drive))); qdev_init_nofail(dev); return DO_UPCAST(IDEDevice, qdev, dev); } diff --git a/hw/isa/pc87312.c b/hw/isa/pc87312.c index 9327c53132..b691a0ca00 100644 --- a/hw/isa/pc87312.c +++ b/hw/isa/pc87312.c @@ -25,6 +25,7 @@ #include "hw/isa/pc87312.h" #include "qemu/error-report.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/sysemu.h" #include "sysemu/char.h" @@ -320,11 +321,13 @@ static void pc87312_realize(DeviceState *dev, Error **errp) qdev_prop_set_uint32(d, "irq", 6); drive = drive_get(IF_FLOPPY, 0, 0); if (drive != NULL) { - qdev_prop_set_drive_nofail(d, "driveA", drive->bdrv); + qdev_prop_set_drive_nofail(d, "driveA", + blk_bs(blk_by_legacy_dinfo(drive))); } drive = drive_get(IF_FLOPPY, 0, 1); if (drive != NULL) { - qdev_prop_set_drive_nofail(d, "driveB", drive->bdrv); + qdev_prop_set_drive_nofail(d, "driveB", + blk_bs(blk_by_legacy_dinfo(drive))); } qdev_init_nofail(d); s->fdc.dev = isa; diff --git a/hw/lm32/lm32_boards.c b/hw/lm32/lm32_boards.c index 5ae6cad1ef..2a1d3dea2a 100644 --- a/hw/lm32/lm32_boards.c +++ b/hw/lm32/lm32_boards.c @@ -23,6 +23,7 @@ #include "hw/devices.h" #include "hw/boards.h" #include "hw/loader.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "elf.h" #include "lm32_hwsetup.h" @@ -119,9 +120,9 @@ static void lm32_evr_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); /* Spansion S29NS128P */ pflash_cfi02_register(flash_base, NULL, "lm32_evr.flash", flash_size, - dinfo ? dinfo->bdrv : NULL, flash_sector_size, - flash_size / flash_sector_size, 1, 2, - 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + flash_sector_size, flash_size / flash_sector_size, + 1, 2, 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); /* create irq lines */ cpu_irq = qemu_allocate_irqs(cpu_irq_handler, cpu, 1); @@ -222,9 +223,9 @@ static void lm32_uclinux_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); /* Spansion S29NS128P */ pflash_cfi02_register(flash_base, NULL, "lm32_uclinux.flash", flash_size, - dinfo ? dinfo->bdrv : NULL, flash_sector_size, - flash_size / flash_sector_size, 1, 2, - 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + flash_sector_size, flash_size / flash_sector_size, + 1, 2, 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); /* create irq lines */ cpu_irq = qemu_allocate_irqs(cpu_irq_handler, env, 1); diff --git a/hw/lm32/milkymist.c b/hw/lm32/milkymist.c index c8832f03b5..8411895aa3 100644 --- a/hw/lm32/milkymist.c +++ b/hw/lm32/milkymist.c @@ -26,6 +26,7 @@ #include "hw/boards.h" #include "hw/loader.h" #include "elf.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "milkymist-hw.h" #include "lm32.h" @@ -126,9 +127,9 @@ milkymist_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); /* Numonyx JS28F256J3F105 */ pflash_cfi01_register(flash_base, NULL, "milkymist.flash", flash_size, - dinfo ? dinfo->bdrv : NULL, flash_sector_size, - flash_size / flash_sector_size, 2, - 0x00, 0x89, 0x00, 0x1d, 1); + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + flash_sector_size, flash_size / flash_sector_size, + 2, 0x00, 0x89, 0x00, 0x1d, 1); /* create irq lines */ cpu_irq = qemu_allocate_irqs(cpu_irq_handler, cpu, 1); diff --git a/hw/microblaze/petalogix_ml605_mmu.c b/hw/microblaze/petalogix_ml605_mmu.c index fcb51bc070..8c0532d872 100644 --- a/hw/microblaze/petalogix_ml605_mmu.c +++ b/hw/microblaze/petalogix_ml605_mmu.c @@ -32,6 +32,7 @@ #include "sysemu/sysemu.h" #include "hw/devices.h" #include "hw/boards.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/char/serial.h" #include "exec/address-spaces.h" @@ -113,8 +114,8 @@ petalogix_ml605_init(MachineState *machine) * 10th paremeter 0 means little-endian */ pflash_cfi01_register(FLASH_BASEADDR, NULL, "petalogix_ml605.flash", FLASH_SIZE, - dinfo ? dinfo->bdrv : NULL, (64 * 1024), - FLASH_SIZE >> 16, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + (64 * 1024), FLASH_SIZE >> 16, 2, 0x89, 0x18, 0x0000, 0x0, 0); diff --git a/hw/microblaze/petalogix_s3adsp1800_mmu.c b/hw/microblaze/petalogix_s3adsp1800_mmu.c index 8e0fca9ebf..c3fd743e5f 100644 --- a/hw/microblaze/petalogix_s3adsp1800_mmu.c +++ b/hw/microblaze/petalogix_s3adsp1800_mmu.c @@ -30,6 +30,7 @@ #include "sysemu/sysemu.h" #include "hw/devices.h" #include "hw/boards.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" @@ -94,8 +95,8 @@ petalogix_s3adsp1800_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi01_register(FLASH_BASEADDR, NULL, "petalogix_s3adsp1800.flash", FLASH_SIZE, - dinfo ? dinfo->bdrv : NULL, (64 * 1024), - FLASH_SIZE >> 16, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + (64 * 1024), FLASH_SIZE >> 16, 1, 0x89, 0x18, 0x0000, 0x0, 1); dev = qdev_create(NULL, "xlnx.xps-intc"); diff --git a/hw/mips/mips_malta.c b/hw/mips/mips_malta.c index b20807c4e4..59020ec176 100644 --- a/hw/mips/mips_malta.c +++ b/hw/mips/mips_malta.c @@ -44,6 +44,7 @@ #include "elf.h" #include "hw/timer/mc146818rtc.h" #include "hw/timer/i8254.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "hw/sysbus.h" /* SysBusDevice */ @@ -1036,7 +1037,8 @@ void mips_malta_init(MachineState *machine) } #endif fl = pflash_cfi01_register(FLASH_ADDRESS, NULL, "mips_malta.bios", - BIOS_SIZE, dinfo ? dinfo->bdrv : NULL, + BIOS_SIZE, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, 65536, fl_sectors, 4, 0x0000, 0x0000, 0x0000, 0x0000, be); bios = pflash_cfi01_get_memory(fl); diff --git a/hw/mips/mips_r4k.c b/hw/mips/mips_r4k.c index 93606a490c..e966a1bb1c 100644 --- a/hw/mips/mips_r4k.c +++ b/hw/mips/mips_r4k.c @@ -24,6 +24,7 @@ #include "elf.h" #include "hw/timer/mc146818rtc.h" #include "hw/timer/i8254.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" @@ -241,8 +242,8 @@ void mips_r4k_init(MachineState *machine) } else if ((dinfo = drive_get(IF_PFLASH, 0, 0)) != NULL) { uint32_t mips_rom = 0x00400000; if (!pflash_cfi01_register(0x1fc00000, NULL, "mips_r4k.bios", mips_rom, - dinfo->bdrv, sector_len, - mips_rom / sector_len, + blk_bs(blk_by_legacy_dinfo(dinfo)), + sector_len, mips_rom / sector_len, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); } diff --git a/hw/pci/pci-hotplug-old.c b/hw/pci/pci-hotplug-old.c index 6ab28b703c..c6625b9d9f 100644 --- a/hw/pci/pci-hotplug-old.c +++ b/hw/pci/pci-hotplug-old.c @@ -33,6 +33,7 @@ #include "hw/scsi/scsi.h" #include "hw/virtio/virtio-blk.h" #include "qemu/config-file.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "qapi/error.h" @@ -127,8 +128,10 @@ static int scsi_hot_add(Monitor *mon, DeviceState *adapter, */ dinfo->unit = qemu_opt_get_number(dinfo->opts, "unit", -1); dinfo->bus = scsibus->busnr; - scsidev = scsi_bus_legacy_add_drive(scsibus, dinfo->bdrv, dinfo->unit, - false, -1, NULL, &local_err); + scsidev = scsi_bus_legacy_add_drive(scsibus, + blk_bs(blk_by_legacy_dinfo(dinfo)), + dinfo->unit, false, -1, NULL, + &local_err); if (!scsidev) { error_report("%s", error_get_pretty(local_err)); error_free(local_err); @@ -250,7 +253,8 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon, return NULL; } dev = pci_create(bus, devfn, "virtio-blk-pci"); - if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) { + if (qdev_prop_set_drive(&dev->qdev, "drive", + blk_bs(blk_by_legacy_dinfo(dinfo))) < 0) { object_unparent(OBJECT(dev)); dev = NULL; break; diff --git a/hw/ppc/ppc405_boards.c b/hw/ppc/ppc405_boards.c index 18a4ec5e79..aeae45063c 100644 --- a/hw/ppc/ppc405_boards.c +++ b/hw/ppc/ppc405_boards.c @@ -33,6 +33,7 @@ #include "qemu/log.h" #include "qemu/error-report.h" #include "hw/loader.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" @@ -225,17 +226,19 @@ static void ref405ep_init(MachineState *machine) #ifdef USE_FLASH_BIOS dinfo = drive_get(IF_PFLASH, 0, fl_idx); if (dinfo) { - bios_size = bdrv_getlength(dinfo->bdrv); + BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + + bios_size = bdrv_getlength(bs); fl_sectors = (bios_size + 65535) >> 16; #ifdef DEBUG_BOARD_INIT printf("Register parallel flash %d size %lx" " at addr %lx '%s' %d\n", fl_idx, bios_size, -bios_size, - bdrv_get_device_name(dinfo->bdrv), fl_sectors); + bdrv_get_device_name(bs), fl_sectors); #endif pflash_cfi02_register((uint32_t)(-bios_size), NULL, "ef405ep.bios", bios_size, - dinfo->bdrv, 65536, fl_sectors, 1, + bs, 65536, fl_sectors, 1, 2, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA, 1); fl_idx++; @@ -548,7 +551,9 @@ static void taihu_405ep_init(MachineState *machine) #if defined(USE_FLASH_BIOS) dinfo = drive_get(IF_PFLASH, 0, fl_idx); if (dinfo) { - bios_size = bdrv_getlength(dinfo->bdrv); + BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + + bios_size = bdrv_getlength(bs); /* XXX: should check that size is 2MB */ // bios_size = 2 * 1024 * 1024; fl_sectors = (bios_size + 65535) >> 16; @@ -556,11 +561,11 @@ static void taihu_405ep_init(MachineState *machine) printf("Register parallel flash %d size %lx" " at addr %lx '%s' %d\n", fl_idx, bios_size, -bios_size, - bdrv_get_device_name(dinfo->bdrv), fl_sectors); + bdrv_get_device_name(bs), fl_sectors); #endif pflash_cfi02_register((uint32_t)(-bios_size), NULL, "taihu_405ep.bios", bios_size, - dinfo->bdrv, 65536, fl_sectors, 1, + bs, 65536, fl_sectors, 1, 4, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA, 1); fl_idx++; @@ -595,7 +600,9 @@ static void taihu_405ep_init(MachineState *machine) /* Register Linux flash */ dinfo = drive_get(IF_PFLASH, 0, fl_idx); if (dinfo) { - bios_size = bdrv_getlength(dinfo->bdrv); + BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + + bios_size = bdrv_getlength(bs); /* XXX: should check that size is 32MB */ bios_size = 32 * 1024 * 1024; fl_sectors = (bios_size + 65535) >> 16; @@ -603,10 +610,10 @@ static void taihu_405ep_init(MachineState *machine) printf("Register parallel flash %d size %lx" " at addr " TARGET_FMT_lx " '%s'\n", fl_idx, bios_size, (target_ulong)0xfc000000, - bdrv_get_device_name(dinfo->bdrv)); + bdrv_get_device_name(bs)); #endif pflash_cfi02_register(0xfc000000, NULL, "taihu_405ep.flash", bios_size, - dinfo->bdrv, 65536, fl_sectors, 1, + bs, 65536, fl_sectors, 1, 4, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA, 1); fl_idx++; diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c index 2becc9ff07..0605ce8205 100644 --- a/hw/ppc/spapr.c +++ b/hw/ppc/spapr.c @@ -29,6 +29,7 @@ #include "hw/fw-path-provider.h" #include "elf.h" #include "net/net.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/cpus.h" #include "sysemu/kvm.h" @@ -925,7 +926,8 @@ static void spapr_create_nvram(sPAPREnvironment *spapr) DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); if (dinfo) { - qdev_prop_set_drive_nofail(dev, "drive", dinfo->bdrv); + qdev_prop_set_drive_nofail(dev, "drive", + blk_bs(blk_by_legacy_dinfo(dinfo))); } qdev_init_nofail(dev); diff --git a/hw/ppc/virtex_ml507.c b/hw/ppc/virtex_ml507.c index 0de51481f3..a0ce447e9c 100644 --- a/hw/ppc/virtex_ml507.c +++ b/hw/ppc/virtex_ml507.c @@ -39,6 +39,7 @@ #include "hw/ppc/ppc4xx.h" #include "ppc405.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "qapi/qmp/qerror.h" @@ -227,8 +228,8 @@ static void virtex_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi01_register(PFLASH_BASEADDR, NULL, "virtex.flash", FLASH_SIZE, - dinfo ? dinfo->bdrv : NULL, (64 * 1024), - FLASH_SIZE >> 16, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + (64 * 1024), FLASH_SIZE >> 16, 1, 0x89, 0x18, 0x0000, 0x0, 1); cpu_irq = (qemu_irq *) &env->irq_inputs[PPC40x_INPUT_INT]; diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c index 022a524074..b4bbd9ca4d 100644 --- a/hw/scsi/scsi-bus.c +++ b/hw/scsi/scsi-bus.c @@ -3,6 +3,7 @@ #include "hw/scsi/scsi.h" #include "block/scsi.h" #include "hw/qdev.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "trace.h" #include "sysemu/dma.h" @@ -270,8 +271,8 @@ void scsi_bus_legacy_handle_cmdline(SCSIBus *bus, Error **errp) continue; } qemu_opts_loc_restore(dinfo->opts); - scsi_bus_legacy_add_drive(bus, dinfo->bdrv, unit, false, -1, NULL, - &err); + scsi_bus_legacy_add_drive(bus, blk_bs(blk_by_legacy_dinfo(dinfo)), + unit, false, -1, NULL, &err); if (err != NULL) { error_report("%s", error_get_pretty(err)); error_propagate(errp, err); diff --git a/hw/sd/milkymist-memcard.c b/hw/sd/milkymist-memcard.c index 2a40f92732..501aa3a2c4 100644 --- a/hw/sd/milkymist-memcard.c +++ b/hw/sd/milkymist-memcard.c @@ -26,6 +26,7 @@ #include "sysemu/sysemu.h" #include "trace.h" #include "qemu/error-report.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/sd.h" @@ -252,14 +253,16 @@ static int milkymist_memcard_init(SysBusDevice *dev) { MilkymistMemcardState *s = MILKYMIST_MEMCARD(dev); DriveInfo *dinfo; + BlockDriverState *bs; dinfo = drive_get_next(IF_SD); - s->card = sd_init(dinfo ? dinfo->bdrv : NULL, false); + bs = dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL; + s->card = sd_init(bs, false); if (s->card == NULL) { return -1; } - s->enabled = dinfo ? bdrv_is_inserted(dinfo->bdrv) : 0; + s->enabled = bs && bdrv_is_inserted(bs); memory_region_init_io(&s->regs_region, OBJECT(s), &memcard_mmio_ops, s, "milkymist-memcard", R_MAX * 4); diff --git a/hw/sd/pl181.c b/hw/sd/pl181.c index 462558b76d..0501d4079c 100644 --- a/hw/sd/pl181.c +++ b/hw/sd/pl181.c @@ -7,6 +7,7 @@ * This code is licensed under the GPL. */ +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/sysbus.h" #include "hw/sd.h" @@ -490,7 +491,7 @@ static int pl181_init(SysBusDevice *sbd) sysbus_init_irq(sbd, &s->irq[1]); qdev_init_gpio_out(dev, s->cardstatus, 2); dinfo = drive_get_next(IF_SD); - s->card = sd_init(dinfo ? dinfo->bdrv : NULL, false); + s->card = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, false); if (s->card == NULL) { return -1; } diff --git a/hw/sd/sdhci.c b/hw/sd/sdhci.c index f9fe700add..0b7d754380 100644 --- a/hw/sd/sdhci.c +++ b/hw/sd/sdhci.c @@ -23,6 +23,7 @@ */ #include "hw/hw.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/dma.h" #include "qemu/timer.h" @@ -1165,7 +1166,7 @@ static void sdhci_initfn(Object *obj) DriveInfo *di; di = drive_get_next(IF_SD); - s->card = sd_init(di ? di->bdrv : NULL, false); + s->card = sd_init(di ? blk_bs(blk_by_legacy_dinfo(di)) : NULL, false); if (s->card == NULL) { exit(1); } diff --git a/hw/sd/ssi-sd.c b/hw/sd/ssi-sd.c index b012e57f64..6ae99e4008 100644 --- a/hw/sd/ssi-sd.c +++ b/hw/sd/ssi-sd.c @@ -10,6 +10,7 @@ * GNU GPL, version 2 or (at your option) any later version. */ +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/ssi.h" #include "hw/sd.h" @@ -255,7 +256,7 @@ static int ssi_sd_init(SSISlave *d) s->mode = SSI_SD_CMD; dinfo = drive_get_next(IF_SD); - s->sd = sd_init(dinfo ? dinfo->bdrv : NULL, true); + s->sd = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, true); if (s->sd == NULL) { return -1; } diff --git a/hw/sh4/r2d.c b/hw/sh4/r2d.c index 321379ece7..80ac132a0c 100644 --- a/hw/sh4/r2d.c +++ b/hw/sh4/r2d.c @@ -36,6 +36,7 @@ #include "hw/loader.h" #include "hw/usb.h" #include "hw/block/flash.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/address-spaces.h" @@ -290,8 +291,8 @@ static void r2d_init(MachineState *machine) /* onboard flash memory */ dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi02_register(0x0, NULL, "r2d.flash", FLASH_SIZE, - dinfo ? dinfo->bdrv : NULL, (16 * 1024), - FLASH_SIZE >> 16, + dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + (16 * 1024), FLASH_SIZE >> 16, 1, 4, 0x0000, 0x0000, 0x0000, 0x0000, 0x555, 0x2aa, 0); diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c index 5bfc72ca45..44b4d046af 100644 --- a/hw/usb/dev-storage.c +++ b/hw/usb/dev-storage.c @@ -16,6 +16,7 @@ #include "ui/console.h" #include "monitor/monitor.h" #include "sysemu/sysemu.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "qapi/visitor.h" @@ -707,7 +708,8 @@ static USBDevice *usb_msd_init(USBBus *bus, const char *filename) if (!dev) { return NULL; } - if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) { + if (qdev_prop_set_drive(&dev->qdev, "drive", + blk_bs(blk_by_legacy_dinfo(dinfo))) < 0) { object_unparent(OBJECT(dev)); return NULL; } diff --git a/hw/xtensa/xtfpga.c b/hw/xtensa/xtfpga.c index ed06ff7956..4ac1ceff2f 100644 --- a/hw/xtensa/xtfpga.c +++ b/hw/xtensa/xtfpga.c @@ -35,6 +35,7 @@ #include "net/net.h" #include "hw/sysbus.h" #include "hw/block/flash.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/char.h" #include "sysemu/device_tree.h" @@ -230,7 +231,8 @@ static void lx_init(const LxBoardDesc *board, MachineState *machine) if (dinfo) { flash = pflash_cfi01_register(board->flash_base, NULL, "lx60.io.flash", board->flash_size, - dinfo->bdrv, board->flash_sector_size, + blk_bs(blk_by_legacy_dinfo(dinfo)), + board->flash_sector_size, board->flash_size / board->flash_sector_size, 4, 0x0000, 0x0000, 0x0000, 0x0000, be); if (flash == NULL) { diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h index 439844d6dd..4de76d17b7 100644 --- a/include/sysemu/blockdev.h +++ b/include/sysemu/blockdev.h @@ -30,7 +30,6 @@ typedef enum { } BlockInterfaceType; struct DriveInfo { - BlockDriverState *bdrv; char *id; const char *devaddr; BlockInterfaceType type; From 7c84b1b8310cd634825c77d45b4db89bb44c5cee Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:14 +0200 Subject: [PATCH 16/28] block: Rename BlockDriverAIOCB* to BlockAIOCB* I'll use BlockDriverAIOCB with block backends shortly, and the name is going to fit badly there. It's a block layer thing anyway, not just a block driver thing. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block-migration.c | 2 +- block.c | 124 ++++++++++++++++++------------------ block/archipelago.c | 22 +++---- block/blkdebug.c | 10 +-- block/blkverify.c | 12 ++-- block/curl.c | 4 +- block/iscsi.c | 6 +- block/linux-aio.c | 6 +- block/null.c | 34 +++++----- block/qed.c | 32 +++++----- block/qed.h | 2 +- block/quorum.c | 36 +++++------ block/raw-aio.h | 4 +- block/raw-posix.c | 16 ++--- block/raw-win32.c | 8 +-- block/raw_bsd.c | 8 +-- block/rbd.c | 56 ++++++++-------- block/sheepdog.c | 4 +- block/win32-aio.c | 4 +- dma-helpers.c | 20 +++--- docs/blkdebug.txt | 8 +-- hw/block/nvme.h | 2 +- hw/ide/ahci.h | 2 +- hw/ide/core.c | 8 +-- hw/ide/internal.h | 6 +- hw/ppc/mac.h | 2 +- include/block/aio.h | 8 +-- include/block/block.h | 34 +++++----- include/block/block_int.h | 10 +-- include/block/thread-pool.h | 2 +- include/hw/scsi/scsi.h | 2 +- include/sysemu/dma.h | 26 ++++---- tests/test-thread-pool.c | 2 +- thread-pool.c | 8 +-- 34 files changed, 265 insertions(+), 265 deletions(-) diff --git a/block-migration.c b/block-migration.c index da30e93158..08db01a364 100644 --- a/block-migration.c +++ b/block-migration.c @@ -72,7 +72,7 @@ typedef struct BlkMigBlock { int nr_sectors; struct iovec iov; QEMUIOVector qiov; - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; /* Protected by block migration lock. */ int ret; diff --git a/block.c b/block.c index 2d80d6a588..a5911456a7 100644 --- a/block.c +++ b/block.c @@ -61,10 +61,10 @@ struct BdrvDirtyBitmap { #define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */ static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); -static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, +static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque); -static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, +static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque); static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, @@ -79,14 +79,14 @@ static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, int64_t offset, unsigned int bytes, QEMUIOVector *qiov, BdrvRequestFlags flags); -static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, - void *opaque, - bool is_write); +static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BdrvRequestFlags flags, + BlockDriverCompletionFunc *cb, + void *opaque, + bool is_write); static void coroutine_fn bdrv_co_do_rw(void *opaque); static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); @@ -4413,9 +4413,9 @@ int bdrv_get_backing_file_depth(BlockDriverState *bs) /**************************************************************/ /* async I/Os */ -BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, - QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) +BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *qiov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque) { trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); @@ -4423,9 +4423,9 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, cb, opaque, false); } -BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, - QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) +BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *qiov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque) { trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); @@ -4433,7 +4433,7 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, cb, opaque, true); } -BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags, BlockDriverCompletionFunc *cb, void *opaque) { @@ -4627,7 +4627,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) return 0; } -void bdrv_aio_cancel(BlockDriverAIOCB *acb) +void bdrv_aio_cancel(BlockAIOCB *acb) { qemu_aio_ref(acb); bdrv_aio_cancel_async(acb); @@ -4646,7 +4646,7 @@ void bdrv_aio_cancel(BlockDriverAIOCB *acb) /* Async version of aio cancel. The caller is not blocked if the acb implements * cancel_async, otherwise we do nothing and let the request normally complete. * In either case the completion callback must be called. */ -void bdrv_aio_cancel_async(BlockDriverAIOCB *acb) +void bdrv_aio_cancel_async(BlockAIOCB *acb) { if (acb->aiocb_info->cancel_async) { acb->aiocb_info->cancel_async(acb); @@ -4656,23 +4656,23 @@ void bdrv_aio_cancel_async(BlockDriverAIOCB *acb) /**************************************************************/ /* async block device emulation */ -typedef struct BlockDriverAIOCBSync { - BlockDriverAIOCB common; +typedef struct BlockAIOCBSync { + BlockAIOCB common; QEMUBH *bh; int ret; /* vector translation state */ QEMUIOVector *qiov; uint8_t *bounce; int is_write; -} BlockDriverAIOCBSync; +} BlockAIOCBSync; static const AIOCBInfo bdrv_em_aiocb_info = { - .aiocb_size = sizeof(BlockDriverAIOCBSync), + .aiocb_size = sizeof(BlockAIOCBSync), }; static void bdrv_aio_bh_cb(void *opaque) { - BlockDriverAIOCBSync *acb = opaque; + BlockAIOCBSync *acb = opaque; if (!acb->is_write && acb->ret >= 0) { qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); @@ -4684,16 +4684,16 @@ static void bdrv_aio_bh_cb(void *opaque) qemu_aio_unref(acb); } -static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque, - int is_write) +static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque, + int is_write) { - BlockDriverAIOCBSync *acb; + BlockAIOCBSync *acb; acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque); acb->is_write = is_write; @@ -4715,14 +4715,14 @@ static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, return &acb->common; } -static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, +static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); } -static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, +static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -4730,21 +4730,21 @@ static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, } -typedef struct BlockDriverAIOCBCoroutine { - BlockDriverAIOCB common; +typedef struct BlockAIOCBCoroutine { + BlockAIOCB common; BlockRequest req; bool is_write; bool *done; QEMUBH* bh; -} BlockDriverAIOCBCoroutine; +} BlockAIOCBCoroutine; static const AIOCBInfo bdrv_em_co_aiocb_info = { - .aiocb_size = sizeof(BlockDriverAIOCBCoroutine), + .aiocb_size = sizeof(BlockAIOCBCoroutine), }; static void bdrv_co_em_bh(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; acb->common.cb(acb->common.opaque, acb->req.error); @@ -4755,7 +4755,7 @@ static void bdrv_co_em_bh(void *opaque) /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */ static void coroutine_fn bdrv_co_do_rw(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; BlockDriverState *bs = acb->common.bs; if (!acb->is_write) { @@ -4770,17 +4770,17 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque) qemu_bh_schedule(acb->bh); } -static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, - void *opaque, - bool is_write) +static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BdrvRequestFlags flags, + BlockDriverCompletionFunc *cb, + void *opaque, + bool is_write) { Coroutine *co; - BlockDriverAIOCBCoroutine *acb; + BlockAIOCBCoroutine *acb; acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); acb->req.sector = sector_num; @@ -4797,7 +4797,7 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; BlockDriverState *bs = acb->common.bs; acb->req.error = bdrv_co_flush(bs); @@ -4805,13 +4805,13 @@ static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque) qemu_bh_schedule(acb->bh); } -BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque) { trace_bdrv_aio_flush(bs, opaque); Coroutine *co; - BlockDriverAIOCBCoroutine *acb; + BlockAIOCBCoroutine *acb; acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); @@ -4823,7 +4823,7 @@ BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque) { - BlockDriverAIOCBCoroutine *acb = opaque; + BlockAIOCBCoroutine *acb = opaque; BlockDriverState *bs = acb->common.bs; acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors); @@ -4831,12 +4831,12 @@ static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque) qemu_bh_schedule(acb->bh); } -BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { Coroutine *co; - BlockDriverAIOCBCoroutine *acb; + BlockAIOCBCoroutine *acb; trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque); @@ -4863,7 +4863,7 @@ void bdrv_init_with_whitelist(void) void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque) { - BlockDriverAIOCB *acb; + BlockAIOCB *acb; acb = g_slice_alloc(aiocb_info->aiocb_size); acb->aiocb_info = aiocb_info; @@ -4876,13 +4876,13 @@ void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, void qemu_aio_ref(void *p) { - BlockDriverAIOCB *acb = p; + BlockAIOCB *acb = p; acb->refcnt++; } void qemu_aio_unref(void *p) { - BlockDriverAIOCB *acb = p; + BlockAIOCB *acb = p; assert(acb->refcnt > 0); if (--acb->refcnt == 0) { g_slice_free1(acb->aiocb_info->aiocb_size, acb); @@ -4912,7 +4912,7 @@ static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num, CoroutineIOCompletion co = { .coroutine = qemu_coroutine_self(), }; - BlockDriverAIOCB *acb; + BlockAIOCB *acb; if (is_write) { acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors, @@ -4978,7 +4978,7 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs) if (bs->drv->bdrv_co_flush_to_disk) { ret = bs->drv->bdrv_co_flush_to_disk(bs); } else if (bs->drv->bdrv_aio_flush) { - BlockDriverAIOCB *acb; + BlockAIOCB *acb; CoroutineIOCompletion co = { .coroutine = qemu_coroutine_self(), }; @@ -5153,7 +5153,7 @@ int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, if (bs->drv->bdrv_co_discard) { ret = bs->drv->bdrv_co_discard(bs, sector_num, num); } else { - BlockDriverAIOCB *acb; + BlockAIOCB *acb; CoroutineIOCompletion co = { .coroutine = qemu_coroutine_self(), }; @@ -5279,7 +5279,7 @@ int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) return -ENOTSUP; } -BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, BlockDriverCompletionFunc *cb, void *opaque) { diff --git a/block/archipelago.c b/block/archipelago.c index 73d91a422f..4c468aaf04 100644 --- a/block/archipelago.c +++ b/block/archipelago.c @@ -86,7 +86,7 @@ typedef enum { } ARCHIPCmd; typedef struct ArchipelagoAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; struct BDRVArchipelagoState *s; QEMUIOVector *qiov; @@ -856,13 +856,13 @@ err_exit: return ret; } -static BlockDriverAIOCB *qemu_archipelago_aio_rw(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque, - int op) +static BlockAIOCB *qemu_archipelago_aio_rw(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque, + int op) { ArchipelagoAIOCB *aio_cb; BDRVArchipelagoState *s = bs->opaque; @@ -894,7 +894,7 @@ err_exit: return NULL; } -static BlockDriverAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs, +static BlockAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -902,7 +902,7 @@ static BlockDriverAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs, opaque, ARCHIP_OP_READ); } -static BlockDriverAIOCB *qemu_archipelago_aio_writev(BlockDriverState *bs, +static BlockAIOCB *qemu_archipelago_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -1052,7 +1052,7 @@ static QemuOptsList qemu_archipelago_create_opts = { } }; -static BlockDriverAIOCB *qemu_archipelago_aio_flush(BlockDriverState *bs, +static BlockAIOCB *qemu_archipelago_aio_flush(BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque) { return qemu_archipelago_aio_rw(bs, 0, NULL, 0, cb, opaque, diff --git a/block/blkdebug.c b/block/blkdebug.c index f8fbb0f3d4..f6291407f2 100644 --- a/block/blkdebug.c +++ b/block/blkdebug.c @@ -41,7 +41,7 @@ typedef struct BDRVBlkdebugState { } BDRVBlkdebugState; typedef struct BlkdebugAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; int ret; } BlkdebugAIOCB; @@ -463,7 +463,7 @@ static void error_callback_bh(void *opaque) qemu_aio_unref(acb); } -static BlockDriverAIOCB *inject_error(BlockDriverState *bs, +static BlockAIOCB *inject_error(BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque, BlkdebugRule *rule) { BDRVBlkdebugState *s = bs->opaque; @@ -489,7 +489,7 @@ static BlockDriverAIOCB *inject_error(BlockDriverState *bs, return &acb->common; } -static BlockDriverAIOCB *blkdebug_aio_readv(BlockDriverState *bs, +static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -511,7 +511,7 @@ static BlockDriverAIOCB *blkdebug_aio_readv(BlockDriverState *bs, return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque); } -static BlockDriverAIOCB *blkdebug_aio_writev(BlockDriverState *bs, +static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -533,7 +533,7 @@ static BlockDriverAIOCB *blkdebug_aio_writev(BlockDriverState *bs, return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque); } -static BlockDriverAIOCB *blkdebug_aio_flush(BlockDriverState *bs, +static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque) { BDRVBlkdebugState *s = bs->opaque; diff --git a/block/blkverify.c b/block/blkverify.c index 7d64a23a09..0c49063440 100644 --- a/block/blkverify.c +++ b/block/blkverify.c @@ -19,7 +19,7 @@ typedef struct { typedef struct BlkverifyAIOCB BlkverifyAIOCB; struct BlkverifyAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; /* Request metadata */ @@ -229,7 +229,7 @@ static void blkverify_verify_readv(BlkverifyAIOCB *acb) } } -static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs, +static BlockAIOCB *blkverify_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -249,7 +249,7 @@ static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs, return &acb->common; } -static BlockDriverAIOCB *blkverify_aio_writev(BlockDriverState *bs, +static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -264,9 +264,9 @@ static BlockDriverAIOCB *blkverify_aio_writev(BlockDriverState *bs, return &acb->common; } -static BlockDriverAIOCB *blkverify_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *blkverify_aio_flush(BlockDriverState *bs, + BlockDriverCompletionFunc *cb, + void *opaque) { BDRVBlkverifyState *s = bs->opaque; diff --git a/block/curl.c b/block/curl.c index 225407c643..0ff70b74d3 100644 --- a/block/curl.c +++ b/block/curl.c @@ -78,7 +78,7 @@ static CURLMcode __curl_multi_socket_action(CURLM *multi_handle, struct BDRVCURLState; typedef struct CURLAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; QEMUIOVector *qiov; @@ -680,7 +680,7 @@ static void curl_readv_bh_cb(void *p) curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running); } -static BlockDriverAIOCB *curl_aio_readv(BlockDriverState *bs, +static BlockAIOCB *curl_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { diff --git a/block/iscsi.c b/block/iscsi.c index a7fb764e4d..3ca29515e7 100644 --- a/block/iscsi.c +++ b/block/iscsi.c @@ -80,7 +80,7 @@ typedef struct IscsiTask { } IscsiTask; typedef struct IscsiAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUIOVector *qiov; QEMUBH *bh; IscsiLun *iscsilun; @@ -227,7 +227,7 @@ iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data, } static void -iscsi_aio_cancel(BlockDriverAIOCB *blockacb) +iscsi_aio_cancel(BlockAIOCB *blockacb) { IscsiAIOCB *acb = (IscsiAIOCB *)blockacb; IscsiLun *iscsilun = acb->iscsilun; @@ -663,7 +663,7 @@ iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status, iscsi_schedule_bh(acb); } -static BlockDriverAIOCB *iscsi_aio_ioctl(BlockDriverState *bs, +static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, BlockDriverCompletionFunc *cb, void *opaque) { diff --git a/block/linux-aio.c b/block/linux-aio.c index f4baba2be0..16e09d18a5 100644 --- a/block/linux-aio.c +++ b/block/linux-aio.c @@ -28,7 +28,7 @@ #define MAX_QUEUED_IO 128 struct qemu_laiocb { - BlockDriverAIOCB common; + BlockAIOCB common; struct qemu_laio_state *ctx; struct iocb iocb; ssize_t ret; @@ -146,7 +146,7 @@ static void qemu_laio_completion_cb(EventNotifier *e) } } -static void laio_cancel(BlockDriverAIOCB *blockacb) +static void laio_cancel(BlockAIOCB *blockacb) { struct qemu_laiocb *laiocb = (struct qemu_laiocb *)blockacb; struct io_event event; @@ -243,7 +243,7 @@ int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug) return ret; } -BlockDriverAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, +BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type) { diff --git a/block/null.c b/block/null.c index 828441999c..e9547d785a 100644 --- a/block/null.c +++ b/block/null.c @@ -78,7 +78,7 @@ static coroutine_fn int null_co_flush(BlockDriverState *bs) } typedef struct { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; } NullAIOCB; @@ -94,9 +94,9 @@ static void null_bh_cb(void *opaque) qemu_aio_unref(acb); } -static inline BlockDriverAIOCB *null_aio_common(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, - void *opaque) +static inline BlockAIOCB *null_aio_common(BlockDriverState *bs, + BlockDriverCompletionFunc *cb, + void *opaque) { NullAIOCB *acb; @@ -106,27 +106,27 @@ static inline BlockDriverAIOCB *null_aio_common(BlockDriverState *bs, return &acb->common; } -static BlockDriverAIOCB *null_aio_readv(BlockDriverState *bs, - int64_t sector_num, QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *null_aio_readv(BlockDriverState *bs, + int64_t sector_num, QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { return null_aio_common(bs, cb, opaque); } -static BlockDriverAIOCB *null_aio_writev(BlockDriverState *bs, - int64_t sector_num, QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *null_aio_writev(BlockDriverState *bs, + int64_t sector_num, QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { return null_aio_common(bs, cb, opaque); } -static BlockDriverAIOCB *null_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *null_aio_flush(BlockDriverState *bs, + BlockDriverCompletionFunc *cb, + void *opaque) { return null_aio_common(bs, cb, opaque); } diff --git a/block/qed.c b/block/qed.c index 7f03c26227..4c14ac27e6 100644 --- a/block/qed.c +++ b/block/qed.c @@ -1365,11 +1365,11 @@ static void qed_aio_next_io(void *opaque, int ret) io_fn, acb); } -static BlockDriverAIOCB *qed_aio_setup(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque, int flags) +static BlockAIOCB *qed_aio_setup(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque, int flags) { QEDAIOCB *acb = qemu_aio_get(&qed_aiocb_info, bs, cb, opaque); @@ -1390,20 +1390,20 @@ static BlockDriverAIOCB *qed_aio_setup(BlockDriverState *bs, return &acb->common; } -static BlockDriverAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); } -static BlockDriverAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, QED_AIOCB_WRITE); @@ -1431,7 +1431,7 @@ static int coroutine_fn bdrv_qed_co_write_zeroes(BlockDriverState *bs, int nb_sectors, BdrvRequestFlags flags) { - BlockDriverAIOCB *blockacb; + BlockAIOCB *blockacb; BDRVQEDState *s = bs->opaque; QEDWriteZeroesCB cb = { .done = false }; QEMUIOVector qiov; diff --git a/block/qed.h b/block/qed.h index 2b0e724e05..fc4980494a 100644 --- a/block/qed.h +++ b/block/qed.h @@ -128,7 +128,7 @@ enum { }; typedef struct QEDAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; int bh_ret; /* final return status for completion bh */ QSIMPLEQ_ENTRY(QEDAIOCB) next; /* next request */ diff --git a/block/quorum.c b/block/quorum.c index 6ce5904824..e173ef0fbd 100644 --- a/block/quorum.c +++ b/block/quorum.c @@ -92,7 +92,7 @@ typedef struct QuorumAIOCB QuorumAIOCB; * $children_count QuorumChildRequest. */ typedef struct QuorumChildRequest { - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; QEMUIOVector qiov; uint8_t *buf; int ret; @@ -105,7 +105,7 @@ typedef struct QuorumChildRequest { * used to do operations on each children and track overall progress. */ struct QuorumAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; /* Request metadata */ uint64_t sector_num; @@ -130,7 +130,7 @@ struct QuorumAIOCB { static bool quorum_vote(QuorumAIOCB *acb); -static void quorum_aio_cancel(BlockDriverAIOCB *blockacb) +static void quorum_aio_cancel(BlockAIOCB *blockacb) { QuorumAIOCB *acb = container_of(blockacb, QuorumAIOCB, common); BDRVQuorumState *s = acb->common.bs->opaque; @@ -264,7 +264,7 @@ static void quorum_rewrite_aio_cb(void *opaque, int ret) quorum_aio_finalize(acb); } -static BlockDriverAIOCB *read_fifo_child(QuorumAIOCB *acb); +static BlockAIOCB *read_fifo_child(QuorumAIOCB *acb); static void quorum_copy_qiov(QEMUIOVector *dest, QEMUIOVector *source) { @@ -640,7 +640,7 @@ free_exit: return rewrite; } -static BlockDriverAIOCB *read_quorum_children(QuorumAIOCB *acb) +static BlockAIOCB *read_quorum_children(QuorumAIOCB *acb) { BDRVQuorumState *s = acb->common.bs->opaque; int i; @@ -659,7 +659,7 @@ static BlockDriverAIOCB *read_quorum_children(QuorumAIOCB *acb) return &acb->common; } -static BlockDriverAIOCB *read_fifo_child(QuorumAIOCB *acb) +static BlockAIOCB *read_fifo_child(QuorumAIOCB *acb) { BDRVQuorumState *s = acb->common.bs->opaque; @@ -675,12 +675,12 @@ static BlockDriverAIOCB *read_fifo_child(QuorumAIOCB *acb) return &acb->common; } -static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *quorum_aio_readv(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { BDRVQuorumState *s = bs->opaque; QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num, @@ -696,12 +696,12 @@ static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs, return read_fifo_child(acb); } -static BlockDriverAIOCB *quorum_aio_writev(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *quorum_aio_writev(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { BDRVQuorumState *s = bs->opaque; QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num, nb_sectors, diff --git a/block/raw-aio.h b/block/raw-aio.h index e18c97509a..e1eee3f6f0 100644 --- a/block/raw-aio.h +++ b/block/raw-aio.h @@ -35,7 +35,7 @@ #ifdef CONFIG_LINUX_AIO void *laio_init(void); void laio_cleanup(void *s); -BlockDriverAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, +BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type); void laio_detach_aio_context(void *s, AioContext *old_context); @@ -49,7 +49,7 @@ typedef struct QEMUWin32AIOState QEMUWin32AIOState; QEMUWin32AIOState *win32_aio_init(void); void win32_aio_cleanup(QEMUWin32AIOState *aio); int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile); -BlockDriverAIOCB *win32_aio_submit(BlockDriverState *bs, +BlockAIOCB *win32_aio_submit(BlockDriverState *bs, QEMUWin32AIOState *aio, HANDLE hfile, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type); diff --git a/block/raw-posix.c b/block/raw-posix.c index eb76f0e233..0fbaba00b1 100644 --- a/block/raw-posix.c +++ b/block/raw-posix.c @@ -1041,7 +1041,7 @@ static int paio_submit_co(BlockDriverState *bs, int fd, return thread_pool_submit_co(pool, aio_worker, acb); } -static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, int fd, +static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type) { @@ -1066,7 +1066,7 @@ static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, int fd, return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque); } -static BlockDriverAIOCB *raw_aio_submit(BlockDriverState *bs, +static BlockAIOCB *raw_aio_submit(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type) { @@ -1125,7 +1125,7 @@ static void raw_aio_flush_io_queue(BlockDriverState *bs) #endif } -static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, +static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -1133,7 +1133,7 @@ static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, cb, opaque, QEMU_AIO_READ); } -static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, +static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -1141,7 +1141,7 @@ static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, cb, opaque, QEMU_AIO_WRITE); } -static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs, +static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; @@ -1595,7 +1595,7 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs, return ret; } -static coroutine_fn BlockDriverAIOCB *raw_aio_discard(BlockDriverState *bs, +static coroutine_fn BlockAIOCB *raw_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -1935,7 +1935,7 @@ static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) return ioctl(s->fd, req, buf); } -static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs, +static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, BlockDriverCompletionFunc *cb, void *opaque) { @@ -1976,7 +1976,7 @@ static int fd_open(BlockDriverState *bs) #endif /* !linux && !FreeBSD */ -static coroutine_fn BlockDriverAIOCB *hdev_aio_discard(BlockDriverState *bs, +static coroutine_fn BlockAIOCB *hdev_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { diff --git a/block/raw-win32.c b/block/raw-win32.c index 9bf82252b8..c11d522250 100644 --- a/block/raw-win32.c +++ b/block/raw-win32.c @@ -138,7 +138,7 @@ static int aio_worker(void *arg) return ret; } -static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile, +static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type) { @@ -369,7 +369,7 @@ fail: return ret; } -static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, +static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -383,7 +383,7 @@ static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, } } -static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, +static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { @@ -397,7 +397,7 @@ static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, } } -static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs, +static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; diff --git a/block/raw_bsd.c b/block/raw_bsd.c index f82f4c25df..cde05fcf5f 100644 --- a/block/raw_bsd.c +++ b/block/raw_bsd.c @@ -129,10 +129,10 @@ static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) return bdrv_ioctl(bs->file, req, buf); } -static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState *bs, - unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *raw_aio_ioctl(BlockDriverState *bs, + unsigned long int req, void *buf, + BlockDriverCompletionFunc *cb, + void *opaque) { return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque); } diff --git a/block/rbd.c b/block/rbd.c index 96947e328a..a385a6e0cd 100644 --- a/block/rbd.c +++ b/block/rbd.c @@ -68,7 +68,7 @@ typedef enum { } RBDAIOCmd; typedef struct RBDAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; int64_t ret; QEMUIOVector *qiov; @@ -589,13 +589,13 @@ static int rbd_aio_flush_wrapper(rbd_image_t image, #endif } -static BlockDriverAIOCB *rbd_start_aio(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque, - RBDAIOCmd cmd) +static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque, + RBDAIOCmd cmd) { RBDAIOCB *acb; RADOSCB *rcb = NULL; @@ -675,32 +675,32 @@ failed: return NULL; } -static BlockDriverAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, RBD_AIO_READ); } -static BlockDriverAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, - int64_t sector_num, - QEMUIOVector *qiov, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, RBD_AIO_WRITE); } #ifdef LIBRBD_SUPPORTS_AIO_FLUSH -static BlockDriverAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, + BlockDriverCompletionFunc *cb, + void *opaque) { return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); } @@ -876,11 +876,11 @@ static int qemu_rbd_snap_list(BlockDriverState *bs, } #ifdef LIBRBD_SUPPORTS_DISCARD -static BlockDriverAIOCB* qemu_rbd_aio_discard(BlockDriverState *bs, - int64_t sector_num, - int nb_sectors, - BlockDriverCompletionFunc *cb, - void *opaque) +static BlockAIOCB* qemu_rbd_aio_discard(BlockDriverState *bs, + int64_t sector_num, + int nb_sectors, + BlockDriverCompletionFunc *cb, + void *opaque) { return rbd_start_aio(bs, sector_num, NULL, nb_sectors, cb, opaque, RBD_AIO_DISCARD); diff --git a/block/sheepdog.c b/block/sheepdog.c index 2d78ef91f7..be3176fcb4 100644 --- a/block/sheepdog.c +++ b/block/sheepdog.c @@ -301,7 +301,7 @@ enum AIOCBState { }; struct SheepdogAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUIOVector *qiov; @@ -473,7 +473,7 @@ static bool sd_acb_cancelable(const SheepdogAIOCB *acb) return true; } -static void sd_aio_cancel(BlockDriverAIOCB *blockacb) +static void sd_aio_cancel(BlockAIOCB *blockacb) { SheepdogAIOCB *acb = (SheepdogAIOCB *)blockacb; BDRVSheepdogState *s = acb->common.bs->opaque; diff --git a/block/win32-aio.c b/block/win32-aio.c index 9323c1aed1..16c31a8cb1 100644 --- a/block/win32-aio.c +++ b/block/win32-aio.c @@ -44,7 +44,7 @@ struct QEMUWin32AIOState { }; typedef struct QEMUWin32AIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; struct QEMUWin32AIOState *ctx; int nbytes; OVERLAPPED ov; @@ -110,7 +110,7 @@ static const AIOCBInfo win32_aiocb_info = { .aiocb_size = sizeof(QEMUWin32AIOCB), }; -BlockDriverAIOCB *win32_aio_submit(BlockDriverState *bs, +BlockAIOCB *win32_aio_submit(BlockDriverState *bs, QEMUWin32AIOState *aio, HANDLE hfile, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type) diff --git a/dma-helpers.c b/dma-helpers.c index 7f86e18e72..229192bfd9 100644 --- a/dma-helpers.c +++ b/dma-helpers.c @@ -67,9 +67,9 @@ void qemu_sglist_destroy(QEMUSGList *qsg) } typedef struct { - BlockDriverAIOCB common; + BlockAIOCB common; BlockDriverState *bs; - BlockDriverAIOCB *acb; + BlockAIOCB *acb; QEMUSGList *sg; uint64_t sector_num; DMADirection dir; @@ -173,7 +173,7 @@ static void dma_bdrv_cb(void *opaque, int ret) assert(dbs->acb); } -static void dma_aio_cancel(BlockDriverAIOCB *acb) +static void dma_aio_cancel(BlockAIOCB *acb) { DMAAIOCB *dbs = container_of(acb, DMAAIOCB, common); @@ -190,7 +190,7 @@ static const AIOCBInfo dma_aiocb_info = { .cancel_async = dma_aio_cancel, }; -BlockDriverAIOCB *dma_bdrv_io( +BlockAIOCB *dma_bdrv_io( BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, void *opaque, DMADirection dir) @@ -214,17 +214,17 @@ BlockDriverAIOCB *dma_bdrv_io( } -BlockDriverAIOCB *dma_bdrv_read(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector, - void (*cb)(void *opaque, int ret), void *opaque) +BlockAIOCB *dma_bdrv_read(BlockDriverState *bs, + QEMUSGList *sg, uint64_t sector, + void (*cb)(void *opaque, int ret), void *opaque) { return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, DMA_DIRECTION_FROM_DEVICE); } -BlockDriverAIOCB *dma_bdrv_write(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector, - void (*cb)(void *opaque, int ret), void *opaque) +BlockAIOCB *dma_bdrv_write(BlockDriverState *bs, + QEMUSGList *sg, uint64_t sector, + void (*cb)(void *opaque, int ret), void *opaque) { return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, DMA_DIRECTION_TO_DEVICE); diff --git a/docs/blkdebug.txt b/docs/blkdebug.txt index 5dde07234f..cba1186f12 100644 --- a/docs/blkdebug.txt +++ b/docs/blkdebug.txt @@ -70,10 +70,10 @@ Rules support the following attributes: once - (optional, default "off") only execute this action on the first matching request - immediately - (optional, default "off") return a NULL BlockDriverAIOCB - pointer and fail without an errno instead. This exercises the - code path where BlockDriverAIOCB fails and the caller's - BlockDriverCompletionFunc is not invoked. + immediately - (optional, default "off") return a NULL BlockAIOCB + pointer and fail without an errno instead. This + exercises the code path where BlockAIOCB fails and the + caller's BlockDriverCompletionFunc is not invoked. Events ------ diff --git a/hw/block/nvme.h b/hw/block/nvme.h index bd8fc3e4bb..993c51131c 100644 --- a/hw/block/nvme.h +++ b/hw/block/nvme.h @@ -636,7 +636,7 @@ typedef struct NvmeAsyncEvent { typedef struct NvmeRequest { struct NvmeSQueue *sq; - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; uint16_t status; NvmeCqe cqe; BlockAcctCookie acct; diff --git a/hw/ide/ahci.h b/hw/ide/ahci.h index e223258820..e8ea34a1df 100644 --- a/hw/ide/ahci.h +++ b/hw/ide/ahci.h @@ -241,7 +241,7 @@ typedef struct AHCIDevice AHCIDevice; typedef struct NCQTransferState { AHCIDevice *drive; - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; QEMUSGList sglist; BlockAcctCookie acct; uint16_t sector_count; diff --git a/hw/ide/core.c b/hw/ide/core.c index ae85428864..0ef587e66b 100644 --- a/hw/ide/core.c +++ b/hw/ide/core.c @@ -360,15 +360,15 @@ static void ide_set_signature(IDEState *s) } typedef struct TrimAIOCB { - BlockDriverAIOCB common; + BlockAIOCB common; QEMUBH *bh; int ret; QEMUIOVector *qiov; - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; int i, j; } TrimAIOCB; -static void trim_aio_cancel(BlockDriverAIOCB *acb) +static void trim_aio_cancel(BlockAIOCB *acb) { TrimAIOCB *iocb = container_of(acb, TrimAIOCB, common); @@ -438,7 +438,7 @@ static void ide_issue_trim_cb(void *opaque, int ret) } } -BlockDriverAIOCB *ide_issue_trim(BlockDriverState *bs, +BlockAIOCB *ide_issue_trim(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { diff --git a/hw/ide/internal.h b/hw/ide/internal.h index 5c19f79437..c661a74dfd 100644 --- a/hw/ide/internal.h +++ b/hw/ide/internal.h @@ -389,7 +389,7 @@ struct IDEState { int cd_sector_size; int atapi_dma; /* true if dma is requested for the packet cmd */ BlockAcctCookie acct; - BlockDriverAIOCB *pio_aiocb; + BlockAIOCB *pio_aiocb; struct iovec iov; QEMUIOVector qiov; /* ATA DMA state */ @@ -442,7 +442,7 @@ struct IDEDMA { const struct IDEDMAOps *ops; struct iovec iov; QEMUIOVector qiov; - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; }; struct IDEBus { @@ -555,7 +555,7 @@ void ide_transfer_start(IDEState *s, uint8_t *buf, int size, EndTransferFunc *end_transfer_func); void ide_transfer_stop(IDEState *s); void ide_set_inactive(IDEState *s, bool more); -BlockDriverAIOCB *ide_issue_trim(BlockDriverState *bs, +BlockAIOCB *ide_issue_trim(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque); diff --git a/hw/ppc/mac.h b/hw/ppc/mac.h index aff2b9a566..8bdba30c1e 100644 --- a/hw/ppc/mac.h +++ b/hw/ppc/mac.h @@ -131,7 +131,7 @@ typedef struct MACIOIDEState { MemoryRegion mem; IDEBus bus; - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; IDEDMA dma; void *dbdma; bool dma_active; diff --git a/include/block/aio.h b/include/block/aio.h index 156272177f..ce992502f1 100644 --- a/include/block/aio.h +++ b/include/block/aio.h @@ -22,16 +22,16 @@ #include "qemu/rfifolock.h" #include "qemu/timer.h" -typedef struct BlockDriverAIOCB BlockDriverAIOCB; +typedef struct BlockAIOCB BlockAIOCB; typedef void BlockDriverCompletionFunc(void *opaque, int ret); typedef struct AIOCBInfo { - void (*cancel_async)(BlockDriverAIOCB *acb); - AioContext *(*get_aio_context)(BlockDriverAIOCB *acb); + void (*cancel_async)(BlockAIOCB *acb); + AioContext *(*get_aio_context)(BlockAIOCB *acb); size_t aiocb_size; } AIOCBInfo; -struct BlockDriverAIOCB { +struct BlockAIOCB { const AIOCBInfo *aiocb_info; BlockDriverState *bs; BlockDriverCompletionFunc *cb; diff --git a/include/block/block.h b/include/block/block.h index 3dc7c56037..0edddfe4f3 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -248,9 +248,9 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors); int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); -BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num, - int nb_sectors, BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, void *opaque); +BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, BdrvRequestFlags flags, + BlockDriverCompletionFunc *cb, void *opaque); int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags); int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int count); @@ -326,19 +326,19 @@ BlockDriverState *check_to_replace_node(const char *node_name, Error **errp); /* async block I/O */ typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector, int sector_num); -BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, - QEMUIOVector *iov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); -BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, - QEMUIOVector *iov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); -BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque); -BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs, - int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); -void bdrv_aio_cancel(BlockDriverAIOCB *acb); -void bdrv_aio_cancel_async(BlockDriverAIOCB *acb); +BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque); +BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque); +BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs, + BlockDriverCompletionFunc *cb, void *opaque); +BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque); +void bdrv_aio_cancel(BlockAIOCB *acb); +void bdrv_aio_cancel_async(BlockAIOCB *acb); typedef struct BlockRequest { /* Fields to be filled by multiwrite caller */ @@ -358,7 +358,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, /* sg packet commands */ int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf); -BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, +BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, BlockDriverCompletionFunc *cb, void *opaque); diff --git a/include/block/block_int.h b/include/block/block_int.h index da00aa5cfc..ab74618464 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -128,15 +128,15 @@ struct BlockDriver { void (*bdrv_refresh_filename)(BlockDriverState *bs); /* aio */ - BlockDriverAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs, + BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque); - BlockDriverAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs, + BlockAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque); - BlockDriverAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, + BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque); - BlockDriverAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs, + BlockAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque); @@ -218,7 +218,7 @@ struct BlockDriver { /* to control generic scsi devices */ int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf); - BlockDriverAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, + BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf, BlockDriverCompletionFunc *cb, void *opaque); diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h index 472375227a..1fd57ec22d 100644 --- a/include/block/thread-pool.h +++ b/include/block/thread-pool.h @@ -27,7 +27,7 @@ typedef struct ThreadPool ThreadPool; ThreadPool *thread_pool_new(struct AioContext *ctx); void thread_pool_free(ThreadPool *pool); -BlockDriverAIOCB *thread_pool_submit_aio(ThreadPool *pool, +BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool, ThreadPoolFunc *func, void *arg, BlockDriverCompletionFunc *cb, void *opaque); int coroutine_fn thread_pool_submit_co(ThreadPool *pool, diff --git a/include/hw/scsi/scsi.h b/include/hw/scsi/scsi.h index caaa3201ce..809aefb8c1 100644 --- a/include/hw/scsi/scsi.h +++ b/include/hw/scsi/scsi.h @@ -68,7 +68,7 @@ struct SCSIRequest { bool io_canceled; bool retry; bool dma_started; - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; QEMUSGList *sg; QTAILQ_ENTRY(SCSIRequest) next; }; diff --git a/include/sysemu/dma.h b/include/sysemu/dma.h index 73ff86d4b9..1bc22234f1 100644 --- a/include/sysemu/dma.h +++ b/include/sysemu/dma.h @@ -197,20 +197,20 @@ void qemu_sglist_add(QEMUSGList *qsg, dma_addr_t base, dma_addr_t len); void qemu_sglist_destroy(QEMUSGList *qsg); #endif -typedef BlockDriverAIOCB *DMAIOFunc(BlockDriverState *bs, int64_t sector_num, - QEMUIOVector *iov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); +typedef BlockAIOCB *DMAIOFunc(BlockDriverState *bs, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque); -BlockDriverAIOCB *dma_bdrv_io(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector_num, - DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, - void *opaque, DMADirection dir); -BlockDriverAIOCB *dma_bdrv_read(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector, - BlockDriverCompletionFunc *cb, void *opaque); -BlockDriverAIOCB *dma_bdrv_write(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector, - BlockDriverCompletionFunc *cb, void *opaque); +BlockAIOCB *dma_bdrv_io(BlockDriverState *bs, + QEMUSGList *sg, uint64_t sector_num, + DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, + void *opaque, DMADirection dir); +BlockAIOCB *dma_bdrv_read(BlockDriverState *bs, + QEMUSGList *sg, uint64_t sector, + BlockDriverCompletionFunc *cb, void *opaque); +BlockAIOCB *dma_bdrv_write(BlockDriverState *bs, + QEMUSGList *sg, uint64_t sector, + BlockDriverCompletionFunc *cb, void *opaque); uint64_t dma_buf_read(uint8_t *ptr, int32_t len, QEMUSGList *sg); uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg); diff --git a/tests/test-thread-pool.c b/tests/test-thread-pool.c index 8c4d68b345..6a0b9813f5 100644 --- a/tests/test-thread-pool.c +++ b/tests/test-thread-pool.c @@ -11,7 +11,7 @@ static ThreadPool *pool; static int active; typedef struct { - BlockDriverAIOCB *aiocb; + BlockAIOCB *aiocb; int n; int ret; } WorkerTestData; diff --git a/thread-pool.c b/thread-pool.c index 86fa4a8f89..70ebb50e6d 100644 --- a/thread-pool.c +++ b/thread-pool.c @@ -34,7 +34,7 @@ enum ThreadState { }; struct ThreadPoolElement { - BlockDriverAIOCB common; + BlockAIOCB common; ThreadPool *pool; ThreadPoolFunc *func; void *arg; @@ -195,7 +195,7 @@ restart: } } -static void thread_pool_cancel(BlockDriverAIOCB *acb) +static void thread_pool_cancel(BlockAIOCB *acb) { ThreadPoolElement *elem = (ThreadPoolElement *)acb; ThreadPool *pool = elem->pool; @@ -220,7 +220,7 @@ static void thread_pool_cancel(BlockDriverAIOCB *acb) qemu_mutex_unlock(&pool->lock); } -static AioContext *thread_pool_get_aio_context(BlockDriverAIOCB *acb) +static AioContext *thread_pool_get_aio_context(BlockAIOCB *acb) { ThreadPoolElement *elem = (ThreadPoolElement *)acb; ThreadPool *pool = elem->pool; @@ -233,7 +233,7 @@ static const AIOCBInfo thread_pool_aiocb_info = { .get_aio_context = thread_pool_get_aio_context, }; -BlockDriverAIOCB *thread_pool_submit_aio(ThreadPool *pool, +BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool, ThreadPoolFunc *func, void *arg, BlockDriverCompletionFunc *cb, void *opaque) { From 097310b53e9d498ef8e127d52ea57905cbe46ec5 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:15 +0200 Subject: [PATCH 17/28] block: Rename BlockDriverCompletionFunc to BlockCompletionFunc I'll use it with block backends shortly, and the name is going to fit badly there. It's a block layer thing anyway, not just a block driver thing. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block.c | 30 +++++++++++++++--------------- block/archipelago.c | 8 ++++---- block/backup.c | 2 +- block/blkdebug.c | 8 ++++---- block/blkverify.c | 8 ++++---- block/commit.c | 2 +- block/curl.c | 2 +- block/iscsi.c | 2 +- block/linux-aio.c | 2 +- block/mirror.c | 6 +++--- block/null.c | 8 ++++---- block/qed-gencb.c | 4 ++-- block/qed-table.c | 10 +++++----- block/qed.c | 18 +++++++++--------- block/qed.h | 10 +++++----- block/quorum.c | 6 +++--- block/raw-aio.h | 4 ++-- block/raw-posix.c | 16 ++++++++-------- block/raw-win32.c | 8 ++++---- block/raw_bsd.c | 2 +- block/rbd.c | 10 +++++----- block/stream.c | 2 +- block/win32-aio.c | 2 +- blockjob.c | 4 ++-- dma-helpers.c | 2 +- docs/blkdebug.txt | 2 +- hw/ide/ahci.c | 2 +- hw/ide/core.c | 4 ++-- hw/ide/internal.h | 6 +++--- hw/ide/macio.c | 2 +- hw/ide/pci.c | 2 +- hw/ide/pci.h | 2 +- hw/scsi/scsi-generic.c | 2 +- include/block/aio.h | 6 +++--- include/block/block.h | 14 +++++++------- include/block/block_int.h | 20 ++++++++++---------- include/block/blockjob.h | 4 ++-- include/block/thread-pool.h | 2 +- include/monitor/monitor.h | 4 ++-- include/sysemu/dma.h | 8 ++++---- monitor.c | 6 +++--- thread-pool.c | 2 +- 42 files changed, 132 insertions(+), 132 deletions(-) diff --git a/block.c b/block.c index a5911456a7..9fee0d28ed 100644 --- a/block.c +++ b/block.c @@ -63,10 +63,10 @@ struct BdrvDirtyBitmap { static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *iov); @@ -84,7 +84,7 @@ static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, QEMUIOVector *qiov, int nb_sectors, BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, bool is_write); static void coroutine_fn bdrv_co_do_rw(void *opaque); @@ -4415,7 +4415,7 @@ int bdrv_get_backing_file_depth(BlockDriverState *bs) BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); @@ -4425,7 +4425,7 @@ BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); @@ -4435,7 +4435,7 @@ BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque); @@ -4450,7 +4450,7 @@ typedef struct MultiwriteCB { int num_requests; int num_callbacks; struct { - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; void *opaque; QEMUIOVector *free_qiov; } callbacks[]; @@ -4688,7 +4688,7 @@ static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, int is_write) @@ -4717,14 +4717,14 @@ static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); } static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); } @@ -4775,7 +4775,7 @@ static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, QEMUIOVector *qiov, int nb_sectors, BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, bool is_write) { @@ -4806,7 +4806,7 @@ static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque) } BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { trace_bdrv_aio_flush(bs, opaque); @@ -4833,7 +4833,7 @@ static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque) BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { Coroutine *co; BlockAIOCBCoroutine *acb; @@ -4861,7 +4861,7 @@ void bdrv_init_with_whitelist(void) } void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BlockAIOCB *acb; @@ -5281,7 +5281,7 @@ int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BlockDriver *drv = bs->drv; diff --git a/block/archipelago.c b/block/archipelago.c index 4c468aaf04..a8114b528b 100644 --- a/block/archipelago.c +++ b/block/archipelago.c @@ -860,7 +860,7 @@ static BlockAIOCB *qemu_archipelago_aio_rw(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, int op) { @@ -896,7 +896,7 @@ err_exit: static BlockAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { return qemu_archipelago_aio_rw(bs, sector_num, qiov, nb_sectors, cb, opaque, ARCHIP_OP_READ); @@ -904,7 +904,7 @@ static BlockAIOCB *qemu_archipelago_aio_readv(BlockDriverState *bs, static BlockAIOCB *qemu_archipelago_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { return qemu_archipelago_aio_rw(bs, sector_num, qiov, nb_sectors, cb, opaque, ARCHIP_OP_WRITE); @@ -1053,7 +1053,7 @@ static QemuOptsList qemu_archipelago_create_opts = { }; static BlockAIOCB *qemu_archipelago_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { return qemu_archipelago_aio_rw(bs, 0, NULL, 0, cb, opaque, ARCHIP_OP_FLUSH); diff --git a/block/backup.c b/block/backup.c index d0b02255ce..e334740161 100644 --- a/block/backup.c +++ b/block/backup.c @@ -353,7 +353,7 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target, int64_t speed, MirrorSyncMode sync_mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, - BlockDriverCompletionFunc *cb, void *opaque, + BlockCompletionFunc *cb, void *opaque, Error **errp) { int64_t len; diff --git a/block/blkdebug.c b/block/blkdebug.c index f6291407f2..e046b920fb 100644 --- a/block/blkdebug.c +++ b/block/blkdebug.c @@ -464,7 +464,7 @@ static void error_callback_bh(void *opaque) } static BlockAIOCB *inject_error(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque, BlkdebugRule *rule) + BlockCompletionFunc *cb, void *opaque, BlkdebugRule *rule) { BDRVBlkdebugState *s = bs->opaque; int error = rule->options.inject.error; @@ -491,7 +491,7 @@ static BlockAIOCB *inject_error(BlockDriverState *bs, static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVBlkdebugState *s = bs->opaque; BlkdebugRule *rule = NULL; @@ -513,7 +513,7 @@ static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs, static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVBlkdebugState *s = bs->opaque; BlkdebugRule *rule = NULL; @@ -534,7 +534,7 @@ static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs, } static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVBlkdebugState *s = bs->opaque; BlkdebugRule *rule = NULL; diff --git a/block/blkverify.c b/block/blkverify.c index 0c49063440..438dff8bcb 100644 --- a/block/blkverify.c +++ b/block/blkverify.c @@ -165,7 +165,7 @@ static int64_t blkverify_getlength(BlockDriverState *bs) static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aiocb_info, bs, cb, opaque); @@ -231,7 +231,7 @@ static void blkverify_verify_readv(BlkverifyAIOCB *acb) static BlockAIOCB *blkverify_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVBlkverifyState *s = bs->opaque; BlkverifyAIOCB *acb = blkverify_aio_get(bs, false, sector_num, qiov, @@ -251,7 +251,7 @@ static BlockAIOCB *blkverify_aio_readv(BlockDriverState *bs, static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVBlkverifyState *s = bs->opaque; BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov, @@ -265,7 +265,7 @@ static BlockAIOCB *blkverify_aio_writev(BlockDriverState *bs, } static BlockAIOCB *blkverify_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { BDRVBlkverifyState *s = bs->opaque; diff --git a/block/commit.c b/block/commit.c index 91517d3512..60a2accf04 100644 --- a/block/commit.c +++ b/block/commit.c @@ -182,7 +182,7 @@ static const BlockJobDriver commit_job_driver = { void commit_start(BlockDriverState *bs, BlockDriverState *base, BlockDriverState *top, int64_t speed, - BlockdevOnError on_error, BlockDriverCompletionFunc *cb, + BlockdevOnError on_error, BlockCompletionFunc *cb, void *opaque, const char *backing_file_str, Error **errp) { CommitBlockJob *s; diff --git a/block/curl.c b/block/curl.c index 0ff70b74d3..b4157cc8b3 100644 --- a/block/curl.c +++ b/block/curl.c @@ -682,7 +682,7 @@ static void curl_readv_bh_cb(void *p) static BlockAIOCB *curl_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { CURLAIOCB *acb; diff --git a/block/iscsi.c b/block/iscsi.c index 3ca29515e7..233f46285c 100644 --- a/block/iscsi.c +++ b/block/iscsi.c @@ -665,7 +665,7 @@ iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status, static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { IscsiLun *iscsilun = bs->opaque; struct iscsi_context *iscsi = iscsilun->iscsi; diff --git a/block/linux-aio.c b/block/linux-aio.c index 16e09d18a5..d92513b0f9 100644 --- a/block/linux-aio.c +++ b/block/linux-aio.c @@ -245,7 +245,7 @@ int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug) BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque, int type) + BlockCompletionFunc *cb, void *opaque, int type) { struct qemu_laio_state *s = aio_ctx; struct qemu_laiocb *laiocb; diff --git a/block/mirror.c b/block/mirror.c index 829be2f88a..e8a43eb39e 100644 --- a/block/mirror.c +++ b/block/mirror.c @@ -613,7 +613,7 @@ static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target, int64_t buf_size, BlockdevOnError on_source_error, BlockdevOnError on_target_error, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, Error **errp, const BlockJobDriver *driver, bool is_none_mode, BlockDriverState *base) @@ -673,7 +673,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, int64_t speed, int64_t granularity, int64_t buf_size, MirrorSyncMode mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, Error **errp) { bool is_none_mode; @@ -690,7 +690,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, void commit_active_start(BlockDriverState *bs, BlockDriverState *base, int64_t speed, BlockdevOnError on_error, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, Error **errp) { int64_t length, base_length; diff --git a/block/null.c b/block/null.c index e9547d785a..ec2bd27a4b 100644 --- a/block/null.c +++ b/block/null.c @@ -95,7 +95,7 @@ static void null_bh_cb(void *opaque) } static inline BlockAIOCB *null_aio_common(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { NullAIOCB *acb; @@ -109,7 +109,7 @@ static inline BlockAIOCB *null_aio_common(BlockDriverState *bs, static BlockAIOCB *null_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return null_aio_common(bs, cb, opaque); @@ -118,14 +118,14 @@ static BlockAIOCB *null_aio_readv(BlockDriverState *bs, static BlockAIOCB *null_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return null_aio_common(bs, cb, opaque); } static BlockAIOCB *null_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return null_aio_common(bs, cb, opaque); diff --git a/block/qed-gencb.c b/block/qed-gencb.c index 7d7ac1ffc8..b817a8bf50 100644 --- a/block/qed-gencb.c +++ b/block/qed-gencb.c @@ -13,7 +13,7 @@ #include "qed.h" -void *gencb_alloc(size_t len, BlockDriverCompletionFunc *cb, void *opaque) +void *gencb_alloc(size_t len, BlockCompletionFunc *cb, void *opaque) { GenericCB *gencb = g_malloc(len); gencb->cb = cb; @@ -24,7 +24,7 @@ void *gencb_alloc(size_t len, BlockDriverCompletionFunc *cb, void *opaque) void gencb_complete(void *opaque, int ret) { GenericCB *gencb = opaque; - BlockDriverCompletionFunc *cb = gencb->cb; + BlockCompletionFunc *cb = gencb->cb; void *user_opaque = gencb->opaque; g_free(gencb); diff --git a/block/qed-table.c b/block/qed-table.c index f61107a1cf..513aa872c9 100644 --- a/block/qed-table.c +++ b/block/qed-table.c @@ -49,7 +49,7 @@ out: } static void qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { QEDReadTableCB *read_table_cb = gencb_alloc(sizeof(*read_table_cb), cb, opaque); @@ -119,7 +119,7 @@ out: */ static void qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, unsigned int index, unsigned int n, bool flush, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { QEDWriteTableCB *write_table_cb; unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1; @@ -180,7 +180,7 @@ int qed_read_l1_table_sync(BDRVQEDState *s) } void qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE); qed_write_table(s, s->header.l1_table_offset, @@ -235,7 +235,7 @@ static void qed_read_l2_table_cb(void *opaque, int ret) } void qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { QEDReadL2TableCB *read_l2_table_cb; @@ -275,7 +275,7 @@ int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset void qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, unsigned int index, unsigned int n, bool flush, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE); qed_write_table(s, request->l2_table->offset, diff --git a/block/qed.c b/block/qed.c index 4c14ac27e6..80f18d82e2 100644 --- a/block/qed.c +++ b/block/qed.c @@ -130,7 +130,7 @@ static void qed_write_header_read_cb(void *opaque, int ret) * This function only updates known header fields in-place and does not affect * extra data after the QED header. */ -static void qed_write_header(BDRVQEDState *s, BlockDriverCompletionFunc cb, +static void qed_write_header(BDRVQEDState *s, BlockCompletionFunc cb, void *opaque) { /* We must write full sectors for O_DIRECT but cannot necessarily generate @@ -759,7 +759,7 @@ static BDRVQEDState *acb_to_s(QEDAIOCB *acb) static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos, QEMUIOVector *qiov, QEMUIOVector **backing_qiov, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { uint64_t backing_length = 0; size_t size; @@ -851,7 +851,7 @@ static void qed_copy_from_backing_file_write(void *opaque, int ret) */ static void qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, uint64_t len, uint64_t offset, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { CopyFromBackingFileCB *copy_cb; @@ -902,7 +902,7 @@ static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index, static void qed_aio_complete_bh(void *opaque) { QEDAIOCB *acb = opaque; - BlockDriverCompletionFunc *cb = acb->common.cb; + BlockCompletionFunc *cb = acb->common.cb; void *user_opaque = acb->common.opaque; int ret = acb->bh_ret; @@ -1064,7 +1064,7 @@ static void qed_aio_write_main(void *opaque, int ret) BDRVQEDState *s = acb_to_s(acb); uint64_t offset = acb->cur_cluster + qed_offset_into_cluster(s, acb->cur_pos); - BlockDriverCompletionFunc *next_fn; + BlockCompletionFunc *next_fn; trace_qed_aio_write_main(s, acb, ret, offset, acb->cur_qiov.size); @@ -1164,7 +1164,7 @@ static void qed_aio_write_zero_cluster(void *opaque, int ret) static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len) { BDRVQEDState *s = acb_to_s(acb); - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; /* Cancel timer when the first allocating request comes in */ if (QSIMPLEQ_EMPTY(&s->allocating_write_reqs)) { @@ -1368,7 +1368,7 @@ static void qed_aio_next_io(void *opaque, int ret) static BlockAIOCB *qed_aio_setup(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, int flags) { QEDAIOCB *acb = qemu_aio_get(&qed_aiocb_info, bs, cb, opaque); @@ -1393,7 +1393,7 @@ static BlockAIOCB *qed_aio_setup(BlockDriverState *bs, static BlockAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); @@ -1402,7 +1402,7 @@ static BlockAIOCB *bdrv_qed_aio_readv(BlockDriverState *bs, static BlockAIOCB *bdrv_qed_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return qed_aio_setup(bs, sector_num, qiov, nb_sectors, cb, diff --git a/block/qed.h b/block/qed.h index fc4980494a..d3934a05cd 100644 --- a/block/qed.h +++ b/block/qed.h @@ -203,11 +203,11 @@ typedef void QEDFindClusterFunc(void *opaque, int ret, uint64_t offset, size_t l * Generic callback for chaining async callbacks */ typedef struct { - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; void *opaque; } GenericCB; -void *gencb_alloc(size_t len, BlockDriverCompletionFunc *cb, void *opaque); +void *gencb_alloc(size_t len, BlockCompletionFunc *cb, void *opaque); void gencb_complete(void *opaque, int ret); /** @@ -230,16 +230,16 @@ void qed_commit_l2_cache_entry(L2TableCache *l2_cache, CachedL2Table *l2_table); */ int qed_read_l1_table_sync(BDRVQEDState *s); void qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); int qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, unsigned int n); int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset); void qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); void qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, unsigned int index, unsigned int n, bool flush, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request, unsigned int index, unsigned int n, bool flush); diff --git a/block/quorum.c b/block/quorum.c index e173ef0fbd..437b12251d 100644 --- a/block/quorum.c +++ b/block/quorum.c @@ -186,7 +186,7 @@ static QuorumAIOCB *quorum_aio_get(BDRVQuorumState *s, QEMUIOVector *qiov, uint64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { QuorumAIOCB *acb = qemu_aio_get(&quorum_aiocb_info, bs, cb, opaque); @@ -679,7 +679,7 @@ static BlockAIOCB *quorum_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { BDRVQuorumState *s = bs->opaque; @@ -700,7 +700,7 @@ static BlockAIOCB *quorum_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { BDRVQuorumState *s = bs->opaque; diff --git a/block/raw-aio.h b/block/raw-aio.h index e1eee3f6f0..80681ce175 100644 --- a/block/raw-aio.h +++ b/block/raw-aio.h @@ -37,7 +37,7 @@ void *laio_init(void); void laio_cleanup(void *s); BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque, int type); + BlockCompletionFunc *cb, void *opaque, int type); void laio_detach_aio_context(void *s, AioContext *old_context); void laio_attach_aio_context(void *s, AioContext *new_context); void laio_io_plug(BlockDriverState *bs, void *aio_ctx); @@ -52,7 +52,7 @@ int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile); BlockAIOCB *win32_aio_submit(BlockDriverState *bs, QEMUWin32AIOState *aio, HANDLE hfile, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque, int type); + BlockCompletionFunc *cb, void *opaque, int type); void win32_aio_detach_aio_context(QEMUWin32AIOState *aio, AioContext *old_context); void win32_aio_attach_aio_context(QEMUWin32AIOState *aio, diff --git a/block/raw-posix.c b/block/raw-posix.c index 0fbaba00b1..ee4ca3c01e 100644 --- a/block/raw-posix.c +++ b/block/raw-posix.c @@ -1043,7 +1043,7 @@ static int paio_submit_co(BlockDriverState *bs, int fd, static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque, int type) + BlockCompletionFunc *cb, void *opaque, int type) { RawPosixAIOData *acb = g_slice_new(RawPosixAIOData); ThreadPool *pool; @@ -1068,7 +1068,7 @@ static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd, static BlockAIOCB *raw_aio_submit(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque, int type) + BlockCompletionFunc *cb, void *opaque, int type) { BDRVRawState *s = bs->opaque; @@ -1127,7 +1127,7 @@ static void raw_aio_flush_io_queue(BlockDriverState *bs) static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { return raw_aio_submit(bs, sector_num, qiov, nb_sectors, cb, opaque, QEMU_AIO_READ); @@ -1135,14 +1135,14 @@ static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { return raw_aio_submit(bs, sector_num, qiov, nb_sectors, cb, opaque, QEMU_AIO_WRITE); } static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; @@ -1597,7 +1597,7 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs, static coroutine_fn BlockAIOCB *raw_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; @@ -1937,7 +1937,7 @@ static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; RawPosixAIOData *acb; @@ -1978,7 +1978,7 @@ static int fd_open(BlockDriverState *bs) static coroutine_fn BlockAIOCB *hdev_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; diff --git a/block/raw-win32.c b/block/raw-win32.c index c11d522250..7b588815b9 100644 --- a/block/raw-win32.c +++ b/block/raw-win32.c @@ -140,7 +140,7 @@ static int aio_worker(void *arg) static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque, int type) + BlockCompletionFunc *cb, void *opaque, int type) { RawWin32AIOData *acb = g_slice_new(RawWin32AIOData); ThreadPool *pool; @@ -371,7 +371,7 @@ fail: static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; if (s->aio) { @@ -385,7 +385,7 @@ static BlockAIOCB *raw_aio_readv(BlockDriverState *bs, static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; if (s->aio) { @@ -398,7 +398,7 @@ static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, } static BlockAIOCB *raw_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { BDRVRawState *s = bs->opaque; return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH); diff --git a/block/raw_bsd.c b/block/raw_bsd.c index cde05fcf5f..401b967e85 100644 --- a/block/raw_bsd.c +++ b/block/raw_bsd.c @@ -131,7 +131,7 @@ static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) static BlockAIOCB *raw_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque); diff --git a/block/rbd.c b/block/rbd.c index a385a6e0cd..47cab8be94 100644 --- a/block/rbd.c +++ b/block/rbd.c @@ -593,7 +593,7 @@ static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, RBDAIOCmd cmd) { @@ -679,7 +679,7 @@ static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, @@ -690,7 +690,7 @@ static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, @@ -699,7 +699,7 @@ static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, #ifdef LIBRBD_SUPPORTS_AIO_FLUSH static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); @@ -879,7 +879,7 @@ static int qemu_rbd_snap_list(BlockDriverState *bs, static BlockAIOCB* qemu_rbd_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque) { return rbd_start_aio(bs, sector_num, NULL, nb_sectors, cb, opaque, diff --git a/block/stream.c b/block/stream.c index cdea3e8d0c..a1dc8da484 100644 --- a/block/stream.c +++ b/block/stream.c @@ -220,7 +220,7 @@ static const BlockJobDriver stream_job_driver = { void stream_start(BlockDriverState *bs, BlockDriverState *base, const char *backing_file_str, int64_t speed, BlockdevOnError on_error, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, Error **errp) { StreamBlockJob *s; diff --git a/block/win32-aio.c b/block/win32-aio.c index 16c31a8cb1..64e86827bc 100644 --- a/block/win32-aio.c +++ b/block/win32-aio.c @@ -113,7 +113,7 @@ static const AIOCBInfo win32_aiocb_info = { BlockAIOCB *win32_aio_submit(BlockDriverState *bs, QEMUWin32AIOState *aio, HANDLE hfile, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque, int type) + BlockCompletionFunc *cb, void *opaque, int type) { struct QEMUWin32AIOCB *waiocb; uint64_t offset = sector_num * 512; diff --git a/blockjob.c b/blockjob.c index 3af0f6c863..ff0908a653 100644 --- a/blockjob.c +++ b/blockjob.c @@ -36,7 +36,7 @@ #include "qapi-event.h" void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs, - int64_t speed, BlockDriverCompletionFunc *cb, + int64_t speed, BlockCompletionFunc *cb, void *opaque, Error **errp) { BlockJob *job; @@ -155,7 +155,7 @@ void block_job_iostatus_reset(BlockJob *job) struct BlockCancelData { BlockJob *job; - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; void *opaque; bool cancelled; int ret; diff --git a/dma-helpers.c b/dma-helpers.c index 229192bfd9..c347d4bafe 100644 --- a/dma-helpers.c +++ b/dma-helpers.c @@ -192,7 +192,7 @@ static const AIOCBInfo dma_aiocb_info = { BlockAIOCB *dma_bdrv_io( BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, - DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, + DMAIOFunc *io_func, BlockCompletionFunc *cb, void *opaque, DMADirection dir) { DMAAIOCB *dbs = qemu_aio_get(&dma_aiocb_info, bs, cb, opaque); diff --git a/docs/blkdebug.txt b/docs/blkdebug.txt index cba1186f12..b67a36d5c6 100644 --- a/docs/blkdebug.txt +++ b/docs/blkdebug.txt @@ -73,7 +73,7 @@ Rules support the following attributes: immediately - (optional, default "off") return a NULL BlockAIOCB pointer and fail without an errno instead. This exercises the code path where BlockAIOCB fails and the - caller's BlockDriverCompletionFunc is not invoked. + caller's BlockCompletionFunc is not invoked. Events ------ diff --git a/hw/ide/ahci.c b/hw/ide/ahci.c index 063730e8df..f3d4e70e24 100644 --- a/hw/ide/ahci.c +++ b/hw/ide/ahci.c @@ -1122,7 +1122,7 @@ out: } static void ahci_start_dma(IDEDMA *dma, IDEState *s, - BlockDriverCompletionFunc *dma_cb) + BlockCompletionFunc *dma_cb) { #ifdef DEBUG_AHCI AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma); diff --git a/hw/ide/core.c b/hw/ide/core.c index 0ef587e66b..0505c45685 100644 --- a/hw/ide/core.c +++ b/hw/ide/core.c @@ -440,7 +440,7 @@ static void ide_issue_trim_cb(void *opaque, int ret) BlockAIOCB *ide_issue_trim(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { TrimAIOCB *iocb; @@ -789,7 +789,7 @@ static void ide_sector_start_dma(IDEState *s, enum ide_dma_cmd dma_cmd) ide_start_dma(s, ide_dma_cb); } -void ide_start_dma(IDEState *s, BlockDriverCompletionFunc *cb) +void ide_start_dma(IDEState *s, BlockCompletionFunc *cb) { if (s->bus->dma->ops->start_dma) { s->bus->dma->ops->start_dma(s->bus->dma, s, cb); diff --git a/hw/ide/internal.h b/hw/ide/internal.h index c661a74dfd..9314c8060e 100644 --- a/hw/ide/internal.h +++ b/hw/ide/internal.h @@ -319,7 +319,7 @@ typedef enum { IDE_HD, IDE_CD, IDE_CFATA } IDEDriveKind; typedef void EndTransferFunc(IDEState *); -typedef void DMAStartFunc(IDEDMA *, IDEState *, BlockDriverCompletionFunc *); +typedef void DMAStartFunc(IDEDMA *, IDEState *, BlockCompletionFunc *); typedef void DMAVoidFunc(IDEDMA *); typedef int DMAIntFunc(IDEDMA *, int); typedef void DMAStopFunc(IDEDMA *, bool); @@ -521,7 +521,7 @@ void ide_bus_reset(IDEBus *bus); int64_t ide_get_sector(IDEState *s); void ide_set_sector(IDEState *s, int64_t sector_num); -void ide_start_dma(IDEState *s, BlockDriverCompletionFunc *cb); +void ide_start_dma(IDEState *s, BlockCompletionFunc *cb); void ide_dma_error(IDEState *s); void ide_atapi_cmd_ok(IDEState *s); @@ -557,7 +557,7 @@ void ide_transfer_stop(IDEState *s); void ide_set_inactive(IDEState *s, bool more); BlockAIOCB *ide_issue_trim(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); /* hw/ide/atapi.c */ void ide_atapi_cmd(IDEState *s); diff --git a/hw/ide/macio.c b/hw/ide/macio.c index cefc85cf12..6b5cce534f 100644 --- a/hw/ide/macio.c +++ b/hw/ide/macio.c @@ -558,7 +558,7 @@ static void ide_nop_restart(void *opaque, int x, RunState y) } static void ide_dbdma_start(IDEDMA *dma, IDEState *s, - BlockDriverCompletionFunc *cb) + BlockCompletionFunc *cb) { MACIOIDEState *m = container_of(dma, MACIOIDEState, dma); diff --git a/hw/ide/pci.c b/hw/ide/pci.c index 2397f355cc..6ff1c58be9 100644 --- a/hw/ide/pci.c +++ b/hw/ide/pci.c @@ -38,7 +38,7 @@ IDE_RETRY_READ | IDE_RETRY_FLUSH) static void bmdma_start_dma(IDEDMA *dma, IDEState *s, - BlockDriverCompletionFunc *dma_cb) + BlockCompletionFunc *dma_cb) { BMDMAState *bm = DO_UPCAST(BMDMAState, dma, dma); diff --git a/hw/ide/pci.h b/hw/ide/pci.h index 517711f913..2e9314ad87 100644 --- a/hw/ide/pci.h +++ b/hw/ide/pci.h @@ -23,7 +23,7 @@ typedef struct BMDMAState { uint32_t cur_prd_addr; uint32_t cur_prd_len; uint8_t unit; - BlockDriverCompletionFunc *dma_cb; + BlockCompletionFunc *dma_cb; int64_t sector_num; uint32_t nsector; MemoryRegion addr_ioport; diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c index 84a1d5bfe3..4177c5357e 100644 --- a/hw/scsi/scsi-generic.c +++ b/hw/scsi/scsi-generic.c @@ -143,7 +143,7 @@ done: static int execute_command(BlockDriverState *bdrv, SCSIGenericReq *r, int direction, - BlockDriverCompletionFunc *complete) + BlockCompletionFunc *complete) { r->io_header.interface_id = 'S'; r->io_header.dxfer_direction = direction; diff --git a/include/block/aio.h b/include/block/aio.h index ce992502f1..6bf0e0456a 100644 --- a/include/block/aio.h +++ b/include/block/aio.h @@ -23,7 +23,7 @@ #include "qemu/timer.h" typedef struct BlockAIOCB BlockAIOCB; -typedef void BlockDriverCompletionFunc(void *opaque, int ret); +typedef void BlockCompletionFunc(void *opaque, int ret); typedef struct AIOCBInfo { void (*cancel_async)(BlockAIOCB *acb); @@ -34,13 +34,13 @@ typedef struct AIOCBInfo { struct BlockAIOCB { const AIOCBInfo *aiocb_info; BlockDriverState *bs; - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; void *opaque; int refcnt; }; void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); void qemu_aio_unref(void *p); void qemu_aio_ref(void *p); diff --git a/include/block/block.h b/include/block/block.h index 0edddfe4f3..9a490c221c 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -250,7 +250,7 @@ int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors, BdrvRequestFlags flags, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags); int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int count); @@ -328,15 +328,15 @@ typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector, int sector_num); BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *iov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *iov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); void bdrv_aio_cancel(BlockAIOCB *acb); void bdrv_aio_cancel_async(BlockAIOCB *acb); @@ -346,7 +346,7 @@ typedef struct BlockRequest { int nb_sectors; int flags; QEMUIOVector *qiov; - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; void *opaque; /* Filled by multiwrite implementation */ @@ -360,7 +360,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf); BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); /* Invalidate any cached metadata used by image formats */ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp); diff --git a/include/block/block_int.h b/include/block/block_int.h index ab74618464..e8e33a8b43 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -130,15 +130,15 @@ struct BlockDriver { /* aio */ BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs, int64_t sector_num, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); @@ -220,7 +220,7 @@ struct BlockDriver { int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf); BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); /* List of options for creating images, terminated by name == NULL */ QemuOptsList *create_opts; @@ -501,7 +501,7 @@ int is_windows_drive(const char *filename); */ void stream_start(BlockDriverState *bs, BlockDriverState *base, const char *base_id, int64_t speed, BlockdevOnError on_error, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, Error **errp); /** @@ -519,7 +519,7 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base, */ void commit_start(BlockDriverState *bs, BlockDriverState *base, BlockDriverState *top, int64_t speed, - BlockdevOnError on_error, BlockDriverCompletionFunc *cb, + BlockdevOnError on_error, BlockCompletionFunc *cb, void *opaque, const char *backing_file_str, Error **errp); /** * commit_active_start: @@ -535,7 +535,7 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, void commit_active_start(BlockDriverState *bs, BlockDriverState *base, int64_t speed, BlockdevOnError on_error, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, Error **errp); /* * mirror_start: @@ -563,7 +563,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, int64_t speed, int64_t granularity, int64_t buf_size, MirrorSyncMode mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, - BlockDriverCompletionFunc *cb, + BlockCompletionFunc *cb, void *opaque, Error **errp); /* @@ -584,7 +584,7 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target, int64_t speed, MirrorSyncMode sync_mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, - BlockDriverCompletionFunc *cb, void *opaque, + BlockCompletionFunc *cb, void *opaque, Error **errp); #endif /* BLOCK_INT_H */ diff --git a/include/block/blockjob.h b/include/block/blockjob.h index 60aa835ec0..acb399f87d 100644 --- a/include/block/blockjob.h +++ b/include/block/blockjob.h @@ -104,7 +104,7 @@ struct BlockJob { int64_t speed; /** The completion function that will be called when the job completes. */ - BlockDriverCompletionFunc *cb; + BlockCompletionFunc *cb; /** Block other operations when block job is running */ Error *blocker; @@ -132,7 +132,7 @@ struct BlockJob { * called from a wrapper that is specific to the job type. */ void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs, - int64_t speed, BlockDriverCompletionFunc *cb, + int64_t speed, BlockCompletionFunc *cb, void *opaque, Error **errp); /** diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h index 1fd57ec22d..42eb5e8421 100644 --- a/include/block/thread-pool.h +++ b/include/block/thread-pool.h @@ -29,7 +29,7 @@ void thread_pool_free(ThreadPool *pool); BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool, ThreadPoolFunc *func, void *arg, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); int coroutine_fn thread_pool_submit_co(ThreadPool *pool, ThreadPoolFunc *func, void *arg); void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg); diff --git a/include/monitor/monitor.h b/include/monitor/monitor.h index 78a5fc8197..47606d04ad 100644 --- a/include/monitor/monitor.h +++ b/include/monitor/monitor.h @@ -27,10 +27,10 @@ int monitor_suspend(Monitor *mon); void monitor_resume(Monitor *mon); int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, - BlockDriverCompletionFunc *completion_cb, + BlockCompletionFunc *completion_cb, void *opaque); int monitor_read_block_device_key(Monitor *mon, const char *device, - BlockDriverCompletionFunc *completion_cb, + BlockCompletionFunc *completion_cb, void *opaque); int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp); diff --git a/include/sysemu/dma.h b/include/sysemu/dma.h index 1bc22234f1..bcff53a2c2 100644 --- a/include/sysemu/dma.h +++ b/include/sysemu/dma.h @@ -199,18 +199,18 @@ void qemu_sglist_destroy(QEMUSGList *qsg); typedef BlockAIOCB *DMAIOFunc(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *iov, int nb_sectors, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *dma_bdrv_io(BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, - DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, + DMAIOFunc *io_func, BlockCompletionFunc *cb, void *opaque, DMADirection dir); BlockAIOCB *dma_bdrv_read(BlockDriverState *bs, QEMUSGList *sg, uint64_t sector, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *dma_bdrv_write(BlockDriverState *bs, QEMUSGList *sg, uint64_t sector, - BlockDriverCompletionFunc *cb, void *opaque); + BlockCompletionFunc *cb, void *opaque); uint64_t dma_buf_read(uint8_t *ptr, int32_t len, QEMUSGList *sg); uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg); diff --git a/monitor.c b/monitor.c index 412e63fdd9..fba4ce2fbe 100644 --- a/monitor.c +++ b/monitor.c @@ -206,7 +206,7 @@ struct Monitor { ReadLineState *rs; MonitorControl *mc; CPUState *mon_cpu; - BlockDriverCompletionFunc *password_completion_cb; + BlockCompletionFunc *password_completion_cb; void *password_opaque; mon_cmd_t *cmd_table; QError *error; @@ -5374,7 +5374,7 @@ ReadLineState *monitor_get_rs(Monitor *mon) } int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, - BlockDriverCompletionFunc *completion_cb, + BlockCompletionFunc *completion_cb, void *opaque) { int err; @@ -5406,7 +5406,7 @@ int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, } int monitor_read_block_device_key(Monitor *mon, const char *device, - BlockDriverCompletionFunc *completion_cb, + BlockCompletionFunc *completion_cb, void *opaque) { BlockDriverState *bs; diff --git a/thread-pool.c b/thread-pool.c index 70ebb50e6d..e2cac8e4ff 100644 --- a/thread-pool.c +++ b/thread-pool.c @@ -235,7 +235,7 @@ static const AIOCBInfo thread_pool_aiocb_info = { BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool, ThreadPoolFunc *func, void *arg, - BlockDriverCompletionFunc *cb, void *opaque) + BlockCompletionFunc *cb, void *opaque) { ThreadPoolElement *req; From f75167313c8b7c7c46319b54210a66e7864b88c4 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:16 +0200 Subject: [PATCH 18/28] virtio-blk: Drop redundant VirtIOBlock member conf MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Commit 12c5674 turned it into a pointer to member blk.conf. Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- hw/block/virtio-blk.c | 26 +++++++++++++------------- include/hw/virtio/virtio-blk.h | 1 - 2 files changed, 13 insertions(+), 14 deletions(-) diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 1fa97709c8..162182620f 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -296,7 +296,7 @@ static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, if (sector & dev->sector_mask) { return false; } - if (size % dev->conf->logical_block_size) { + if (size % dev->blk.conf.logical_block_size) { return false; } bdrv_get_geometry(dev->bs, &total_sectors); @@ -513,19 +513,20 @@ static void virtio_blk_reset(VirtIODevice *vdev) static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) { VirtIOBlock *s = VIRTIO_BLK(vdev); + BlockConf *conf = &s->blk.conf; struct virtio_blk_config blkcfg; uint64_t capacity; - int blk_size = s->conf->logical_block_size; + int blk_size = conf->logical_block_size; bdrv_get_geometry(s->bs, &capacity); memset(&blkcfg, 0, sizeof(blkcfg)); virtio_stq_p(vdev, &blkcfg.capacity, capacity); virtio_stl_p(vdev, &blkcfg.seg_max, 128 - 2); - virtio_stw_p(vdev, &blkcfg.cylinders, s->conf->cyls); + virtio_stw_p(vdev, &blkcfg.cylinders, conf->cyls); virtio_stl_p(vdev, &blkcfg.blk_size, blk_size); - virtio_stw_p(vdev, &blkcfg.min_io_size, s->conf->min_io_size / blk_size); - virtio_stw_p(vdev, &blkcfg.opt_io_size, s->conf->opt_io_size / blk_size); - blkcfg.heads = s->conf->heads; + virtio_stw_p(vdev, &blkcfg.min_io_size, conf->min_io_size / blk_size); + virtio_stw_p(vdev, &blkcfg.opt_io_size, conf->opt_io_size / blk_size); + blkcfg.heads = conf->heads; /* * We must ensure that the block device capacity is a multiple of * the logical block size. If that is not the case, let's use @@ -537,13 +538,13 @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) * divided by 512 - instead it is the amount of blk_size blocks * per track (cylinder). */ - if (bdrv_getlength(s->bs) / s->conf->heads / s->conf->secs % blk_size) { - blkcfg.sectors = s->conf->secs & ~s->sector_mask; + if (bdrv_getlength(s->bs) / conf->heads / conf->secs % blk_size) { + blkcfg.sectors = conf->secs & ~s->sector_mask; } else { - blkcfg.sectors = s->conf->secs; + blkcfg.sectors = conf->secs; } blkcfg.size_max = 0; - blkcfg.physical_block_exp = get_physical_block_exp(s->conf); + blkcfg.physical_block_exp = get_physical_block_exp(conf); blkcfg.alignment_offset = 0; blkcfg.wce = bdrv_enable_write_cache(s->bs); memcpy(config, &blkcfg, sizeof(struct virtio_blk_config)); @@ -746,9 +747,8 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) sizeof(struct virtio_blk_config)); s->bs = blk->conf.bs; - s->conf = &blk->conf; s->rq = NULL; - s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1; + s->sector_mask = (s->blk.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1; s->vq = virtio_add_queue(vdev, 128, virtio_blk_handle_output); s->complete_request = virtio_blk_complete_request; @@ -765,7 +765,7 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) register_savevm(dev, "virtio-blk", virtio_blk_id++, 2, virtio_blk_save, virtio_blk_load, s); bdrv_set_dev_ops(s->bs, &virtio_block_ops, s); - bdrv_set_guest_block_size(s->bs, s->conf->logical_block_size); + bdrv_set_guest_block_size(s->bs, s->blk.conf.logical_block_size); bdrv_iostatus_enable(s->bs); } diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h index f3853f2b75..0f4323d73c 100644 --- a/include/hw/virtio/virtio-blk.h +++ b/include/hw/virtio/virtio-blk.h @@ -125,7 +125,6 @@ typedef struct VirtIOBlock { VirtQueue *vq; void *rq; QEMUBH *bh; - BlockConf *conf; VirtIOBlkConf blk; unsigned short sector_mask; bool original_wce; From 2a30307f709e6a395d23cf94837e9aae15f8e8fa Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:17 +0200 Subject: [PATCH 19/28] virtio-blk: Rename VirtIOBlkConf variables to conf This is consistent with how VirtIOFOOConf variables are named elsewhere, and makes blk available for BlockBackend variables. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- hw/block/dataplane/virtio-blk.c | 33 +++++++++++----------- hw/block/dataplane/virtio-blk.h | 2 +- hw/block/virtio-blk.c | 50 ++++++++++++++++----------------- include/hw/virtio/virtio-blk.h | 2 +- 4 files changed, 44 insertions(+), 43 deletions(-) diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c index 5458f9d25f..bd250df886 100644 --- a/hw/block/dataplane/virtio-blk.c +++ b/hw/block/dataplane/virtio-blk.c @@ -30,7 +30,7 @@ struct VirtIOBlockDataPlane { bool stopping; bool disabled; - VirtIOBlkConf *blk; + VirtIOBlkConf *conf; VirtIODevice *vdev; Vring vring; /* virtqueue vring */ @@ -94,7 +94,7 @@ static void handle_notify(EventNotifier *e) VirtIOBlock *vblk = VIRTIO_BLK(s->vdev); event_notifier_test_and_clear(&s->host_notifier); - bdrv_io_plug(s->blk->conf.bs); + bdrv_io_plug(s->conf->conf.bs); for (;;) { MultiReqBuffer mrb = { .num_writes = 0, @@ -120,7 +120,7 @@ static void handle_notify(EventNotifier *e) virtio_blk_handle_request(req, &mrb); } - virtio_submit_multiwrite(s->blk->conf.bs, &mrb); + virtio_submit_multiwrite(s->conf->conf.bs, &mrb); if (likely(ret == -EAGAIN)) { /* vring emptied */ /* Re-enable guest->host notifies and stop processing the vring. @@ -133,11 +133,11 @@ static void handle_notify(EventNotifier *e) break; } } - bdrv_io_unplug(s->blk->conf.bs); + bdrv_io_unplug(s->conf->conf.bs); } /* Context: QEMU global mutex held */ -void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, +void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, VirtIOBlockDataPlane **dataplane, Error **errp) { @@ -148,7 +148,7 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, *dataplane = NULL; - if (!blk->data_plane && !blk->iothread) { + if (!conf->data_plane && !conf->iothread) { return; } @@ -163,7 +163,8 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, /* If dataplane is (re-)enabled while the guest is running there could be * block jobs that can conflict. */ - if (bdrv_op_is_blocked(blk->conf.bs, BLOCK_OP_TYPE_DATAPLANE, &local_err)) { + if (bdrv_op_is_blocked(conf->conf.bs, BLOCK_OP_TYPE_DATAPLANE, + &local_err)) { error_setg(errp, "cannot start dataplane thread: %s", error_get_pretty(local_err)); error_free(local_err); @@ -172,10 +173,10 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, s = g_new0(VirtIOBlockDataPlane, 1); s->vdev = vdev; - s->blk = blk; + s->conf = conf; - if (blk->iothread) { - s->iothread = blk->iothread; + if (conf->iothread) { + s->iothread = conf->iothread; object_ref(OBJECT(s->iothread)); } else { /* Create per-device IOThread if none specified. This is for @@ -192,9 +193,9 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, s->bh = aio_bh_new(s->ctx, notify_guest_bh, s); error_setg(&s->blocker, "block device is in use by data plane"); - bdrv_op_block_all(blk->conf.bs, s->blocker); - bdrv_op_unblock(blk->conf.bs, BLOCK_OP_TYPE_RESIZE, s->blocker); - bdrv_op_unblock(blk->conf.bs, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker); + bdrv_op_block_all(conf->conf.bs, s->blocker); + bdrv_op_unblock(conf->conf.bs, BLOCK_OP_TYPE_RESIZE, s->blocker); + bdrv_op_unblock(conf->conf.bs, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker); *dataplane = s; } @@ -207,7 +208,7 @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s) } virtio_blk_data_plane_stop(s); - bdrv_op_unblock_all(s->blk->conf.bs, s->blocker); + bdrv_op_unblock_all(s->conf->conf.bs, s->blocker); error_free(s->blocker); object_unref(OBJECT(s->iothread)); qemu_bh_delete(s->bh); @@ -262,7 +263,7 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s) s->started = true; trace_virtio_blk_data_plane_start(s); - bdrv_set_aio_context(s->blk->conf.bs, s->ctx); + bdrv_set_aio_context(s->conf->conf.bs, s->ctx); /* Kick right away to begin processing requests already in vring */ event_notifier_set(virtio_queue_get_host_notifier(vq)); @@ -308,7 +309,7 @@ void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s) aio_set_event_notifier(s->ctx, &s->host_notifier, NULL); /* Drain and switch bs back to the QEMU main loop */ - bdrv_set_aio_context(s->blk->conf.bs, qemu_get_aio_context()); + bdrv_set_aio_context(s->conf->conf.bs, qemu_get_aio_context()); aio_context_release(s->ctx); diff --git a/hw/block/dataplane/virtio-blk.h b/hw/block/dataplane/virtio-blk.h index 1750c9905b..c88d40e72c 100644 --- a/hw/block/dataplane/virtio-blk.h +++ b/hw/block/dataplane/virtio-blk.h @@ -19,7 +19,7 @@ typedef struct VirtIOBlockDataPlane VirtIOBlockDataPlane; -void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk, +void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, VirtIOBlockDataPlane **dataplane, Error **errp); void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s); diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 162182620f..4dc794c2fe 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -155,7 +155,7 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk, */ scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base; - if (!blk->blk.scsi) { + if (!blk->conf.scsi) { status = VIRTIO_BLK_S_UNSUPP; goto fail; } @@ -296,7 +296,7 @@ static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, if (sector & dev->sector_mask) { return false; } - if (size % dev->blk.conf.logical_block_size) { + if (size % dev->conf.conf.logical_block_size) { return false; } bdrv_get_geometry(dev->bs, &total_sectors); @@ -405,7 +405,7 @@ void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb) * NB: per existing s/n string convention the string is * terminated by '\0' only when shorter than buffer. */ - const char *serial = s->blk.serial ? s->blk.serial : ""; + const char *serial = s->conf.serial ? s->conf.serial : ""; size_t size = MIN(strlen(serial) + 1, MIN(iov_size(in_iov, in_num), VIRTIO_BLK_ID_BYTES)); @@ -486,7 +486,7 @@ static void virtio_blk_dma_restart_cb(void *opaque, int running, } if (!s->bh) { - s->bh = aio_bh_new(bdrv_get_aio_context(s->blk.conf.bs), + s->bh = aio_bh_new(bdrv_get_aio_context(s->conf.conf.bs), virtio_blk_dma_restart_bh, s); qemu_bh_schedule(s->bh); } @@ -513,7 +513,7 @@ static void virtio_blk_reset(VirtIODevice *vdev) static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) { VirtIOBlock *s = VIRTIO_BLK(vdev); - BlockConf *conf = &s->blk.conf; + BlockConf *conf = &s->conf.conf; struct virtio_blk_config blkcfg; uint64_t capacity; int blk_size = conf->logical_block_size; @@ -572,7 +572,7 @@ static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features) features |= (1 << VIRTIO_BLK_F_BLK_SIZE); features |= (1 << VIRTIO_BLK_F_SCSI); - if (s->blk.config_wce) { + if (s->conf.config_wce) { features |= (1 << VIRTIO_BLK_F_CONFIG_WCE); } if (bdrv_enable_write_cache(s->bs)) @@ -709,7 +709,7 @@ static void virtio_blk_migration_state_changed(Notifier *notifier, void *data) return; } bdrv_drain_all(); /* complete in-flight non-dataplane requests */ - virtio_blk_data_plane_create(VIRTIO_DEVICE(s), &s->blk, + virtio_blk_data_plane_create(VIRTIO_DEVICE(s), &s->conf, &s->dataplane, &err); if (err != NULL) { error_report("%s", error_get_pretty(err)); @@ -722,22 +722,22 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) { VirtIODevice *vdev = VIRTIO_DEVICE(dev); VirtIOBlock *s = VIRTIO_BLK(dev); - VirtIOBlkConf *blk = &(s->blk); + VirtIOBlkConf *conf = &s->conf; Error *err = NULL; static int virtio_blk_id; - if (!blk->conf.bs) { + if (!conf->conf.bs) { error_setg(errp, "drive property not set"); return; } - if (!bdrv_is_inserted(blk->conf.bs)) { + if (!bdrv_is_inserted(conf->conf.bs)) { error_setg(errp, "Device needs media, but drive is empty"); return; } - blkconf_serial(&blk->conf, &blk->serial); - s->original_wce = bdrv_enable_write_cache(blk->conf.bs); - blkconf_geometry(&blk->conf, NULL, 65535, 255, 255, &err); + blkconf_serial(&conf->conf, &conf->serial); + s->original_wce = bdrv_enable_write_cache(conf->conf.bs); + blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, &err); if (err) { error_propagate(errp, err); return; @@ -746,13 +746,13 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, sizeof(struct virtio_blk_config)); - s->bs = blk->conf.bs; + s->bs = conf->conf.bs; s->rq = NULL; - s->sector_mask = (s->blk.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1; + s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1; s->vq = virtio_add_queue(vdev, 128, virtio_blk_handle_output); s->complete_request = virtio_blk_complete_request; - virtio_blk_data_plane_create(vdev, blk, &s->dataplane, &err); + virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err); if (err != NULL) { error_propagate(errp, err); virtio_cleanup(vdev); @@ -765,7 +765,7 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) register_savevm(dev, "virtio-blk", virtio_blk_id++, 2, virtio_blk_save, virtio_blk_load, s); bdrv_set_dev_ops(s->bs, &virtio_block_ops, s); - bdrv_set_guest_block_size(s->bs, s->blk.conf.logical_block_size); + bdrv_set_guest_block_size(s->bs, s->conf.conf.logical_block_size); bdrv_iostatus_enable(s->bs); } @@ -789,23 +789,23 @@ static void virtio_blk_instance_init(Object *obj) VirtIOBlock *s = VIRTIO_BLK(obj); object_property_add_link(obj, "iothread", TYPE_IOTHREAD, - (Object **)&s->blk.iothread, + (Object **)&s->conf.iothread, qdev_prop_allow_set_link_before_realize, OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL); - device_add_bootindex_property(obj, &s->blk.conf.bootindex, + device_add_bootindex_property(obj, &s->conf.conf.bootindex, "bootindex", "/disk@0,0", DEVICE(obj), NULL); } static Property virtio_blk_properties[] = { - DEFINE_BLOCK_PROPERTIES(VirtIOBlock, blk.conf), - DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, blk.conf), - DEFINE_PROP_STRING("serial", VirtIOBlock, blk.serial), - DEFINE_PROP_BIT("config-wce", VirtIOBlock, blk.config_wce, 0, true), + DEFINE_BLOCK_PROPERTIES(VirtIOBlock, conf.conf), + DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf), + DEFINE_PROP_STRING("serial", VirtIOBlock, conf.serial), + DEFINE_PROP_BIT("config-wce", VirtIOBlock, conf.config_wce, 0, true), #ifdef __linux__ - DEFINE_PROP_BIT("scsi", VirtIOBlock, blk.scsi, 0, true), + DEFINE_PROP_BIT("scsi", VirtIOBlock, conf.scsi, 0, true), #endif - DEFINE_PROP_BIT("x-data-plane", VirtIOBlock, blk.data_plane, 0, false), + DEFINE_PROP_BIT("x-data-plane", VirtIOBlock, conf.data_plane, 0, false), DEFINE_PROP_END_OF_LIST(), }; diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h index 0f4323d73c..0f7ca3ceef 100644 --- a/include/hw/virtio/virtio-blk.h +++ b/include/hw/virtio/virtio-blk.h @@ -125,7 +125,7 @@ typedef struct VirtIOBlock { VirtQueue *vq; void *rq; QEMUBH *bh; - VirtIOBlkConf blk; + VirtIOBlkConf conf; unsigned short sector_mask; bool original_wce; VMChangeStateEntry *change; From 4be746345f13e99e468c60acbd3a355e8183e3ce Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:18 +0200 Subject: [PATCH 20/28] hw: Convert from BlockDriverState to BlockBackend, mostly Device models should access their block backends only through the block-backend.h API. Convert them, and drop direct includes of inappropriate headers. Just four uses of BlockDriverState are left: * The Xen paravirtual block device backend (xen_disk.c) opens images itself when set up via xenbus, bypassing blockdev.c. I figure it should go through qmp_blockdev_add() instead. * Device model "usb-storage" prompts for keys. No other device model does, and this one probably shouldn't do it, either. * ide_issue_trim_cb() uses bdrv_aio_discard() instead of blk_aio_discard() because it fishes its backend out of a BlockAIOCB, which has only the BlockDriverState. * PC87312State has an unused BlockDriverState[] member. The next two commits take care of the latter two. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block/block-backend.c | 262 +++++++++++++++++++++++ blockdev.c | 12 +- dma-helpers.c | 61 +++--- hw/arm/collie.c | 5 +- hw/arm/gumstix.c | 5 +- hw/arm/highbank.c | 2 +- hw/arm/mainstone.c | 2 +- hw/arm/musicpal.c | 10 +- hw/arm/nseries.c | 3 +- hw/arm/omap1.c | 2 +- hw/arm/omap2.c | 2 +- hw/arm/omap_sx1.c | 5 +- hw/arm/pxa2xx.c | 4 +- hw/arm/realview.c | 2 +- hw/arm/spitz.c | 4 +- hw/arm/tosa.c | 3 +- hw/arm/versatilepb.c | 3 +- hw/arm/vexpress.c | 3 +- hw/arm/virt.c | 2 +- hw/arm/xilinx_zynq.c | 3 +- hw/arm/z2.c | 3 +- hw/block/block.c | 7 +- hw/block/dataplane/virtio-blk.c | 24 +-- hw/block/fdc.c | 78 ++++--- hw/block/hd-geometry.c | 24 +-- hw/block/m25p80.c | 28 +-- hw/block/nand.c | 50 ++--- hw/block/nvme.c | 19 +- hw/block/onenand.c | 67 +++--- hw/block/pflash_cfi01.c | 24 +-- hw/block/pflash_cfi02.c | 24 +-- hw/block/virtio-blk.c | 95 ++++---- hw/block/xen_disk.c | 69 +++--- hw/core/qdev-properties-system.c | 26 +-- hw/core/qdev-properties.c | 2 +- hw/cris/axis_dev88.c | 3 +- hw/display/tc6393xb.c | 2 +- hw/i386/pc.c | 2 +- hw/i386/pc_piix.c | 2 +- hw/i386/pc_sysfw.c | 9 +- hw/i386/xen/xen_platform.c | 5 +- hw/ide/ahci.c | 31 +-- hw/ide/atapi.c | 33 +-- hw/ide/cmd646.c | 2 +- hw/ide/core.c | 182 ++++++++-------- hw/ide/ich.c | 2 +- hw/ide/internal.h | 6 +- hw/ide/isa.c | 2 +- hw/ide/macio.c | 48 ++--- hw/ide/microdrive.c | 4 +- hw/ide/mmio.c | 2 +- hw/ide/pci.c | 4 +- hw/ide/piix.c | 8 +- hw/ide/qdev.c | 11 +- hw/ide/via.c | 2 +- hw/isa/pc87312.c | 4 +- hw/lm32/lm32_boards.c | 5 +- hw/lm32/milkymist.c | 3 +- hw/microblaze/petalogix_ml605_mmu.c | 3 +- hw/microblaze/petalogix_s3adsp1800_mmu.c | 3 +- hw/mips/mips_fulong2e.c | 2 +- hw/mips/mips_jazz.c | 2 +- hw/mips/mips_malta.c | 6 +- hw/mips/mips_r4k.c | 3 +- hw/nvram/spapr_nvram.c | 17 +- hw/pci/pci-hotplug-old.c | 5 +- hw/ppc/mac_newworld.c | 2 +- hw/ppc/mac_oldworld.c | 2 +- hw/ppc/ppc405_boards.c | 26 +-- hw/ppc/prep.c | 2 +- hw/ppc/spapr.c | 4 +- hw/ppc/virtex_ml507.c | 3 +- hw/s390x/s390-virtio-bus.c | 2 +- hw/s390x/s390-virtio.c | 2 +- hw/s390x/virtio-ccw.c | 2 +- hw/scsi/megasas.c | 15 +- hw/scsi/scsi-bus.c | 12 +- hw/scsi/scsi-disk.c | 182 ++++++++-------- hw/scsi/scsi-generic.c | 35 +-- hw/scsi/virtio-scsi-dataplane.c | 3 +- hw/scsi/virtio-scsi.c | 15 +- hw/sd/milkymist-memcard.c | 8 +- hw/sd/omap_mmc.c | 8 +- hw/sd/pl181.c | 2 +- hw/sd/pxa2xx_mmci.c | 4 +- hw/sd/sd.c | 60 +++--- hw/sd/sdhci.c | 2 +- hw/sd/ssi-sd.c | 2 +- hw/sh4/r2d.c | 3 +- hw/sparc/sun4m.c | 2 +- hw/sparc64/sun4u.c | 2 +- hw/tpm/tpm_tis.c | 2 +- hw/tricore/tricore_testboard.c | 2 +- hw/usb/dev-storage.c | 17 +- hw/virtio/virtio-pci.c | 2 +- hw/xen/xen_devconfig.c | 1 + hw/xenpv/xen_machine_pv.c | 2 +- hw/xtensa/xtfpga.c | 3 +- include/hw/arm/omap.h | 4 +- include/hw/arm/pxa.h | 2 +- include/hw/block/block.h | 6 +- include/hw/block/flash.h | 6 +- include/hw/qdev-properties.h | 8 +- include/hw/scsi/scsi.h | 4 +- include/hw/sd.h | 2 +- include/hw/virtio/virtio-blk.h | 7 +- include/sysemu/block-backend.h | 76 +++++++ include/sysemu/blockdev.h | 5 +- include/sysemu/dma.h | 20 +- trace-events | 8 +- 110 files changed, 1127 insertions(+), 798 deletions(-) diff --git a/block/block-backend.c b/block/block-backend.c index fb91680f03..58ae634d14 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -237,3 +237,265 @@ void blk_hide_on_behalf_of_do_drive_del(BlockBackend *blk) bdrv_make_anon(blk->bs); } } + +void blk_iostatus_enable(BlockBackend *blk) +{ + bdrv_iostatus_enable(blk->bs); +} + +int blk_attach_dev(BlockBackend *blk, void *dev) +{ + return bdrv_attach_dev(blk->bs, dev); +} + +void blk_attach_dev_nofail(BlockBackend *blk, void *dev) +{ + bdrv_attach_dev_nofail(blk->bs, dev); +} + +void blk_detach_dev(BlockBackend *blk, void *dev) +{ + bdrv_detach_dev(blk->bs, dev); +} + +void *blk_get_attached_dev(BlockBackend *blk) +{ + return bdrv_get_attached_dev(blk->bs); +} + +void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, void *opaque) +{ + bdrv_set_dev_ops(blk->bs, ops, opaque); +} + +int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf, + int nb_sectors) +{ + return bdrv_read(blk->bs, sector_num, buf, nb_sectors); +} + +int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf, + int nb_sectors) +{ + return bdrv_read_unthrottled(blk->bs, sector_num, buf, nb_sectors); +} + +int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf, + int nb_sectors) +{ + return bdrv_write(blk->bs, sector_num, buf, nb_sectors); +} + +BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num, + int nb_sectors, BdrvRequestFlags flags, + BlockCompletionFunc *cb, void *opaque) +{ + return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags, + cb, opaque); +} + +int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count) +{ + return bdrv_pread(blk->bs, offset, buf, count); +} + +int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count) +{ + return bdrv_pwrite(blk->bs, offset, buf, count); +} + +int64_t blk_getlength(BlockBackend *blk) +{ + return bdrv_getlength(blk->bs); +} + +void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr) +{ + bdrv_get_geometry(blk->bs, nb_sectors_ptr); +} + +BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockCompletionFunc *cb, void *opaque) +{ + return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque); +} + +BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockCompletionFunc *cb, void *opaque) +{ + return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque); +} + +BlockAIOCB *blk_aio_flush(BlockBackend *blk, + BlockCompletionFunc *cb, void *opaque) +{ + return bdrv_aio_flush(blk->bs, cb, opaque); +} + +BlockAIOCB *blk_aio_discard(BlockBackend *blk, + int64_t sector_num, int nb_sectors, + BlockCompletionFunc *cb, void *opaque) +{ + return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque); +} + +void blk_aio_cancel(BlockAIOCB *acb) +{ + bdrv_aio_cancel(acb); +} + +void blk_aio_cancel_async(BlockAIOCB *acb) +{ + bdrv_aio_cancel_async(acb); +} + +int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs) +{ + return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs); +} + +int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf) +{ + return bdrv_ioctl(blk->bs, req, buf); +} + +BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf, + BlockCompletionFunc *cb, void *opaque) +{ + return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque); +} + +int blk_flush(BlockBackend *blk) +{ + return bdrv_flush(blk->bs); +} + +int blk_flush_all(void) +{ + return bdrv_flush_all(); +} + +void blk_drain_all(void) +{ + bdrv_drain_all(); +} + +BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read) +{ + return bdrv_get_on_error(blk->bs, is_read); +} + +BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read, + int error) +{ + return bdrv_get_error_action(blk->bs, is_read, error); +} + +void blk_error_action(BlockBackend *blk, BlockErrorAction action, + bool is_read, int error) +{ + bdrv_error_action(blk->bs, action, is_read, error); +} + +int blk_is_read_only(BlockBackend *blk) +{ + return bdrv_is_read_only(blk->bs); +} + +int blk_is_sg(BlockBackend *blk) +{ + return bdrv_is_sg(blk->bs); +} + +int blk_enable_write_cache(BlockBackend *blk) +{ + return bdrv_enable_write_cache(blk->bs); +} + +void blk_set_enable_write_cache(BlockBackend *blk, bool wce) +{ + bdrv_set_enable_write_cache(blk->bs, wce); +} + +int blk_is_inserted(BlockBackend *blk) +{ + return bdrv_is_inserted(blk->bs); +} + +void blk_lock_medium(BlockBackend *blk, bool locked) +{ + bdrv_lock_medium(blk->bs, locked); +} + +void blk_eject(BlockBackend *blk, bool eject_flag) +{ + bdrv_eject(blk->bs, eject_flag); +} + +int blk_get_flags(BlockBackend *blk) +{ + return bdrv_get_flags(blk->bs); +} + +void blk_set_guest_block_size(BlockBackend *blk, int align) +{ + bdrv_set_guest_block_size(blk->bs, align); +} + +void *blk_blockalign(BlockBackend *blk, size_t size) +{ + return qemu_blockalign(blk ? blk->bs : NULL, size); +} + +bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp) +{ + return bdrv_op_is_blocked(blk->bs, op, errp); +} + +void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason) +{ + bdrv_op_unblock(blk->bs, op, reason); +} + +void blk_op_block_all(BlockBackend *blk, Error *reason) +{ + bdrv_op_block_all(blk->bs, reason); +} + +void blk_op_unblock_all(BlockBackend *blk, Error *reason) +{ + bdrv_op_unblock_all(blk->bs, reason); +} + +AioContext *blk_get_aio_context(BlockBackend *blk) +{ + return bdrv_get_aio_context(blk->bs); +} + +void blk_set_aio_context(BlockBackend *blk, AioContext *new_context) +{ + bdrv_set_aio_context(blk->bs, new_context); +} + +void blk_io_plug(BlockBackend *blk) +{ + bdrv_io_plug(blk->bs); +} + +void blk_io_unplug(BlockBackend *blk) +{ + bdrv_io_unplug(blk->bs); +} + +BlockAcctStats *blk_get_stats(BlockBackend *blk) +{ + return bdrv_get_stats(blk->bs); +} + +void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk, + BlockCompletionFunc *cb, void *opaque) +{ + return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque); +} diff --git a/blockdev.c b/blockdev.c index aa37dbc541..c126809d0e 100644 --- a/blockdev.c +++ b/blockdev.c @@ -111,10 +111,10 @@ void override_max_devs(BlockInterfaceType type, int max_devs) * automatic deletion, and generic qdev code calls blockdev_auto_del() * when deletion is actually safe. */ -void blockdev_mark_auto_del(BlockDriverState *bs) +void blockdev_mark_auto_del(BlockBackend *blk) { - BlockBackend *blk = bs->blk; DriveInfo *dinfo = blk_legacy_dinfo(blk); + BlockDriverState *bs = blk_bs(blk); if (dinfo && !dinfo->enable_auto_del) { return; @@ -128,9 +128,8 @@ void blockdev_mark_auto_del(BlockDriverState *bs) } } -void blockdev_auto_del(BlockDriverState *bs) +void blockdev_auto_del(BlockBackend *blk) { - BlockBackend *blk = bs->blk; DriveInfo *dinfo = blk_legacy_dinfo(blk); if (dinfo && dinfo->auto_del) { @@ -266,11 +265,6 @@ DriveInfo *drive_get_next(BlockInterfaceType type) return drive_get(type, 0, next_block_unit[type]++); } -DriveInfo *drive_get_by_blockdev(BlockDriverState *bs) -{ - return bs->blk ? blk_legacy_dinfo(bs->blk) : NULL; -} - static void bdrv_format_print(void *opaque, const char *name) { error_printf(" %s", name); diff --git a/dma-helpers.c b/dma-helpers.c index c347d4bafe..6918572e18 100644 --- a/dma-helpers.c +++ b/dma-helpers.c @@ -7,6 +7,7 @@ * (GNU GPL), version 2 or later. */ +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include "trace.h" #include "qemu/range.h" @@ -68,7 +69,7 @@ void qemu_sglist_destroy(QEMUSGList *qsg) typedef struct { BlockAIOCB common; - BlockDriverState *bs; + BlockBackend *blk; BlockAIOCB *acb; QEMUSGList *sg; uint64_t sector_num; @@ -80,7 +81,7 @@ typedef struct { DMAIOFunc *io_func; } DMAAIOCB; -static void dma_bdrv_cb(void *opaque, int ret); +static void dma_blk_cb(void *opaque, int ret); static void reschedule_dma(void *opaque) { @@ -88,7 +89,7 @@ static void reschedule_dma(void *opaque) qemu_bh_delete(dbs->bh); dbs->bh = NULL; - dma_bdrv_cb(dbs, 0); + dma_blk_cb(dbs, 0); } static void continue_after_map_failure(void *opaque) @@ -99,7 +100,7 @@ static void continue_after_map_failure(void *opaque) qemu_bh_schedule(dbs->bh); } -static void dma_bdrv_unmap(DMAAIOCB *dbs) +static void dma_blk_unmap(DMAAIOCB *dbs) { int i; @@ -115,7 +116,7 @@ static void dma_complete(DMAAIOCB *dbs, int ret) { trace_dma_complete(dbs, ret, dbs->common.cb); - dma_bdrv_unmap(dbs); + dma_blk_unmap(dbs); if (dbs->common.cb) { dbs->common.cb(dbs->common.opaque, ret); } @@ -127,13 +128,13 @@ static void dma_complete(DMAAIOCB *dbs, int ret) qemu_aio_unref(dbs); } -static void dma_bdrv_cb(void *opaque, int ret) +static void dma_blk_cb(void *opaque, int ret) { DMAAIOCB *dbs = (DMAAIOCB *)opaque; dma_addr_t cur_addr, cur_len; void *mem; - trace_dma_bdrv_cb(dbs, ret); + trace_dma_blk_cb(dbs, ret); dbs->acb = NULL; dbs->sector_num += dbs->iov.size / 512; @@ -142,7 +143,7 @@ static void dma_bdrv_cb(void *opaque, int ret) dma_complete(dbs, ret); return; } - dma_bdrv_unmap(dbs); + dma_blk_unmap(dbs); while (dbs->sg_cur_index < dbs->sg->nsg) { cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte; @@ -168,8 +169,8 @@ static void dma_bdrv_cb(void *opaque, int ret) qemu_iovec_discard_back(&dbs->iov, dbs->iov.size & ~BDRV_SECTOR_MASK); } - dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov, - dbs->iov.size / 512, dma_bdrv_cb, dbs); + dbs->acb = dbs->io_func(dbs->blk, dbs->sector_num, &dbs->iov, + dbs->iov.size / 512, dma_blk_cb, dbs); assert(dbs->acb); } @@ -180,7 +181,7 @@ static void dma_aio_cancel(BlockAIOCB *acb) trace_dma_aio_cancel(dbs); if (dbs->acb) { - bdrv_aio_cancel_async(dbs->acb); + blk_aio_cancel_async(dbs->acb); } } @@ -190,17 +191,17 @@ static const AIOCBInfo dma_aiocb_info = { .cancel_async = dma_aio_cancel, }; -BlockAIOCB *dma_bdrv_io( - BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, +BlockAIOCB *dma_blk_io( + BlockBackend *blk, QEMUSGList *sg, uint64_t sector_num, DMAIOFunc *io_func, BlockCompletionFunc *cb, void *opaque, DMADirection dir) { - DMAAIOCB *dbs = qemu_aio_get(&dma_aiocb_info, bs, cb, opaque); + DMAAIOCB *dbs = blk_aio_get(&dma_aiocb_info, blk, cb, opaque); - trace_dma_bdrv_io(dbs, bs, sector_num, (dir == DMA_DIRECTION_TO_DEVICE)); + trace_dma_blk_io(dbs, blk, sector_num, (dir == DMA_DIRECTION_TO_DEVICE)); dbs->acb = NULL; - dbs->bs = bs; + dbs->blk = blk; dbs->sg = sg; dbs->sector_num = sector_num; dbs->sg_cur_index = 0; @@ -209,25 +210,25 @@ BlockAIOCB *dma_bdrv_io( dbs->io_func = io_func; dbs->bh = NULL; qemu_iovec_init(&dbs->iov, sg->nsg); - dma_bdrv_cb(dbs, 0); + dma_blk_cb(dbs, 0); return &dbs->common; } -BlockAIOCB *dma_bdrv_read(BlockDriverState *bs, +BlockAIOCB *dma_blk_read(BlockBackend *blk, + QEMUSGList *sg, uint64_t sector, + void (*cb)(void *opaque, int ret), void *opaque) +{ + return dma_blk_io(blk, sg, sector, blk_aio_readv, cb, opaque, + DMA_DIRECTION_FROM_DEVICE); +} + +BlockAIOCB *dma_blk_write(BlockBackend *blk, QEMUSGList *sg, uint64_t sector, void (*cb)(void *opaque, int ret), void *opaque) { - return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, - DMA_DIRECTION_FROM_DEVICE); -} - -BlockAIOCB *dma_bdrv_write(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector, - void (*cb)(void *opaque, int ret), void *opaque) -{ - return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, - DMA_DIRECTION_TO_DEVICE); + return dma_blk_io(blk, sg, sector, blk_aio_writev, cb, opaque, + DMA_DIRECTION_TO_DEVICE); } @@ -262,8 +263,8 @@ uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg) return dma_buf_rw(ptr, len, sg, DMA_DIRECTION_TO_DEVICE); } -void dma_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, +void dma_acct_start(BlockBackend *blk, BlockAcctCookie *cookie, QEMUSGList *sg, enum BlockAcctType type) { - block_acct_start(bdrv_get_stats(bs), cookie, sg->size, type); + block_acct_start(blk_get_stats(blk), cookie, sg->size, type); } diff --git a/hw/arm/collie.c b/hw/arm/collie.c index 024729042e..6c9b82fc54 100644 --- a/hw/arm/collie.c +++ b/hw/arm/collie.c @@ -16,7 +16,6 @@ #include "hw/arm/arm.h" #include "hw/block/flash.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" static struct arm_boot_info collie_binfo = { @@ -42,12 +41,12 @@ static void collie_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi01_register(SA_CS0, NULL, "collie.fl1", 0x02000000, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, (64 * 1024), 512, 4, 0x00, 0x00, 0x00, 0x00, 0); dinfo = drive_get(IF_PFLASH, 0, 1); pflash_cfi01_register(SA_CS1, NULL, "collie.fl2", 0x02000000, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, (64 * 1024), 512, 4, 0x00, 0x00, 0x00, 0x00, 0); sysbus_create_simple("scoop", 0x40800000, NULL); diff --git a/hw/arm/gumstix.c b/hw/arm/gumstix.c index 49f9339e6a..8103278b15 100644 --- a/hw/arm/gumstix.c +++ b/hw/arm/gumstix.c @@ -41,7 +41,6 @@ #include "hw/devices.h" #include "hw/boards.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" @@ -72,7 +71,7 @@ static void connex_init(MachineState *machine) be = 0; #endif if (!pflash_cfi01_register(0x00000000, NULL, "connext.rom", connex_rom, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, sector_len, connex_rom / sector_len, 2, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); @@ -110,7 +109,7 @@ static void verdex_init(MachineState *machine) be = 0; #endif if (!pflash_cfi01_register(0x00000000, NULL, "verdex.rom", verdex_rom, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, sector_len, verdex_rom / sector_len, 2, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); diff --git a/hw/arm/highbank.c b/hw/arm/highbank.c index fa61e5fa13..30f744a1bd 100644 --- a/hw/arm/highbank.c +++ b/hw/arm/highbank.c @@ -24,7 +24,7 @@ #include "net/net.h" #include "sysemu/sysemu.h" #include "hw/boards.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" #include "qemu/error-report.h" diff --git a/hw/arm/mainstone.c b/hw/arm/mainstone.c index a4a25b5c10..0da02a67ec 100644 --- a/hw/arm/mainstone.c +++ b/hw/arm/mainstone.c @@ -149,7 +149,7 @@ static void mainstone_common_init(MemoryRegion *address_space_mem, if (!pflash_cfi01_register(mainstone_flash_base[i], NULL, i ? "mainstone.flash1" : "mainstone.flash0", MAINSTONE_FLASH, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), sector_len, MAINSTONE_FLASH / sector_len, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); diff --git a/hw/arm/musicpal.c b/hw/arm/musicpal.c index 77ad4eb1fd..3712de6cba 100644 --- a/hw/arm/musicpal.c +++ b/hw/arm/musicpal.c @@ -18,12 +18,10 @@ #include "hw/char/serial.h" #include "qemu/timer.h" #include "hw/ptimer.h" -#include "block/block.h" #include "hw/block/flash.h" #include "ui/console.h" #include "hw/i2c/i2c.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "ui/pixel_ops.h" @@ -1633,9 +1631,9 @@ static void musicpal_init(MachineState *machine) /* Register flash */ dinfo = drive_get(IF_PFLASH, 0, 0); if (dinfo) { - BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + BlockBackend *blk = blk_by_legacy_dinfo(dinfo); - flash_size = bdrv_getlength(bs); + flash_size = blk_getlength(blk); if (flash_size != 8*1024*1024 && flash_size != 16*1024*1024 && flash_size != 32*1024*1024) { fprintf(stderr, "Invalid flash image size\n"); @@ -1650,14 +1648,14 @@ static void musicpal_init(MachineState *machine) #ifdef TARGET_WORDS_BIGENDIAN pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL, "musicpal.flash", flash_size, - bs, 0x10000, (flash_size + 0xffff) >> 16, + blk, 0x10000, (flash_size + 0xffff) >> 16, MP_FLASH_SIZE_MAX / flash_size, 2, 0x00BF, 0x236D, 0x0000, 0x0000, 0x5555, 0x2AAA, 1); #else pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL, "musicpal.flash", flash_size, - bs, 0x10000, (flash_size + 0xffff) >> 16, + blk, 0x10000, (flash_size + 0xffff) >> 16, MP_FLASH_SIZE_MAX / flash_size, 2, 0x00BF, 0x236D, 0x0000, 0x0000, 0x5555, 0x2AAA, 0); diff --git a/hw/arm/nseries.c b/hw/arm/nseries.c index 253607826c..c7ebaa6abc 100644 --- a/hw/arm/nseries.c +++ b/hw/arm/nseries.c @@ -32,7 +32,6 @@ #include "hw/bt.h" #include "hw/loader.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "hw/sysbus.h" #include "exec/address-spaces.h" @@ -175,7 +174,7 @@ static void n8x0_nand_setup(struct n800_s *s) dinfo = drive_get(IF_MTD, 0, 0); if (dinfo) { qdev_prop_set_drive_nofail(s->nand, "drive", - blk_bs(blk_by_legacy_dinfo(dinfo))); + blk_by_legacy_dinfo(dinfo)); } qdev_init_nofail(s->nand); sysbus_connect_irq(SYS_BUS_DEVICE(s->nand), 0, diff --git a/hw/arm/omap1.c b/hw/arm/omap1.c index 74dac49fbe..abb183c2d5 100644 --- a/hw/arm/omap1.c +++ b/hw/arm/omap1.c @@ -3980,7 +3980,7 @@ struct omap_mpu_state_s *omap310_mpu_init(MemoryRegion *system_memory, exit(1); } s->mmc = omap_mmc_init(0xfffb7800, system_memory, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), qdev_get_gpio_in(s->ih[1], OMAP_INT_OQN), &s->drq[OMAP_DMA_MMC_TX], omap_findclk(s, "mmc_ck")); diff --git a/hw/arm/omap2.c b/hw/arm/omap2.c index 0b6a95e75a..b083ebebc8 100644 --- a/hw/arm/omap2.c +++ b/hw/arm/omap2.c @@ -2463,7 +2463,7 @@ struct omap_mpu_state_s *omap2420_mpu_init(MemoryRegion *sysmem, exit(1); } s->mmc = omap2_mmc_init(omap_l4tao(s->l4, 9), - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), qdev_get_gpio_in(s->ih[0], OMAP_INT_24XX_MMC_IRQ), &s->drq[OMAP24XX_DMA_MMC1_TX], omap_findclk(s, "mmc_fclk"), omap_findclk(s, "mmc_iclk")); diff --git a/hw/arm/omap_sx1.c b/hw/arm/omap_sx1.c index 0a4e7405a5..671e02c4ed 100644 --- a/hw/arm/omap_sx1.c +++ b/hw/arm/omap_sx1.c @@ -32,7 +32,6 @@ #include "hw/arm/arm.h" #include "hw/block/flash.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "sysemu/qtest.h" #include "exec/address-spaces.h" @@ -155,7 +154,7 @@ static void sx1_init(MachineState *machine, const int version) if ((dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) { if (!pflash_cfi01_register(OMAP_CS0_BASE, NULL, "omap_sx1.flash0-1", flash_size, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), sector_size, flash_size / sector_size, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory %d.\n", @@ -179,7 +178,7 @@ static void sx1_init(MachineState *machine, const int version) if (!pflash_cfi01_register(OMAP_CS1_BASE, NULL, "omap_sx1.flash1-1", flash1_size, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), sector_size, flash1_size / sector_size, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory %d.\n", diff --git a/hw/arm/pxa2xx.c b/hw/arm/pxa2xx.c index 6b7abe134a..693dfec9f2 100644 --- a/hw/arm/pxa2xx.c +++ b/hw/arm/pxa2xx.c @@ -2087,7 +2087,7 @@ PXA2xxState *pxa270_init(MemoryRegion *address_space, exit(1); } s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC), qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI), qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI)); @@ -2220,7 +2220,7 @@ PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size) exit(1); } s->mmc = pxa2xx_mmci_init(address_space, 0x41100000, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC), qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI), qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI)); diff --git a/hw/arm/realview.c b/hw/arm/realview.c index 8bd3ff60e4..af65aa4082 100644 --- a/hw/arm/realview.c +++ b/hw/arm/realview.c @@ -16,7 +16,7 @@ #include "sysemu/sysemu.h" #include "hw/boards.h" #include "hw/i2c/i2c.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" #include "qemu/error-report.h" diff --git a/hw/arm/spitz.c b/hw/arm/spitz.c index ff12f9b219..a16831c2e5 100644 --- a/hw/arm/spitz.c +++ b/hw/arm/spitz.c @@ -22,11 +22,9 @@ #include "hw/devices.h" #include "hw/arm/sharpsl.h" #include "ui/console.h" -#include "block/block.h" #include "audio/audio.h" #include "hw/boards.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "hw/sysbus.h" #include "exec/address-spaces.h" @@ -171,7 +169,7 @@ static int sl_nand_init(SysBusDevice *dev) s->ctl = 0; nand = drive_get(IF_MTD, 0, 0); - s->nand = nand_init(nand ? blk_bs(blk_by_legacy_dinfo(nand)) : NULL, + s->nand = nand_init(nand ? blk_by_legacy_dinfo(nand) : NULL, s->manf_id, s->chip_id); memory_region_init_io(&s->iomem, OBJECT(s), &sl_ops, s, "sl", 0x40); diff --git a/hw/arm/tosa.c b/hw/arm/tosa.c index 6c574bc418..73572ebe01 100644 --- a/hw/arm/tosa.c +++ b/hw/arm/tosa.c @@ -17,11 +17,10 @@ #include "hw/devices.h" #include "hw/arm/sharpsl.h" #include "hw/pcmcia.h" -#include "block/block.h" #include "hw/boards.h" #include "hw/i2c/i2c.h" #include "hw/ssi.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/sysbus.h" #include "exec/address-spaces.h" diff --git a/hw/arm/versatilepb.c b/hw/arm/versatilepb.c index 2ff46b048d..e6ef0a2e7e 100644 --- a/hw/arm/versatilepb.c +++ b/hw/arm/versatilepb.c @@ -16,7 +16,6 @@ #include "hw/i2c/i2c.h" #include "hw/boards.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "hw/block/flash.h" @@ -340,7 +339,7 @@ static void versatile_init(MachineState *machine, int board_id) dinfo = drive_get(IF_PFLASH, 0, 0); if (!pflash_cfi01_register(VERSATILE_FLASH_ADDR, NULL, "versatile.flash", VERSATILE_FLASH_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, VERSATILE_FLASH_SECT_SIZE, VERSATILE_FLASH_SIZE / VERSATILE_FLASH_SECT_SIZE, 4, 0x0089, 0x0018, 0x0000, 0x0, 0)) { diff --git a/hw/arm/vexpress.c b/hw/arm/vexpress.c index 828228c748..7cbd13f182 100644 --- a/hw/arm/vexpress.c +++ b/hw/arm/vexpress.c @@ -31,7 +31,6 @@ #include "hw/loader.h" #include "exec/address-spaces.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "hw/block/flash.h" #include "sysemu/device_tree.h" #include "qemu/error-report.h" @@ -493,7 +492,7 @@ static pflash_t *ve_pflash_cfi01_register(hwaddr base, const char *name, DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); if (di && qdev_prop_set_drive(dev, "drive", - blk_bs(blk_by_legacy_dinfo(di)))) { + blk_by_legacy_dinfo(di))) { abort(); } diff --git a/hw/arm/virt.c b/hw/arm/virt.c index e5fce2ad06..8ea592e92d 100644 --- a/hw/arm/virt.c +++ b/hw/arm/virt.c @@ -452,7 +452,7 @@ static void create_one_flash(const char *name, hwaddr flashbase, const uint64_t sectorlength = 256 * 1024; if (dinfo && qdev_prop_set_drive(dev, "drive", - blk_bs(blk_by_legacy_dinfo(dinfo)))) { + blk_by_legacy_dinfo(dinfo))) { abort(); } diff --git a/hw/arm/xilinx_zynq.c b/hw/arm/xilinx_zynq.c index 415344fc5e..b59039297a 100644 --- a/hw/arm/xilinx_zynq.c +++ b/hw/arm/xilinx_zynq.c @@ -23,7 +23,6 @@ #include "hw/boards.h" #include "hw/block/flash.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "hw/loader.h" #include "hw/ssi.h" #include "qemu/error-report.h" @@ -165,7 +164,7 @@ static void zynq_init(MachineState *machine) /* AMD */ pflash_cfi02_register(0xe2000000, NULL, "zynq.pflash", FLASH_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, FLASH_SECTOR_SIZE, FLASH_SIZE/FLASH_SECTOR_SIZE, 1, 1, 0x0066, 0x0022, 0x0000, 0x0000, 0x0555, 0x2aa, diff --git a/hw/arm/z2.c b/hw/arm/z2.c index 9b38a2bc01..17355479a1 100644 --- a/hw/arm/z2.c +++ b/hw/arm/z2.c @@ -21,7 +21,6 @@ #include "sysemu/sysemu.h" #include "hw/block/flash.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "ui/console.h" #include "audio/audio.h" #include "exec/address-spaces.h" @@ -337,7 +336,7 @@ static void z2_init(MachineState *machine) if (!pflash_cfi01_register(Z2_FLASH_BASE, NULL, "z2.flash0", Z2_FLASH_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, sector_len, Z2_FLASH_SIZE / sector_len, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); diff --git a/hw/block/block.c b/hw/block/block.c index b6a6dc6baa..0666dd337c 100644 --- a/hw/block/block.c +++ b/hw/block/block.c @@ -8,6 +8,7 @@ */ #include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/block/block.h" #include "qemu/error-report.h" @@ -17,7 +18,7 @@ void blkconf_serial(BlockConf *conf, char **serial) if (!*serial) { /* try to fall back to value set with legacy -drive serial=... */ - dinfo = drive_get_by_blockdev(conf->bs); + dinfo = blk_legacy_dinfo(conf->blk); *serial = g_strdup(dinfo->serial); } } @@ -30,7 +31,7 @@ void blkconf_geometry(BlockConf *conf, int *ptrans, if (!conf->cyls && !conf->heads && !conf->secs) { /* try to fall back to value set with legacy -drive cyls=... */ - dinfo = drive_get_by_blockdev(conf->bs); + dinfo = blk_legacy_dinfo(conf->blk); conf->cyls = dinfo->cyls; conf->heads = dinfo->heads; conf->secs = dinfo->secs; @@ -39,7 +40,7 @@ void blkconf_geometry(BlockConf *conf, int *ptrans, } } if (!conf->cyls && !conf->heads && !conf->secs) { - hd_geometry_guess(conf->bs, + hd_geometry_guess(conf->blk, &conf->cyls, &conf->heads, &conf->secs, ptrans); } else if (ptrans && *ptrans == BIOS_ATA_TRANSLATION_AUTO) { diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c index bd250df886..45b1164c3e 100644 --- a/hw/block/dataplane/virtio-blk.c +++ b/hw/block/dataplane/virtio-blk.c @@ -17,7 +17,7 @@ #include "qemu/thread.h" #include "qemu/error-report.h" #include "hw/virtio/dataplane/vring.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "hw/virtio/virtio-blk.h" #include "virtio-blk.h" #include "block/aio.h" @@ -94,7 +94,7 @@ static void handle_notify(EventNotifier *e) VirtIOBlock *vblk = VIRTIO_BLK(s->vdev); event_notifier_test_and_clear(&s->host_notifier); - bdrv_io_plug(s->conf->conf.bs); + blk_io_plug(s->conf->conf.blk); for (;;) { MultiReqBuffer mrb = { .num_writes = 0, @@ -120,7 +120,7 @@ static void handle_notify(EventNotifier *e) virtio_blk_handle_request(req, &mrb); } - virtio_submit_multiwrite(s->conf->conf.bs, &mrb); + virtio_submit_multiwrite(s->conf->conf.blk, &mrb); if (likely(ret == -EAGAIN)) { /* vring emptied */ /* Re-enable guest->host notifies and stop processing the vring. @@ -133,7 +133,7 @@ static void handle_notify(EventNotifier *e) break; } } - bdrv_io_unplug(s->conf->conf.bs); + blk_io_unplug(s->conf->conf.blk); } /* Context: QEMU global mutex held */ @@ -163,8 +163,8 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, /* If dataplane is (re-)enabled while the guest is running there could be * block jobs that can conflict. */ - if (bdrv_op_is_blocked(conf->conf.bs, BLOCK_OP_TYPE_DATAPLANE, - &local_err)) { + if (blk_op_is_blocked(conf->conf.blk, BLOCK_OP_TYPE_DATAPLANE, + &local_err)) { error_setg(errp, "cannot start dataplane thread: %s", error_get_pretty(local_err)); error_free(local_err); @@ -193,9 +193,9 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, s->bh = aio_bh_new(s->ctx, notify_guest_bh, s); error_setg(&s->blocker, "block device is in use by data plane"); - bdrv_op_block_all(conf->conf.bs, s->blocker); - bdrv_op_unblock(conf->conf.bs, BLOCK_OP_TYPE_RESIZE, s->blocker); - bdrv_op_unblock(conf->conf.bs, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker); + blk_op_block_all(conf->conf.blk, s->blocker); + blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_RESIZE, s->blocker); + blk_op_unblock(conf->conf.blk, BLOCK_OP_TYPE_DRIVE_DEL, s->blocker); *dataplane = s; } @@ -208,7 +208,7 @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s) } virtio_blk_data_plane_stop(s); - bdrv_op_unblock_all(s->conf->conf.bs, s->blocker); + blk_op_unblock_all(s->conf->conf.blk, s->blocker); error_free(s->blocker); object_unref(OBJECT(s->iothread)); qemu_bh_delete(s->bh); @@ -263,7 +263,7 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s) s->started = true; trace_virtio_blk_data_plane_start(s); - bdrv_set_aio_context(s->conf->conf.bs, s->ctx); + blk_set_aio_context(s->conf->conf.blk, s->ctx); /* Kick right away to begin processing requests already in vring */ event_notifier_set(virtio_queue_get_host_notifier(vq)); @@ -309,7 +309,7 @@ void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s) aio_set_event_notifier(s->ctx, &s->host_notifier, NULL); /* Drain and switch bs back to the QEMU main loop */ - bdrv_set_aio_context(s->conf->conf.bs, qemu_get_aio_context()); + blk_set_aio_context(s->conf->conf.blk, qemu_get_aio_context()); aio_context_release(s->ctx); diff --git a/hw/block/fdc.c b/hw/block/fdc.c index c25d7676d2..739a03ed58 100644 --- a/hw/block/fdc.c +++ b/hw/block/fdc.c @@ -114,7 +114,7 @@ static const FDFormat fd_formats[] = { { FDRIVE_DRV_NONE, -1, -1, 0, 0, }, }; -static void pick_geometry(BlockDriverState *bs, int *nb_heads, +static void pick_geometry(BlockBackend *blk, int *nb_heads, int *max_track, int *last_sect, FDriveType drive_in, FDriveType *drive, FDriveRate *rate) @@ -123,7 +123,7 @@ static void pick_geometry(BlockDriverState *bs, int *nb_heads, uint64_t nb_sectors, size; int i, first_match, match; - bdrv_get_geometry(bs, &nb_sectors); + blk_get_geometry(blk, &nb_sectors); match = -1; first_match = -1; for (i = 0; ; i++) { @@ -176,7 +176,7 @@ typedef enum FDiskFlags { typedef struct FDrive { FDCtrl *fdctrl; - BlockDriverState *bs; + BlockBackend *blk; /* Drive status */ FDriveType drive; uint8_t perpendicular; /* 2.88 MB access mode */ @@ -261,7 +261,7 @@ static int fd_seek(FDrive *drv, uint8_t head, uint8_t track, uint8_t sect, #endif drv->head = head; if (drv->track != track) { - if (drv->bs != NULL && bdrv_is_inserted(drv->bs)) { + if (drv->blk != NULL && blk_is_inserted(drv->blk)) { drv->media_changed = 0; } ret = 1; @@ -270,7 +270,7 @@ static int fd_seek(FDrive *drv, uint8_t head, uint8_t track, uint8_t sect, drv->sect = sect; } - if (drv->bs == NULL || !bdrv_is_inserted(drv->bs)) { + if (drv->blk == NULL || !blk_is_inserted(drv->blk)) { ret = 2; } @@ -292,11 +292,11 @@ static void fd_revalidate(FDrive *drv) FDriveRate rate; FLOPPY_DPRINTF("revalidate\n"); - if (drv->bs != NULL) { - ro = bdrv_is_read_only(drv->bs); - pick_geometry(drv->bs, &nb_heads, &max_track, + if (drv->blk != NULL) { + ro = blk_is_read_only(drv->blk); + pick_geometry(drv->blk, &nb_heads, &max_track, &last_sect, drv->drive, &drive, &rate); - if (!bdrv_is_inserted(drv->bs)) { + if (!blk_is_inserted(drv->blk)) { FLOPPY_DPRINTF("No disk in drive\n"); } else { FLOPPY_DPRINTF("Floppy disk (%d h %d t %d s) %s\n", nb_heads, @@ -666,7 +666,7 @@ static bool fdrive_media_changed_needed(void *opaque) { FDrive *drive = opaque; - return (drive->bs != NULL && drive->media_changed != 1); + return (drive->blk != NULL && drive->media_changed != 1); } static const VMStateDescription vmstate_fdrive_media_changed = { @@ -911,8 +911,9 @@ static void fdctrl_reset(FDCtrl *fdctrl, int do_irq) /* Initialise controller */ fdctrl->sra = 0; fdctrl->srb = 0xc0; - if (!fdctrl->drives[1].bs) + if (!fdctrl->drives[1].blk) { fdctrl->sra |= FD_SRA_nDRV2; + } fdctrl->cur_drv = 0; fdctrl->dor = FD_DOR_nRESET; fdctrl->dor |= (fdctrl->dma_chann != -1) ? FD_DOR_DMAEN : 0; @@ -1404,7 +1405,7 @@ static int fdctrl_transfer_handler (void *opaque, int nchan, status2 = FD_SR2_SNS; if (dma_len > fdctrl->data_len) dma_len = fdctrl->data_len; - if (cur_drv->bs == NULL) { + if (cur_drv->blk == NULL) { if (fdctrl->data_dir == FD_DIR_WRITE) fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00); else @@ -1425,8 +1426,8 @@ static int fdctrl_transfer_handler (void *opaque, int nchan, if (fdctrl->data_dir != FD_DIR_WRITE || len < FD_SECTOR_LEN || rel_pos != 0) { /* READ & SCAN commands and realign to a sector for WRITE */ - if (bdrv_read(cur_drv->bs, fd_sector(cur_drv), - fdctrl->fifo, 1) < 0) { + if (blk_read(cur_drv->blk, fd_sector(cur_drv), + fdctrl->fifo, 1) < 0) { FLOPPY_DPRINTF("Floppy: error getting sector %d\n", fd_sector(cur_drv)); /* Sure, image size is too small... */ @@ -1453,8 +1454,8 @@ static int fdctrl_transfer_handler (void *opaque, int nchan, DMA_read_memory (nchan, fdctrl->fifo + rel_pos, fdctrl->data_pos, len); - if (bdrv_write(cur_drv->bs, fd_sector(cur_drv), - fdctrl->fifo, 1) < 0) { + if (blk_write(cur_drv->blk, fd_sector(cur_drv), + fdctrl->fifo, 1) < 0) { FLOPPY_DPRINTF("error writing sector %d\n", fd_sector(cur_drv)); fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00); @@ -1529,7 +1530,8 @@ static uint32_t fdctrl_read_data(FDCtrl *fdctrl) fd_sector(cur_drv)); return 0; } - if (bdrv_read(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { + if (blk_read(cur_drv->blk, fd_sector(cur_drv), fdctrl->fifo, 1) + < 0) { FLOPPY_DPRINTF("error getting sector %d\n", fd_sector(cur_drv)); /* Sure, image size is too small... */ @@ -1598,8 +1600,8 @@ static void fdctrl_format_sector(FDCtrl *fdctrl) break; } memset(fdctrl->fifo, 0, FD_SECTOR_LEN); - if (cur_drv->bs == NULL || - bdrv_write(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { + if (cur_drv->blk == NULL || + blk_write(cur_drv->blk, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { FLOPPY_DPRINTF("error formatting sector %d\n", fd_sector(cur_drv)); fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00); } else { @@ -1989,7 +1991,8 @@ static void fdctrl_write_data(FDCtrl *fdctrl, uint32_t value) if (pos == FD_SECTOR_LEN - 1 || fdctrl->data_pos == fdctrl->data_len) { cur_drv = get_cur_drv(fdctrl); - if (bdrv_write(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { + if (blk_write(cur_drv->blk, fd_sector(cur_drv), fdctrl->fifo, 1) + < 0) { FLOPPY_DPRINTF("error writing sector %d\n", fd_sector(cur_drv)); return; @@ -2077,12 +2080,12 @@ static void fdctrl_connect_drives(FDCtrl *fdctrl, Error **errp) drive = &fdctrl->drives[i]; drive->fdctrl = fdctrl; - if (drive->bs) { - if (bdrv_get_on_error(drive->bs, 0) != BLOCKDEV_ON_ERROR_ENOSPC) { + if (drive->blk) { + if (blk_get_on_error(drive->blk, 0) != BLOCKDEV_ON_ERROR_ENOSPC) { error_setg(errp, "fdc doesn't support drive option werror"); return; } - if (bdrv_get_on_error(drive->bs, 1) != BLOCKDEV_ON_ERROR_REPORT) { + if (blk_get_on_error(drive->blk, 1) != BLOCKDEV_ON_ERROR_REPORT) { error_setg(errp, "fdc doesn't support drive option rerror"); return; } @@ -2090,8 +2093,8 @@ static void fdctrl_connect_drives(FDCtrl *fdctrl, Error **errp) fd_init(drive); fdctrl_change_cb(drive, 0); - if (drive->bs) { - bdrv_set_dev_ops(drive->bs, &fdctrl_block_ops, drive); + if (drive->blk) { + blk_set_dev_ops(drive->blk, &fdctrl_block_ops, drive); } } } @@ -2108,12 +2111,10 @@ ISADevice *fdctrl_init_isa(ISABus *bus, DriveInfo **fds) dev = DEVICE(isadev); if (fds[0]) { - qdev_prop_set_drive_nofail(dev, "driveA", - blk_bs(blk_by_legacy_dinfo(fds[0]))); + qdev_prop_set_drive_nofail(dev, "driveA", blk_by_legacy_dinfo(fds[0])); } if (fds[1]) { - qdev_prop_set_drive_nofail(dev, "driveB", - blk_bs(blk_by_legacy_dinfo(fds[1]))); + qdev_prop_set_drive_nofail(dev, "driveB", blk_by_legacy_dinfo(fds[1])); } qdev_init_nofail(dev); @@ -2133,12 +2134,10 @@ void fdctrl_init_sysbus(qemu_irq irq, int dma_chann, fdctrl = &sys->state; fdctrl->dma_chann = dma_chann; /* FIXME */ if (fds[0]) { - qdev_prop_set_drive_nofail(dev, "driveA", - blk_bs(blk_by_legacy_dinfo(fds[0]))); + qdev_prop_set_drive_nofail(dev, "driveA", blk_by_legacy_dinfo(fds[0])); } if (fds[1]) { - qdev_prop_set_drive_nofail(dev, "driveB", - blk_bs(blk_by_legacy_dinfo(fds[1]))); + qdev_prop_set_drive_nofail(dev, "driveB", blk_by_legacy_dinfo(fds[1])); } qdev_init_nofail(dev); sbd = SYS_BUS_DEVICE(dev); @@ -2154,8 +2153,7 @@ void sun4m_fdctrl_init(qemu_irq irq, hwaddr io_base, dev = qdev_create(NULL, "SUNW,fdtwo"); if (fds[0]) { - qdev_prop_set_drive_nofail(dev, "drive", - blk_bs(blk_by_legacy_dinfo(fds[0]))); + qdev_prop_set_drive_nofail(dev, "drive", blk_by_legacy_dinfo(fds[0])); } qdev_init_nofail(dev); sys = SYSBUS_FDC(dev); @@ -2292,8 +2290,8 @@ static Property isa_fdc_properties[] = { DEFINE_PROP_UINT32("iobase", FDCtrlISABus, iobase, 0x3f0), DEFINE_PROP_UINT32("irq", FDCtrlISABus, irq, 6), DEFINE_PROP_UINT32("dma", FDCtrlISABus, dma, 2), - DEFINE_PROP_DRIVE("driveA", FDCtrlISABus, state.drives[0].bs), - DEFINE_PROP_DRIVE("driveB", FDCtrlISABus, state.drives[1].bs), + DEFINE_PROP_DRIVE("driveA", FDCtrlISABus, state.drives[0].blk), + DEFINE_PROP_DRIVE("driveB", FDCtrlISABus, state.drives[1].blk), DEFINE_PROP_BIT("check_media_rate", FDCtrlISABus, state.check_media_rate, 0, true), DEFINE_PROP_END_OF_LIST(), @@ -2342,8 +2340,8 @@ static const VMStateDescription vmstate_sysbus_fdc ={ }; static Property sysbus_fdc_properties[] = { - DEFINE_PROP_DRIVE("driveA", FDCtrlSysBus, state.drives[0].bs), - DEFINE_PROP_DRIVE("driveB", FDCtrlSysBus, state.drives[1].bs), + DEFINE_PROP_DRIVE("driveA", FDCtrlSysBus, state.drives[0].blk), + DEFINE_PROP_DRIVE("driveB", FDCtrlSysBus, state.drives[1].blk), DEFINE_PROP_END_OF_LIST(), }; @@ -2363,7 +2361,7 @@ static const TypeInfo sysbus_fdc_info = { }; static Property sun4m_fdc_properties[] = { - DEFINE_PROP_DRIVE("drive", FDCtrlSysBus, state.drives[0].bs), + DEFINE_PROP_DRIVE("drive", FDCtrlSysBus, state.drives[0].blk), DEFINE_PROP_END_OF_LIST(), }; diff --git a/hw/block/hd-geometry.c b/hw/block/hd-geometry.c index 6feb4f8175..6fcf74df44 100644 --- a/hw/block/hd-geometry.c +++ b/hw/block/hd-geometry.c @@ -30,7 +30,7 @@ * THE SOFTWARE. */ -#include "block/block.h" +#include "sysemu/block-backend.h" #include "hw/block/block.h" #include "trace.h" @@ -49,7 +49,7 @@ struct partition { /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */ -static int guess_disk_lchs(BlockDriverState *bs, +static int guess_disk_lchs(BlockBackend *blk, int *pcylinders, int *pheads, int *psectors) { uint8_t buf[BDRV_SECTOR_SIZE]; @@ -58,14 +58,14 @@ static int guess_disk_lchs(BlockDriverState *bs, uint32_t nr_sects; uint64_t nb_sectors; - bdrv_get_geometry(bs, &nb_sectors); + blk_get_geometry(blk, &nb_sectors); /** * The function will be invoked during startup not only in sync I/O mode, * but also in async I/O mode. So the I/O throttling function has to * be disabled temporarily here, not permanently. */ - if (bdrv_read_unthrottled(bs, 0, buf, 1) < 0) { + if (blk_read_unthrottled(blk, 0, buf, 1) < 0) { return -1; } /* test msdos magic */ @@ -90,20 +90,20 @@ static int guess_disk_lchs(BlockDriverState *bs, *pheads = heads; *psectors = sectors; *pcylinders = cylinders; - trace_hd_geometry_lchs_guess(bs, cylinders, heads, sectors); + trace_hd_geometry_lchs_guess(blk, cylinders, heads, sectors); return 0; } } return -1; } -static void guess_chs_for_size(BlockDriverState *bs, +static void guess_chs_for_size(BlockBackend *blk, uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs) { uint64_t nb_sectors; int cylinders; - bdrv_get_geometry(bs, &nb_sectors); + blk_get_geometry(blk, &nb_sectors); cylinders = nb_sectors / (16 * 63); if (cylinders > 16383) { @@ -116,21 +116,21 @@ static void guess_chs_for_size(BlockDriverState *bs, *psecs = 63; } -void hd_geometry_guess(BlockDriverState *bs, +void hd_geometry_guess(BlockBackend *blk, uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs, int *ptrans) { int cylinders, heads, secs, translation; - if (guess_disk_lchs(bs, &cylinders, &heads, &secs) < 0) { + if (guess_disk_lchs(blk, &cylinders, &heads, &secs) < 0) { /* no LCHS guess: use a standard physical disk geometry */ - guess_chs_for_size(bs, pcyls, pheads, psecs); + guess_chs_for_size(blk, pcyls, pheads, psecs); translation = hd_bios_chs_auto_trans(*pcyls, *pheads, *psecs); } else if (heads > 16) { /* LCHS guess with heads > 16 means that a BIOS LBA translation was active, so a standard physical disk geometry is OK */ - guess_chs_for_size(bs, pcyls, pheads, psecs); + guess_chs_for_size(blk, pcyls, pheads, psecs); translation = *pcyls * *pheads <= 131072 ? BIOS_ATA_TRANSLATION_LARGE : BIOS_ATA_TRANSLATION_LBA; @@ -146,7 +146,7 @@ void hd_geometry_guess(BlockDriverState *bs, if (ptrans) { *ptrans = translation; } - trace_hd_geometry_guess(bs, *pcyls, *pheads, *psecs, translation); + trace_hd_geometry_guess(blk, *pcyls, *pheads, *psecs, translation); } int hd_bios_chs_auto_trans(uint32_t cyls, uint32_t heads, uint32_t secs) diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c index 78280a881a..ff1106b6c9 100644 --- a/hw/block/m25p80.c +++ b/hw/block/m25p80.c @@ -246,7 +246,7 @@ typedef struct Flash { uint32_t r; - BlockDriverState *bdrv; + BlockBackend *blk; uint8_t *storage; uint32_t size; @@ -280,7 +280,7 @@ typedef struct M25P80Class { #define M25P80_GET_CLASS(obj) \ OBJECT_GET_CLASS(M25P80Class, (obj), TYPE_M25P80) -static void bdrv_sync_complete(void *opaque, int ret) +static void blk_sync_complete(void *opaque, int ret) { /* do nothing. Masters do not directly interact with the backing store, * only the working copy so no mutexing required. @@ -289,20 +289,20 @@ static void bdrv_sync_complete(void *opaque, int ret) static void flash_sync_page(Flash *s, int page) { - int bdrv_sector, nb_sectors; + int blk_sector, nb_sectors; QEMUIOVector iov; - if (!s->bdrv || bdrv_is_read_only(s->bdrv)) { + if (!s->blk || blk_is_read_only(s->blk)) { return; } - bdrv_sector = (page * s->pi->page_size) / BDRV_SECTOR_SIZE; + blk_sector = (page * s->pi->page_size) / BDRV_SECTOR_SIZE; nb_sectors = DIV_ROUND_UP(s->pi->page_size, BDRV_SECTOR_SIZE); qemu_iovec_init(&iov, 1); - qemu_iovec_add(&iov, s->storage + bdrv_sector * BDRV_SECTOR_SIZE, + qemu_iovec_add(&iov, s->storage + blk_sector * BDRV_SECTOR_SIZE, nb_sectors * BDRV_SECTOR_SIZE); - bdrv_aio_writev(s->bdrv, bdrv_sector, &iov, nb_sectors, bdrv_sync_complete, - NULL); + blk_aio_writev(s->blk, blk_sector, &iov, nb_sectors, blk_sync_complete, + NULL); } static inline void flash_sync_area(Flash *s, int64_t off, int64_t len) @@ -310,7 +310,7 @@ static inline void flash_sync_area(Flash *s, int64_t off, int64_t len) int64_t start, end, nb_sectors; QEMUIOVector iov; - if (!s->bdrv || bdrv_is_read_only(s->bdrv)) { + if (!s->blk || blk_is_read_only(s->blk)) { return; } @@ -321,7 +321,7 @@ static inline void flash_sync_area(Flash *s, int64_t off, int64_t len) qemu_iovec_init(&iov, 1); qemu_iovec_add(&iov, s->storage + (start * BDRV_SECTOR_SIZE), nb_sectors * BDRV_SECTOR_SIZE); - bdrv_aio_writev(s->bdrv, start, &iov, nb_sectors, bdrv_sync_complete, NULL); + blk_aio_writev(s->blk, start, &iov, nb_sectors, blk_sync_complete, NULL); } static void flash_erase(Flash *s, int offset, FlashCMD cmd) @@ -621,17 +621,17 @@ static int m25p80_init(SSISlave *ss) s->size = s->pi->sector_size * s->pi->n_sectors; s->dirty_page = -1; - s->storage = qemu_blockalign(s->bdrv, s->size); + s->storage = blk_blockalign(s->blk, s->size); dinfo = drive_get_next(IF_MTD); if (dinfo) { DB_PRINT_L(0, "Binding to IF_MTD drive\n"); - s->bdrv = blk_bs(blk_by_legacy_dinfo(dinfo)); + s->blk = blk_by_legacy_dinfo(dinfo); /* FIXME: Move to late init */ - if (bdrv_read(s->bdrv, 0, s->storage, DIV_ROUND_UP(s->size, - BDRV_SECTOR_SIZE))) { + if (blk_read(s->blk, 0, s->storage, + DIV_ROUND_UP(s->size, BDRV_SECTOR_SIZE))) { fprintf(stderr, "Failed to initialize SPI flash!\n"); return 1; } diff --git a/hw/block/nand.c b/hw/block/nand.c index 38eefd436d..1882a0cbeb 100644 --- a/hw/block/nand.c +++ b/hw/block/nand.c @@ -20,7 +20,7 @@ # include "hw/hw.h" # include "hw/block/flash.h" -# include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/qdev.h" #include "qemu/error-report.h" @@ -61,7 +61,7 @@ struct NANDFlashState { int size, pages; int page_shift, oob_shift, erase_shift, addr_shift; uint8_t *storage; - BlockDriverState *bdrv; + BlockBackend *blk; int mem_oob; uint8_t cle, ale, ce, wp, gnd; @@ -400,12 +400,12 @@ static void nand_realize(DeviceState *dev, Error **errp) pagesize = 1 << s->oob_shift; s->mem_oob = 1; - if (s->bdrv) { - if (bdrv_is_read_only(s->bdrv)) { + if (s->blk) { + if (blk_is_read_only(s->blk)) { error_setg(errp, "Can't use a read-only drive"); return; } - if (bdrv_getlength(s->bdrv) >= + if (blk_getlength(s->blk) >= (s->pages << s->page_shift) + (s->pages << s->oob_shift)) { pagesize = 0; s->mem_oob = 0; @@ -424,7 +424,7 @@ static void nand_realize(DeviceState *dev, Error **errp) static Property nand_properties[] = { DEFINE_PROP_UINT8("manufacturer_id", NANDFlashState, manf_id, 0), DEFINE_PROP_UINT8("chip_id", NANDFlashState, chip_id, 0), - DEFINE_PROP_DRIVE("drive", NANDFlashState, bdrv), + DEFINE_PROP_DRIVE("drive", NANDFlashState, blk), DEFINE_PROP_END_OF_LIST(), }; @@ -624,7 +624,7 @@ uint32_t nand_getbuswidth(DeviceState *dev) return s->buswidth << 3; } -DeviceState *nand_init(BlockDriverState *bdrv, int manf_id, int chip_id) +DeviceState *nand_init(BlockBackend *blk, int manf_id, int chip_id) { DeviceState *dev; @@ -634,8 +634,8 @@ DeviceState *nand_init(BlockDriverState *bdrv, int manf_id, int chip_id) dev = DEVICE(object_new(TYPE_NAND)); qdev_prop_set_uint8(dev, "manufacturer_id", manf_id); qdev_prop_set_uint8(dev, "chip_id", chip_id); - if (bdrv) { - qdev_prop_set_drive_nofail(dev, "drive", bdrv); + if (blk) { + qdev_prop_set_drive_nofail(dev, "drive", blk); } qdev_init_nofail(dev); @@ -654,14 +654,14 @@ static void glue(nand_blk_write_, PAGE_SIZE)(NANDFlashState *s) if (PAGE(s->addr) >= s->pages) return; - if (!s->bdrv) { + if (!s->blk) { mem_and(s->storage + PAGE_START(s->addr) + (s->addr & PAGE_MASK) + s->offset, s->io, s->iolen); } else if (s->mem_oob) { sector = SECTOR(s->addr); off = (s->addr & PAGE_MASK) + s->offset; soff = SECTOR_OFFSET(s->addr); - if (bdrv_read(s->bdrv, sector, iobuf, PAGE_SECTORS) < 0) { + if (blk_read(s->blk, sector, iobuf, PAGE_SECTORS) < 0) { printf("%s: read error in sector %" PRIu64 "\n", __func__, sector); return; } @@ -673,21 +673,21 @@ static void glue(nand_blk_write_, PAGE_SIZE)(NANDFlashState *s) MIN(OOB_SIZE, off + s->iolen - PAGE_SIZE)); } - if (bdrv_write(s->bdrv, sector, iobuf, PAGE_SECTORS) < 0) { + if (blk_write(s->blk, sector, iobuf, PAGE_SECTORS) < 0) { printf("%s: write error in sector %" PRIu64 "\n", __func__, sector); } } else { off = PAGE_START(s->addr) + (s->addr & PAGE_MASK) + s->offset; sector = off >> 9; soff = off & 0x1ff; - if (bdrv_read(s->bdrv, sector, iobuf, PAGE_SECTORS + 2) < 0) { + if (blk_read(s->blk, sector, iobuf, PAGE_SECTORS + 2) < 0) { printf("%s: read error in sector %" PRIu64 "\n", __func__, sector); return; } mem_and(iobuf + soff, s->io, s->iolen); - if (bdrv_write(s->bdrv, sector, iobuf, PAGE_SECTORS + 2) < 0) { + if (blk_write(s->blk, sector, iobuf, PAGE_SECTORS + 2) < 0) { printf("%s: write error in sector %" PRIu64 "\n", __func__, sector); } } @@ -705,7 +705,7 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s) return; } - if (!s->bdrv) { + if (!s->blk) { memset(s->storage + PAGE_START(addr), 0xff, (PAGE_SIZE + OOB_SIZE) << s->erase_shift); } else if (s->mem_oob) { @@ -714,17 +714,17 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s) i = SECTOR(addr); page = SECTOR(addr + (ADDR_SHIFT + s->erase_shift)); for (; i < page; i ++) - if (bdrv_write(s->bdrv, i, iobuf, 1) < 0) { + if (blk_write(s->blk, i, iobuf, 1) < 0) { printf("%s: write error in sector %" PRIu64 "\n", __func__, i); } } else { addr = PAGE_START(addr); page = addr >> 9; - if (bdrv_read(s->bdrv, page, iobuf, 1) < 0) { + if (blk_read(s->blk, page, iobuf, 1) < 0) { printf("%s: read error in sector %" PRIu64 "\n", __func__, page); } memset(iobuf + (addr & 0x1ff), 0xff, (~addr & 0x1ff) + 1); - if (bdrv_write(s->bdrv, page, iobuf, 1) < 0) { + if (blk_write(s->blk, page, iobuf, 1) < 0) { printf("%s: write error in sector %" PRIu64 "\n", __func__, page); } @@ -732,18 +732,18 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s) i = (addr & ~0x1ff) + 0x200; for (addr += ((PAGE_SIZE + OOB_SIZE) << s->erase_shift) - 0x200; i < addr; i += 0x200) { - if (bdrv_write(s->bdrv, i >> 9, iobuf, 1) < 0) { + if (blk_write(s->blk, i >> 9, iobuf, 1) < 0) { printf("%s: write error in sector %" PRIu64 "\n", __func__, i >> 9); } } page = i >> 9; - if (bdrv_read(s->bdrv, page, iobuf, 1) < 0) { + if (blk_read(s->blk, page, iobuf, 1) < 0) { printf("%s: read error in sector %" PRIu64 "\n", __func__, page); } memset(iobuf, 0xff, ((addr - 1) & 0x1ff) + 1); - if (bdrv_write(s->bdrv, page, iobuf, 1) < 0) { + if (blk_write(s->blk, page, iobuf, 1) < 0) { printf("%s: write error in sector %" PRIu64 "\n", __func__, page); } } @@ -756,9 +756,9 @@ static void glue(nand_blk_load_, PAGE_SIZE)(NANDFlashState *s, return; } - if (s->bdrv) { + if (s->blk) { if (s->mem_oob) { - if (bdrv_read(s->bdrv, SECTOR(addr), s->io, PAGE_SECTORS) < 0) { + if (blk_read(s->blk, SECTOR(addr), s->io, PAGE_SECTORS) < 0) { printf("%s: read error in sector %" PRIu64 "\n", __func__, SECTOR(addr)); } @@ -767,8 +767,8 @@ static void glue(nand_blk_load_, PAGE_SIZE)(NANDFlashState *s, OOB_SIZE); s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset; } else { - if (bdrv_read(s->bdrv, PAGE_START(addr) >> 9, - s->io, (PAGE_SECTORS + 2)) < 0) { + if (blk_read(s->blk, PAGE_START(addr) >> 9, + s->io, (PAGE_SECTORS + 2)) < 0) { printf("%s: read error in sector %" PRIu64 "\n", __func__, PAGE_START(addr) >> 9); } diff --git a/hw/block/nvme.c b/hw/block/nvme.c index 9a95f7530b..b6263dcabc 100644 --- a/hw/block/nvme.c +++ b/hw/block/nvme.c @@ -26,6 +26,7 @@ #include #include "sysemu/sysemu.h" #include "qapi/visitor.h" +#include "sysemu/block-backend.h" #include "nvme.h" @@ -199,7 +200,7 @@ static void nvme_rw_cb(void *opaque, int ret) NvmeCtrl *n = sq->ctrl; NvmeCQueue *cq = n->cq[sq->cqid]; - block_acct_done(bdrv_get_stats(n->conf.bs), &req->acct); + block_acct_done(blk_get_stats(n->conf.blk), &req->acct); if (!ret) { req->status = NVME_SUCCESS; } else { @@ -233,11 +234,11 @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd, } assert((nlb << data_shift) == req->qsg.size); - dma_acct_start(n->conf.bs, &req->acct, &req->qsg, is_write ? - BLOCK_ACCT_WRITE : BLOCK_ACCT_READ); + dma_acct_start(n->conf.blk, &req->acct, &req->qsg, + is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ); req->aiocb = is_write ? - dma_bdrv_write(n->conf.bs, &req->qsg, aio_slba, nvme_rw_cb, req) : - dma_bdrv_read(n->conf.bs, &req->qsg, aio_slba, nvme_rw_cb, req); + dma_blk_write(n->conf.blk, &req->qsg, aio_slba, nvme_rw_cb, req) : + dma_blk_read(n->conf.blk, &req->qsg, aio_slba, nvme_rw_cb, req); return NVME_NO_COMPLETE; } @@ -290,7 +291,7 @@ static uint16_t nvme_del_sq(NvmeCtrl *n, NvmeCmd *cmd) while (!QTAILQ_EMPTY(&sq->out_req_list)) { req = QTAILQ_FIRST(&sq->out_req_list); assert(req->aiocb); - bdrv_aio_cancel(req->aiocb); + blk_aio_cancel(req->aiocb); } if (!nvme_check_cqid(n, sq->cqid)) { cq = n->cq[sq->cqid]; @@ -565,7 +566,7 @@ static void nvme_clear_ctrl(NvmeCtrl *n) } } - bdrv_flush(n->conf.bs); + blk_flush(n->conf.blk); n->bar.cc = 0; } @@ -750,11 +751,11 @@ static int nvme_init(PCIDevice *pci_dev) int64_t bs_size; uint8_t *pci_conf; - if (!(n->conf.bs)) { + if (!n->conf.blk) { return -1; } - bs_size = bdrv_getlength(n->conf.bs); + bs_size = blk_getlength(n->conf.blk); if (bs_size < 0) { return -1; } diff --git a/hw/block/onenand.c b/hw/block/onenand.c index e48e5859f3..348630d905 100644 --- a/hw/block/onenand.c +++ b/hw/block/onenand.c @@ -22,6 +22,7 @@ #include "hw/hw.h" #include "hw/block/flash.h" #include "hw/irq.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "exec/memory.h" #include "exec/address-spaces.h" @@ -49,8 +50,8 @@ typedef struct OneNANDState { hwaddr base; qemu_irq intr; qemu_irq rdy; - BlockDriverState *bdrv; - BlockDriverState *bdrv_cur; + BlockBackend *blk; + BlockBackend *blk_cur; uint8_t *image; uint8_t *otp; uint8_t *current; @@ -213,7 +214,7 @@ static void onenand_reset(OneNANDState *s, int cold) s->wpstatus = 0x0002; s->cycle = 0; s->otpmode = 0; - s->bdrv_cur = s->bdrv; + s->blk_cur = s->blk; s->current = s->image; s->secs_cur = s->secs; @@ -221,7 +222,7 @@ static void onenand_reset(OneNANDState *s, int cold) /* Lock the whole flash */ memset(s->blockwp, ONEN_LOCK_LOCKED, s->blocks); - if (s->bdrv_cur && bdrv_read(s->bdrv_cur, 0, s->boot[0], 8) < 0) { + if (s->blk_cur && blk_read(s->blk_cur, 0, s->boot[0], 8) < 0) { hw_error("%s: Loading the BootRAM failed.\n", __func__); } } @@ -237,10 +238,11 @@ static void onenand_system_reset(DeviceState *dev) static inline int onenand_load_main(OneNANDState *s, int sec, int secn, void *dest) { - if (s->bdrv_cur) - return bdrv_read(s->bdrv_cur, sec, dest, secn) < 0; - else if (sec + secn > s->secs_cur) + if (s->blk_cur) { + return blk_read(s->blk_cur, sec, dest, secn) < 0; + } else if (sec + secn > s->secs_cur) { return 1; + } memcpy(dest, s->current + (sec << 9), secn << 9); @@ -256,9 +258,9 @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn, uint32_t size = (uint32_t)secn * 512; const uint8_t *sp = (const uint8_t *)src; uint8_t *dp = 0; - if (s->bdrv_cur) { + if (s->blk_cur) { dp = g_malloc(size); - if (!dp || bdrv_read(s->bdrv_cur, sec, dp, secn) < 0) { + if (!dp || blk_read(s->blk_cur, sec, dp, secn) < 0) { result = 1; } } else { @@ -273,11 +275,11 @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn, for (i = 0; i < size; i++) { dp[i] &= sp[i]; } - if (s->bdrv_cur) { - result = bdrv_write(s->bdrv_cur, sec, dp, secn) < 0; + if (s->blk_cur) { + result = blk_write(s->blk_cur, sec, dp, secn) < 0; } } - if (dp && s->bdrv_cur) { + if (dp && s->blk_cur) { g_free(dp); } } @@ -290,14 +292,16 @@ static inline int onenand_load_spare(OneNANDState *s, int sec, int secn, { uint8_t buf[512]; - if (s->bdrv_cur) { - if (bdrv_read(s->bdrv_cur, s->secs_cur + (sec >> 5), buf, 1) < 0) + if (s->blk_cur) { + if (blk_read(s->blk_cur, s->secs_cur + (sec >> 5), buf, 1) < 0) { return 1; + } memcpy(dest, buf + ((sec & 31) << 4), secn << 4); - } else if (sec + secn > s->secs_cur) + } else if (sec + secn > s->secs_cur) { return 1; - else + } else { memcpy(dest, s->current + (s->secs_cur << 9) + (sec << 4), secn << 4); + } return 0; } @@ -309,11 +313,10 @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn, if (secn > 0) { const uint8_t *sp = (const uint8_t *)src; uint8_t *dp = 0, *dpp = 0; - if (s->bdrv_cur) { + if (s->blk_cur) { dp = g_malloc(512); - if (!dp || bdrv_read(s->bdrv_cur, - s->secs_cur + (sec >> 5), - dp, 1) < 0) { + if (!dp + || blk_read(s->blk_cur, s->secs_cur + (sec >> 5), dp, 1) < 0) { result = 1; } else { dpp = dp + ((sec & 31) << 4); @@ -330,9 +333,9 @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn, for (i = 0; i < (secn << 4); i++) { dpp[i] &= sp[i]; } - if (s->bdrv_cur) { - result = bdrv_write(s->bdrv_cur, s->secs_cur + (sec >> 5), - dp, 1) < 0; + if (s->blk_cur) { + result = blk_write(s->blk_cur, s->secs_cur + (sec >> 5), + dp, 1) < 0; } } g_free(dp); @@ -354,16 +357,16 @@ static inline int onenand_erase(OneNANDState *s, int sec, int num) } memset(blankbuf, 0xff, 512); for (; num > 0; num--, sec++) { - if (s->bdrv_cur) { + if (s->blk_cur) { int erasesec = s->secs_cur + (sec >> 5); - if (bdrv_write(s->bdrv_cur, sec, blankbuf, 1) < 0) { + if (blk_write(s->blk_cur, sec, blankbuf, 1) < 0) { goto fail; } - if (bdrv_read(s->bdrv_cur, erasesec, tmpbuf, 1) < 0) { + if (blk_read(s->blk_cur, erasesec, tmpbuf, 1) < 0) { goto fail; } memcpy(tmpbuf + ((sec & 31) << 4), blankbuf, 1 << 4); - if (bdrv_write(s->bdrv_cur, erasesec, tmpbuf, 1) < 0) { + if (blk_write(s->blk_cur, erasesec, tmpbuf, 1) < 0) { goto fail; } } else { @@ -576,7 +579,7 @@ static void onenand_command(OneNANDState *s) case 0x65: /* OTP Access */ s->intstatus |= ONEN_INT; - s->bdrv_cur = NULL; + s->blk_cur = NULL; s->current = s->otp; s->secs_cur = 1 << (BLOCK_SHIFT - 9); s->addr[ONEN_BUF_BLOCK] = 0; @@ -776,15 +779,15 @@ static int onenand_initfn(SysBusDevice *sbd) ? (1 << (6 + ((s->id.dev >> 4) & 7))) : 0; memory_region_init_io(&s->iomem, OBJECT(s), &onenand_ops, s, "onenand", 0x10000 << s->shift); - if (!s->bdrv) { + if (!s->blk) { s->image = memset(g_malloc(size + (size >> 5)), 0xff, size + (size >> 5)); } else { - if (bdrv_is_read_only(s->bdrv)) { + if (blk_is_read_only(s->blk)) { error_report("Can't use a read-only drive"); return -1; } - s->bdrv_cur = s->bdrv; + s->blk_cur = s->blk; } s->otp = memset(g_malloc((64 + 2) << PAGE_SHIFT), 0xff, (64 + 2) << PAGE_SHIFT); @@ -815,7 +818,7 @@ static Property onenand_properties[] = { DEFINE_PROP_UINT16("device_id", OneNANDState, id.dev, 0), DEFINE_PROP_UINT16("version_id", OneNANDState, id.ver, 0), DEFINE_PROP_INT32("shift", OneNANDState, shift, 0), - DEFINE_PROP_DRIVE("drive", OneNANDState, bdrv), + DEFINE_PROP_DRIVE("drive", OneNANDState, blk), DEFINE_PROP_END_OF_LIST(), }; diff --git a/hw/block/pflash_cfi01.c b/hw/block/pflash_cfi01.c index 1346541c80..89d380e59d 100644 --- a/hw/block/pflash_cfi01.c +++ b/hw/block/pflash_cfi01.c @@ -38,7 +38,7 @@ #include "hw/hw.h" #include "hw/block/flash.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "qemu/timer.h" #include "qemu/bitops.h" #include "exec/address-spaces.h" @@ -69,7 +69,7 @@ struct pflash_t { SysBusDevice parent_obj; /*< public >*/ - BlockDriverState *bs; + BlockBackend *blk; uint32_t nb_blocs; uint64_t sector_len; uint8_t bank_width; @@ -395,13 +395,13 @@ static void pflash_update(pflash_t *pfl, int offset, int size) { int offset_end; - if (pfl->bs) { + if (pfl->blk) { offset_end = offset + size; /* round to sectors */ offset = offset >> 9; offset_end = (offset_end + 511) >> 9; - bdrv_write(pfl->bs, offset, pfl->storage + (offset << 9), - offset_end - offset); + blk_write(pfl->blk, offset, pfl->storage + (offset << 9), + offset_end - offset); } } @@ -784,9 +784,9 @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp) pfl->storage = memory_region_get_ram_ptr(&pfl->mem); sysbus_init_mmio(SYS_BUS_DEVICE(dev), &pfl->mem); - if (pfl->bs) { + if (pfl->blk) { /* read the initial flash content */ - ret = bdrv_read(pfl->bs, 0, pfl->storage, total_len >> 9); + ret = blk_read(pfl->blk, 0, pfl->storage, total_len >> 9); if (ret < 0) { vmstate_unregister_ram(&pfl->mem, DEVICE(pfl)); @@ -795,8 +795,8 @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp) } } - if (pfl->bs) { - pfl->ro = bdrv_is_read_only(pfl->bs); + if (pfl->blk) { + pfl->ro = blk_is_read_only(pfl->blk); } else { pfl->ro = 0; } @@ -898,7 +898,7 @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp) } static Property pflash_cfi01_properties[] = { - DEFINE_PROP_DRIVE("drive", struct pflash_t, bs), + DEFINE_PROP_DRIVE("drive", struct pflash_t, blk), /* num-blocks is the number of blocks actually visible to the guest, * ie the total size of the device divided by the sector length. * If we're emulating flash devices wired in parallel the actual @@ -962,14 +962,14 @@ type_init(pflash_cfi01_register_types) pflash_t *pflash_cfi01_register(hwaddr base, DeviceState *qdev, const char *name, hwaddr size, - BlockDriverState *bs, + BlockBackend *blk, uint32_t sector_len, int nb_blocs, int bank_width, uint16_t id0, uint16_t id1, uint16_t id2, uint16_t id3, int be) { DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH01); - if (bs && qdev_prop_set_drive(dev, "drive", bs)) { + if (blk && qdev_prop_set_drive(dev, "drive", blk)) { abort(); } qdev_prop_set_uint32(dev, "num-blocks", nb_blocs); diff --git a/hw/block/pflash_cfi02.c b/hw/block/pflash_cfi02.c index 01011cf339..8513a17e9f 100644 --- a/hw/block/pflash_cfi02.c +++ b/hw/block/pflash_cfi02.c @@ -38,7 +38,7 @@ #include "hw/hw.h" #include "hw/block/flash.h" #include "qemu/timer.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" #include "qemu/host-utils.h" #include "hw/sysbus.h" @@ -63,7 +63,7 @@ struct pflash_t { SysBusDevice parent_obj; /*< public >*/ - BlockDriverState *bs; + BlockBackend *blk; uint32_t sector_len; uint32_t nb_blocs; uint32_t chip_len; @@ -249,13 +249,13 @@ static void pflash_update(pflash_t *pfl, int offset, int size) { int offset_end; - if (pfl->bs) { + if (pfl->blk) { offset_end = offset + size; /* round to sectors */ offset = offset >> 9; offset_end = (offset_end + 511) >> 9; - bdrv_write(pfl->bs, offset, pfl->storage + (offset << 9), - offset_end - offset); + blk_write(pfl->blk, offset, pfl->storage + (offset << 9), + offset_end - offset); } } @@ -618,9 +618,9 @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp) vmstate_register_ram(&pfl->orig_mem, DEVICE(pfl)); pfl->storage = memory_region_get_ram_ptr(&pfl->orig_mem); pfl->chip_len = chip_len; - if (pfl->bs) { + if (pfl->blk) { /* read the initial flash content */ - ret = bdrv_read(pfl->bs, 0, pfl->storage, chip_len >> 9); + ret = blk_read(pfl->blk, 0, pfl->storage, chip_len >> 9); if (ret < 0) { vmstate_unregister_ram(&pfl->orig_mem, DEVICE(pfl)); error_setg(errp, "failed to read the initial flash content"); @@ -632,8 +632,8 @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp) pfl->rom_mode = 1; sysbus_init_mmio(SYS_BUS_DEVICE(dev), &pfl->mem); - if (pfl->bs) { - pfl->ro = bdrv_is_read_only(pfl->bs); + if (pfl->blk) { + pfl->ro = blk_is_read_only(pfl->blk); } else { pfl->ro = 0; } @@ -722,7 +722,7 @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp) } static Property pflash_cfi02_properties[] = { - DEFINE_PROP_DRIVE("drive", struct pflash_t, bs), + DEFINE_PROP_DRIVE("drive", struct pflash_t, blk), DEFINE_PROP_UINT32("num-blocks", struct pflash_t, nb_blocs, 0), DEFINE_PROP_UINT32("sector-length", struct pflash_t, sector_len, 0), DEFINE_PROP_UINT8("width", struct pflash_t, width, 0), @@ -763,7 +763,7 @@ type_init(pflash_cfi02_register_types) pflash_t *pflash_cfi02_register(hwaddr base, DeviceState *qdev, const char *name, hwaddr size, - BlockDriverState *bs, uint32_t sector_len, + BlockBackend *blk, uint32_t sector_len, int nb_blocs, int nb_mappings, int width, uint16_t id0, uint16_t id1, uint16_t id2, uint16_t id3, @@ -772,7 +772,7 @@ pflash_t *pflash_cfi02_register(hwaddr base, { DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH02); - if (bs && qdev_prop_set_drive(dev, "drive", bs)) { + if (blk && qdev_prop_set_drive(dev, "drive", blk)) { abort(); } qdev_prop_set_uint32(dev, "num-blocks", nb_blocs); diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c index 4dc794c2fe..b19b102b42 100644 --- a/hw/block/virtio-blk.c +++ b/hw/block/virtio-blk.c @@ -16,6 +16,7 @@ #include "qemu/error-report.h" #include "trace.h" #include "hw/block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/virtio/virtio-blk.h" #include "dataplane/virtio-blk.h" @@ -64,7 +65,8 @@ static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status) static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error, bool is_read) { - BlockErrorAction action = bdrv_get_error_action(req->dev->bs, is_read, error); + BlockErrorAction action = blk_get_error_action(req->dev->blk, + is_read, error); VirtIOBlock *s = req->dev; if (action == BLOCK_ERROR_ACTION_STOP) { @@ -72,11 +74,11 @@ static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error, s->rq = req; } else if (action == BLOCK_ERROR_ACTION_REPORT) { virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR); - block_acct_done(bdrv_get_stats(s->bs), &req->acct); + block_acct_done(blk_get_stats(s->blk), &req->acct); virtio_blk_free_request(req); } - bdrv_error_action(s->bs, action, is_read, error); + blk_error_action(s->blk, action, is_read, error); return action != BLOCK_ERROR_ACTION_IGNORE; } @@ -94,7 +96,7 @@ static void virtio_blk_rw_complete(void *opaque, int ret) } virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); - block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct); + block_acct_done(blk_get_stats(req->dev->blk), &req->acct); virtio_blk_free_request(req); } @@ -109,7 +111,7 @@ static void virtio_blk_flush_complete(void *opaque, int ret) } virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); - block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct); + block_acct_done(blk_get_stats(req->dev->blk), &req->acct); virtio_blk_free_request(req); } @@ -209,7 +211,7 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk, hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base; hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len; - status = bdrv_ioctl(blk->bs, SG_IO, &hdr); + status = blk_ioctl(blk->blk, SG_IO, &hdr); if (status) { status = VIRTIO_BLK_S_UNSUPP; goto fail; @@ -255,7 +257,7 @@ static void virtio_blk_handle_scsi(VirtIOBlockReq *req) virtio_blk_free_request(req); } -void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb) +void virtio_submit_multiwrite(BlockBackend *blk, MultiReqBuffer *mrb) { int i, ret; @@ -263,7 +265,7 @@ void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb) return; } - ret = bdrv_aio_multiwrite(bs, mrb->blkreq, mrb->num_writes); + ret = blk_aio_multiwrite(blk, mrb->blkreq, mrb->num_writes); if (ret != 0) { for (i = 0; i < mrb->num_writes; i++) { if (mrb->blkreq[i].error) { @@ -277,14 +279,14 @@ void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb) static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb) { - block_acct_start(bdrv_get_stats(req->dev->bs), &req->acct, 0, + block_acct_start(blk_get_stats(req->dev->blk), &req->acct, 0, BLOCK_ACCT_FLUSH); /* * Make sure all outstanding writes are posted to the backing device. */ - virtio_submit_multiwrite(req->dev->bs, mrb); - bdrv_aio_flush(req->dev->bs, virtio_blk_flush_complete, req); + virtio_submit_multiwrite(req->dev->blk, mrb); + blk_aio_flush(req->dev->blk, virtio_blk_flush_complete, req); } static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, @@ -299,7 +301,7 @@ static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, if (size % dev->conf.conf.logical_block_size) { return false; } - bdrv_get_geometry(dev->bs, &total_sectors); + blk_get_geometry(dev->blk, &total_sectors); if (sector > total_sectors || nb_sectors > total_sectors - sector) { return false; } @@ -321,11 +323,11 @@ static void virtio_blk_handle_write(VirtIOBlockReq *req, MultiReqBuffer *mrb) return; } - block_acct_start(bdrv_get_stats(req->dev->bs), &req->acct, req->qiov.size, + block_acct_start(blk_get_stats(req->dev->blk), &req->acct, req->qiov.size, BLOCK_ACCT_WRITE); if (mrb->num_writes == 32) { - virtio_submit_multiwrite(req->dev->bs, mrb); + virtio_submit_multiwrite(req->dev->blk, mrb); } blkreq = &mrb->blkreq[mrb->num_writes]; @@ -353,11 +355,11 @@ static void virtio_blk_handle_read(VirtIOBlockReq *req) return; } - block_acct_start(bdrv_get_stats(req->dev->bs), &req->acct, req->qiov.size, + block_acct_start(blk_get_stats(req->dev->blk), &req->acct, req->qiov.size, BLOCK_ACCT_READ); - bdrv_aio_readv(req->dev->bs, sector, &req->qiov, - req->qiov.size / BDRV_SECTOR_SIZE, - virtio_blk_rw_complete, req); + blk_aio_readv(req->dev->blk, sector, &req->qiov, + req->qiov.size / BDRV_SECTOR_SIZE, + virtio_blk_rw_complete, req); } void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb) @@ -445,7 +447,7 @@ static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq) virtio_blk_handle_request(req, &mrb); } - virtio_submit_multiwrite(s->bs, &mrb); + virtio_submit_multiwrite(s->blk, &mrb); /* * FIXME: Want to check for completions before returning to guest mode, @@ -473,7 +475,7 @@ static void virtio_blk_dma_restart_bh(void *opaque) req = next; } - virtio_submit_multiwrite(s->bs, &mrb); + virtio_submit_multiwrite(s->blk, &mrb); } static void virtio_blk_dma_restart_cb(void *opaque, int running, @@ -486,7 +488,7 @@ static void virtio_blk_dma_restart_cb(void *opaque, int running, } if (!s->bh) { - s->bh = aio_bh_new(bdrv_get_aio_context(s->conf.conf.bs), + s->bh = aio_bh_new(blk_get_aio_context(s->conf.conf.blk), virtio_blk_dma_restart_bh, s); qemu_bh_schedule(s->bh); } @@ -504,8 +506,8 @@ static void virtio_blk_reset(VirtIODevice *vdev) * This should cancel pending requests, but can't do nicely until there * are per-device request lists. */ - bdrv_drain_all(); - bdrv_set_enable_write_cache(s->bs, s->original_wce); + blk_drain_all(); + blk_set_enable_write_cache(s->blk, s->original_wce); } /* coalesce internal state, copy to pci i/o region 0 @@ -518,7 +520,7 @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) uint64_t capacity; int blk_size = conf->logical_block_size; - bdrv_get_geometry(s->bs, &capacity); + blk_get_geometry(s->blk, &capacity); memset(&blkcfg, 0, sizeof(blkcfg)); virtio_stq_p(vdev, &blkcfg.capacity, capacity); virtio_stl_p(vdev, &blkcfg.seg_max, 128 - 2); @@ -538,7 +540,7 @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) * divided by 512 - instead it is the amount of blk_size blocks * per track (cylinder). */ - if (bdrv_getlength(s->bs) / conf->heads / conf->secs % blk_size) { + if (blk_getlength(s->blk) / conf->heads / conf->secs % blk_size) { blkcfg.sectors = conf->secs & ~s->sector_mask; } else { blkcfg.sectors = conf->secs; @@ -546,7 +548,7 @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) blkcfg.size_max = 0; blkcfg.physical_block_exp = get_physical_block_exp(conf); blkcfg.alignment_offset = 0; - blkcfg.wce = bdrv_enable_write_cache(s->bs); + blkcfg.wce = blk_enable_write_cache(s->blk); memcpy(config, &blkcfg, sizeof(struct virtio_blk_config)); } @@ -557,9 +559,9 @@ static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config) memcpy(&blkcfg, config, sizeof(blkcfg)); - aio_context_acquire(bdrv_get_aio_context(s->bs)); - bdrv_set_enable_write_cache(s->bs, blkcfg.wce != 0); - aio_context_release(bdrv_get_aio_context(s->bs)); + aio_context_acquire(blk_get_aio_context(s->blk)); + blk_set_enable_write_cache(s->blk, blkcfg.wce != 0); + aio_context_release(blk_get_aio_context(s->blk)); } static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features) @@ -575,11 +577,12 @@ static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features) if (s->conf.config_wce) { features |= (1 << VIRTIO_BLK_F_CONFIG_WCE); } - if (bdrv_enable_write_cache(s->bs)) + if (blk_enable_write_cache(s->blk)) { features |= (1 << VIRTIO_BLK_F_WCE); - - if (bdrv_is_read_only(s->bs)) + } + if (blk_is_read_only(s->blk)) { features |= 1 << VIRTIO_BLK_F_RO; + } return features; } @@ -613,13 +616,13 @@ static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status) * Guest writes 1 to the WCE configuration field (writeback mode) * Guest sets DRIVER_OK bit in status field * - * s->bs would erroneously be placed in writethrough mode. + * s->blk would erroneously be placed in writethrough mode. */ if (!(features & (1 << VIRTIO_BLK_F_CONFIG_WCE))) { - aio_context_acquire(bdrv_get_aio_context(s->bs)); - bdrv_set_enable_write_cache(s->bs, - !!(features & (1 << VIRTIO_BLK_F_WCE))); - aio_context_release(bdrv_get_aio_context(s->bs)); + aio_context_acquire(blk_get_aio_context(s->blk)); + blk_set_enable_write_cache(s->blk, + !!(features & (1 << VIRTIO_BLK_F_WCE))); + aio_context_release(blk_get_aio_context(s->blk)); } } @@ -708,7 +711,7 @@ static void virtio_blk_migration_state_changed(Notifier *notifier, void *data) if (s->dataplane) { return; } - bdrv_drain_all(); /* complete in-flight non-dataplane requests */ + blk_drain_all(); /* complete in-flight non-dataplane requests */ virtio_blk_data_plane_create(VIRTIO_DEVICE(s), &s->conf, &s->dataplane, &err); if (err != NULL) { @@ -726,17 +729,17 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) Error *err = NULL; static int virtio_blk_id; - if (!conf->conf.bs) { + if (!conf->conf.blk) { error_setg(errp, "drive property not set"); return; } - if (!bdrv_is_inserted(conf->conf.bs)) { + if (!blk_is_inserted(conf->conf.blk)) { error_setg(errp, "Device needs media, but drive is empty"); return; } blkconf_serial(&conf->conf, &conf->serial); - s->original_wce = bdrv_enable_write_cache(conf->conf.bs); + s->original_wce = blk_enable_write_cache(conf->conf.blk); blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, &err); if (err) { error_propagate(errp, err); @@ -746,7 +749,7 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, sizeof(struct virtio_blk_config)); - s->bs = conf->conf.bs; + s->blk = conf->conf.blk; s->rq = NULL; s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1; @@ -764,10 +767,10 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s); register_savevm(dev, "virtio-blk", virtio_blk_id++, 2, virtio_blk_save, virtio_blk_load, s); - bdrv_set_dev_ops(s->bs, &virtio_block_ops, s); - bdrv_set_guest_block_size(s->bs, s->conf.conf.logical_block_size); + blk_set_dev_ops(s->blk, &virtio_block_ops, s); + blk_set_guest_block_size(s->blk, s->conf.conf.logical_block_size); - bdrv_iostatus_enable(s->bs); + blk_iostatus_enable(s->blk); } static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp) @@ -780,7 +783,7 @@ static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp) s->dataplane = NULL; qemu_del_vm_change_state_handler(s->change); unregister_savevm(dev, "virtio-blk", s); - blockdev_mark_auto_del(s->bs); + blockdev_mark_auto_del(s->blk); virtio_cleanup(vdev); } diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index ca4f855c5d..231e9a7392 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -123,7 +123,7 @@ struct XenBlkDev { /* qemu block driver */ DriveInfo *dinfo; - BlockDriverState *bs; + BlockBackend *blk; QEMUBH *bh; }; @@ -480,7 +480,7 @@ static void qemu_aio_complete(void *opaque, int ret) if (ioreq->postsync) { ioreq->postsync = 0; ioreq->aio_inflight++; - bdrv_aio_flush(ioreq->blkdev->bs, qemu_aio_complete, ioreq); + blk_aio_flush(ioreq->blkdev->blk, qemu_aio_complete, ioreq); return; } @@ -494,7 +494,7 @@ static void qemu_aio_complete(void *opaque, int ret) break; } case BLKIF_OP_READ: - block_acct_done(bdrv_get_stats(ioreq->blkdev->bs), &ioreq->acct); + block_acct_done(blk_get_stats(ioreq->blkdev->blk), &ioreq->acct); break; case BLKIF_OP_DISCARD: default: @@ -513,18 +513,18 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) ioreq->aio_inflight++; if (ioreq->presync) { - bdrv_aio_flush(ioreq->blkdev->bs, qemu_aio_complete, ioreq); + blk_aio_flush(ioreq->blkdev->blk, qemu_aio_complete, ioreq); return 0; } switch (ioreq->req.operation) { case BLKIF_OP_READ: - block_acct_start(bdrv_get_stats(blkdev->bs), &ioreq->acct, + block_acct_start(blk_get_stats(blkdev->blk), &ioreq->acct, ioreq->v.size, BLOCK_ACCT_READ); ioreq->aio_inflight++; - bdrv_aio_readv(blkdev->bs, ioreq->start / BLOCK_SIZE, - &ioreq->v, ioreq->v.size / BLOCK_SIZE, - qemu_aio_complete, ioreq); + blk_aio_readv(blkdev->blk, ioreq->start / BLOCK_SIZE, + &ioreq->v, ioreq->v.size / BLOCK_SIZE, + qemu_aio_complete, ioreq); break; case BLKIF_OP_WRITE: case BLKIF_OP_FLUSH_DISKCACHE: @@ -532,18 +532,18 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) break; } - block_acct_start(bdrv_get_stats(blkdev->bs), &ioreq->acct, + block_acct_start(blk_get_stats(blkdev->blk), &ioreq->acct, ioreq->v.size, BLOCK_ACCT_WRITE); ioreq->aio_inflight++; - bdrv_aio_writev(blkdev->bs, ioreq->start / BLOCK_SIZE, - &ioreq->v, ioreq->v.size / BLOCK_SIZE, - qemu_aio_complete, ioreq); + blk_aio_writev(blkdev->blk, ioreq->start / BLOCK_SIZE, + &ioreq->v, ioreq->v.size / BLOCK_SIZE, + qemu_aio_complete, ioreq); break; case BLKIF_OP_DISCARD: { struct blkif_request_discard *discard_req = (void *)&ioreq->req; ioreq->aio_inflight++; - bdrv_aio_discard(blkdev->bs, + blk_aio_discard(blkdev->blk, discard_req->sector_number, discard_req->nr_sectors, qemu_aio_complete, ioreq); break; @@ -857,6 +857,7 @@ static int blk_connect(struct XenDevice *xendev) Error *local_err = NULL; BlockBackend *blk; BlockDriver *drv; + BlockDriverState *bs; /* setup via xenbus -> create new block driver instance */ xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); @@ -864,39 +865,39 @@ static int blk_connect(struct XenDevice *xendev) if (!blk) { return -1; } - blkdev->bs = blk_bs(blk); + blkdev->blk = blk; + bs = blk_bs(blk); drv = bdrv_find_whitelisted_format(blkdev->fileproto, readonly); - if (bdrv_open(&blkdev->bs, blkdev->filename, NULL, NULL, qflags, + if (bdrv_open(&bs, blkdev->filename, NULL, NULL, qflags, drv, &local_err) != 0) { xen_be_printf(&blkdev->xendev, 0, "error: %s\n", error_get_pretty(local_err)); error_free(local_err); blk_unref(blk); - blkdev->bs = NULL; + blkdev->blk = NULL; return -1; } + assert(bs == blk_bs(blk)); } else { /* setup via qemu cmdline -> already setup for us */ xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n"); - blkdev->bs = blk_bs(blk_by_legacy_dinfo(blkdev->dinfo)); - if (bdrv_is_read_only(blkdev->bs) && !readonly) { + blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo); + if (blk_is_read_only(blkdev->blk) && !readonly) { xen_be_printf(&blkdev->xendev, 0, "Unexpected read-only drive"); - blkdev->bs = NULL; + blkdev->blk = NULL; return -1; } - /* blkdev->bs is not create by us, we get a reference - * so we can bdrv_unref() unconditionally */ - /* Except we don't bdrv_unref() anymore, we blk_unref(). - * Conditionally, because we can't easily blk_ref() here. - * TODO Clean this up! */ + /* blkdev->blk is not create by us, we get a reference + * so we can blk_unref() unconditionally */ + blk_ref(blkdev->blk); } - bdrv_attach_dev_nofail(blkdev->bs, blkdev); - blkdev->file_size = bdrv_getlength(blkdev->bs); + blk_attach_dev_nofail(blkdev->blk, blkdev); + blkdev->file_size = blk_getlength(blkdev->blk); if (blkdev->file_size < 0) { - xen_be_printf(&blkdev->xendev, 1, "bdrv_getlength: %d (%s) | drv %s\n", + xen_be_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n", (int)blkdev->file_size, strerror(-blkdev->file_size), - bdrv_get_format_name(blkdev->bs) ?: "-"); + bdrv_get_format_name(blk_bs(blkdev->blk)) ?: "-"); blkdev->file_size = 0; } @@ -987,12 +988,10 @@ static void blk_disconnect(struct XenDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); - if (blkdev->bs) { - bdrv_detach_dev(blkdev->bs, blkdev); - if (!blkdev->dinfo) { - blk_unref(blk_by_name(blkdev->dev)); - } - blkdev->bs = NULL; + if (blkdev->blk) { + blk_detach_dev(blkdev->blk, blkdev); + blk_unref(blkdev->blk); + blkdev->blk = NULL; } xen_be_unbind_evtchn(&blkdev->xendev); @@ -1008,7 +1007,7 @@ static int blk_free(struct XenDevice *xendev) struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct ioreq *ioreq; - if (blkdev->bs || blkdev->sring) { + if (blkdev->blk || blkdev->sring) { blk_disconnect(xendev); } diff --git a/hw/core/qdev-properties-system.c b/hw/core/qdev-properties-system.c index f2bd954be5..65901ef10e 100644 --- a/hw/core/qdev-properties-system.c +++ b/hw/core/qdev-properties-system.c @@ -13,6 +13,7 @@ #include "net/net.h" #include "hw/qdev.h" #include "qapi/qmp/qerror.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/block/block.h" #include "net/hub.h" @@ -68,16 +69,16 @@ static void set_pointer(Object *obj, Visitor *v, Property *prop, static int parse_drive(DeviceState *dev, const char *str, void **ptr) { - BlockDriverState *bs; + BlockBackend *blk; - bs = bdrv_find(str); - if (bs == NULL) { + blk = blk_by_name(str); + if (!blk) { return -ENOENT; } - if (bdrv_attach_dev(bs, dev) < 0) { + if (blk_attach_dev(blk, dev) < 0) { return -EEXIST; } - *ptr = bs; + *ptr = blk; return 0; } @@ -85,17 +86,17 @@ static void release_drive(Object *obj, const char *name, void *opaque) { DeviceState *dev = DEVICE(obj); Property *prop = opaque; - BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop); + BlockBackend **ptr = qdev_get_prop_ptr(dev, prop); if (*ptr) { - bdrv_detach_dev(*ptr, dev); + blk_detach_dev(*ptr, dev); blockdev_auto_del(*ptr); } } static char *print_drive(void *ptr) { - return g_strdup(bdrv_get_device_name(ptr)); + return g_strdup(blk_name(ptr)); } static void get_drive(Object *obj, Visitor *v, void *opaque, @@ -335,12 +336,11 @@ PropertyInfo qdev_prop_vlan = { }; int qdev_prop_set_drive(DeviceState *dev, const char *name, - BlockDriverState *value) + BlockBackend *value) { Error *err = NULL; - const char *bdrv_name = value ? bdrv_get_device_name(value) : ""; - object_property_set_str(OBJECT(dev), bdrv_name, - name, &err); + object_property_set_str(OBJECT(dev), + value ? blk_name(value) : "", name, &err); if (err) { qerror_report_err(err); error_free(err); @@ -350,7 +350,7 @@ int qdev_prop_set_drive(DeviceState *dev, const char *name, } void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, - BlockDriverState *value) + BlockBackend *value) { if (qdev_prop_set_drive(dev, name, value) < 0) { exit(1); diff --git a/hw/core/qdev-properties.c b/hw/core/qdev-properties.c index 2ed995f2b7..2e47f70eb4 100644 --- a/hw/core/qdev-properties.c +++ b/hw/core/qdev-properties.c @@ -1,7 +1,7 @@ #include "net/net.h" #include "hw/qdev.h" #include "qapi/qmp/qerror.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/block/block.h" #include "net/hub.h" #include "qapi/visitor.h" diff --git a/hw/cris/axis_dev88.c b/hw/cris/axis_dev88.c index 417702aced..047919686d 100644 --- a/hw/cris/axis_dev88.c +++ b/hw/cris/axis_dev88.c @@ -31,7 +31,6 @@ #include "elf.h" #include "boot.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" @@ -285,7 +284,7 @@ void axisdev88_init(MachineState *machine) /* Attach a NAND flash to CS1. */ nand = drive_get(IF_MTD, 0, 0); - nand_state.nand = nand_init(nand ? blk_bs(blk_by_legacy_dinfo(nand)) : NULL, + nand_state.nand = nand_init(nand ? blk_by_legacy_dinfo(nand) : NULL, NAND_MFR_STMICRO, 0x39); memory_region_init_io(&nand_state.iomem, NULL, &nand_ops, &nand_state, "nand", 0x05000000); diff --git a/hw/display/tc6393xb.c b/hw/display/tc6393xb.c index 576f319d12..4306adc959 100644 --- a/hw/display/tc6393xb.c +++ b/hw/display/tc6393xb.c @@ -577,7 +577,7 @@ TC6393xbState *tc6393xb_init(MemoryRegion *sysmem, uint32_t base, qemu_irq irq) s->sub_irqs = qemu_allocate_irqs(tc6393xb_sub_irq, s, TC6393XB_NR_IRQS); nand = drive_get(IF_MTD, 0, 0); - s->flash = nand_init(nand ? blk_bs(blk_by_legacy_dinfo(nand)) : NULL, + s->flash = nand_init(nand ? blk_by_legacy_dinfo(nand) : NULL, NAND_MFR_TOSHIBA, 0x76); memory_region_init_io(&s->iomem, NULL, &tc6393xb_ops, s, "tc6393xb", 0x10000); diff --git a/hw/i386/pc.c b/hw/i386/pc.c index d045e8b454..61aba9fc54 100644 --- a/hw/i386/pc.c +++ b/hw/i386/pc.c @@ -44,7 +44,7 @@ #include "sysemu/kvm.h" #include "kvm_i386.h" #include "hw/xen/xen.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/block/block.h" #include "ui/qemu-spice.h" #include "exec/memory.h" diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c index 43846339bc..91a20cb8f4 100644 --- a/hw/i386/pc_piix.c +++ b/hw/i386/pc_piix.c @@ -41,7 +41,7 @@ #include "hw/sysbus.h" #include "hw/cpu/icc_bus.h" #include "sysemu/arch_init.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/i2c/smbus.h" #include "hw/xen/xen.h" #include "exec/memory.h" diff --git a/hw/i386/pc_sysfw.c b/hw/i386/pc_sysfw.c index 9bf22b6a47..75913c5b2f 100644 --- a/hw/i386/pc_sysfw.c +++ b/hw/i386/pc_sysfw.c @@ -24,7 +24,6 @@ */ #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "qemu/error-report.h" #include "hw/sysbus.h" #include "hw/hw.h" @@ -104,7 +103,7 @@ static void pc_system_flash_init(MemoryRegion *rom_memory) { int unit; DriveInfo *pflash_drv; - BlockDriverState *bdrv; + BlockBackend *blk; int64_t size; char *fatal_errmsg = NULL; hwaddr phys_addr = 0x100000000ULL; @@ -120,8 +119,8 @@ static void pc_system_flash_init(MemoryRegion *rom_memory) (unit < FLASH_MAP_UNIT_MAX && (pflash_drv = drive_get(IF_PFLASH, 0, unit)) != NULL); ++unit) { - bdrv = blk_bs(blk_by_legacy_dinfo(pflash_drv)); - size = bdrv_getlength(bdrv); + blk = blk_by_legacy_dinfo(pflash_drv); + size = blk_getlength(blk); if (size < 0) { fatal_errmsg = g_strdup_printf("failed to get backing file size"); } else if (size == 0) { @@ -157,7 +156,7 @@ static void pc_system_flash_init(MemoryRegion *rom_memory) /* pflash_cfi01_register() creates a deep copy of the name */ snprintf(name, sizeof name, "system.flash%d", unit); system_flash = pflash_cfi01_register(phys_addr, NULL /* qdev */, name, - size, bdrv, sector_size, + size, blk, sector_size, size >> sector_bits, 1 /* width */, 0x0000 /* id0 */, diff --git a/hw/i386/xen/xen_platform.c b/hw/i386/xen/xen_platform.c index 8bb18b403a..28b324a6f4 100644 --- a/hw/i386/xen/xen_platform.c +++ b/hw/i386/xen/xen_platform.c @@ -34,6 +34,7 @@ #include "hw/xen/xen_backend.h" #include "trace.h" #include "exec/address-spaces.h" +#include "sysemu/block-backend.h" #include @@ -132,8 +133,8 @@ static void platform_fixed_ioport_writew(void *opaque, uint32_t addr, uint32_t v devices, and bit 2 the non-primary-master IDE devices. */ if (val & UNPLUG_ALL_IDE_DISKS) { DPRINTF("unplug disks\n"); - bdrv_drain_all(); - bdrv_flush_all(); + blk_drain_all(); + blk_flush_all(); pci_unplug_disks(pci_dev->bus); } if (val & UNPLUG_ALL_NICS) { diff --git a/hw/ide/ahci.c b/hw/ide/ahci.c index f3d4e70e24..70958e3655 100644 --- a/hw/ide/ahci.c +++ b/hw/ide/ahci.c @@ -28,6 +28,7 @@ #include #include "monitor/monitor.h" +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include "internal.h" #include @@ -84,7 +85,7 @@ static uint32_t ahci_port_read(AHCIState *s, int port, int offset) val = pr->sig; break; case PORT_SCR_STAT: - if (s->dev[port].port.ifs[0].bs) { + if (s->dev[port].port.ifs[0].blk) { val = SATA_SCR_SSTATUS_DET_DEV_PRESENT_PHY_UP | SATA_SCR_SSTATUS_SPD_GEN1 | SATA_SCR_SSTATUS_IPM_ACTIVE; } else { @@ -501,7 +502,7 @@ static void ahci_reset_port(AHCIState *s, int port) d->init_d2h_sent = false; ide_state = &s->dev[port].port.ifs[0]; - if (!ide_state->bs) { + if (!ide_state->blk) { return; } @@ -513,11 +514,11 @@ static void ahci_reset_port(AHCIState *s, int port) } if (ncq_tfs->aiocb) { - bdrv_aio_cancel(ncq_tfs->aiocb); + blk_aio_cancel(ncq_tfs->aiocb); ncq_tfs->aiocb = NULL; } - /* Maybe we just finished the request thanks to bdrv_aio_cancel() */ + /* Maybe we just finished the request thanks to blk_aio_cancel() */ if (!ncq_tfs->used) { continue; } @@ -527,7 +528,7 @@ static void ahci_reset_port(AHCIState *s, int port) } s->dev[port].port_state = STATE_RUN; - if (!ide_state->bs) { + if (!ide_state->blk) { pr->sig = 0; ide_state->status = SEEK_STAT | WRERR_STAT; } else if (ide_state->drive_kind == IDE_CD) { @@ -826,7 +827,7 @@ static void ncq_cb(void *opaque, int ret) DPRINTF(ncq_tfs->drive->port_no, "NCQ transfer tag %d finished\n", ncq_tfs->tag); - block_acct_done(bdrv_get_stats(ncq_tfs->drive->port.ifs[0].bs), + block_acct_done(blk_get_stats(ncq_tfs->drive->port.ifs[0].blk), &ncq_tfs->acct); qemu_sglist_destroy(&ncq_tfs->sglist); ncq_tfs->used = 0; @@ -877,11 +878,11 @@ static void process_ncq_command(AHCIState *s, int port, uint8_t *cmd_fis, DPRINTF(port, "tag %d aio read %"PRId64"\n", ncq_tfs->tag, ncq_tfs->lba); - dma_acct_start(ncq_tfs->drive->port.ifs[0].bs, &ncq_tfs->acct, + dma_acct_start(ncq_tfs->drive->port.ifs[0].blk, &ncq_tfs->acct, &ncq_tfs->sglist, BLOCK_ACCT_READ); - ncq_tfs->aiocb = dma_bdrv_read(ncq_tfs->drive->port.ifs[0].bs, - &ncq_tfs->sglist, ncq_tfs->lba, - ncq_cb, ncq_tfs); + ncq_tfs->aiocb = dma_blk_read(ncq_tfs->drive->port.ifs[0].blk, + &ncq_tfs->sglist, ncq_tfs->lba, + ncq_cb, ncq_tfs); break; case WRITE_FPDMA_QUEUED: DPRINTF(port, "NCQ writing %d sectors to LBA %"PRId64", tag %d\n", @@ -890,11 +891,11 @@ static void process_ncq_command(AHCIState *s, int port, uint8_t *cmd_fis, DPRINTF(port, "tag %d aio write %"PRId64"\n", ncq_tfs->tag, ncq_tfs->lba); - dma_acct_start(ncq_tfs->drive->port.ifs[0].bs, &ncq_tfs->acct, + dma_acct_start(ncq_tfs->drive->port.ifs[0].blk, &ncq_tfs->acct, &ncq_tfs->sglist, BLOCK_ACCT_WRITE); - ncq_tfs->aiocb = dma_bdrv_write(ncq_tfs->drive->port.ifs[0].bs, - &ncq_tfs->sglist, ncq_tfs->lba, - ncq_cb, ncq_tfs); + ncq_tfs->aiocb = dma_blk_write(ncq_tfs->drive->port.ifs[0].blk, + &ncq_tfs->sglist, ncq_tfs->lba, + ncq_cb, ncq_tfs); break; default: DPRINTF(port, "error: tried to process non-NCQ command as NCQ\n"); @@ -943,7 +944,7 @@ static int handle_cmd(AHCIState *s, int port, int slot) /* The device we are working for */ ide_state = &s->dev[port].port.ifs[0]; - if (!ide_state->bs) { + if (!ide_state->blk) { DPRINTF(port, "error: guest accessed unused port"); goto out; } diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c index 10218dfa3a..c63b7e556e 100644 --- a/hw/ide/atapi.c +++ b/hw/ide/atapi.c @@ -25,6 +25,7 @@ #include "hw/ide/internal.h" #include "hw/scsi/scsi.h" +#include "sysemu/block-backend.h" static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret); @@ -110,16 +111,16 @@ static int cd_read_sector(IDEState *s, int lba, uint8_t *buf, int sector_size) switch(sector_size) { case 2048: - block_acct_start(bdrv_get_stats(s->bs), &s->acct, + block_acct_start(blk_get_stats(s->blk), &s->acct, 4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); - ret = bdrv_read(s->bs, (int64_t)lba << 2, buf, 4); - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + ret = blk_read(s->blk, (int64_t)lba << 2, buf, 4); + block_acct_done(blk_get_stats(s->blk), &s->acct); break; case 2352: - block_acct_start(bdrv_get_stats(s->bs), &s->acct, + block_acct_start(blk_get_stats(s->blk), &s->acct, 4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); - ret = bdrv_read(s->bs, (int64_t)lba << 2, buf + 16, 4); - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + ret = blk_read(s->blk, (int64_t)lba << 2, buf + 16, 4); + block_acct_done(blk_get_stats(s->blk), &s->acct); if (ret < 0) return ret; cd_data_to_raw(buf, lba); @@ -254,7 +255,7 @@ static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size) s->io_buffer_index = 0; if (s->atapi_dma) { - block_acct_start(bdrv_get_stats(s->bs), &s->acct, size, + block_acct_start(blk_get_stats(s->blk), &s->acct, size, BLOCK_ACCT_READ); s->status = READY_STAT | SEEK_STAT | DRQ_STAT; ide_start_dma(s, ide_atapi_cmd_read_dma_cb); @@ -350,13 +351,13 @@ static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret) s->bus->dma->iov.iov_len = n * 4 * 512; qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1); - s->bus->dma->aiocb = bdrv_aio_readv(s->bs, (int64_t)s->lba << 2, + s->bus->dma->aiocb = blk_aio_readv(s->blk, (int64_t)s->lba << 2, &s->bus->dma->qiov, n * 4, ide_atapi_cmd_read_dma_cb, s); return; eot: - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + block_acct_done(blk_get_stats(s->blk), &s->acct); ide_set_inactive(s, false); } @@ -371,7 +372,7 @@ static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors, s->io_buffer_size = 0; s->cd_sector_size = sector_size; - block_acct_start(bdrv_get_stats(s->bs), &s->acct, s->packet_transfer_size, + block_acct_start(blk_get_stats(s->blk), &s->acct, s->packet_transfer_size, BLOCK_ACCT_READ); /* XXX: check if BUSY_STAT should be set */ @@ -504,7 +505,7 @@ static unsigned int event_status_media(IDEState *s, media_status = 0; if (s->tray_open) { media_status = MS_TRAY_OPEN; - } else if (bdrv_is_inserted(s->bs)) { + } else if (blk_is_inserted(s->blk)) { media_status = MS_MEDIA_PRESENT; } @@ -800,7 +801,7 @@ static void cmd_test_unit_ready(IDEState *s, uint8_t *buf) static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf) { s->tray_locked = buf[4] & 1; - bdrv_lock_medium(s->bs, buf[4] & 1); + blk_lock_medium(s->blk, buf[4] & 1); ide_atapi_cmd_ok(s); } @@ -884,14 +885,14 @@ static void cmd_start_stop_unit(IDEState *s, uint8_t* buf) if (loej) { if (!start && !s->tray_open && s->tray_locked) { - sense = bdrv_is_inserted(s->bs) + sense = blk_is_inserted(s->blk) ? NOT_READY : ILLEGAL_REQUEST; ide_atapi_cmd_error(s, sense, ASC_MEDIA_REMOVAL_PREVENTED); return; } if (s->tray_open != !start) { - bdrv_eject(s->bs, !start); + blk_eject(s->blk, !start); s->tray_open = !start; } } @@ -1125,7 +1126,7 @@ void ide_atapi_cmd(IDEState *s) * states rely on this behavior. */ if (!(atapi_cmd_table[s->io_buffer[0]].flags & ALLOW_UA) && - !s->tray_open && bdrv_is_inserted(s->bs) && s->cdrom_changed) { + !s->tray_open && blk_is_inserted(s->blk) && s->cdrom_changed) { if (s->cdrom_changed == 1) { ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT); @@ -1140,7 +1141,7 @@ void ide_atapi_cmd(IDEState *s) /* Report a Not Ready condition if appropriate for the command */ if ((atapi_cmd_table[s->io_buffer[0]].flags & CHECK_READY) && - (!media_present(s) || !bdrv_is_inserted(s->bs))) + (!media_present(s) || !blk_is_inserted(s->blk))) { ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT); return; diff --git a/hw/ide/cmd646.c b/hw/ide/cmd646.c index 91048f202f..c8b0322155 100644 --- a/hw/ide/cmd646.c +++ b/hw/ide/cmd646.c @@ -26,7 +26,7 @@ #include #include #include -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/sysemu.h" #include "sysemu/dma.h" diff --git a/hw/ide/core.c b/hw/ide/core.c index 0505c45685..a5c4698368 100644 --- a/hw/ide/core.c +++ b/hw/ide/core.c @@ -31,7 +31,7 @@ #include "sysemu/sysemu.h" #include "sysemu/dma.h" #include "hw/block/block.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include @@ -158,10 +158,11 @@ static void ide_identify(IDEState *s) put_le16(p + 84, (1 << 14) | 0); } /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */ - if (bdrv_enable_write_cache(s->bs)) - put_le16(p + 85, (1 << 14) | (1 << 5) | 1); - else - put_le16(p + 85, (1 << 14) | 1); + if (blk_enable_write_cache(s->blk)) { + put_le16(p + 85, (1 << 14) | (1 << 5) | 1); + } else { + put_le16(p + 85, (1 << 14) | 1); + } /* 13=flush_cache_ext,12=flush_cache,10=lba48 */ put_le16(p + 86, (1 << 13) | (1 <<12) | (1 << 10)); /* 14=set to 1, 8=has WWN, 1=SMART self test, 0=SMART error logging */ @@ -350,7 +351,7 @@ static void ide_set_signature(IDEState *s) if (s->drive_kind == IDE_CD) { s->lcyl = 0x14; s->hcyl = 0xeb; - } else if (s->bs) { + } else if (s->blk) { s->lcyl = 0; s->hcyl = 0; } else { @@ -379,7 +380,7 @@ static void trim_aio_cancel(BlockAIOCB *acb) iocb->ret = -ECANCELED; if (iocb->aiocb) { - bdrv_aio_cancel_async(iocb->aiocb); + blk_aio_cancel_async(iocb->aiocb); iocb->aiocb = NULL; } } @@ -438,13 +439,13 @@ static void ide_issue_trim_cb(void *opaque, int ret) } } -BlockAIOCB *ide_issue_trim(BlockDriverState *bs, +BlockAIOCB *ide_issue_trim(BlockBackend *blk, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockCompletionFunc *cb, void *opaque) { TrimAIOCB *iocb; - iocb = qemu_aio_get(&trim_aiocb_info, bs, cb, opaque); + iocb = blk_aio_get(&trim_aiocb_info, blk, cb, opaque); iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb); iocb->ret = 0; iocb->qiov = qiov; @@ -551,7 +552,7 @@ static bool ide_sect_range_ok(IDEState *s, { uint64_t total_sectors; - bdrv_get_geometry(s->bs, &total_sectors); + blk_get_geometry(s->blk, &total_sectors); if (sector > total_sectors || nb_sectors > total_sectors - sector) { return false; } @@ -569,7 +570,7 @@ static void ide_sector_read_cb(void *opaque, int ret) if (ret == -ECANCELED) { return; } - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + block_acct_done(blk_get_stats(s->blk), &s->acct); if (ret != 0) { if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO | IDE_RETRY_READ)) { @@ -625,10 +626,10 @@ void ide_sector_read(IDEState *s) s->iov.iov_len = n * BDRV_SECTOR_SIZE; qemu_iovec_init_external(&s->qiov, &s->iov, 1); - block_acct_start(bdrv_get_stats(s->bs), &s->acct, + block_acct_start(blk_get_stats(s->blk), &s->acct, n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); - s->pio_aiocb = bdrv_aio_readv(s->bs, sector_num, &s->qiov, n, - ide_sector_read_cb, s); + s->pio_aiocb = blk_aio_readv(s->blk, sector_num, &s->qiov, n, + ide_sector_read_cb, s); } static void dma_buf_commit(IDEState *s) @@ -655,7 +656,7 @@ void ide_dma_error(IDEState *s) static int ide_handle_rw_error(IDEState *s, int error, int op) { bool is_read = (op & IDE_RETRY_READ) != 0; - BlockErrorAction action = bdrv_get_error_action(s->bs, is_read, error); + BlockErrorAction action = blk_get_error_action(s->blk, is_read, error); if (action == BLOCK_ERROR_ACTION_STOP) { s->bus->dma->ops->set_unit(s->bus->dma, s->unit); @@ -668,7 +669,7 @@ static int ide_handle_rw_error(IDEState *s, int error, int op) ide_rw_error(s); } } - bdrv_error_action(s->bs, action, is_read, error); + blk_error_action(s->blk, action, is_read, error); return action != BLOCK_ERROR_ACTION_IGNORE; } @@ -744,24 +745,24 @@ void ide_dma_cb(void *opaque, int ret) switch (s->dma_cmd) { case IDE_DMA_READ: - s->bus->dma->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num, - ide_dma_cb, s); + s->bus->dma->aiocb = dma_blk_read(s->blk, &s->sg, sector_num, + ide_dma_cb, s); break; case IDE_DMA_WRITE: - s->bus->dma->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num, - ide_dma_cb, s); + s->bus->dma->aiocb = dma_blk_write(s->blk, &s->sg, sector_num, + ide_dma_cb, s); break; case IDE_DMA_TRIM: - s->bus->dma->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num, - ide_issue_trim, ide_dma_cb, s, - DMA_DIRECTION_TO_DEVICE); + s->bus->dma->aiocb = dma_blk_io(s->blk, &s->sg, sector_num, + ide_issue_trim, ide_dma_cb, s, + DMA_DIRECTION_TO_DEVICE); break; } return; eot: if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) { - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + block_acct_done(blk_get_stats(s->blk), &s->acct); } ide_set_inactive(s, stay_active); } @@ -775,11 +776,11 @@ static void ide_sector_start_dma(IDEState *s, enum ide_dma_cmd dma_cmd) switch (dma_cmd) { case IDE_DMA_READ: - block_acct_start(bdrv_get_stats(s->bs), &s->acct, + block_acct_start(blk_get_stats(s->blk), &s->acct, s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); break; case IDE_DMA_WRITE: - block_acct_start(bdrv_get_stats(s->bs), &s->acct, + block_acct_start(blk_get_stats(s->blk), &s->acct, s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE); break; default: @@ -810,7 +811,7 @@ static void ide_sector_write_cb(void *opaque, int ret) if (ret == -ECANCELED) { return; } - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + block_acct_done(blk_get_stats(s->blk), &s->acct); s->pio_aiocb = NULL; s->status &= ~BUSY_STAT; @@ -877,10 +878,10 @@ void ide_sector_write(IDEState *s) s->iov.iov_len = n * BDRV_SECTOR_SIZE; qemu_iovec_init_external(&s->qiov, &s->iov, 1); - block_acct_start(bdrv_get_stats(s->bs), &s->acct, + block_acct_start(blk_get_stats(s->blk), &s->acct, n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); - s->pio_aiocb = bdrv_aio_writev(s->bs, sector_num, &s->qiov, n, - ide_sector_write_cb, s); + s->pio_aiocb = blk_aio_writev(s->blk, sector_num, &s->qiov, n, + ide_sector_write_cb, s); } static void ide_flush_cb(void *opaque, int ret) @@ -899,8 +900,8 @@ static void ide_flush_cb(void *opaque, int ret) } } - if (s->bs) { - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + if (s->blk) { + block_acct_done(blk_get_stats(s->blk), &s->acct); } s->status = READY_STAT | SEEK_STAT; ide_cmd_done(s); @@ -909,14 +910,14 @@ static void ide_flush_cb(void *opaque, int ret) void ide_flush_cache(IDEState *s) { - if (s->bs == NULL) { + if (s->blk == NULL) { ide_flush_cb(s, 0); return; } s->status |= BUSY_STAT; - block_acct_start(bdrv_get_stats(s->bs), &s->acct, 0, BLOCK_ACCT_FLUSH); - s->pio_aiocb = bdrv_aio_flush(s->bs, ide_flush_cb, s); + block_acct_start(blk_get_stats(s->blk), &s->acct, 0, BLOCK_ACCT_FLUSH); + s->pio_aiocb = blk_aio_flush(s->blk, ide_flush_cb, s); } static void ide_cfata_metadata_inquiry(IDEState *s) @@ -979,7 +980,7 @@ static void ide_cd_change_cb(void *opaque, bool load) uint64_t nb_sectors; s->tray_open = !load; - bdrv_get_geometry(s->bs, &nb_sectors); + blk_get_geometry(s->blk, &nb_sectors); s->nb_sectors = nb_sectors; /* @@ -1113,7 +1114,7 @@ static bool cmd_data_set_management(IDEState *s, uint8_t cmd) { switch (s->feature) { case DSM_TRIM: - if (s->bs) { + if (s->blk) { ide_sector_start_dma(s, IDE_DMA_TRIM); return false; } @@ -1126,7 +1127,7 @@ static bool cmd_data_set_management(IDEState *s, uint8_t cmd) static bool cmd_identify(IDEState *s, uint8_t cmd) { - if (s->bs && s->drive_kind != IDE_CD) { + if (s->blk && s->drive_kind != IDE_CD) { if (s->drive_kind != IDE_CFATA) { ide_identify(s); } else { @@ -1176,7 +1177,7 @@ static bool cmd_read_multiple(IDEState *s, uint8_t cmd) { bool lba48 = (cmd == WIN_MULTREAD_EXT); - if (!s->bs || !s->mult_sectors) { + if (!s->blk || !s->mult_sectors) { ide_abort_command(s); return true; } @@ -1192,7 +1193,7 @@ static bool cmd_write_multiple(IDEState *s, uint8_t cmd) bool lba48 = (cmd == WIN_MULTWRITE_EXT); int n; - if (!s->bs || !s->mult_sectors) { + if (!s->blk || !s->mult_sectors) { ide_abort_command(s); return true; } @@ -1220,7 +1221,7 @@ static bool cmd_read_pio(IDEState *s, uint8_t cmd) return true; } - if (!s->bs) { + if (!s->blk) { ide_abort_command(s); return true; } @@ -1236,7 +1237,7 @@ static bool cmd_write_pio(IDEState *s, uint8_t cmd) { bool lba48 = (cmd == WIN_WRITE_EXT); - if (!s->bs) { + if (!s->blk) { ide_abort_command(s); return true; } @@ -1256,7 +1257,7 @@ static bool cmd_read_dma(IDEState *s, uint8_t cmd) { bool lba48 = (cmd == WIN_READDMA_EXT); - if (!s->bs) { + if (!s->blk) { ide_abort_command(s); return true; } @@ -1271,7 +1272,7 @@ static bool cmd_write_dma(IDEState *s, uint8_t cmd) { bool lba48 = (cmd == WIN_WRITEDMA_EXT); - if (!s->bs) { + if (!s->blk) { ide_abort_command(s); return true; } @@ -1322,7 +1323,7 @@ static bool cmd_set_features(IDEState *s, uint8_t cmd) { uint16_t *identify_data; - if (!s->bs) { + if (!s->blk) { ide_abort_command(s); return true; } @@ -1330,12 +1331,12 @@ static bool cmd_set_features(IDEState *s, uint8_t cmd) /* XXX: valid for CDROM ? */ switch (s->feature) { case 0x02: /* write cache enable */ - bdrv_set_enable_write_cache(s->bs, true); + blk_set_enable_write_cache(s->blk, true); identify_data = (uint16_t *)s->identify_data; put_le16(identify_data + 85, (1 << 14) | (1 << 5) | 1); return true; case 0x82: /* write cache disable */ - bdrv_set_enable_write_cache(s->bs, false); + blk_set_enable_write_cache(s->blk, false); identify_data = (uint16_t *)s->identify_data; put_le16(identify_data + 85, (1 << 14) | 1); ide_flush_cache(s); @@ -1802,8 +1803,9 @@ void ide_exec_cmd(IDEBus *bus, uint32_t val) #endif s = idebus_active_if(bus); /* ignore commands to non existent slave */ - if (s != bus->ifs && !s->bs) + if (s != bus->ifs && !s->blk) { return; + } /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */ if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET) @@ -1848,59 +1850,66 @@ uint32_t ide_ioport_read(void *opaque, uint32_t addr1) ret = 0xff; break; case 1: - if ((!bus->ifs[0].bs && !bus->ifs[1].bs) || - (s != bus->ifs && !s->bs)) + if ((!bus->ifs[0].blk && !bus->ifs[1].blk) || + (s != bus->ifs && !s->blk)) { ret = 0; - else if (!hob) + } else if (!hob) { ret = s->error; - else + } else { ret = s->hob_feature; + } break; case 2: - if (!bus->ifs[0].bs && !bus->ifs[1].bs) + if (!bus->ifs[0].blk && !bus->ifs[1].blk) { ret = 0; - else if (!hob) + } else if (!hob) { ret = s->nsector & 0xff; - else + } else { ret = s->hob_nsector; + } break; case 3: - if (!bus->ifs[0].bs && !bus->ifs[1].bs) + if (!bus->ifs[0].blk && !bus->ifs[1].blk) { ret = 0; - else if (!hob) + } else if (!hob) { ret = s->sector; - else + } else { ret = s->hob_sector; + } break; case 4: - if (!bus->ifs[0].bs && !bus->ifs[1].bs) + if (!bus->ifs[0].blk && !bus->ifs[1].blk) { ret = 0; - else if (!hob) + } else if (!hob) { ret = s->lcyl; - else + } else { ret = s->hob_lcyl; + } break; case 5: - if (!bus->ifs[0].bs && !bus->ifs[1].bs) + if (!bus->ifs[0].blk && !bus->ifs[1].blk) { ret = 0; - else if (!hob) + } else if (!hob) { ret = s->hcyl; - else + } else { ret = s->hob_hcyl; + } break; case 6: - if (!bus->ifs[0].bs && !bus->ifs[1].bs) + if (!bus->ifs[0].blk && !bus->ifs[1].blk) { ret = 0; - else + } else { ret = s->select; + } break; default: case 7: - if ((!bus->ifs[0].bs && !bus->ifs[1].bs) || - (s != bus->ifs && !s->bs)) + if ((!bus->ifs[0].blk && !bus->ifs[1].blk) || + (s != bus->ifs && !s->blk)) { ret = 0; - else + } else { ret = s->status; + } qemu_irq_lower(bus->irq); break; } @@ -1916,11 +1925,12 @@ uint32_t ide_status_read(void *opaque, uint32_t addr) IDEState *s = idebus_active_if(bus); int ret; - if ((!bus->ifs[0].bs && !bus->ifs[1].bs) || - (s != bus->ifs && !s->bs)) + if ((!bus->ifs[0].blk && !bus->ifs[1].blk) || + (s != bus->ifs && !s->blk)) { ret = 0; - else + } else { ret = s->status; + } #ifdef DEBUG_IDE printf("ide: read status addr=0x%x val=%02x\n", addr, ret); #endif @@ -2081,7 +2091,7 @@ static void ide_reset(IDEState *s) #endif if (s->pio_aiocb) { - bdrv_aio_cancel(s->pio_aiocb); + blk_aio_cancel(s->pio_aiocb); s->pio_aiocb = NULL; } @@ -2145,7 +2155,7 @@ void ide_bus_reset(IDEBus *bus) #ifdef DEBUG_AIO printf("aio_cancel\n"); #endif - bdrv_aio_cancel(bus->dma->aiocb); + blk_aio_cancel(bus->dma->aiocb); bus->dma->aiocb = NULL; } @@ -2174,7 +2184,7 @@ static void ide_resize_cb(void *opaque) return; } - bdrv_get_geometry(s->bs, &nb_sectors); + blk_get_geometry(s->blk, &nb_sectors); s->nb_sectors = nb_sectors; /* Update the identify data buffer. */ @@ -2198,7 +2208,7 @@ static const BlockDevOps ide_hd_block_ops = { .resize_cb = ide_resize_cb, }; -int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, +int ide_init_drive(IDEState *s, BlockBackend *blk, IDEDriveKind kind, const char *version, const char *serial, const char *model, uint64_t wwn, uint32_t cylinders, uint32_t heads, uint32_t secs, @@ -2206,10 +2216,10 @@ int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, { uint64_t nb_sectors; - s->bs = bs; + s->blk = blk; s->drive_kind = kind; - bdrv_get_geometry(bs, &nb_sectors); + blk_get_geometry(blk, &nb_sectors); s->cylinders = cylinders; s->heads = heads; s->sectors = secs; @@ -2223,18 +2233,18 @@ int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, s->smart_errors = 0; s->smart_selftest_count = 0; if (kind == IDE_CD) { - bdrv_set_dev_ops(bs, &ide_cd_block_ops, s); - bdrv_set_guest_block_size(bs, 2048); + blk_set_dev_ops(blk, &ide_cd_block_ops, s); + blk_set_guest_block_size(blk, 2048); } else { - if (!bdrv_is_inserted(s->bs)) { + if (!blk_is_inserted(s->blk)) { error_report("Device needs media, but drive is empty"); return -1; } - if (bdrv_is_read_only(bs)) { + if (blk_is_read_only(blk)) { error_report("Can't use a read-only drive"); return -1; } - bdrv_set_dev_ops(bs, &ide_hd_block_ops, s); + blk_set_dev_ops(blk, &ide_hd_block_ops, s); } if (serial) { pstrcpy(s->drive_serial_str, sizeof(s->drive_serial_str), serial); @@ -2265,7 +2275,7 @@ int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, } ide_reset(s); - bdrv_iostatus_enable(bs); + blk_iostatus_enable(blk); return 0; } @@ -2282,7 +2292,7 @@ static void ide_init1(IDEBus *bus, int unit) s->io_buffer = qemu_memalign(2048, s->io_buffer_total_len); memset(s->io_buffer, 0, s->io_buffer_total_len); - s->smart_selftest_data = qemu_blockalign(s->bs, 512); + s->smart_selftest_data = blk_blockalign(s->blk, 512); memset(s->smart_selftest_data, 0, 512); s->sector_write_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, @@ -2377,7 +2387,7 @@ static int ide_drive_post_load(void *opaque, int version_id) IDEState *s = opaque; if (s->identify_set) { - bdrv_set_enable_write_cache(s->bs, !!(s->identify_data[85] & (1 << 5))); + blk_set_enable_write_cache(s->blk, !!(s->identify_data[85] & (1 << 5))); } return 0; } diff --git a/hw/ide/ich.c b/hw/ide/ich.c index 8eb77a1472..fb1d095503 100644 --- a/hw/ide/ich.c +++ b/hw/ide/ich.c @@ -65,7 +65,7 @@ #include #include #include -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include diff --git a/hw/ide/internal.h b/hw/ide/internal.h index 9314c8060e..68ac610d6f 100644 --- a/hw/ide/internal.h +++ b/hw/ide/internal.h @@ -373,7 +373,7 @@ struct IDEState { /* set for lba48 access */ uint8_t lba48; - BlockDriverState *bs; + BlockBackend *blk; char version[9]; /* ATAPI specific */ struct unreported_events events; @@ -537,7 +537,7 @@ uint32_t ide_data_readw(void *opaque, uint32_t addr); void ide_data_writel(void *opaque, uint32_t addr, uint32_t val); uint32_t ide_data_readl(void *opaque, uint32_t addr); -int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, +int ide_init_drive(IDEState *s, BlockBackend *blk, IDEDriveKind kind, const char *version, const char *serial, const char *model, uint64_t wwn, uint32_t cylinders, uint32_t heads, uint32_t secs, @@ -555,7 +555,7 @@ void ide_transfer_start(IDEState *s, uint8_t *buf, int size, EndTransferFunc *end_transfer_func); void ide_transfer_stop(IDEState *s); void ide_set_inactive(IDEState *s, bool more); -BlockAIOCB *ide_issue_trim(BlockDriverState *bs, +BlockAIOCB *ide_issue_trim(BlockBackend *blk, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockCompletionFunc *cb, void *opaque); diff --git a/hw/ide/isa.c b/hw/ide/isa.c index 4cbcb1cdf2..b084162ddc 100644 --- a/hw/ide/isa.c +++ b/hw/ide/isa.c @@ -25,7 +25,7 @@ #include #include #include -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include diff --git a/hw/ide/macio.c b/hw/ide/macio.c index 6b5cce534f..9a55407059 100644 --- a/hw/ide/macio.c +++ b/hw/ide/macio.c @@ -25,7 +25,7 @@ #include "hw/hw.h" #include "hw/ppc/mac.h" #include "hw/ppc/mac_dbdma.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include @@ -134,7 +134,7 @@ static void pmac_ide_atapi_transfer_cb(void *opaque, int ret) MACIO_DPRINTF("precopying unaligned %d bytes to %#" HWADDR_PRIx "\n", unaligned, io->addr + io->len - unaligned); - bdrv_read(s->bs, sector_num + nsector, io->remainder, 1); + blk_read(s->blk, sector_num + nsector, io->remainder, 1); cpu_physical_memory_write(io->addr + io->len - unaligned, io->remainder, unaligned); @@ -164,14 +164,14 @@ static void pmac_ide_atapi_transfer_cb(void *opaque, int ret) (s->lba << 2) + (s->io_buffer_index >> 9), s->packet_transfer_size, s->dma_cmd); - m->aiocb = dma_bdrv_read(s->bs, &s->sg, - (int64_t)(s->lba << 2) + (s->io_buffer_index >> 9), - pmac_ide_atapi_transfer_cb, io); + m->aiocb = dma_blk_read(s->blk, &s->sg, + (int64_t)(s->lba << 2) + (s->io_buffer_index >> 9), + pmac_ide_atapi_transfer_cb, io); return; done: MACIO_DPRINTF("done DMA\n"); - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + block_acct_done(blk_get_stats(s->blk), &s->acct); io->dma_end(opaque); } @@ -254,8 +254,8 @@ static void pmac_ide_transfer_cb(void *opaque, int ret) qemu_iovec_reset(&io->iov); qemu_iovec_add(&io->iov, io->remainder, 0x200); - m->aiocb = bdrv_aio_writev(s->bs, sector_num - 1, &io->iov, 1, - pmac_ide_transfer_cb, io); + m->aiocb = blk_aio_writev(s->blk, sector_num - 1, &io->iov, 1, + pmac_ide_transfer_cb, io); } } @@ -294,8 +294,8 @@ static void pmac_ide_transfer_cb(void *opaque, int ret) qemu_iovec_reset(&io->iov); qemu_iovec_add(&io->iov, io->remainder, 0x200); - m->aiocb = bdrv_aio_readv(s->bs, sector_num + nsector, &io->iov, 1, - pmac_ide_transfer_cb, io); + m->aiocb = blk_aio_readv(s->blk, sector_num + nsector, &io->iov, 1, + pmac_ide_transfer_cb, io); break; case IDE_DMA_WRITE: /* cache the contents in our io struct */ @@ -333,17 +333,17 @@ static void pmac_ide_transfer_cb(void *opaque, int ret) switch (s->dma_cmd) { case IDE_DMA_READ: - m->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num, - pmac_ide_transfer_cb, io); + m->aiocb = dma_blk_read(s->blk, &s->sg, sector_num, + pmac_ide_transfer_cb, io); break; case IDE_DMA_WRITE: - m->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num, - pmac_ide_transfer_cb, io); + m->aiocb = dma_blk_write(s->blk, &s->sg, sector_num, + pmac_ide_transfer_cb, io); break; case IDE_DMA_TRIM: - m->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num, - ide_issue_trim, pmac_ide_transfer_cb, io, - DMA_DIRECTION_TO_DEVICE); + m->aiocb = dma_blk_io(s->blk, &s->sg, sector_num, + ide_issue_trim, pmac_ide_transfer_cb, io, + DMA_DIRECTION_TO_DEVICE); break; } @@ -352,7 +352,7 @@ static void pmac_ide_transfer_cb(void *opaque, int ret) done: if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) { - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + block_acct_done(blk_get_stats(s->blk), &s->acct); } io->dma_end(io); } @@ -370,7 +370,7 @@ static void pmac_ide_transfer(DBDMA_io *io) /* Handle non-block ATAPI DMA transfers */ if (s->lba == -1) { s->io_buffer_size = MIN(io->len, s->packet_transfer_size); - block_acct_start(bdrv_get_stats(s->bs), &s->acct, s->io_buffer_size, + block_acct_start(blk_get_stats(s->blk), &s->acct, s->io_buffer_size, BLOCK_ACCT_READ); MACIO_DPRINTF("non-block ATAPI DMA transfer size: %d\n", s->io_buffer_size); @@ -382,12 +382,12 @@ static void pmac_ide_transfer(DBDMA_io *io) m->dma_active = false; MACIO_DPRINTF("end of non-block ATAPI DMA transfer\n"); - block_acct_done(bdrv_get_stats(s->bs), &s->acct); + block_acct_done(blk_get_stats(s->blk), &s->acct); io->dma_end(io); return; } - block_acct_start(bdrv_get_stats(s->bs), &s->acct, io->len, + block_acct_start(blk_get_stats(s->blk), &s->acct, io->len, BLOCK_ACCT_READ); pmac_ide_atapi_transfer_cb(io, 0); return; @@ -395,11 +395,11 @@ static void pmac_ide_transfer(DBDMA_io *io) switch (s->dma_cmd) { case IDE_DMA_READ: - block_acct_start(bdrv_get_stats(s->bs), &s->acct, io->len, + block_acct_start(blk_get_stats(s->blk), &s->acct, io->len, BLOCK_ACCT_READ); break; case IDE_DMA_WRITE: - block_acct_start(bdrv_get_stats(s->bs), &s->acct, io->len, + block_acct_start(blk_get_stats(s->blk), &s->acct, io->len, BLOCK_ACCT_WRITE); break; default: @@ -415,7 +415,7 @@ static void pmac_ide_flush(DBDMA_io *io) MACIOIDEState *m = io->opaque; if (m->aiocb) { - bdrv_drain_all(); + blk_drain_all(); } } diff --git a/hw/ide/microdrive.c b/hw/ide/microdrive.c index 15671b8c4d..ed85185a74 100644 --- a/hw/ide/microdrive.c +++ b/hw/ide/microdrive.c @@ -25,7 +25,7 @@ #include #include #include -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include @@ -247,7 +247,7 @@ static uint16_t md_common_read(PCMCIACardState *card, uint32_t at) return ide_ioport_read(&s->bus, 0x1); case 0xe: /* Alternate Status */ ifs = idebus_active_if(&s->bus); - if (ifs->bs) { + if (ifs->blk) { return ifs->status; } else { return 0; diff --git a/hw/ide/mmio.c b/hw/ide/mmio.c index 334c8ccf08..b6ce62ac5a 100644 --- a/hw/ide/mmio.c +++ b/hw/ide/mmio.c @@ -24,7 +24,7 @@ */ #include "hw/hw.h" #include "hw/sysbus.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include diff --git a/hw/ide/pci.c b/hw/ide/pci.c index 6ff1c58be9..2dad50e8aa 100644 --- a/hw/ide/pci.c +++ b/hw/ide/pci.c @@ -26,7 +26,7 @@ #include #include #include -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/dma.h" #include @@ -302,7 +302,7 @@ void bmdma_cmd_writeb(BMDMAState *bm, uint32_t val) * aio operation with preadv/pwritev. */ if (bm->bus->dma->aiocb) { - bdrv_drain_all(); + blk_drain_all(); assert(bm->bus->dma->aiocb == NULL); } bm->status &= ~BM_STATUS_DMAING; diff --git a/hw/ide/piix.c b/hw/ide/piix.c index 0e87e51148..574b9c164b 100644 --- a/hw/ide/piix.c +++ b/hw/ide/piix.c @@ -28,7 +28,6 @@ #include #include #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "sysemu/sysemu.h" #include "sysemu/dma.h" @@ -180,12 +179,11 @@ int pci_piix3_xen_ide_unplug(DeviceState *dev) di = drive_get_by_index(IF_IDE, i); if (di != NULL && !di->media_cd) { BlockBackend *blk = blk_by_legacy_dinfo(di); - BlockDriverState *bs = blk_bs(blk); - DeviceState *ds = bdrv_get_attached_dev(bs); + DeviceState *ds = blk_get_attached_dev(blk); if (ds) { - bdrv_detach_dev(bs, ds); + blk_detach_dev(blk, ds); } - pci_ide->bus[di->bus].ifs[di->unit].bs = NULL; + pci_ide->bus[di->bus].ifs[di->unit].blk = NULL; blk_unref(blk); } } diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c index 816167b99b..600e67c232 100644 --- a/hw/ide/qdev.c +++ b/hw/ide/qdev.c @@ -73,7 +73,7 @@ static int ide_qdev_init(DeviceState *qdev) IDEDeviceClass *dc = IDE_DEVICE_GET_CLASS(dev); IDEBus *bus = DO_UPCAST(IDEBus, qbus, qdev->parent_bus); - if (!dev->conf.bs) { + if (!dev->conf.blk) { error_report("No drive specified"); goto err; } @@ -118,8 +118,7 @@ IDEDevice *ide_create_drive(IDEBus *bus, int unit, DriveInfo *drive) dev = qdev_create(&bus->qbus, drive->media_cd ? "ide-cd" : "ide-hd"); qdev_prop_set_uint32(dev, "unit", unit); - qdev_prop_set_drive_nofail(dev, "drive", - blk_bs(blk_by_legacy_dinfo(drive))); + qdev_prop_set_drive_nofail(dev, "drive", blk_by_legacy_dinfo(drive)); qdev_init_nofail(dev); return DO_UPCAST(IDEDevice, qdev, dev); } @@ -129,7 +128,7 @@ int ide_get_geometry(BusState *bus, int unit, { IDEState *s = &DO_UPCAST(IDEBus, qbus, bus)->ifs[unit]; - if (s->drive_kind != IDE_HD || !s->bs) { + if (s->drive_kind != IDE_HD || !s->blk) { return -1; } @@ -174,7 +173,7 @@ static int ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind) } } - if (ide_init_drive(s, dev->conf.bs, kind, + if (ide_init_drive(s, dev->conf.blk, kind, dev->version, dev->serial, dev->model, dev->wwn, dev->conf.cyls, dev->conf.heads, dev->conf.secs, dev->chs_trans) < 0) { @@ -251,7 +250,7 @@ static int ide_cd_initfn(IDEDevice *dev) static int ide_drive_initfn(IDEDevice *dev) { - DriveInfo *dinfo = drive_get_by_blockdev(dev->conf.bs); + DriveInfo *dinfo = blk_legacy_dinfo(dev->conf.blk); return ide_dev_initfn(dev, dinfo->media_cd ? IDE_CD : IDE_HD); } diff --git a/hw/ide/via.c b/hw/ide/via.c index 89d27b4c5b..4d8089de75 100644 --- a/hw/ide/via.c +++ b/hw/ide/via.c @@ -27,7 +27,7 @@ #include #include #include -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/sysemu.h" #include "sysemu/dma.h" diff --git a/hw/isa/pc87312.c b/hw/isa/pc87312.c index b691a0ca00..40a11060a5 100644 --- a/hw/isa/pc87312.c +++ b/hw/isa/pc87312.c @@ -322,12 +322,12 @@ static void pc87312_realize(DeviceState *dev, Error **errp) drive = drive_get(IF_FLOPPY, 0, 0); if (drive != NULL) { qdev_prop_set_drive_nofail(d, "driveA", - blk_bs(blk_by_legacy_dinfo(drive))); + blk_by_legacy_dinfo(drive)); } drive = drive_get(IF_FLOPPY, 0, 1); if (drive != NULL) { qdev_prop_set_drive_nofail(d, "driveB", - blk_bs(blk_by_legacy_dinfo(drive))); + blk_by_legacy_dinfo(drive)); } qdev_init_nofail(d); s->fdc.dev = isa; diff --git a/hw/lm32/lm32_boards.c b/hw/lm32/lm32_boards.c index 2a1d3dea2a..af0abdbed9 100644 --- a/hw/lm32/lm32_boards.c +++ b/hw/lm32/lm32_boards.c @@ -24,7 +24,6 @@ #include "hw/boards.h" #include "hw/loader.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "elf.h" #include "lm32_hwsetup.h" #include "lm32.h" @@ -120,7 +119,7 @@ static void lm32_evr_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); /* Spansion S29NS128P */ pflash_cfi02_register(flash_base, NULL, "lm32_evr.flash", flash_size, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, flash_sector_size, flash_size / flash_sector_size, 1, 2, 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); @@ -223,7 +222,7 @@ static void lm32_uclinux_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); /* Spansion S29NS128P */ pflash_cfi02_register(flash_base, NULL, "lm32_uclinux.flash", flash_size, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, flash_sector_size, flash_size / flash_sector_size, 1, 2, 0x01, 0x7e, 0x43, 0x00, 0x555, 0x2aa, 1); diff --git a/hw/lm32/milkymist.c b/hw/lm32/milkymist.c index 8411895aa3..256c1029ce 100644 --- a/hw/lm32/milkymist.c +++ b/hw/lm32/milkymist.c @@ -27,7 +27,6 @@ #include "hw/loader.h" #include "elf.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "milkymist-hw.h" #include "lm32.h" #include "exec/address-spaces.h" @@ -127,7 +126,7 @@ milkymist_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); /* Numonyx JS28F256J3F105 */ pflash_cfi01_register(flash_base, NULL, "milkymist.flash", flash_size, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, flash_sector_size, flash_size / flash_sector_size, 2, 0x00, 0x89, 0x00, 0x1d, 1); diff --git a/hw/microblaze/petalogix_ml605_mmu.c b/hw/microblaze/petalogix_ml605_mmu.c index 8c0532d872..48c264b9d7 100644 --- a/hw/microblaze/petalogix_ml605_mmu.c +++ b/hw/microblaze/petalogix_ml605_mmu.c @@ -33,7 +33,6 @@ #include "hw/devices.h" #include "hw/boards.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "hw/char/serial.h" #include "exec/address-spaces.h" #include "hw/ssi.h" @@ -114,7 +113,7 @@ petalogix_ml605_init(MachineState *machine) * 10th paremeter 0 means little-endian */ pflash_cfi01_register(FLASH_BASEADDR, NULL, "petalogix_ml605.flash", FLASH_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, (64 * 1024), FLASH_SIZE >> 16, 2, 0x89, 0x18, 0x0000, 0x0, 0); diff --git a/hw/microblaze/petalogix_s3adsp1800_mmu.c b/hw/microblaze/petalogix_s3adsp1800_mmu.c index c3fd743e5f..84f6e74653 100644 --- a/hw/microblaze/petalogix_s3adsp1800_mmu.c +++ b/hw/microblaze/petalogix_s3adsp1800_mmu.c @@ -31,7 +31,6 @@ #include "hw/devices.h" #include "hw/boards.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "boot.h" @@ -95,7 +94,7 @@ petalogix_s3adsp1800_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi01_register(FLASH_BASEADDR, NULL, "petalogix_s3adsp1800.flash", FLASH_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, (64 * 1024), FLASH_SIZE >> 16, 1, 0x89, 0x18, 0x0000, 0x0, 1); diff --git a/hw/mips/mips_fulong2e.c b/hw/mips/mips_fulong2e.c index 29cd708e07..6a9ebfa911 100644 --- a/hw/mips/mips_fulong2e.c +++ b/hw/mips/mips_fulong2e.c @@ -25,7 +25,7 @@ #include "net/net.h" #include "hw/boards.h" #include "hw/i2c/smbus.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "hw/block/flash.h" #include "hw/mips/mips.h" #include "hw/mips/cpudevs.h" diff --git a/hw/mips/mips_jazz.c b/hw/mips/mips_jazz.c index 6c31cb8fe9..3f33093fd9 100644 --- a/hw/mips/mips_jazz.c +++ b/hw/mips/mips_jazz.c @@ -39,7 +39,7 @@ #include "hw/timer/mc146818rtc.h" #include "hw/timer/i8254.h" #include "hw/audio/pcspk.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "hw/sysbus.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" diff --git a/hw/mips/mips_malta.c b/hw/mips/mips_malta.c index 59020ec176..514f06ccc4 100644 --- a/hw/mips/mips_malta.c +++ b/hw/mips/mips_malta.c @@ -29,7 +29,7 @@ #include "net/net.h" #include "hw/boards.h" #include "hw/i2c/smbus.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "hw/block/flash.h" #include "hw/mips/mips.h" #include "hw/mips/cpudevs.h" @@ -1033,12 +1033,12 @@ void mips_malta_init(MachineState *machine) printf("Register parallel flash %d size " TARGET_FMT_lx " at " "addr %08llx '%s' %x\n", fl_idx, bios_size, FLASH_ADDRESS, - bdrv_get_device_name(dinfo->bdrv), fl_sectors); + blk_name(dinfo->bdrv), fl_sectors); } #endif fl = pflash_cfi01_register(FLASH_ADDRESS, NULL, "mips_malta.bios", BIOS_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, 65536, fl_sectors, 4, 0x0000, 0x0000, 0x0000, 0x0000, be); bios = pflash_cfi01_get_memory(fl); diff --git a/hw/mips/mips_r4k.c b/hw/mips/mips_r4k.c index e966a1bb1c..a7fe0ceadf 100644 --- a/hw/mips/mips_r4k.c +++ b/hw/mips/mips_r4k.c @@ -25,7 +25,6 @@ #include "hw/timer/mc146818rtc.h" #include "hw/timer/i8254.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" #include "sysemu/qtest.h" @@ -242,7 +241,7 @@ void mips_r4k_init(MachineState *machine) } else if ((dinfo = drive_get(IF_PFLASH, 0, 0)) != NULL) { uint32_t mips_rom = 0x00400000; if (!pflash_cfi01_register(0x1fc00000, NULL, "mips_r4k.bios", mips_rom, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), sector_len, mips_rom / sector_len, 4, 0, 0, 0, 0, be)) { fprintf(stderr, "qemu: Error registering flash memory.\n"); diff --git a/hw/nvram/spapr_nvram.c b/hw/nvram/spapr_nvram.c index 6a72ef4814..10b5b2e86b 100644 --- a/hw/nvram/spapr_nvram.c +++ b/hw/nvram/spapr_nvram.c @@ -24,6 +24,7 @@ #include +#include "sysemu/block-backend.h" #include "sysemu/device_tree.h" #include "hw/sysbus.h" #include "hw/ppc/spapr.h" @@ -33,7 +34,7 @@ typedef struct sPAPRNVRAM { VIOsPAPRDevice sdev; uint32_t size; uint8_t *buf; - BlockDriverState *drive; + BlockBackend *blk; } sPAPRNVRAM; #define TYPE_VIO_SPAPR_NVRAM "spapr-nvram" @@ -77,8 +78,8 @@ static void rtas_nvram_fetch(PowerPCCPU *cpu, sPAPREnvironment *spapr, } membuf = cpu_physical_memory_map(buffer, &len, 1); - if (nvram->drive) { - alen = bdrv_pread(nvram->drive, offset, membuf, len); + if (nvram->blk) { + alen = blk_pread(nvram->blk, offset, membuf, len); } else { assert(nvram->buf); @@ -122,8 +123,8 @@ static void rtas_nvram_store(PowerPCCPU *cpu, sPAPREnvironment *spapr, } membuf = cpu_physical_memory_map(buffer, &len, 0); - if (nvram->drive) { - alen = bdrv_pwrite(nvram->drive, offset, membuf, len); + if (nvram->blk) { + alen = blk_pwrite(nvram->blk, offset, membuf, len); } else { assert(nvram->buf); @@ -140,8 +141,8 @@ static int spapr_nvram_init(VIOsPAPRDevice *dev) { sPAPRNVRAM *nvram = VIO_SPAPR_NVRAM(dev); - if (nvram->drive) { - nvram->size = bdrv_getlength(nvram->drive); + if (nvram->blk) { + nvram->size = blk_getlength(nvram->blk); } else { nvram->size = DEFAULT_NVRAM_SIZE; nvram->buf = g_malloc0(nvram->size); @@ -168,7 +169,7 @@ static int spapr_nvram_devnode(VIOsPAPRDevice *dev, void *fdt, int node_off) static Property spapr_nvram_properties[] = { DEFINE_SPAPR_PROPERTIES(sPAPRNVRAM, sdev), - DEFINE_PROP_DRIVE("drive", sPAPRNVRAM, drive), + DEFINE_PROP_DRIVE("drive", sPAPRNVRAM, blk), DEFINE_PROP_END_OF_LIST(), }; diff --git a/hw/pci/pci-hotplug-old.c b/hw/pci/pci-hotplug-old.c index c6625b9d9f..0c09c72ac5 100644 --- a/hw/pci/pci-hotplug-old.c +++ b/hw/pci/pci-hotplug-old.c @@ -34,7 +34,6 @@ #include "hw/virtio/virtio-blk.h" #include "qemu/config-file.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "qapi/error.h" static int pci_read_devaddr(Monitor *mon, const char *addr, @@ -129,7 +128,7 @@ static int scsi_hot_add(Monitor *mon, DeviceState *adapter, dinfo->unit = qemu_opt_get_number(dinfo->opts, "unit", -1); dinfo->bus = scsibus->busnr; scsidev = scsi_bus_legacy_add_drive(scsibus, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), dinfo->unit, false, -1, NULL, &local_err); if (!scsidev) { @@ -254,7 +253,7 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon, } dev = pci_create(bus, devfn, "virtio-blk-pci"); if (qdev_prop_set_drive(&dev->qdev, "drive", - blk_bs(blk_by_legacy_dinfo(dinfo))) < 0) { + blk_by_legacy_dinfo(dinfo)) < 0) { object_unparent(OBJECT(dev)); dev = NULL; break; diff --git a/hw/ppc/mac_newworld.c b/hw/ppc/mac_newworld.c index 4094beb0ed..89aee716d4 100644 --- a/hw/ppc/mac_newworld.c +++ b/hw/ppc/mac_newworld.c @@ -65,7 +65,7 @@ #include "sysemu/kvm.h" #include "kvm_ppc.h" #include "hw/usb.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" #include "hw/sysbus.h" diff --git a/hw/ppc/mac_oldworld.c b/hw/ppc/mac_oldworld.c index ebd87fb8f5..32c21a4286 100644 --- a/hw/ppc/mac_oldworld.c +++ b/hw/ppc/mac_oldworld.c @@ -40,7 +40,7 @@ #include "elf.h" #include "sysemu/kvm.h" #include "kvm_ppc.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" #define MAX_IDE_BUS 2 diff --git a/hw/ppc/ppc405_boards.c b/hw/ppc/ppc405_boards.c index aeae45063c..1dcea7730e 100644 --- a/hw/ppc/ppc405_boards.c +++ b/hw/ppc/ppc405_boards.c @@ -28,7 +28,7 @@ #include "hw/block/flash.h" #include "sysemu/sysemu.h" #include "sysemu/qtest.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "hw/boards.h" #include "qemu/log.h" #include "qemu/error-report.h" @@ -226,19 +226,19 @@ static void ref405ep_init(MachineState *machine) #ifdef USE_FLASH_BIOS dinfo = drive_get(IF_PFLASH, 0, fl_idx); if (dinfo) { - BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + BlockBackend *blk = blk_by_legacy_dinfo(dinfo); - bios_size = bdrv_getlength(bs); + bios_size = blk_getlength(blk); fl_sectors = (bios_size + 65535) >> 16; #ifdef DEBUG_BOARD_INIT printf("Register parallel flash %d size %lx" " at addr %lx '%s' %d\n", fl_idx, bios_size, -bios_size, - bdrv_get_device_name(bs), fl_sectors); + blk_name(blk), fl_sectors); #endif pflash_cfi02_register((uint32_t)(-bios_size), NULL, "ef405ep.bios", bios_size, - bs, 65536, fl_sectors, 1, + blk, 65536, fl_sectors, 1, 2, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA, 1); fl_idx++; @@ -551,9 +551,9 @@ static void taihu_405ep_init(MachineState *machine) #if defined(USE_FLASH_BIOS) dinfo = drive_get(IF_PFLASH, 0, fl_idx); if (dinfo) { - BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + BlockBackend *blk = blk_by_legacy_dinfo(dinfo); - bios_size = bdrv_getlength(bs); + bios_size = blk_getlength(blk); /* XXX: should check that size is 2MB */ // bios_size = 2 * 1024 * 1024; fl_sectors = (bios_size + 65535) >> 16; @@ -561,11 +561,11 @@ static void taihu_405ep_init(MachineState *machine) printf("Register parallel flash %d size %lx" " at addr %lx '%s' %d\n", fl_idx, bios_size, -bios_size, - bdrv_get_device_name(bs), fl_sectors); + blk_name(blk), fl_sectors); #endif pflash_cfi02_register((uint32_t)(-bios_size), NULL, "taihu_405ep.bios", bios_size, - bs, 65536, fl_sectors, 1, + blk, 65536, fl_sectors, 1, 4, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA, 1); fl_idx++; @@ -600,9 +600,9 @@ static void taihu_405ep_init(MachineState *machine) /* Register Linux flash */ dinfo = drive_get(IF_PFLASH, 0, fl_idx); if (dinfo) { - BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo)); + BlockBackend *blk = blk_by_legacy_dinfo(dinfo); - bios_size = bdrv_getlength(bs); + bios_size = blk_getlength(blk); /* XXX: should check that size is 32MB */ bios_size = 32 * 1024 * 1024; fl_sectors = (bios_size + 65535) >> 16; @@ -610,10 +610,10 @@ static void taihu_405ep_init(MachineState *machine) printf("Register parallel flash %d size %lx" " at addr " TARGET_FMT_lx " '%s'\n", fl_idx, bios_size, (target_ulong)0xfc000000, - bdrv_get_device_name(bs)); + blk_name(blk)); #endif pflash_cfi02_register(0xfc000000, NULL, "taihu_405ep.flash", bios_size, - bs, 65536, fl_sectors, 1, + blk, 65536, fl_sectors, 1, 4, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x2AA, 1); fl_idx++; diff --git a/hw/ppc/prep.c b/hw/ppc/prep.c index 9f484cdcb8..dd8433d0c9 100644 --- a/hw/ppc/prep.c +++ b/hw/ppc/prep.c @@ -38,7 +38,7 @@ #include "hw/loader.h" #include "hw/timer/mc146818rtc.h" #include "hw/isa/pc87312.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "sysemu/arch_init.h" #include "sysemu/qtest.h" #include "exec/address-spaces.h" diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c index 0605ce8205..45764a7032 100644 --- a/hw/ppc/spapr.c +++ b/hw/ppc/spapr.c @@ -30,7 +30,6 @@ #include "elf.h" #include "net/net.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "sysemu/cpus.h" #include "sysemu/kvm.h" #include "kvm_ppc.h" @@ -926,8 +925,7 @@ static void spapr_create_nvram(sPAPREnvironment *spapr) DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); if (dinfo) { - qdev_prop_set_drive_nofail(dev, "drive", - blk_bs(blk_by_legacy_dinfo(dinfo))); + qdev_prop_set_drive_nofail(dev, "drive", blk_by_legacy_dinfo(dinfo)); } qdev_init_nofail(dev); diff --git a/hw/ppc/virtex_ml507.c b/hw/ppc/virtex_ml507.c index a0ce447e9c..6ebd5bee8b 100644 --- a/hw/ppc/virtex_ml507.c +++ b/hw/ppc/virtex_ml507.c @@ -40,7 +40,6 @@ #include "ppc405.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "qapi/qmp/qerror.h" #define EPAPR_MAGIC (0x45504150) @@ -228,7 +227,7 @@ static void virtex_init(MachineState *machine) dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi01_register(PFLASH_BASEADDR, NULL, "virtex.flash", FLASH_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, (64 * 1024), FLASH_SIZE >> 16, 1, 0x89, 0x18, 0x0000, 0x0, 1); diff --git a/hw/s390x/s390-virtio-bus.c b/hw/s390x/s390-virtio-bus.c index 29ecdb4194..2059874ae3 100644 --- a/hw/s390x/s390-virtio-bus.c +++ b/hw/s390x/s390-virtio-bus.c @@ -18,7 +18,7 @@ */ #include "hw/hw.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/sysemu.h" #include "hw/boards.h" #include "monitor/monitor.h" diff --git a/hw/s390x/s390-virtio.c b/hw/s390x/s390-virtio.c index af0004a0ac..c215cd80e3 100644 --- a/hw/s390x/s390-virtio.c +++ b/hw/s390x/s390-virtio.c @@ -22,7 +22,7 @@ */ #include "hw/hw.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/sysemu.h" #include "net/net.h" diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c index f5ec94657f..1c0d91321a 100644 --- a/hw/s390x/virtio-ccw.c +++ b/hw/s390x/virtio-ccw.c @@ -10,7 +10,7 @@ */ #include "hw/hw.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "sysemu/sysemu.h" #include "net/net.h" diff --git a/hw/scsi/megasas.c b/hw/scsi/megasas.c index eedc9922a7..36a04f31bb 100644 --- a/hw/scsi/megasas.c +++ b/hw/scsi/megasas.c @@ -21,6 +21,7 @@ #include "hw/hw.h" #include "hw/pci/pci.h" #include "sysemu/dma.h" +#include "sysemu/block-backend.h" #include "hw/pci/msi.h" #include "hw/pci/msix.h" #include "qemu/iov.h" @@ -976,7 +977,6 @@ static int megasas_pd_get_info_submit(SCSIDevice *sdev, int lun, { struct mfi_pd_info *info = cmd->iov_buf; size_t dcmd_size = sizeof(struct mfi_pd_info); - BlockConf *conf = &sdev->conf; uint64_t pd_size; uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF); uint8_t cmdbuf[6]; @@ -1037,7 +1037,7 @@ static int megasas_pd_get_info_submit(SCSIDevice *sdev, int lun, info->ref.v.device_id = cpu_to_le16(sdev_id); info->state.ddf.pd_type = cpu_to_le16(MFI_PD_DDF_TYPE_IN_VD| MFI_PD_DDF_TYPE_INTF_SAS); - bdrv_get_geometry(conf->bs, &pd_size); + blk_get_geometry(sdev->conf.blk, &pd_size); info->raw_size = cpu_to_le64(pd_size); info->non_coerced_size = cpu_to_le64(pd_size); info->coerced_size = cpu_to_le64(pd_size); @@ -1100,13 +1100,12 @@ static int megasas_dcmd_ld_get_list(MegasasState *s, MegasasCmd *cmd) } QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) { SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child); - BlockConf *conf = &sdev->conf; if (num_ld_disks >= max_ld_disks) { break; } /* Logical device size is in blocks */ - bdrv_get_geometry(conf->bs, &ld_size); + blk_get_geometry(sdev->conf.blk, &ld_size); info.ld_list[num_ld_disks].ld.v.target_id = sdev->id; info.ld_list[num_ld_disks].ld.v.lun_id = sdev->lun; info.ld_list[num_ld_disks].state = MFI_LD_STATE_OPTIMAL; @@ -1144,7 +1143,6 @@ static int megasas_ld_get_info_submit(SCSIDevice *sdev, int lun, uint8_t cdb[6]; SCSIRequest *req; ssize_t len, resid; - BlockConf *conf = &sdev->conf; uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF); uint64_t ld_size; @@ -1177,7 +1175,7 @@ static int megasas_ld_get_info_submit(SCSIDevice *sdev, int lun, info->ld_config.params.num_drives = 1; info->ld_config.params.is_consistent = 1; /* Logical device size is in blocks */ - bdrv_get_geometry(conf->bs, &ld_size); + blk_get_geometry(sdev->conf.blk, &ld_size); info->size = cpu_to_le64(ld_size); memset(info->ld_config.span, 0, sizeof(info->ld_config.span)); info->ld_config.span[0].start_block = 0; @@ -1261,7 +1259,6 @@ static int megasas_dcmd_cfg_read(MegasasState *s, MegasasCmd *cmd) QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) { SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child); - BlockConf *conf = &sdev->conf; uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (sdev->lun & 0xFF); struct mfi_array *array; struct mfi_ld_config *ld; @@ -1269,7 +1266,7 @@ static int megasas_dcmd_cfg_read(MegasasState *s, MegasasCmd *cmd) int i; array = (struct mfi_array *)(data + array_offset); - bdrv_get_geometry(conf->bs, &pd_size); + blk_get_geometry(sdev->conf.blk, &pd_size); array->size = cpu_to_le64(pd_size); array->num_drives = 1; array->array_ref = cpu_to_le16(sdev_id); @@ -1340,7 +1337,7 @@ static int megasas_dcmd_get_properties(MegasasState *s, MegasasCmd *cmd) static int megasas_cache_flush(MegasasState *s, MegasasCmd *cmd) { - bdrv_drain_all(); + blk_drain_all(); return MFI_STAT_OK; } diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c index b4bbd9ca4d..af7707cf27 100644 --- a/hw/scsi/scsi-bus.c +++ b/hw/scsi/scsi-bus.c @@ -222,7 +222,7 @@ static void scsi_qdev_unrealize(DeviceState *qdev, Error **errp) } /* handle legacy '-drive if=scsi,...' cmd line args */ -SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, +SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockBackend *blk, int unit, bool removable, int bootindex, const char *serial, Error **errp) { @@ -230,7 +230,7 @@ SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, DeviceState *dev; Error *err = NULL; - driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk"; + driver = blk_is_sg(blk) ? "scsi-generic" : "scsi-disk"; dev = qdev_create(&bus->qbus, driver); qdev_prop_set_uint32(dev, "scsi-id", unit); if (bootindex >= 0) { @@ -243,7 +243,7 @@ SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, if (serial && object_property_find(OBJECT(dev), "serial", NULL)) { qdev_prop_set_string(dev, "serial", serial); } - if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) { + if (qdev_prop_set_drive(dev, "drive", blk) < 0) { error_setg(errp, "Setting drive property failed"); object_unparent(OBJECT(dev)); return NULL; @@ -271,7 +271,7 @@ void scsi_bus_legacy_handle_cmdline(SCSIBus *bus, Error **errp) continue; } qemu_opts_loc_restore(dinfo->opts); - scsi_bus_legacy_add_drive(bus, blk_bs(blk_by_legacy_dinfo(dinfo)), + scsi_bus_legacy_add_drive(bus, blk_by_legacy_dinfo(dinfo), unit, false, -1, NULL, &err); if (err != NULL) { error_report("%s", error_get_pretty(err)); @@ -1754,7 +1754,7 @@ void scsi_req_cancel_async(SCSIRequest *req, Notifier *notifier) scsi_req_dequeue(req); req->io_canceled = true; if (req->aiocb) { - bdrv_aio_cancel_async(req->aiocb); + blk_aio_cancel_async(req->aiocb); } } @@ -1768,7 +1768,7 @@ void scsi_req_cancel(SCSIRequest *req) scsi_req_dequeue(req); req->io_canceled = true; if (req->aiocb) { - bdrv_aio_cancel(req->aiocb); + blk_aio_cancel(req->aiocb); } } diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c index ae9e08dd13..300ba01045 100644 --- a/hw/scsi/scsi-disk.c +++ b/hw/scsi/scsi-disk.c @@ -33,6 +33,7 @@ do { printf("scsi-disk: " fmt , ## __VA_ARGS__); } while (0) #include "hw/scsi/scsi.h" #include "block/scsi.h" #include "sysemu/sysemu.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #include "hw/block/block.h" #include "sysemu/dma.h" @@ -111,7 +112,7 @@ static uint32_t scsi_init_iovec(SCSIDiskReq *r, size_t size) if (!r->iov.iov_base) { r->buflen = size; - r->iov.iov_base = qemu_blockalign(s->qdev.conf.bs, r->buflen); + r->iov.iov_base = blk_blockalign(s->qdev.conf.blk, r->buflen); } r->iov.iov_len = MIN(r->sector_count * 512, r->buflen); qemu_iovec_init_external(&r->qiov, &r->iov, 1); @@ -166,7 +167,7 @@ static void scsi_aio_complete(void *opaque, int ret) assert(r->req.aiocb != NULL); r->req.aiocb = NULL; - block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct); + block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); goto done; @@ -220,9 +221,9 @@ static void scsi_write_do_fua(SCSIDiskReq *r) } if (scsi_is_cmd_fua(&r->req.cmd)) { - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, 0, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, BLOCK_ACCT_FLUSH); - r->req.aiocb = bdrv_aio_flush(s->qdev.conf.bs, scsi_aio_complete, r); + r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r); return; } @@ -239,7 +240,7 @@ static void scsi_dma_complete_noio(void *opaque, int ret) if (r->req.aiocb != NULL) { r->req.aiocb = NULL; - block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct); + block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); } if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); @@ -281,7 +282,7 @@ static void scsi_read_complete(void * opaque, int ret) assert(r->req.aiocb != NULL); r->req.aiocb = NULL; - block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct); + block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); goto done; @@ -313,7 +314,7 @@ static void scsi_do_read(void *opaque, int ret) if (r->req.aiocb != NULL) { r->req.aiocb = NULL; - block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct); + block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); } if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); @@ -330,16 +331,16 @@ static void scsi_do_read(void *opaque, int ret) scsi_req_ref(&r->req); if (r->req.sg) { - dma_acct_start(s->qdev.conf.bs, &r->acct, r->req.sg, BLOCK_ACCT_READ); + dma_acct_start(s->qdev.conf.blk, &r->acct, r->req.sg, BLOCK_ACCT_READ); r->req.resid -= r->req.sg->size; - r->req.aiocb = dma_bdrv_read(s->qdev.conf.bs, r->req.sg, r->sector, - scsi_dma_complete, r); + r->req.aiocb = dma_blk_read(s->qdev.conf.blk, r->req.sg, r->sector, + scsi_dma_complete, r); } else { n = scsi_init_iovec(r, SCSI_DMA_BUF_SIZE); - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ); - r->req.aiocb = bdrv_aio_readv(s->qdev.conf.bs, r->sector, &r->qiov, n, - scsi_read_complete, r); + r->req.aiocb = blk_aio_readv(s->qdev.conf.blk, r->sector, &r->qiov, n, + scsi_read_complete, r); } done: @@ -379,9 +380,9 @@ static void scsi_read_data(SCSIRequest *req) first = !r->started; r->started = true; if (first && scsi_is_cmd_fua(&r->req.cmd)) { - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, 0, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, BLOCK_ACCT_FLUSH); - r->req.aiocb = bdrv_aio_flush(s->qdev.conf.bs, scsi_do_read, r); + r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_do_read, r); } else { scsi_do_read(r, 0); } @@ -398,7 +399,8 @@ static int scsi_handle_rw_error(SCSIDiskReq *r, int error) { bool is_read = (r->req.cmd.xfer == SCSI_XFER_FROM_DEV); SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); - BlockErrorAction action = bdrv_get_error_action(s->qdev.conf.bs, is_read, error); + BlockErrorAction action = blk_get_error_action(s->qdev.conf.blk, + is_read, error); if (action == BLOCK_ERROR_ACTION_REPORT) { switch (error) { @@ -419,7 +421,7 @@ static int scsi_handle_rw_error(SCSIDiskReq *r, int error) break; } } - bdrv_error_action(s->qdev.conf.bs, action, is_read, error); + blk_error_action(s->qdev.conf.blk, action, is_read, error); if (action == BLOCK_ERROR_ACTION_STOP) { scsi_req_retry(&r->req); } @@ -434,7 +436,7 @@ static void scsi_write_complete(void * opaque, int ret) if (r->req.aiocb != NULL) { r->req.aiocb = NULL; - block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct); + block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); } if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); @@ -502,16 +504,16 @@ static void scsi_write_data(SCSIRequest *req) } if (r->req.sg) { - dma_acct_start(s->qdev.conf.bs, &r->acct, r->req.sg, BLOCK_ACCT_WRITE); + dma_acct_start(s->qdev.conf.blk, &r->acct, r->req.sg, BLOCK_ACCT_WRITE); r->req.resid -= r->req.sg->size; - r->req.aiocb = dma_bdrv_write(s->qdev.conf.bs, r->req.sg, r->sector, - scsi_dma_complete, r); + r->req.aiocb = dma_blk_write(s->qdev.conf.blk, r->req.sg, r->sector, + scsi_dma_complete, r); } else { n = r->qiov.size / 512; - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, n * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE); - r->req.aiocb = bdrv_aio_writev(s->qdev.conf.bs, r->sector, &r->qiov, n, - scsi_write_complete, r); + r->req.aiocb = blk_aio_writev(s->qdev.conf.blk, r->sector, &r->qiov, n, + scsi_write_complete, r); } } @@ -578,7 +580,7 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) case 0x83: /* Device identification page, mandatory */ { - const char *str = s->serial ?: bdrv_get_device_name(s->qdev.conf.bs); + const char *str = s->serial ?: blk_name(s->qdev.conf.blk); int max_len = s->serial ? 20 : 255 - 8; int id_len = strlen(str); @@ -739,10 +741,10 @@ static inline bool media_is_dvd(SCSIDiskState *s) if (s->qdev.type != TYPE_ROM) { return false; } - if (!bdrv_is_inserted(s->qdev.conf.bs)) { + if (!blk_is_inserted(s->qdev.conf.blk)) { return false; } - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); return nb_sectors > CD_MAX_SECTORS; } @@ -752,10 +754,10 @@ static inline bool media_is_cd(SCSIDiskState *s) if (s->qdev.type != TYPE_ROM) { return false; } - if (!bdrv_is_inserted(s->qdev.conf.bs)) { + if (!blk_is_inserted(s->qdev.conf.blk)) { return false; } - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); return nb_sectors <= CD_MAX_SECTORS; } @@ -816,7 +818,7 @@ static int scsi_read_dvd_structure(SCSIDiskState *s, SCSIDiskReq *r, } if (format != 0xff) { - if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) { + if (s->tray_open || !blk_is_inserted(s->qdev.conf.blk)) { scsi_check_condition(r, SENSE_CODE(NO_MEDIUM)); return -1; } @@ -838,7 +840,7 @@ static int scsi_read_dvd_structure(SCSIDiskState *s, SCSIDiskReq *r, if (layer != 0) { goto fail; } - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); outbuf[4] = 1; /* DVD-ROM, part version 1 */ outbuf[5] = 0xf; /* 120mm disc, minimum rate unspecified */ @@ -893,7 +895,7 @@ static int scsi_event_status_media(SCSIDiskState *s, uint8_t *outbuf) media_status = 0; if (s->tray_open) { media_status = MS_TRAY_OPEN; - } else if (bdrv_is_inserted(s->qdev.conf.bs)) { + } else if (blk_is_inserted(s->qdev.conf.blk)) { media_status = MS_MEDIA_PRESENT; } @@ -1091,7 +1093,7 @@ static int mode_sense_page(SCSIDiskState *s, int page, uint8_t **p_outbuf, case MODE_PAGE_CACHING: length = 0x12; if (page_control == 1 || /* Changeable Values */ - bdrv_enable_write_cache(s->qdev.conf.bs)) { + blk_enable_write_cache(s->qdev.conf.blk)) { p[0] = 4; /* WCE */ } break; @@ -1172,7 +1174,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 (bdrv_is_read_only(s->qdev.conf.bs)) { + if (blk_is_read_only(s->qdev.conf.blk)) { dev_specific_param |= 0x80; /* Readonly. */ } } else { @@ -1194,7 +1196,7 @@ static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf) p += 8; } - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); if (!dbd && nb_sectors) { if (r->req.cmd.buf[0] == MODE_SENSE) { outbuf[3] = 8; /* Block descriptor length */ @@ -1257,7 +1259,7 @@ static int scsi_disk_emulate_read_toc(SCSIRequest *req, uint8_t *outbuf) msf = req->cmd.buf[1] & 2; format = req->cmd.buf[2] & 0xf; start_track = req->cmd.buf[6]; - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track, format, msf >> 1); nb_sectors /= s->qdev.blocksize / 512; switch (format) { @@ -1297,14 +1299,14 @@ static int scsi_disk_emulate_start_stop(SCSIDiskReq *r) if ((s->features & (1 << SCSI_DISK_F_REMOVABLE)) && loej) { if (!start && !s->tray_open && s->tray_locked) { scsi_check_condition(r, - bdrv_is_inserted(s->qdev.conf.bs) + blk_is_inserted(s->qdev.conf.blk) ? SENSE_CODE(ILLEGAL_REQ_REMOVAL_PREVENTED) : SENSE_CODE(NOT_READY_REMOVAL_PREVENTED)); return -1; } if (s->tray_open != !start) { - bdrv_eject(s->qdev.conf.bs, !start); + blk_eject(s->qdev.conf.blk, !start); s->tray_open = !start; } } @@ -1371,7 +1373,7 @@ static void scsi_disk_apply_mode_select(SCSIDiskState *s, int page, uint8_t *p) { switch (page) { case MODE_PAGE_CACHING: - bdrv_set_enable_write_cache(s->qdev.conf.bs, (p[0] & 4) != 0); + blk_set_enable_write_cache(s->qdev.conf.blk, (p[0] & 4) != 0); break; default: @@ -1474,12 +1476,12 @@ static void scsi_disk_emulate_mode_select(SCSIDiskReq *r, uint8_t *inbuf) return; } } - if (!bdrv_enable_write_cache(s->qdev.conf.bs)) { + if (!blk_enable_write_cache(s->qdev.conf.blk)) { /* The request is used as the AIO opaque value, so add a ref. */ scsi_req_ref(&r->req); - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, 0, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, BLOCK_ACCT_FLUSH); - r->req.aiocb = bdrv_aio_flush(s->qdev.conf.bs, scsi_aio_complete, r); + r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r); return; } @@ -1548,10 +1550,10 @@ static void scsi_unmap_complete(void *opaque, int ret) goto done; } - r->req.aiocb = bdrv_aio_discard(s->qdev.conf.bs, - sector_num * (s->qdev.blocksize / 512), - nb_sectors * (s->qdev.blocksize / 512), - scsi_unmap_complete, data); + r->req.aiocb = blk_aio_discard(s->qdev.conf.blk, + sector_num * (s->qdev.blocksize / 512), + nb_sectors * (s->qdev.blocksize / 512), + scsi_unmap_complete, data); data->count--; data->inbuf += 16; return; @@ -1589,7 +1591,7 @@ static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf) goto invalid_param_len; } - if (bdrv_is_read_only(s->qdev.conf.bs)) { + if (blk_is_read_only(s->qdev.conf.blk)) { scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); return; } @@ -1628,7 +1630,7 @@ static void scsi_write_same_complete(void *opaque, int ret) assert(r->req.aiocb != NULL); r->req.aiocb = NULL; - block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct); + block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); goto done; @@ -1644,11 +1646,11 @@ static void scsi_write_same_complete(void *opaque, int ret) data->sector += data->iov.iov_len / 512; data->iov.iov_len = MIN(data->nb_sectors * 512, data->iov.iov_len); if (data->iov.iov_len) { - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, data->iov.iov_len, BLOCK_ACCT_WRITE); - r->req.aiocb = bdrv_aio_writev(s->qdev.conf.bs, data->sector, - &data->qiov, data->iov.iov_len / 512, - scsi_write_same_complete, data); + r->req.aiocb = blk_aio_writev(s->qdev.conf.blk, data->sector, + &data->qiov, data->iov.iov_len / 512, + scsi_write_same_complete, data); return; } @@ -1675,7 +1677,7 @@ static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf) return; } - if (bdrv_is_read_only(s->qdev.conf.bs)) { + if (blk_is_read_only(s->qdev.conf.blk)) { scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); return; } @@ -1689,13 +1691,13 @@ static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf) /* The request is used as the AIO opaque value, so add a ref. */ scsi_req_ref(&r->req); - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, nb_sectors * s->qdev.blocksize, BLOCK_ACCT_WRITE); - r->req.aiocb = bdrv_aio_write_zeroes(s->qdev.conf.bs, - r->req.cmd.lba * (s->qdev.blocksize / 512), - nb_sectors * (s->qdev.blocksize / 512), - flags, scsi_aio_complete, r); + r->req.aiocb = blk_aio_write_zeroes(s->qdev.conf.blk, + r->req.cmd.lba * (s->qdev.blocksize / 512), + nb_sectors * (s->qdev.blocksize / 512), + flags, scsi_aio_complete, r); return; } @@ -1704,7 +1706,8 @@ static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf) data->sector = r->req.cmd.lba * (s->qdev.blocksize / 512); data->nb_sectors = nb_sectors * (s->qdev.blocksize / 512); data->iov.iov_len = MIN(data->nb_sectors * 512, SCSI_WRITE_SAME_MAX); - data->iov.iov_base = buf = qemu_blockalign(s->qdev.conf.bs, data->iov.iov_len); + data->iov.iov_base = buf = blk_blockalign(s->qdev.conf.blk, + data->iov.iov_len); qemu_iovec_init_external(&data->qiov, &data->iov, 1); for (i = 0; i < data->iov.iov_len; i += s->qdev.blocksize) { @@ -1712,11 +1715,11 @@ static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf) } scsi_req_ref(&r->req); - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, data->iov.iov_len, BLOCK_ACCT_WRITE); - r->req.aiocb = bdrv_aio_writev(s->qdev.conf.bs, data->sector, - &data->qiov, data->iov.iov_len / 512, - scsi_write_same_complete, data); + r->req.aiocb = blk_aio_writev(s->qdev.conf.blk, data->sector, + &data->qiov, data->iov.iov_len / 512, + scsi_write_same_complete, data); } static void scsi_disk_emulate_write_data(SCSIRequest *req) @@ -1785,7 +1788,7 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) break; default: - if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) { + if (s->tray_open || !blk_is_inserted(s->qdev.conf.blk)) { scsi_check_condition(r, SENSE_CODE(NO_MEDIUM)); return 0; } @@ -1806,7 +1809,7 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) r->buflen = MAX(4096, req->cmd.xfer); if (!r->iov.iov_base) { - r->iov.iov_base = qemu_blockalign(s->qdev.conf.bs, r->buflen); + r->iov.iov_base = blk_blockalign(s->qdev.conf.blk, r->buflen); } buflen = req->cmd.xfer; @@ -1814,7 +1817,7 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) memset(outbuf, 0, r->buflen); switch (req->cmd.buf[0]) { case TEST_UNIT_READY: - assert(!s->tray_open && bdrv_is_inserted(s->qdev.conf.bs)); + assert(!s->tray_open && blk_is_inserted(s->qdev.conf.blk)); break; case INQUIRY: buflen = scsi_disk_emulate_inquiry(req, outbuf); @@ -1862,12 +1865,12 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) break; case ALLOW_MEDIUM_REMOVAL: s->tray_locked = req->cmd.buf[4] & 1; - bdrv_lock_medium(s->qdev.conf.bs, req->cmd.buf[4] & 1); + blk_lock_medium(s->qdev.conf.blk, req->cmd.buf[4] & 1); break; case READ_CAPACITY_10: /* The normal LEN field for this command is zero. */ memset(outbuf, 0, 8); - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); if (!nb_sectors) { scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY)); return 0; @@ -1936,7 +1939,7 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) if ((req->cmd.buf[1] & 31) == SAI_READ_CAPACITY_16) { DPRINTF("SAI READ CAPACITY(16)\n"); memset(outbuf, 0, req->cmd.xfer); - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); if (!nb_sectors) { scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY)); return 0; @@ -1977,9 +1980,9 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) case SYNCHRONIZE_CACHE: /* The request is used as the AIO opaque value, so add a ref. */ scsi_req_ref(&r->req); - block_acct_start(bdrv_get_stats(s->qdev.conf.bs), &r->acct, 0, + block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, BLOCK_ACCT_FLUSH); - r->req.aiocb = bdrv_aio_flush(s->qdev.conf.bs, scsi_aio_complete, r); + r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r); return 0; case SEEK_10: DPRINTF("Seek(10) (sector %" PRId64 ")\n", r->req.cmd.lba); @@ -2053,7 +2056,7 @@ static int32_t scsi_disk_dma_command(SCSIRequest *req, uint8_t *buf) command = buf[0]; - if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) { + if (s->tray_open || !blk_is_inserted(s->qdev.conf.blk)) { scsi_check_condition(r, SENSE_CODE(NO_MEDIUM)); return 0; } @@ -2081,7 +2084,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 (bdrv_is_read_only(s->qdev.conf.bs)) { + if (blk_is_read_only(s->qdev.conf.blk)) { scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); return 0; } @@ -2124,7 +2127,7 @@ static void scsi_disk_reset(DeviceState *dev) scsi_device_purge_requests(&s->qdev, SENSE_CODE(RESET)); - bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors); + blk_get_geometry(s->qdev.conf.blk, &nb_sectors); nb_sectors /= s->qdev.blocksize / 512; if (nb_sectors) { nb_sectors--; @@ -2140,7 +2143,7 @@ static void scsi_unrealize(SCSIDevice *dev, Error **errp) SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); scsi_device_purge_requests(&s->qdev, SENSE_CODE(NO_SENSE)); - blockdev_mark_auto_del(s->qdev.conf.bs); + blockdev_mark_auto_del(s->qdev.conf.blk); } static void scsi_disk_resize_cb(void *opaque) @@ -2223,13 +2226,13 @@ static void scsi_realize(SCSIDevice *dev, Error **errp) SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); Error *err = NULL; - if (!s->qdev.conf.bs) { + if (!s->qdev.conf.blk) { error_setg(errp, "drive property not set"); return; } if (!(s->features & (1 << SCSI_DISK_F_REMOVABLE)) && - !bdrv_is_inserted(s->qdev.conf.bs)) { + !blk_is_inserted(s->qdev.conf.blk)) { error_setg(errp, "Device needs media, but drive is empty"); return; } @@ -2255,20 +2258,20 @@ static void scsi_realize(SCSIDevice *dev, Error **errp) s->vendor = g_strdup("QEMU"); } - if (bdrv_is_sg(s->qdev.conf.bs)) { + if (blk_is_sg(s->qdev.conf.blk)) { error_setg(errp, "unwanted /dev/sg*"); return; } if ((s->features & (1 << SCSI_DISK_F_REMOVABLE)) && !(s->features & (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS))) { - bdrv_set_dev_ops(s->qdev.conf.bs, &scsi_disk_removable_block_ops, s); + blk_set_dev_ops(s->qdev.conf.blk, &scsi_disk_removable_block_ops, s); } else { - bdrv_set_dev_ops(s->qdev.conf.bs, &scsi_disk_block_ops, s); + blk_set_dev_ops(s->qdev.conf.blk, &scsi_disk_block_ops, s); } - bdrv_set_guest_block_size(s->qdev.conf.bs, s->qdev.blocksize); + blk_set_guest_block_size(s->qdev.conf.blk, s->qdev.blocksize); - bdrv_iostatus_enable(s->qdev.conf.bs); + blk_iostatus_enable(s->qdev.conf.blk); } static void scsi_hd_realize(SCSIDevice *dev, Error **errp) @@ -2299,14 +2302,14 @@ static void scsi_disk_realize(SCSIDevice *dev, Error **errp) DriveInfo *dinfo; Error *local_err = NULL; - if (!dev->conf.bs) { + if (!dev->conf.blk) { scsi_realize(dev, &local_err); assert(local_err); error_propagate(errp, local_err); return; } - dinfo = drive_get_by_blockdev(dev->conf.bs); + dinfo = blk_legacy_dinfo(dev->conf.blk); if (dinfo->media_cd) { scsi_cd_realize(dev, errp); } else { @@ -2406,7 +2409,6 @@ static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun, #ifdef __linux__ static int get_device_type(SCSIDiskState *s) { - BlockDriverState *bdrv = s->qdev.conf.bs; uint8_t cmd[16]; uint8_t buf[36]; uint8_t sensebuf[8]; @@ -2429,7 +2431,7 @@ static int get_device_type(SCSIDiskState *s) io_header.sbp = sensebuf; io_header.timeout = 6000; /* XXX */ - ret = bdrv_ioctl(bdrv, SG_IO, &io_header); + ret = blk_ioctl(s->qdev.conf.blk, SG_IO, &io_header); if (ret < 0 || io_header.driver_status || io_header.host_status) { return -1; } @@ -2446,13 +2448,13 @@ static void scsi_block_realize(SCSIDevice *dev, Error **errp) int sg_version; int rc; - if (!s->qdev.conf.bs) { + if (!s->qdev.conf.blk) { error_setg(errp, "drive property not set"); return; } /* check we are using a driver managing SG_IO (version 3 and after) */ - rc = bdrv_ioctl(s->qdev.conf.bs, SG_GET_VERSION_NUM, &sg_version); + rc = blk_ioctl(s->qdev.conf.blk, SG_GET_VERSION_NUM, &sg_version); if (rc < 0) { error_setg(errp, "cannot get SG_IO version number: %s. " "Is this a SCSI device?", @@ -2511,7 +2513,7 @@ static bool scsi_block_is_passthrough(SCSIDiskState *s, uint8_t *buf) * ones (such as WRITE SAME or EXTENDED COPY, etc.). So, without * O_DIRECT everything must go through SG_IO. */ - if (!(bdrv_get_flags(s->qdev.conf.bs) & BDRV_O_NOCACHE)) { + if (!(blk_get_flags(s->qdev.conf.blk) & BDRV_O_NOCACHE)) { break; } @@ -2660,7 +2662,7 @@ static const TypeInfo scsi_cd_info = { #ifdef __linux__ static Property scsi_block_properties[] = { - DEFINE_PROP_DRIVE("drive", SCSIDiskState, qdev.conf.bs), + DEFINE_PROP_DRIVE("drive", SCSIDiskState, qdev.conf.blk), DEFINE_PROP_END_OF_LIST(), }; diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c index 4177c5357e..f2e53afd09 100644 --- a/hw/scsi/scsi-generic.c +++ b/hw/scsi/scsi-generic.c @@ -14,6 +14,7 @@ #include "qemu-common.h" #include "qemu/error-report.h" #include "hw/scsi/scsi.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" #ifdef __linux__ @@ -141,7 +142,7 @@ done: scsi_req_unref(&r->req); } -static int execute_command(BlockDriverState *bdrv, +static int execute_command(BlockBackend *blk, SCSIGenericReq *r, int direction, BlockCompletionFunc *complete) { @@ -157,7 +158,7 @@ static int execute_command(BlockDriverState *bdrv, r->io_header.usr_ptr = r; r->io_header.flags |= SG_FLAG_DIRECT_IO; - r->req.aiocb = bdrv_aio_ioctl(bdrv, SG_IO, &r->io_header, complete, r); + r->req.aiocb = blk_aio_ioctl(blk, SG_IO, &r->io_header, complete, r); if (r->req.aiocb == NULL) { return -EIO; } @@ -193,7 +194,7 @@ static void scsi_read_complete(void * opaque, int ret) s->blocksize = ldl_be_p(&r->buf[8]); s->max_lba = ldq_be_p(&r->buf[0]); } - bdrv_set_guest_block_size(s->conf.bs, s->blocksize); + blk_set_guest_block_size(s->conf.blk, s->blocksize); scsi_req_data(&r->req, len); scsi_req_unref(&r->req); @@ -216,7 +217,8 @@ static void scsi_read_data(SCSIRequest *req) return; } - ret = execute_command(s->conf.bs, r, SG_DXFER_FROM_DEV, scsi_read_complete); + ret = execute_command(s->conf.blk, r, SG_DXFER_FROM_DEV, + scsi_read_complete); if (ret < 0) { scsi_command_complete(r, ret); } @@ -260,7 +262,7 @@ static void scsi_write_data(SCSIRequest *req) /* The request is used as the AIO opaque value, so add a ref. */ scsi_req_ref(&r->req); - ret = execute_command(s->conf.bs, r, SG_DXFER_TO_DEV, scsi_write_complete); + ret = execute_command(s->conf.blk, r, SG_DXFER_TO_DEV, scsi_write_complete); if (ret < 0) { scsi_command_complete(r, ret); } @@ -302,7 +304,8 @@ static int32_t scsi_send_command(SCSIRequest *req, uint8_t *cmd) r->buf = NULL; /* The request is used as the AIO opaque value, so add a ref. */ scsi_req_ref(&r->req); - ret = execute_command(s->conf.bs, r, SG_DXFER_NONE, scsi_command_complete); + ret = execute_command(s->conf.blk, r, SG_DXFER_NONE, + scsi_command_complete); if (ret < 0) { scsi_command_complete(r, ret); return 0; @@ -327,7 +330,7 @@ static int32_t scsi_send_command(SCSIRequest *req, uint8_t *cmd) } } -static int get_stream_blocksize(BlockDriverState *bdrv) +static int get_stream_blocksize(BlockBackend *blk) { uint8_t cmd[6]; uint8_t buf[12]; @@ -351,7 +354,7 @@ static int get_stream_blocksize(BlockDriverState *bdrv) io_header.sbp = sensebuf; io_header.timeout = 6000; /* XXX */ - ret = bdrv_ioctl(bdrv, SG_IO, &io_header); + ret = blk_ioctl(blk, SG_IO, &io_header); if (ret < 0 || io_header.driver_status || io_header.host_status) { return -1; } @@ -368,7 +371,7 @@ static void scsi_generic_reset(DeviceState *dev) static void scsi_unrealize(SCSIDevice *s, Error **errp) { scsi_device_purge_requests(s, SENSE_CODE(NO_SENSE)); - blockdev_mark_auto_del(s->conf.bs); + blockdev_mark_auto_del(s->conf.blk); } static void scsi_generic_realize(SCSIDevice *s, Error **errp) @@ -377,22 +380,22 @@ static void scsi_generic_realize(SCSIDevice *s, Error **errp) int sg_version; struct sg_scsi_id scsiid; - if (!s->conf.bs) { + if (!s->conf.blk) { error_setg(errp, "drive property not set"); return; } - if (bdrv_get_on_error(s->conf.bs, 0) != BLOCKDEV_ON_ERROR_ENOSPC) { + if (blk_get_on_error(s->conf.blk, 0) != BLOCKDEV_ON_ERROR_ENOSPC) { error_setg(errp, "Device doesn't support drive option werror"); return; } - if (bdrv_get_on_error(s->conf.bs, 1) != BLOCKDEV_ON_ERROR_REPORT) { + if (blk_get_on_error(s->conf.blk, 1) != BLOCKDEV_ON_ERROR_REPORT) { error_setg(errp, "Device doesn't support drive option rerror"); return; } /* check we are using a driver managing SG_IO (version 3 and after */ - rc = bdrv_ioctl(s->conf.bs, SG_GET_VERSION_NUM, &sg_version); + rc = blk_ioctl(s->conf.blk, SG_GET_VERSION_NUM, &sg_version); if (rc < 0) { error_setg(errp, "cannot get SG_IO version number: %s. " "Is this a SCSI device?", @@ -405,7 +408,7 @@ static void scsi_generic_realize(SCSIDevice *s, Error **errp) } /* get LUN of the /dev/sg? */ - if (bdrv_ioctl(s->conf.bs, SG_GET_SCSI_ID, &scsiid)) { + if (blk_ioctl(s->conf.blk, SG_GET_SCSI_ID, &scsiid)) { error_setg(errp, "SG_GET_SCSI_ID ioctl failed"); return; } @@ -416,7 +419,7 @@ static void scsi_generic_realize(SCSIDevice *s, Error **errp) switch (s->type) { case TYPE_TAPE: - s->blocksize = get_stream_blocksize(s->conf.bs); + s->blocksize = get_stream_blocksize(s->conf.blk); if (s->blocksize == -1) { s->blocksize = 0; } @@ -459,7 +462,7 @@ static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun, } static Property scsi_generic_properties[] = { - DEFINE_PROP_DRIVE("drive", SCSIDevice, conf.bs), + DEFINE_PROP_DRIVE("drive", SCSIDevice, conf.blk), DEFINE_PROP_END_OF_LIST(), }; diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c index b778e051f8..48dcfd2852 100644 --- a/hw/scsi/virtio-scsi-dataplane.c +++ b/hw/scsi/virtio-scsi-dataplane.c @@ -13,6 +13,7 @@ #include "hw/virtio/virtio-scsi.h" #include "qemu/error-report.h" +#include "sysemu/block-backend.h" #include #include #include @@ -205,7 +206,7 @@ void virtio_scsi_dataplane_stop(VirtIOSCSI *s) aio_set_event_notifier(s->ctx, &s->cmd_vrings[i]->host_notifier, NULL); } - bdrv_drain_all(); /* ensure there are no in-flight requests */ + blk_drain_all(); /* ensure there are no in-flight requests */ aio_context_release(s->ctx); diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c index 8547ea0475..a1725b8f48 100644 --- a/hw/scsi/virtio-scsi.c +++ b/hw/scsi/virtio-scsi.c @@ -16,6 +16,7 @@ #include "hw/virtio/virtio-scsi.h" #include "qemu/error-report.h" #include "qemu/iov.h" +#include "sysemu/block-backend.h" #include #include #include @@ -236,9 +237,9 @@ static int virtio_scsi_do_tmf(VirtIOSCSI *s, VirtIOSCSIReq *req) int target; int ret = 0; - if (s->dataplane_started && bdrv_get_aio_context(d->conf.bs) != s->ctx) { + if (s->dataplane_started && blk_get_aio_context(d->conf.blk) != s->ctx) { aio_context_acquire(s->ctx); - bdrv_set_aio_context(d->conf.bs, s->ctx); + blk_set_aio_context(d->conf.blk, s->ctx); aio_context_release(s->ctx); } /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */ @@ -522,9 +523,9 @@ bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req) virtio_scsi_complete_cmd_req(req); return false; } - if (s->dataplane_started && bdrv_get_aio_context(d->conf.bs) != s->ctx) { + if (s->dataplane_started && blk_get_aio_context(d->conf.blk) != s->ctx) { aio_context_acquire(s->ctx); - bdrv_set_aio_context(d->conf.bs, s->ctx); + blk_set_aio_context(d->conf.blk, s->ctx); aio_context_release(s->ctx); } req->sreq = scsi_req_new(d, req->req.cmd.tag, @@ -539,7 +540,7 @@ bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req) return false; } scsi_req_ref(req->sreq); - bdrv_io_plug(d->conf.bs); + blk_io_plug(d->conf.blk); return true; } @@ -549,7 +550,7 @@ void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req) if (scsi_req_enqueue(sreq)) { scsi_req_continue(sreq); } - bdrv_io_unplug(sreq->dev->conf.bs); + blk_io_unplug(sreq->dev->conf.blk); scsi_req_unref(sreq); } @@ -832,7 +833,7 @@ static void virtio_scsi_migration_state_changed(Notifier *notifier, void *data) if (s->dataplane_started) { return; } - bdrv_drain_all(); /* complete in-flight non-dataplane requests */ + blk_drain_all(); /* complete in-flight non-dataplane requests */ s->dataplane_disabled = false; } } diff --git a/hw/sd/milkymist-memcard.c b/hw/sd/milkymist-memcard.c index 501aa3a2c4..9661eafac8 100644 --- a/hw/sd/milkymist-memcard.c +++ b/hw/sd/milkymist-memcard.c @@ -253,16 +253,16 @@ static int milkymist_memcard_init(SysBusDevice *dev) { MilkymistMemcardState *s = MILKYMIST_MEMCARD(dev); DriveInfo *dinfo; - BlockDriverState *bs; + BlockBackend *blk; dinfo = drive_get_next(IF_SD); - bs = dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL; - s->card = sd_init(bs, false); + blk = dinfo ? blk_by_legacy_dinfo(dinfo) : NULL; + s->card = sd_init(blk, false); if (s->card == NULL) { return -1; } - s->enabled = bs && bdrv_is_inserted(bs); + s->enabled = blk && blk_is_inserted(blk); memory_region_init_io(&s->regs_region, OBJECT(s), &memcard_mmio_ops, s, "milkymist-memcard", R_MAX * 4); diff --git a/hw/sd/omap_mmc.c b/hw/sd/omap_mmc.c index 6c92149c04..86c477d720 100644 --- a/hw/sd/omap_mmc.c +++ b/hw/sd/omap_mmc.c @@ -574,7 +574,7 @@ static void omap_mmc_cover_cb(void *opaque, int line, int level) struct omap_mmc_s *omap_mmc_init(hwaddr base, MemoryRegion *sysmem, - BlockDriverState *bd, + BlockBackend *blk, qemu_irq irq, qemu_irq dma[], omap_clk clk) { struct omap_mmc_s *s = (struct omap_mmc_s *) @@ -592,7 +592,7 @@ struct omap_mmc_s *omap_mmc_init(hwaddr base, memory_region_add_subregion(sysmem, base, &s->iomem); /* Instantiate the storage */ - s->card = sd_init(bd, false); + s->card = sd_init(blk, false); if (s->card == NULL) { exit(1); } @@ -601,7 +601,7 @@ struct omap_mmc_s *omap_mmc_init(hwaddr base, } struct omap_mmc_s *omap2_mmc_init(struct omap_target_agent_s *ta, - BlockDriverState *bd, qemu_irq irq, qemu_irq dma[], + BlockBackend *blk, qemu_irq irq, qemu_irq dma[], omap_clk fclk, omap_clk iclk) { struct omap_mmc_s *s = (struct omap_mmc_s *) @@ -620,7 +620,7 @@ struct omap_mmc_s *omap2_mmc_init(struct omap_target_agent_s *ta, omap_l4_attach(ta, 0, &s->iomem); /* Instantiate the storage */ - s->card = sd_init(bd, false); + s->card = sd_init(blk, false); if (s->card == NULL) { exit(1); } diff --git a/hw/sd/pl181.c b/hw/sd/pl181.c index 0501d4079c..e704b6e97a 100644 --- a/hw/sd/pl181.c +++ b/hw/sd/pl181.c @@ -491,7 +491,7 @@ static int pl181_init(SysBusDevice *sbd) sysbus_init_irq(sbd, &s->irq[1]); qdev_init_gpio_out(dev, s->cardstatus, 2); dinfo = drive_get_next(IF_SD); - s->card = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, false); + s->card = sd_init(dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, false); if (s->card == NULL) { return -1; } diff --git a/hw/sd/pxa2xx_mmci.c b/hw/sd/pxa2xx_mmci.c index b9d8b1a3e1..ac3ab39bea 100644 --- a/hw/sd/pxa2xx_mmci.c +++ b/hw/sd/pxa2xx_mmci.c @@ -523,7 +523,7 @@ static int pxa2xx_mmci_load(QEMUFile *f, void *opaque, int version_id) PXA2xxMMCIState *pxa2xx_mmci_init(MemoryRegion *sysmem, hwaddr base, - BlockDriverState *bd, qemu_irq irq, + BlockBackend *blk, qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma) { PXA2xxMMCIState *s; @@ -538,7 +538,7 @@ PXA2xxMMCIState *pxa2xx_mmci_init(MemoryRegion *sysmem, memory_region_add_subregion(sysmem, base, &s->iomem); /* Instantiate the actual storage */ - s->card = sd_init(bd, false); + s->card = sd_init(blk, false); if (s->card == NULL) { exit(1); } diff --git a/hw/sd/sd.c b/hw/sd/sd.c index 5efe8c1af7..f955265f74 100644 --- a/hw/sd/sd.c +++ b/hw/sd/sd.c @@ -30,7 +30,7 @@ */ #include "hw/hw.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "hw/sd.h" #include "qemu/bitmap.h" @@ -110,7 +110,7 @@ struct SDState { uint8_t data[512]; qemu_irq readonly_cb; qemu_irq inserted_cb; - BlockDriverState *bdrv; + BlockBackend *blk; uint8_t *buf; bool enable; @@ -389,13 +389,13 @@ static inline uint64_t sd_addr_to_wpnum(uint64_t addr) return addr >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT); } -static void sd_reset(SDState *sd, BlockDriverState *bdrv) +static void sd_reset(SDState *sd, BlockBackend *blk) { uint64_t size; uint64_t sect; - if (bdrv) { - bdrv_get_geometry(bdrv, §); + if (blk) { + blk_get_geometry(blk, §); } else { sect = 0; } @@ -412,11 +412,11 @@ static void sd_reset(SDState *sd, BlockDriverState *bdrv) sd_set_cardstatus(sd); sd_set_sdstatus(sd); - sd->bdrv = bdrv; + sd->blk = blk; if (sd->wp_groups) g_free(sd->wp_groups); - sd->wp_switch = bdrv ? bdrv_is_read_only(bdrv) : false; + sd->wp_switch = blk ? blk_is_read_only(blk) : false; sd->wpgrps_size = sect; sd->wp_groups = bitmap_new(sd->wpgrps_size); memset(sd->function_group, 0, sizeof(sd->function_group)); @@ -432,9 +432,9 @@ static void sd_cardchange(void *opaque, bool load) { SDState *sd = opaque; - qemu_set_irq(sd->inserted_cb, bdrv_is_inserted(sd->bdrv)); - if (bdrv_is_inserted(sd->bdrv)) { - sd_reset(sd, sd->bdrv); + qemu_set_irq(sd->inserted_cb, blk_is_inserted(sd->blk)); + if (blk_is_inserted(sd->blk)) { + sd_reset(sd, sd->blk); qemu_set_irq(sd->readonly_cb, sd->wp_switch); } } @@ -479,23 +479,23 @@ static const VMStateDescription sd_vmstate = { whether card should be in SSI or MMC/SD mode. It is also up to the board to ensure that ssi transfers only occur when the chip select is asserted. */ -SDState *sd_init(BlockDriverState *bs, bool is_spi) +SDState *sd_init(BlockBackend *blk, bool is_spi) { SDState *sd; - if (bs && bdrv_is_read_only(bs)) { + if (blk && blk_is_read_only(blk)) { fprintf(stderr, "sd_init: Cannot use read-only drive\n"); return NULL; } sd = (SDState *) g_malloc0(sizeof(SDState)); - sd->buf = qemu_blockalign(bs, 512); + sd->buf = blk_blockalign(blk, 512); sd->spi = is_spi; sd->enable = true; - sd_reset(sd, bs); - if (sd->bdrv) { - bdrv_attach_dev_nofail(sd->bdrv, sd); - bdrv_set_dev_ops(sd->bdrv, &sd_block_ops, sd); + sd_reset(sd, blk); + if (sd->blk) { + blk_attach_dev_nofail(sd->blk, sd); + blk_set_dev_ops(sd->blk, &sd_block_ops, sd); } vmstate_register(NULL, -1, &sd_vmstate, sd); return sd; @@ -505,8 +505,8 @@ 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->bdrv ? bdrv_is_read_only(sd->bdrv) : 0); - qemu_set_irq(insert, sd->bdrv ? bdrv_is_inserted(sd->bdrv) : 0); + qemu_set_irq(readonly, sd->blk ? blk_is_read_only(sd->blk) : 0); + qemu_set_irq(insert, sd->blk ? blk_is_inserted(sd->blk) : 0); } static void sd_erase(SDState *sd) @@ -680,7 +680,7 @@ static sd_rsp_type_t sd_normal_command(SDState *sd, default: sd->state = sd_idle_state; - sd_reset(sd, sd->bdrv); + sd_reset(sd, sd->blk); return sd->spi ? sd_r1 : sd_r0; } break; @@ -1347,7 +1347,7 @@ int sd_do_command(SDState *sd, SDRequest *req, sd_rsp_type_t rtype; int rsplen; - if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv) || !sd->enable) { + if (!sd->blk || !blk_is_inserted(sd->blk) || !sd->enable) { return 0; } @@ -1456,7 +1456,7 @@ static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len) DPRINTF("sd_blk_read: addr = 0x%08llx, len = %d\n", (unsigned long long) addr, len); - if (!sd->bdrv || bdrv_read(sd->bdrv, addr >> 9, sd->buf, 1) < 0) { + if (!sd->blk || blk_read(sd->blk, addr >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_read: read error on host side\n"); return; } @@ -1464,7 +1464,7 @@ static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len) if (end > (addr & ~511) + 512) { memcpy(sd->data, sd->buf + (addr & 511), 512 - (addr & 511)); - if (bdrv_read(sd->bdrv, end >> 9, sd->buf, 1) < 0) { + if (blk_read(sd->blk, end >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_read: read error on host side\n"); return; } @@ -1478,29 +1478,29 @@ static void sd_blk_write(SDState *sd, uint64_t addr, uint32_t len) uint64_t end = addr + len; if ((addr & 511) || len < 512) - if (!sd->bdrv || bdrv_read(sd->bdrv, addr >> 9, sd->buf, 1) < 0) { + if (!sd->blk || blk_read(sd->blk, addr >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_write: read error on host side\n"); return; } if (end > (addr & ~511) + 512) { memcpy(sd->buf + (addr & 511), sd->data, 512 - (addr & 511)); - if (bdrv_write(sd->bdrv, addr >> 9, sd->buf, 1) < 0) { + if (blk_write(sd->blk, addr >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_write: write error on host side\n"); return; } - if (bdrv_read(sd->bdrv, end >> 9, sd->buf, 1) < 0) { + if (blk_read(sd->blk, end >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_write: read error on host side\n"); return; } memcpy(sd->buf, sd->data + 512 - (addr & 511), end & 511); - if (bdrv_write(sd->bdrv, end >> 9, sd->buf, 1) < 0) { + if (blk_write(sd->blk, end >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_write: write error on host side\n"); } } else { memcpy(sd->buf + (addr & 511), sd->data, len); - if (!sd->bdrv || bdrv_write(sd->bdrv, addr >> 9, sd->buf, 1) < 0) { + if (!sd->blk || blk_write(sd->blk, addr >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_write: write error on host side\n"); } } @@ -1515,7 +1515,7 @@ void sd_write_data(SDState *sd, uint8_t value) { int i; - if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv) || !sd->enable) + if (!sd->blk || !blk_is_inserted(sd->blk) || !sd->enable) return; if (sd->state != sd_receivingdata_state) { @@ -1641,7 +1641,7 @@ uint8_t sd_read_data(SDState *sd) uint8_t ret; int io_len; - if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv) || !sd->enable) + if (!sd->blk || !blk_is_inserted(sd->blk) || !sd->enable) return 0x00; if (sd->state != sd_sendingdata_state) { diff --git a/hw/sd/sdhci.c b/hw/sd/sdhci.c index 0b7d754380..b38005003c 100644 --- a/hw/sd/sdhci.c +++ b/hw/sd/sdhci.c @@ -1166,7 +1166,7 @@ static void sdhci_initfn(Object *obj) DriveInfo *di; di = drive_get_next(IF_SD); - s->card = sd_init(di ? blk_bs(blk_by_legacy_dinfo(di)) : NULL, false); + s->card = sd_init(di ? blk_by_legacy_dinfo(di) : NULL, false); if (s->card == NULL) { exit(1); } diff --git a/hw/sd/ssi-sd.c b/hw/sd/ssi-sd.c index 6ae99e4008..a71fbca714 100644 --- a/hw/sd/ssi-sd.c +++ b/hw/sd/ssi-sd.c @@ -256,7 +256,7 @@ static int ssi_sd_init(SSISlave *d) s->mode = SSI_SD_CMD; dinfo = drive_get_next(IF_SD); - s->sd = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, true); + s->sd = sd_init(dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, true); if (s->sd == NULL) { return -1; } diff --git a/hw/sh4/r2d.c b/hw/sh4/r2d.c index 80ac132a0c..12f44d28f0 100644 --- a/hw/sh4/r2d.c +++ b/hw/sh4/r2d.c @@ -37,7 +37,6 @@ #include "hw/usb.h" #include "hw/block/flash.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "exec/address-spaces.h" #define FLASH_BASE 0x00000000 @@ -291,7 +290,7 @@ static void r2d_init(MachineState *machine) /* onboard flash memory */ dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi02_register(0x0, NULL, "r2d.flash", FLASH_SIZE, - dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, (16 * 1024), FLASH_SIZE >> 16, 1, 4, 0x0000, 0x0000, 0x0000, 0x0000, 0x555, 0x2aa, 0); diff --git a/hw/sparc/sun4m.c b/hw/sparc/sun4m.c index 2feab35585..8273199f11 100644 --- a/hw/sparc/sun4m.c +++ b/hw/sparc/sun4m.c @@ -40,7 +40,7 @@ #include "hw/empty_slot.h" #include "hw/loader.h" #include "elf.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "trace.h" /* diff --git a/hw/sparc64/sun4u.c b/hw/sparc64/sun4u.c index 871a0ea246..f42112c1b2 100644 --- a/hw/sparc64/sun4u.c +++ b/hw/sparc64/sun4u.c @@ -38,7 +38,7 @@ #include "hw/ide.h" #include "hw/loader.h" #include "elf.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" //#define DEBUG_IRQ diff --git a/hw/tpm/tpm_tis.c b/hw/tpm/tpm_tis.c index 82747ee259..c0e7cd738a 100644 --- a/hw/tpm/tpm_tis.c +++ b/hw/tpm/tpm_tis.c @@ -21,7 +21,7 @@ #include "sysemu/tpm_backend.h" #include "tpm_int.h" -#include "block/block.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" #include "hw/hw.h" #include "hw/i386/pc.h" diff --git a/hw/tricore/tricore_testboard.c b/hw/tricore/tricore_testboard.c index 605de86302..eeb4922c4c 100644 --- a/hw/tricore/tricore_testboard.c +++ b/hw/tricore/tricore_testboard.c @@ -24,7 +24,7 @@ #include "sysemu/sysemu.h" #include "hw/boards.h" #include "hw/loader.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "exec/address-spaces.h" #include "hw/block/flash.h" #include "elf.h" diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c index 44b4d046af..4539733e42 100644 --- a/hw/usb/dev-storage.c +++ b/hw/usb/dev-storage.c @@ -601,11 +601,11 @@ static const struct SCSIBusInfo usb_msd_scsi_info_bot = { static void usb_msd_realize_storage(USBDevice *dev, Error **errp) { MSDState *s = DO_UPCAST(MSDState, dev, dev); - BlockDriverState *bs = s->conf.bs; + BlockBackend *blk = s->conf.blk; SCSIDevice *scsi_dev; Error *err = NULL; - if (!bs) { + if (!blk) { error_setg(errp, "drive property not set"); return; } @@ -621,14 +621,14 @@ static void usb_msd_realize_storage(USBDevice *dev, Error **errp) * * The hack is probably a bad idea. */ - bdrv_detach_dev(bs, &s->dev.qdev); - s->conf.bs = NULL; + blk_detach_dev(blk, &s->dev.qdev); + s->conf.blk = NULL; usb_desc_create_serial(dev); usb_desc_init(dev); scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(dev), &usb_msd_scsi_info_storage, NULL); - scsi_dev = scsi_bus_legacy_add_drive(&s->bus, bs, 0, !!s->removable, + scsi_dev = scsi_bus_legacy_add_drive(&s->bus, blk, 0, !!s->removable, s->conf.bootindex, dev->serial, &err); if (!scsi_dev) { @@ -638,9 +638,10 @@ static void usb_msd_realize_storage(USBDevice *dev, Error **errp) usb_msd_handle_reset(dev); s->scsi_dev = scsi_dev; - if (bdrv_key_required(bs)) { + if (bdrv_key_required(blk_bs(blk))) { if (cur_mon) { - monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb, s); + monitor_read_bdrv_key_start(cur_mon, blk_bs(blk), + usb_msd_password_cb, s); s->dev.auto_attach = 0; } else { autostart = 0; @@ -709,7 +710,7 @@ static USBDevice *usb_msd_init(USBBus *bus, const char *filename) return NULL; } if (qdev_prop_set_drive(&dev->qdev, "drive", - blk_bs(blk_by_legacy_dinfo(dinfo))) < 0) { + blk_by_legacy_dinfo(dinfo)) < 0) { object_unparent(OBJECT(dev)); return NULL; } diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c index ae7fef96d5..542fb9e279 100644 --- a/hw/virtio/virtio-pci.c +++ b/hw/virtio/virtio-pci.c @@ -29,7 +29,7 @@ #include "hw/pci/msix.h" #include "hw/loader.h" #include "sysemu/kvm.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" #include "virtio-pci.h" #include "qemu/range.h" #include "hw/virtio/virtio-bus.h" diff --git a/hw/xen/xen_devconfig.c b/hw/xen/xen_devconfig.c index fa998eff04..e138dbbec9 100644 --- a/hw/xen/xen_devconfig.c +++ b/hw/xen/xen_devconfig.c @@ -1,4 +1,5 @@ #include "hw/xen/xen_backend.h" +#include "sysemu/block-backend.h" #include "sysemu/blockdev.h" /* ------------------------------------------------------------- */ diff --git a/hw/xenpv/xen_machine_pv.c b/hw/xenpv/xen_machine_pv.c index 31500643a2..2e545d2418 100644 --- a/hw/xenpv/xen_machine_pv.c +++ b/hw/xenpv/xen_machine_pv.c @@ -26,7 +26,7 @@ #include "hw/boards.h" #include "hw/xen/xen_backend.h" #include "xen_domainbuild.h" -#include "sysemu/blockdev.h" +#include "sysemu/block-backend.h" static void xen_init_pv(MachineState *machine) { diff --git a/hw/xtensa/xtfpga.c b/hw/xtensa/xtfpga.c index 4ac1ceff2f..0100c3115b 100644 --- a/hw/xtensa/xtfpga.c +++ b/hw/xtensa/xtfpga.c @@ -36,7 +36,6 @@ #include "hw/sysbus.h" #include "hw/block/flash.h" #include "sysemu/block-backend.h" -#include "sysemu/blockdev.h" #include "sysemu/char.h" #include "sysemu/device_tree.h" #include "qemu/error-report.h" @@ -231,7 +230,7 @@ static void lx_init(const LxBoardDesc *board, MachineState *machine) if (dinfo) { flash = pflash_cfi01_register(board->flash_base, NULL, "lx60.io.flash", board->flash_size, - blk_bs(blk_by_legacy_dinfo(dinfo)), + blk_by_legacy_dinfo(dinfo), board->flash_sector_size, board->flash_size / board->flash_sector_size, 4, 0x0000, 0x0000, 0x0000, 0x0000, be); diff --git a/include/hw/arm/omap.h b/include/hw/arm/omap.h index b9655ee397..0ad5fb883c 100644 --- a/include/hw/arm/omap.h +++ b/include/hw/arm/omap.h @@ -755,10 +755,10 @@ void omap_rfbi_attach(struct omap_dss_s *s, int cs, struct rfbi_chip_s *chip); struct omap_mmc_s; struct omap_mmc_s *omap_mmc_init(hwaddr base, MemoryRegion *sysmem, - BlockDriverState *bd, + BlockBackend *blk, qemu_irq irq, qemu_irq dma[], omap_clk clk); struct omap_mmc_s *omap2_mmc_init(struct omap_target_agent_s *ta, - BlockDriverState *bd, qemu_irq irq, qemu_irq dma[], + BlockBackend *blk, qemu_irq irq, qemu_irq dma[], omap_clk fclk, omap_clk iclk); void omap_mmc_reset(struct omap_mmc_s *s); void omap_mmc_handlers(struct omap_mmc_s *s, qemu_irq ro, qemu_irq cover); diff --git a/include/hw/arm/pxa.h b/include/hw/arm/pxa.h index c5079067bb..259b852495 100644 --- a/include/hw/arm/pxa.h +++ b/include/hw/arm/pxa.h @@ -87,7 +87,7 @@ void pxa2xx_lcdc_oritentation(void *opaque, int angle); typedef struct PXA2xxMMCIState PXA2xxMMCIState; PXA2xxMMCIState *pxa2xx_mmci_init(MemoryRegion *sysmem, hwaddr base, - BlockDriverState *bd, qemu_irq irq, + BlockBackend *blk, qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma); void pxa2xx_mmci_handlers(PXA2xxMMCIState *s, qemu_irq readonly, qemu_irq coverswitch); diff --git a/include/hw/block/block.h b/include/hw/block/block.h index 867a226643..0d0ce9a467 100644 --- a/include/hw/block/block.h +++ b/include/hw/block/block.h @@ -17,7 +17,7 @@ /* Configuration */ typedef struct BlockConf { - BlockDriverState *bs; + BlockBackend *blk; uint16_t physical_block_size; uint16_t logical_block_size; uint16_t min_io_size; @@ -42,7 +42,7 @@ static inline unsigned int get_physical_block_exp(BlockConf *conf) } #define DEFINE_BLOCK_PROPERTIES(_state, _conf) \ - DEFINE_PROP_DRIVE("drive", _state, _conf.bs), \ + DEFINE_PROP_DRIVE("drive", _state, _conf.blk), \ DEFINE_PROP_BLOCKSIZE("logical_block_size", _state, \ _conf.logical_block_size, 512), \ DEFINE_PROP_BLOCKSIZE("physical_block_size", _state, \ @@ -66,7 +66,7 @@ void blkconf_geometry(BlockConf *conf, int *trans, /* Hard disk geometry */ -void hd_geometry_guess(BlockDriverState *bs, +void hd_geometry_guess(BlockBackend *blk, uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs, int *ptrans); int hd_bios_chs_auto_trans(uint32_t cyls, uint32_t heads, uint32_t secs); diff --git a/include/hw/block/flash.h b/include/hw/block/flash.h index 920d7596e3..50ccbbcf13 100644 --- a/include/hw/block/flash.h +++ b/include/hw/block/flash.h @@ -11,7 +11,7 @@ typedef struct pflash_t pflash_t; pflash_t *pflash_cfi01_register(hwaddr base, DeviceState *qdev, const char *name, hwaddr size, - BlockDriverState *bs, + BlockBackend *blk, uint32_t sector_len, int nb_blocs, int width, uint16_t id0, uint16_t id1, uint16_t id2, uint16_t id3, int be); @@ -20,7 +20,7 @@ pflash_t *pflash_cfi01_register(hwaddr base, pflash_t *pflash_cfi02_register(hwaddr base, DeviceState *qdev, const char *name, hwaddr size, - BlockDriverState *bs, uint32_t sector_len, + BlockBackend *blk, uint32_t sector_len, int nb_blocs, int nb_mappings, int width, uint16_t id0, uint16_t id1, uint16_t id2, uint16_t id3, @@ -30,7 +30,7 @@ pflash_t *pflash_cfi02_register(hwaddr base, MemoryRegion *pflash_cfi01_get_memory(pflash_t *fl); /* nand.c */ -DeviceState *nand_init(BlockDriverState *bdrv, int manf_id, int chip_id); +DeviceState *nand_init(BlockBackend *blk, int manf_id, int chip_id); void nand_setpins(DeviceState *dev, uint8_t cle, uint8_t ale, uint8_t ce, uint8_t wp, uint8_t gnd); void nand_getpins(DeviceState *dev, int *rb); diff --git a/include/hw/qdev-properties.h b/include/hw/qdev-properties.h index ae56ee59a4..070006c715 100644 --- a/include/hw/qdev-properties.h +++ b/include/hw/qdev-properties.h @@ -141,7 +141,7 @@ extern PropertyInfo qdev_prop_arraylen; #define DEFINE_PROP_VLAN(_n, _s, _f) \ DEFINE_PROP(_n, _s, _f, qdev_prop_vlan, NICPeers) #define DEFINE_PROP_DRIVE(_n, _s, _f) \ - DEFINE_PROP(_n, _s, _f, qdev_prop_drive, BlockDriverState *) + DEFINE_PROP(_n, _s, _f, qdev_prop_drive, BlockBackend *) #define DEFINE_PROP_MACADDR(_n, _s, _f) \ DEFINE_PROP(_n, _s, _f, qdev_prop_macaddr, MACAddr) #define DEFINE_PROP_LOSTTICKPOLICY(_n, _s, _f, _d) \ @@ -168,8 +168,10 @@ void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value); void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value); void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value); void qdev_prop_set_netdev(DeviceState *dev, const char *name, NetClientState *value); -int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value) QEMU_WARN_UNUSED_RESULT; -void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value); +int qdev_prop_set_drive(DeviceState *dev, const char *name, + BlockBackend *value) QEMU_WARN_UNUSED_RESULT; +void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, + BlockBackend *value); void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value); void qdev_prop_set_enum(DeviceState *dev, const char *name, int value); /* FIXME: Remove opaque pointer properties. */ diff --git a/include/hw/scsi/scsi.h b/include/hw/scsi/scsi.h index 809aefb8c1..6bc841ab8b 100644 --- a/include/hw/scsi/scsi.h +++ b/include/hw/scsi/scsi.h @@ -2,7 +2,7 @@ #define QEMU_HW_SCSI_H #include "hw/qdev.h" -#include "block/block.h" +#include "qemu/typedefs.h" #include "hw/block/block.h" #include "sysemu/sysemu.h" #include "qemu/notify.h" @@ -173,7 +173,7 @@ static inline SCSIBus *scsi_bus_from_device(SCSIDevice *d) return DO_UPCAST(SCSIBus, qbus, d->qdev.parent_bus); } -SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, +SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockBackend *blk, int unit, bool removable, int bootindex, const char *serial, Error **errp); void scsi_bus_legacy_handle_cmdline(SCSIBus *bus, Error **errp); diff --git a/include/hw/sd.h b/include/hw/sd.h index d9b97e4466..79adb5bb48 100644 --- a/include/hw/sd.h +++ b/include/hw/sd.h @@ -68,7 +68,7 @@ typedef struct { typedef struct SDState SDState; -SDState *sd_init(BlockDriverState *bs, bool is_spi); +SDState *sd_init(BlockBackend *bs, bool is_spi); int sd_do_command(SDState *sd, SDRequest *req, uint8_t *response); void sd_write_data(SDState *sd, uint8_t value); diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h index 0f7ca3ceef..3979dc41af 100644 --- a/include/hw/virtio/virtio-blk.h +++ b/include/hw/virtio/virtio-blk.h @@ -17,8 +17,7 @@ #include "hw/virtio/virtio.h" #include "hw/block/block.h" #include "sysemu/iothread.h" -#include "block/block.h" -#include "block/accounting.h" +#include "sysemu/block-backend.h" #define TYPE_VIRTIO_BLK "virtio-blk-device" #define VIRTIO_BLK(obj) \ @@ -121,7 +120,7 @@ struct VirtIOBlockDataPlane; struct VirtIOBlockReq; typedef struct VirtIOBlock { VirtIODevice parent_obj; - BlockDriverState *bs; + BlockBackend *blk; VirtQueue *vq; void *rq; QEMUBH *bh; @@ -159,6 +158,6 @@ int virtio_blk_handle_scsi_req(VirtIOBlock *blk, void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb); -void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb); +void virtio_submit_multiwrite(BlockBackend *blk, MultiReqBuffer *mrb); #endif diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h index b97a794e45..f63817a7cc 100644 --- a/include/sysemu/block-backend.h +++ b/include/sysemu/block-backend.h @@ -16,6 +16,15 @@ #include "qemu/typedefs.h" #include "qapi/error.h" +/* + * TODO Have to include block/block.h for a bunch of block layer + * types. Unfortunately, this pulls in the whole BlockDriverState + * API, which we don't want used by many BlockBackend users. Some of + * the types belong here, and the rest should be split into a common + * header and one for the BlockDriverState API. + */ +#include "block/block.h" + BlockBackend *blk_new(const char *name, Error **errp); BlockBackend *blk_new_with_bs(const char *name, Error **errp); void blk_ref(BlockBackend *blk); @@ -28,4 +37,71 @@ BlockDriverState *blk_bs(BlockBackend *blk); void blk_hide_on_behalf_of_do_drive_del(BlockBackend *blk); +void blk_iostatus_enable(BlockBackend *blk); +int blk_attach_dev(BlockBackend *blk, void *dev); +void blk_attach_dev_nofail(BlockBackend *blk, void *dev); +void blk_detach_dev(BlockBackend *blk, void *dev); +void *blk_get_attached_dev(BlockBackend *blk); +void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, void *opaque); +int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf, + int nb_sectors); +int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf, + int nb_sectors); +int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf, + int nb_sectors); +BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num, + int nb_sectors, BdrvRequestFlags flags, + BlockCompletionFunc *cb, void *opaque); +int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count); +int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count); +int64_t blk_getlength(BlockBackend *blk); +void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr); +BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockCompletionFunc *cb, void *opaque); +BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num, + QEMUIOVector *iov, int nb_sectors, + BlockCompletionFunc *cb, void *opaque); +BlockAIOCB *blk_aio_flush(BlockBackend *blk, + BlockCompletionFunc *cb, void *opaque); +BlockAIOCB *blk_aio_discard(BlockBackend *blk, + int64_t sector_num, int nb_sectors, + BlockCompletionFunc *cb, void *opaque); +void blk_aio_cancel(BlockAIOCB *acb); +void blk_aio_cancel_async(BlockAIOCB *acb); +int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs); +int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf); +BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf, + BlockCompletionFunc *cb, void *opaque); +int blk_flush(BlockBackend *blk); +int blk_flush_all(void); +void blk_drain_all(void); +BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read); +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); +int blk_is_read_only(BlockBackend *blk); +int blk_is_sg(BlockBackend *blk); +int blk_enable_write_cache(BlockBackend *blk); +void blk_set_enable_write_cache(BlockBackend *blk, bool wce); +int blk_is_inserted(BlockBackend *blk); +void blk_lock_medium(BlockBackend *blk, bool locked); +void blk_eject(BlockBackend *blk, bool eject_flag); +int blk_get_flags(BlockBackend *blk); +void blk_set_guest_block_size(BlockBackend *blk, int align); +void *blk_blockalign(BlockBackend *blk, size_t size); +bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp); +void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason); +void blk_op_block_all(BlockBackend *blk, Error *reason); +void blk_op_unblock_all(BlockBackend *blk, Error *reason); +AioContext *blk_get_aio_context(BlockBackend *blk); +void blk_set_aio_context(BlockBackend *blk, AioContext *new_context); +void blk_io_plug(BlockBackend *blk); +void blk_io_unplug(BlockBackend *blk); +BlockAcctStats *blk_get_stats(BlockBackend *blk); + +void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk, + BlockCompletionFunc *cb, void *opaque); + #endif diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h index 4de76d17b7..eabc5c7885 100644 --- a/include/sysemu/blockdev.h +++ b/include/sysemu/blockdev.h @@ -14,8 +14,8 @@ #include "qapi/error.h" #include "qemu/queue.h" -void blockdev_mark_auto_del(BlockDriverState *bs); -void blockdev_auto_del(BlockDriverState *bs); +void blockdev_mark_auto_del(BlockBackend *blk); +void blockdev_auto_del(BlockBackend *blk); typedef enum { IF_DEFAULT = -1, /* for use with drive_add() only */ @@ -57,7 +57,6 @@ DriveInfo *drive_get_by_index(BlockInterfaceType type, int index); int drive_get_max_bus(BlockInterfaceType type); int drive_get_max_devs(BlockInterfaceType type); DriveInfo *drive_get_next(BlockInterfaceType type); -DriveInfo *drive_get_by_blockdev(BlockDriverState *bs); QemuOpts *drive_def(const char *optstr); QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file, diff --git a/include/sysemu/dma.h b/include/sysemu/dma.h index bcff53a2c2..3f2f4c89e3 100644 --- a/include/sysemu/dma.h +++ b/include/sysemu/dma.h @@ -197,24 +197,24 @@ void qemu_sglist_add(QEMUSGList *qsg, dma_addr_t base, dma_addr_t len); void qemu_sglist_destroy(QEMUSGList *qsg); #endif -typedef BlockAIOCB *DMAIOFunc(BlockDriverState *bs, int64_t sector_num, +typedef BlockAIOCB *DMAIOFunc(BlockBackend *blk, int64_t sector_num, QEMUIOVector *iov, int nb_sectors, BlockCompletionFunc *cb, void *opaque); -BlockAIOCB *dma_bdrv_io(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector_num, - DMAIOFunc *io_func, BlockCompletionFunc *cb, - void *opaque, DMADirection dir); -BlockAIOCB *dma_bdrv_read(BlockDriverState *bs, +BlockAIOCB *dma_blk_io(BlockBackend *blk, + QEMUSGList *sg, uint64_t sector_num, + DMAIOFunc *io_func, BlockCompletionFunc *cb, + void *opaque, DMADirection dir); +BlockAIOCB *dma_blk_read(BlockBackend *blk, + QEMUSGList *sg, uint64_t sector, + BlockCompletionFunc *cb, void *opaque); +BlockAIOCB *dma_blk_write(BlockBackend *blk, QEMUSGList *sg, uint64_t sector, BlockCompletionFunc *cb, void *opaque); -BlockAIOCB *dma_bdrv_write(BlockDriverState *bs, - QEMUSGList *sg, uint64_t sector, - BlockCompletionFunc *cb, void *opaque); uint64_t dma_buf_read(uint8_t *ptr, int32_t len, QEMUSGList *sg); uint64_t dma_buf_write(uint8_t *ptr, int32_t len, QEMUSGList *sg); -void dma_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, +void dma_acct_start(BlockBackend *blk, BlockAcctCookie *cookie, QEMUSGList *sg, enum BlockAcctType type); #endif diff --git a/trace-events b/trace-events index 529080640a..6c3a4003c1 100644 --- a/trace-events +++ b/trace-events @@ -195,8 +195,8 @@ fw_cfg_add_file_dupe(void *s, char *name) "%p %s" fw_cfg_add_file(void *s, int index, char *name, size_t len) "%p #%d: %s (%zd bytes)" # hw/block/hd-geometry.c -hd_geometry_lchs_guess(void *bs, int cyls, int heads, int secs) "bs %p LCHS %d %d %d" -hd_geometry_guess(void *bs, uint32_t cyls, uint32_t heads, uint32_t secs, int trans) "bs %p CHS %u %u %u trans %d" +hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d" +hd_geometry_guess(void *blk, uint32_t cyls, uint32_t heads, uint32_t secs, int trans) "blk %p CHS %u %u %u trans %d" # hw/display/jazz_led.c jazz_led_read(uint64_t addr, uint8_t val) "read addr=0x%"PRIx64": 0x%x" @@ -1078,10 +1078,10 @@ win_helper_done(uint32_t tl) "tl=%d" win_helper_retry(uint32_t tl) "tl=%d" # dma-helpers.c -dma_bdrv_io(void *dbs, void *bs, int64_t sector_num, bool to_dev) "dbs=%p bs=%p sector_num=%" PRId64 " to_dev=%d" +dma_blk_io(void *dbs, void *bs, int64_t sector_num, bool to_dev) "dbs=%p bs=%p sector_num=%" PRId64 " to_dev=%d" dma_aio_cancel(void *dbs) "dbs=%p" dma_complete(void *dbs, int ret, void *cb) "dbs=%p ret=%d cb=%p" -dma_bdrv_cb(void *dbs, int ret) "dbs=%p ret=%d" +dma_blk_cb(void *dbs, int ret) "dbs=%p ret=%d" dma_map_wait(void *dbs) "dbs=%p" # ui/console.c From a987ee1f1b49529850207057f600618205496c60 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:19 +0200 Subject: [PATCH 21/28] ide: Complete conversion from BlockDriverState to BlockBackend Add a BlockBackend member to TrimAIOCB, so ide_issue_trim_cb() can use blk_aio_discard() instead of bdrv_aio_discard(). Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- hw/ide/core.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/hw/ide/core.c b/hw/ide/core.c index a5c4698368..44e3d502d4 100644 --- a/hw/ide/core.c +++ b/hw/ide/core.c @@ -362,6 +362,7 @@ static void ide_set_signature(IDEState *s) typedef struct TrimAIOCB { BlockAIOCB common; + BlockBackend *blk; QEMUBH *bh; int ret; QEMUIOVector *qiov; @@ -421,8 +422,8 @@ static void ide_issue_trim_cb(void *opaque, int ret) } /* Got an entry! Submit and exit. */ - iocb->aiocb = bdrv_aio_discard(iocb->common.bs, sector, count, - ide_issue_trim_cb, opaque); + iocb->aiocb = blk_aio_discard(iocb->blk, sector, count, + ide_issue_trim_cb, opaque); return; } @@ -446,6 +447,7 @@ BlockAIOCB *ide_issue_trim(BlockBackend *blk, TrimAIOCB *iocb; iocb = blk_aio_get(&trim_aiocb_info, blk, cb, opaque); + iocb->blk = blk; iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb); iocb->ret = 0; iocb->qiov = qiov; From b8864be5f30d6c1c73208215c65c3e3a3b5a5b04 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:20 +0200 Subject: [PATCH 22/28] pc87312: Drop unused members of PC87312State MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- include/hw/isa/pc87312.h | 3 --- 1 file changed, 3 deletions(-) diff --git a/include/hw/isa/pc87312.h b/include/hw/isa/pc87312.h index befc8bdc62..bf74470d40 100644 --- a/include/hw/isa/pc87312.h +++ b/include/hw/isa/pc87312.h @@ -47,13 +47,10 @@ typedef struct PC87312State { struct { ISADevice *dev; - BlockDriverState *drive[2]; - uint32_t base; } fdc; struct { ISADevice *dev; - uint32_t base; } ide; MemoryRegion io; From d3aeb1b7dadacabd175efd515c7c52642141be87 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:21 +0200 Subject: [PATCH 23/28] blockdev: Drop superfluous DriveInfo member id MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- block/block-backend.c | 1 - blockdev.c | 5 ++--- include/sysemu/blockdev.h | 1 - 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/block/block-backend.c b/block/block-backend.c index 58ae634d14..a3e613b383 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -106,7 +106,6 @@ static void drive_info_del(DriveInfo *dinfo) return; } qemu_opts_del(dinfo->opts); - g_free(dinfo->id); g_free(dinfo->serial); g_free(dinfo); } diff --git a/blockdev.c b/blockdev.c index c126809d0e..cdefbb001d 100644 --- a/blockdev.c +++ b/blockdev.c @@ -223,7 +223,7 @@ bool drive_check_orphaned(void) dinfo->type != IF_NONE) { fprintf(stderr, "Warning: Orphaned drive without device: " "id=%s,file=%s,if=%s,bus=%d,unit=%d\n", - dinfo->id, blk_bs(blk)->filename, if_name[dinfo->type], + blk_name(blk), blk_bs(blk)->filename, if_name[dinfo->type], dinfo->bus, dinfo->unit); rs = true; } @@ -519,7 +519,6 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, } dinfo = g_malloc0(sizeof(*dinfo)); - dinfo->id = g_strdup(qemu_opts_id(opts)); blk_set_legacy_dinfo(blk, dinfo); if (!file || !*file) { @@ -553,7 +552,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, if (ret < 0) { error_setg(errp, "could not open disk image %s: %s", - file ?: dinfo->id, error_get_pretty(error)); + file ?: blk_name(blk), error_get_pretty(error)); error_free(error); goto err; } diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h index eabc5c7885..0c70c29be3 100644 --- a/include/sysemu/blockdev.h +++ b/include/sysemu/blockdev.h @@ -30,7 +30,6 @@ typedef enum { } BlockInterfaceType; struct DriveInfo { - char *id; const char *devaddr; BlockInterfaceType type; int bus; From 26f8b3a84750546342d4397f86efb1ea7798d5dd Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:22 +0200 Subject: [PATCH 24/28] blockdev: Fix blockdev-add not to create DriveInfo blockdev_init() always creates a DriveInfo, but only drive_new() fills it in. qmp_blockdev_add() leaves it blank. This results in a drive with type = IF_IDE, bus = 0, unit = 0. Screwed up in commit ee13ed1c. Board initialization code looking for IDE drive (0,0) can pick up one of these bogus drives. The QMP command has to execute really early to be visible. Not sure how likely that is in practice. Fix by creating DriveInfo in drive_new(). Block backends created by blockdev-add don't get one. Breaks the test for "has been created by qmp_blockdev_add()" in blockdev_mark_auto_del() and do_drive_del(), because it changes the value of dinfo && !dinfo->enable_auto_del from true to false. Simply test !dinfo instead. Leaves DriveInfo member enable_auto_del unused. Drop it. A few places assume a block backend always has a DriveInfo. Fix them up. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block/block-backend.c | 2 +- blockdev.c | 22 +++++++--------------- hw/block/block.c | 16 ++++++++++------ hw/ide/qdev.c | 2 +- hw/scsi/scsi-disk.c | 2 +- include/sysemu/blockdev.h | 1 - 6 files changed, 20 insertions(+), 25 deletions(-) diff --git a/block/block-backend.c b/block/block-backend.c index a3e613b383..ae30873df1 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -18,7 +18,7 @@ struct BlockBackend { char *name; int refcnt; BlockDriverState *bs; - DriveInfo *legacy_dinfo; + DriveInfo *legacy_dinfo; /* null unless created by drive_new() */ QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */ }; diff --git a/blockdev.c b/blockdev.c index cdefbb001d..2a3d908320 100644 --- a/blockdev.c +++ b/blockdev.c @@ -116,16 +116,14 @@ void blockdev_mark_auto_del(BlockBackend *blk) DriveInfo *dinfo = blk_legacy_dinfo(blk); BlockDriverState *bs = blk_bs(blk); - if (dinfo && !dinfo->enable_auto_del) { + if (!dinfo) { return; } if (bs->job) { block_job_cancel(bs->job); } - if (dinfo) { - dinfo->auto_del = 1; - } + dinfo->auto_del = 1; } void blockdev_auto_del(BlockBackend *blk) @@ -346,7 +344,6 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, int on_read_error, on_write_error; BlockBackend *blk; BlockDriverState *bs; - DriveInfo *dinfo; ThrottleConfig cfg; int snapshot = 0; bool copy_on_read; @@ -518,9 +515,6 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, bdrv_set_io_limits(bs, &cfg); } - dinfo = g_malloc0(sizeof(*dinfo)); - blk_set_legacy_dinfo(blk, dinfo); - if (!file || !*file) { if (has_driver_specific_opts) { file = NULL; @@ -990,9 +984,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type) assert(!local_err); } - /* Set legacy DriveInfo fields */ - dinfo = blk_legacy_dinfo(blk); - dinfo->enable_auto_del = true; + /* Create legacy DriveInfo */ + dinfo = g_malloc0(sizeof(*dinfo)); dinfo->opts = all_opts; dinfo->cyls = cyls; @@ -1004,9 +997,10 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type) dinfo->bus = bus_id; dinfo->unit = unit_id; dinfo->devaddr = devaddr; - dinfo->serial = g_strdup(serial); + blk_set_legacy_dinfo(blk, dinfo); + switch(type) { case IF_IDE: case IF_SCSI: @@ -1810,7 +1804,6 @@ int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) const char *id = qdict_get_str(qdict, "id"); BlockBackend *blk; BlockDriverState *bs; - DriveInfo *dinfo; AioContext *aio_context; Error *local_err = NULL; @@ -1821,8 +1814,7 @@ int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) } bs = blk_bs(blk); - dinfo = blk_legacy_dinfo(blk); - if (dinfo && !dinfo->enable_auto_del) { + if (!blk_legacy_dinfo(blk)) { error_report("Deleting device added with blockdev-add" " is not supported"); return -1; diff --git a/hw/block/block.c b/hw/block/block.c index 0666dd337c..a625773d44 100644 --- a/hw/block/block.c +++ b/hw/block/block.c @@ -19,7 +19,9 @@ void blkconf_serial(BlockConf *conf, char **serial) if (!*serial) { /* try to fall back to value set with legacy -drive serial=... */ dinfo = blk_legacy_dinfo(conf->blk); - *serial = g_strdup(dinfo->serial); + if (dinfo) { + *serial = g_strdup(dinfo->serial); + } } } @@ -32,11 +34,13 @@ void blkconf_geometry(BlockConf *conf, int *ptrans, if (!conf->cyls && !conf->heads && !conf->secs) { /* try to fall back to value set with legacy -drive cyls=... */ dinfo = blk_legacy_dinfo(conf->blk); - conf->cyls = dinfo->cyls; - conf->heads = dinfo->heads; - conf->secs = dinfo->secs; - if (ptrans) { - *ptrans = dinfo->trans; + if (dinfo) { + conf->cyls = dinfo->cyls; + conf->heads = dinfo->heads; + conf->secs = dinfo->secs; + if (ptrans) { + *ptrans = dinfo->trans; + } } } if (!conf->cyls && !conf->heads && !conf->secs) { diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c index 600e67c232..b4f096e12e 100644 --- a/hw/ide/qdev.c +++ b/hw/ide/qdev.c @@ -252,7 +252,7 @@ static int ide_drive_initfn(IDEDevice *dev) { DriveInfo *dinfo = blk_legacy_dinfo(dev->conf.blk); - return ide_dev_initfn(dev, dinfo->media_cd ? IDE_CD : IDE_HD); + return ide_dev_initfn(dev, dinfo && dinfo->media_cd ? IDE_CD : IDE_HD); } #define DEFINE_IDE_DEV_PROPERTIES() \ diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c index 300ba01045..010eefd443 100644 --- a/hw/scsi/scsi-disk.c +++ b/hw/scsi/scsi-disk.c @@ -2310,7 +2310,7 @@ static void scsi_disk_realize(SCSIDevice *dev, Error **errp) } dinfo = blk_legacy_dinfo(dev->conf.blk); - if (dinfo->media_cd) { + if (dinfo && dinfo->media_cd) { scsi_cd_realize(dev, errp); } else { scsi_hd_realize(dev, errp); diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h index 0c70c29be3..09d1e30b34 100644 --- a/include/sysemu/blockdev.h +++ b/include/sysemu/blockdev.h @@ -35,7 +35,6 @@ struct DriveInfo { int bus; int unit; int auto_del; /* see blockdev_mark_auto_del() */ - bool enable_auto_del; /* Only for legacy drive_new() */ bool is_default; /* Added by default_drive() ? */ int media_cd; int cyls, heads, secs, trans; From d829a2115f0817993e2b683601cb544a27980a8f Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:23 +0200 Subject: [PATCH 25/28] block/qapi: Convert qmp_query_block() to BlockBackend MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Much more command code needs conversion. I start with this one because it's using bdrv_dev_* functions, which I'm about to lift into BlockBackend. While there, give bdrv_query_info() internal linkage. Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- block/qapi.c | 15 ++++++++------- include/block/qapi.h | 3 --- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/block/qapi.c b/block/qapi.c index d071ee564e..fca981d94e 100644 --- a/block/qapi.c +++ b/block/qapi.c @@ -28,6 +28,7 @@ #include "qapi-visit.h" #include "qapi/qmp-output-visitor.h" #include "qapi/qmp/types.h" +#include "sysemu/block-backend.h" #ifdef __linux__ #include #include @@ -264,15 +265,15 @@ void bdrv_query_image_info(BlockDriverState *bs, } /* @p_info will be set only on success. */ -void bdrv_query_info(BlockDriverState *bs, - BlockInfo **p_info, - Error **errp) +static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info, + Error **errp) { BlockInfo *info = g_malloc0(sizeof(*info)); + BlockDriverState *bs = blk_bs(blk); BlockDriverState *bs0; ImageInfo **p_image_info; Error *local_err = NULL; - info->device = g_strdup(bdrv_get_device_name(bs)); + info->device = g_strdup(blk_name(blk)); info->type = g_strdup("unknown"); info->locked = bdrv_dev_is_medium_locked(bs); info->removable = bdrv_dev_has_removable_media(bs); @@ -360,12 +361,12 @@ static BlockStats *bdrv_query_stats(const BlockDriverState *bs) BlockInfoList *qmp_query_block(Error **errp) { BlockInfoList *head = NULL, **p_next = &head; - BlockDriverState *bs = NULL; + BlockBackend *blk; Error *local_err = NULL; - while ((bs = bdrv_next(bs))) { + for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { BlockInfoList *info = g_malloc0(sizeof(*info)); - bdrv_query_info(bs, &info->value, &local_err); + bdrv_query_info(blk, &info->value, &local_err); if (local_err) { error_propagate(errp, local_err); goto err; diff --git a/include/block/qapi.h b/include/block/qapi.h index 03745464d6..168d788521 100644 --- a/include/block/qapi.h +++ b/include/block/qapi.h @@ -36,9 +36,6 @@ int bdrv_query_snapshot_info_list(BlockDriverState *bs, void bdrv_query_image_info(BlockDriverState *bs, ImageInfo **p_info, Error **errp); -void bdrv_query_info(BlockDriverState *bs, - BlockInfo **p_info, - Error **errp); void bdrv_snapshot_dump(fprintf_function func_fprintf, void *f, QEMUSnapshotInfo *sn); From 6007cdd448b6729e82530e85579e5089ddc58eba Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:24 +0200 Subject: [PATCH 26/28] blockdev: Convert qmp_eject(), qmp_change_blockdev() to BlockBackend MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Much more command code needs conversion. I'm converting these now because they're using bdrv_dev_* functions, which I'm about to lift into BlockBackend. Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- blockdev.c | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/blockdev.c b/blockdev.c index 2a3d908320..a32d84c673 100644 --- a/blockdev.c +++ b/blockdev.c @@ -1593,8 +1593,10 @@ exit: } -static void eject_device(BlockDriverState *bs, int force, Error **errp) +static void eject_device(BlockBackend *blk, int force, Error **errp) { + BlockDriverState *bs = blk_bs(blk); + if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) { return; } @@ -1618,15 +1620,15 @@ static void eject_device(BlockDriverState *bs, int force, Error **errp) void qmp_eject(const char *device, bool has_force, bool force, Error **errp) { - BlockDriverState *bs; + BlockBackend *blk; - bs = bdrv_find(device); - if (!bs) { + blk = blk_by_name(device); + if (!blk) { error_set(errp, QERR_DEVICE_NOT_FOUND, device); return; } - eject_device(bs, force, errp); + eject_device(blk, force, errp); } void qmp_block_passwd(bool has_device, const char *device, @@ -1685,16 +1687,18 @@ static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename, void qmp_change_blockdev(const char *device, const char *filename, const char *format, Error **errp) { + BlockBackend *blk; BlockDriverState *bs; BlockDriver *drv = NULL; int bdrv_flags; Error *err = NULL; - bs = bdrv_find(device); - if (!bs) { + blk = blk_by_name(device); + if (!blk) { error_set(errp, QERR_DEVICE_NOT_FOUND, device); return; } + bs = blk_bs(blk); if (format) { drv = bdrv_find_whitelisted_format(format, bs->read_only); @@ -1704,7 +1708,7 @@ void qmp_change_blockdev(const char *device, const char *filename, } } - eject_device(bs, 0, &err); + eject_device(blk, 0, &err); if (err) { error_propagate(errp, err); return; From a7f53e26a6f5bd64cda617cbcca118601d9a01d9 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:25 +0200 Subject: [PATCH 27/28] block: Lift device model API into BlockBackend Move device model attachment / detachment and the BlockDevOps device model callbacks and their wrappers from BlockDriverState to BlockBackend. Wrapper calls in block.c change from bdrv_dev_FOO_cb(bs, ...) to if (bs->blk) { bdrv_dev_FOO_cb(bs->blk, ...); } No change, because both bdrv_dev_change_media_cb() and bdrv_dev_resize_cb() do nothing when no device model is attached, and a device model can be attached only when bs->blk. Signed-off-by: Markus Armbruster Reviewed-by: Max Reitz Reviewed-by: Kevin Wolf Signed-off-by: Kevin Wolf --- block.c | 126 +++-------------------- block/block-backend.c | 179 ++++++++++++++++++++++++++++----- block/qapi.c | 8 +- blockdev.c | 10 +- include/block/block.h | 45 --------- include/block/block_int.h | 12 ++- include/sysemu/block-backend.h | 35 +++++++ 7 files changed, 218 insertions(+), 197 deletions(-) diff --git a/block.c b/block.c index 9fee0d28ed..773e87ef08 100644 --- a/block.c +++ b/block.c @@ -58,9 +58,6 @@ struct BdrvDirtyBitmap { #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ -#define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */ - -static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockCompletionFunc *cb, void *opaque); @@ -1527,7 +1524,9 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, } if (!bdrv_key_required(bs)) { - bdrv_dev_change_media_cb(bs, true); + if (bs->blk) { + blk_dev_change_media_cb(bs->blk, true); + } } else if (!runstate_check(RUN_STATE_PRELAUNCH) && !runstate_check(RUN_STATE_INMIGRATE) && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */ @@ -1852,7 +1851,9 @@ void bdrv_close(BlockDriverState *bs) } } - bdrv_dev_change_media_cb(bs, false); + if (bs->blk) { + blk_dev_change_media_cb(bs->blk, false); + } /*throttling disk I/O limits*/ if (bs->io_limits_enabled) { @@ -1971,9 +1972,6 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, /* move some fields that need to stay attached to the device */ /* dev info */ - bs_dest->dev_ops = bs_src->dev_ops; - bs_dest->dev_opaque = bs_src->dev_opaque; - bs_dest->dev = bs_src->dev; bs_dest->guest_block_size = bs_src->guest_block_size; bs_dest->copy_on_read = bs_src->copy_on_read; @@ -2043,7 +2041,6 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) assert(!bs_new->blk); assert(QLIST_EMPTY(&bs_new->dirty_bitmaps)); assert(bs_new->job == NULL); - assert(bs_new->dev == NULL); assert(bs_new->io_limits_enabled == false); assert(!throttle_have_timer(&bs_new->throttle_state)); @@ -2060,7 +2057,6 @@ void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) assert(!bs_new->blk); /* Check a few fields that should remain attached to the device */ - assert(bs_new->dev == NULL); assert(bs_new->job == NULL); assert(bs_new->io_limits_enabled == false); assert(!throttle_have_timer(&bs_new->throttle_state)); @@ -2099,7 +2095,6 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) static void bdrv_delete(BlockDriverState *bs) { - assert(!bs->dev); assert(!bs->job); assert(bdrv_op_blocker_is_empty(bs)); assert(!bs->refcnt); @@ -2113,105 +2108,6 @@ static void bdrv_delete(BlockDriverState *bs) g_free(bs); } -int bdrv_attach_dev(BlockDriverState *bs, void *dev) -/* TODO change to DeviceState *dev when all users are qdevified */ -{ - if (bs->dev) { - return -EBUSY; - } - bs->dev = dev; - bdrv_iostatus_reset(bs); - - /* We're expecting I/O from the device so bump up coroutine pool size */ - qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION); - return 0; -} - -/* TODO qdevified devices don't use this, remove when devices are qdevified */ -void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev) -{ - if (bdrv_attach_dev(bs, dev) < 0) { - abort(); - } -} - -void bdrv_detach_dev(BlockDriverState *bs, void *dev) -/* TODO change to DeviceState *dev when all users are qdevified */ -{ - assert(bs->dev == dev); - bs->dev = NULL; - bs->dev_ops = NULL; - bs->dev_opaque = NULL; - bs->guest_block_size = 512; - qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION); -} - -/* TODO change to return DeviceState * when all users are qdevified */ -void *bdrv_get_attached_dev(BlockDriverState *bs) -{ - return bs->dev; -} - -void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops, - void *opaque) -{ - bs->dev_ops = ops; - bs->dev_opaque = opaque; -} - -static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load) -{ - if (bs->dev_ops && bs->dev_ops->change_media_cb) { - bool tray_was_closed = !bdrv_dev_is_tray_open(bs); - bs->dev_ops->change_media_cb(bs->dev_opaque, load); - if (tray_was_closed) { - /* tray open */ - qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), - true, &error_abort); - } - if (load) { - /* tray close */ - qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), - false, &error_abort); - } - } -} - -bool bdrv_dev_has_removable_media(BlockDriverState *bs) -{ - return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb); -} - -void bdrv_dev_eject_request(BlockDriverState *bs, bool force) -{ - if (bs->dev_ops && bs->dev_ops->eject_request_cb) { - bs->dev_ops->eject_request_cb(bs->dev_opaque, force); - } -} - -bool bdrv_dev_is_tray_open(BlockDriverState *bs) -{ - if (bs->dev_ops && bs->dev_ops->is_tray_open) { - return bs->dev_ops->is_tray_open(bs->dev_opaque); - } - return false; -} - -static void bdrv_dev_resize_cb(BlockDriverState *bs) -{ - if (bs->dev_ops && bs->dev_ops->resize_cb) { - bs->dev_ops->resize_cb(bs->dev_opaque); - } -} - -bool bdrv_dev_is_medium_locked(BlockDriverState *bs) -{ - if (bs->dev_ops && bs->dev_ops->is_medium_locked) { - return bs->dev_ops->is_medium_locked(bs->dev_opaque); - } - return false; -} - /* * Run consistency checks on an image * @@ -3545,7 +3441,9 @@ int bdrv_truncate(BlockDriverState *bs, int64_t offset) ret = drv->bdrv_truncate(bs, offset); if (ret == 0) { ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); - bdrv_dev_resize_cb(bs); + if (bs->blk) { + blk_dev_resize_cb(bs->blk); + } } return ret; } @@ -3746,8 +3644,10 @@ int bdrv_set_key(BlockDriverState *bs, const char *key) bs->valid_key = 0; } else if (!bs->valid_key) { bs->valid_key = 1; - /* call the change callback now, we skipped it on open */ - bdrv_dev_change_media_cb(bs, true); + if (bs->blk) { + /* call the change callback now, we skipped it on open */ + blk_dev_change_media_cb(bs->blk, true); + } } return ret; } diff --git a/block/block-backend.c b/block/block-backend.c index ae30873df1..bdcbac674a 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -13,6 +13,10 @@ #include "sysemu/block-backend.h" #include "block/block_int.h" #include "sysemu/blockdev.h" +#include "qapi-event.h" + +/* Number of coroutines to reserve per attached device model */ +#define COROUTINE_POOL_RESERVATION 64 struct BlockBackend { char *name; @@ -20,6 +24,11 @@ struct BlockBackend { BlockDriverState *bs; DriveInfo *legacy_dinfo; /* null unless created by drive_new() */ QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */ + + void *dev; /* attached device model, if any */ + /* TODO change to DeviceState when all users are qdevified */ + const BlockDevOps *dev_ops; + void *dev_opaque; }; static void drive_info_del(DriveInfo *dinfo); @@ -85,6 +94,7 @@ BlockBackend *blk_new_with_bs(const char *name, Error **errp) static void blk_delete(BlockBackend *blk) { assert(!blk->refcnt); + assert(!blk->dev); if (blk->bs) { assert(blk->bs->blk == blk); blk->bs->blk = NULL; @@ -237,36 +247,155 @@ void blk_hide_on_behalf_of_do_drive_del(BlockBackend *blk) } } +/* + * Attach device model @dev to @blk. + * Return 0 on success, -EBUSY when a device model is attached already. + */ +int blk_attach_dev(BlockBackend *blk, void *dev) +/* TODO change to DeviceState *dev when all users are qdevified */ +{ + if (blk->dev) { + return -EBUSY; + } + blk->dev = dev; + bdrv_iostatus_reset(blk->bs); + + /* We're expecting I/O from the device so bump up coroutine pool size */ + qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION); + return 0; +} + +/* + * Attach device model @dev to @blk. + * @blk must not have a device model attached already. + * TODO qdevified devices don't use this, remove when devices are qdevified + */ +void blk_attach_dev_nofail(BlockBackend *blk, void *dev) +{ + if (blk_attach_dev(blk, dev) < 0) { + abort(); + } +} + +/* + * Detach device model @dev from @blk. + * @dev must be currently attached to @blk. + */ +void blk_detach_dev(BlockBackend *blk, void *dev) +/* TODO change to DeviceState *dev when all users are qdevified */ +{ + assert(blk->dev == dev); + blk->dev = NULL; + blk->dev_ops = NULL; + blk->dev_opaque = NULL; + bdrv_set_guest_block_size(blk->bs, 512); + qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION); +} + +/* + * Return the device model attached to @blk if any, else null. + */ +void *blk_get_attached_dev(BlockBackend *blk) +/* TODO change to return DeviceState * when all users are qdevified */ +{ + return blk->dev; +} + +/* + * Set @blk's device model callbacks to @ops. + * @opaque is the opaque argument to pass to the callbacks. + * This is for use by device models. + */ +void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, + void *opaque) +{ + blk->dev_ops = ops; + blk->dev_opaque = opaque; +} + +/* + * Notify @blk's attached device model of media change. + * If @load is true, notify of media load. + * Else, notify of media eject. + * Also send DEVICE_TRAY_MOVED events as appropriate. + */ +void blk_dev_change_media_cb(BlockBackend *blk, bool load) +{ + if (blk->dev_ops && blk->dev_ops->change_media_cb) { + bool tray_was_closed = !blk_dev_is_tray_open(blk); + + blk->dev_ops->change_media_cb(blk->dev_opaque, load); + if (tray_was_closed) { + /* tray open */ + qapi_event_send_device_tray_moved(blk_name(blk), + true, &error_abort); + } + if (load) { + /* tray close */ + qapi_event_send_device_tray_moved(blk_name(blk), + false, &error_abort); + } + } +} + +/* + * Does @blk's attached device model have removable media? + * %true if no device model is attached. + */ +bool blk_dev_has_removable_media(BlockBackend *blk) +{ + return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb); +} + +/* + * Notify @blk's attached device model of a media eject request. + * If @force is true, the medium is about to be yanked out forcefully. + */ +void blk_dev_eject_request(BlockBackend *blk, bool force) +{ + if (blk->dev_ops && blk->dev_ops->eject_request_cb) { + blk->dev_ops->eject_request_cb(blk->dev_opaque, force); + } +} + +/* + * Does @blk's attached device model have a tray, and is it open? + */ +bool blk_dev_is_tray_open(BlockBackend *blk) +{ + if (blk->dev_ops && blk->dev_ops->is_tray_open) { + return blk->dev_ops->is_tray_open(blk->dev_opaque); + } + return false; +} + +/* + * Does @blk's attached device model have the medium locked? + * %false if the device model has no such lock. + */ +bool blk_dev_is_medium_locked(BlockBackend *blk) +{ + if (blk->dev_ops && blk->dev_ops->is_medium_locked) { + return blk->dev_ops->is_medium_locked(blk->dev_opaque); + } + return false; +} + +/* + * Notify @blk's attached device model of a backend size change. + */ +void blk_dev_resize_cb(BlockBackend *blk) +{ + if (blk->dev_ops && blk->dev_ops->resize_cb) { + blk->dev_ops->resize_cb(blk->dev_opaque); + } +} + void blk_iostatus_enable(BlockBackend *blk) { bdrv_iostatus_enable(blk->bs); } -int blk_attach_dev(BlockBackend *blk, void *dev) -{ - return bdrv_attach_dev(blk->bs, dev); -} - -void blk_attach_dev_nofail(BlockBackend *blk, void *dev) -{ - bdrv_attach_dev_nofail(blk->bs, dev); -} - -void blk_detach_dev(BlockBackend *blk, void *dev) -{ - bdrv_detach_dev(blk->bs, dev); -} - -void *blk_get_attached_dev(BlockBackend *blk) -{ - return bdrv_get_attached_dev(blk->bs); -} - -void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, void *opaque) -{ - bdrv_set_dev_ops(blk->bs, ops, opaque); -} - int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf, int nb_sectors) { diff --git a/block/qapi.c b/block/qapi.c index fca981d94e..1301144bbc 100644 --- a/block/qapi.c +++ b/block/qapi.c @@ -275,12 +275,12 @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info, Error *local_err = NULL; info->device = g_strdup(blk_name(blk)); info->type = g_strdup("unknown"); - info->locked = bdrv_dev_is_medium_locked(bs); - info->removable = bdrv_dev_has_removable_media(bs); + info->locked = blk_dev_is_medium_locked(blk); + info->removable = blk_dev_has_removable_media(blk); - if (bdrv_dev_has_removable_media(bs)) { + if (blk_dev_has_removable_media(blk)) { info->has_tray_open = true; - info->tray_open = bdrv_dev_is_tray_open(bs); + info->tray_open = blk_dev_is_tray_open(blk); } if (bdrv_iostatus_is_enabled(bs)) { diff --git a/blockdev.c b/blockdev.c index a32d84c673..eb743a956c 100644 --- a/blockdev.c +++ b/blockdev.c @@ -217,7 +217,7 @@ bool drive_check_orphaned(void) dinfo = blk_legacy_dinfo(blk); /* If dinfo->bdrv->dev is NULL, it has no device attached. */ /* Unless this is a default drive, this may be an oversight. */ - if (!blk_bs(blk)->dev && !dinfo->is_default && + if (!blk_get_attached_dev(blk) && !dinfo->is_default && dinfo->type != IF_NONE) { fprintf(stderr, "Warning: Orphaned drive without device: " "id=%s,file=%s,if=%s,bus=%d,unit=%d\n", @@ -1600,14 +1600,14 @@ static void eject_device(BlockBackend *blk, int force, Error **errp) if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) { return; } - if (!bdrv_dev_has_removable_media(bs)) { + if (!blk_dev_has_removable_media(blk)) { error_setg(errp, "Device '%s' is not removable", bdrv_get_device_name(bs)); return; } - if (bdrv_dev_is_medium_locked(bs) && !bdrv_dev_is_tray_open(bs)) { - bdrv_dev_eject_request(bs, force); + if (blk_dev_is_medium_locked(blk) && !blk_dev_is_tray_open(blk)) { + blk_dev_eject_request(blk, force); if (!force) { error_setg(errp, "Device '%s' is locked", bdrv_get_device_name(bs)); @@ -1844,7 +1844,7 @@ int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) * can be removed. If this is a drive with no device backing * then we can just get rid of the block driver state right here. */ - if (bdrv_get_attached_dev(bs)) { + if (blk_get_attached_dev(blk)) { blk_hide_on_behalf_of_do_drive_del(blk); /* Further I/O must not pause the guest */ bdrv_set_on_error(bs, BLOCKDEV_ON_ERROR_REPORT, diff --git a/include/block/block.h b/include/block/block.h index 9a490c221c..c9ec0ab386 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -48,41 +48,6 @@ typedef struct BlockFragInfo { uint64_t compressed_clusters; } BlockFragInfo; -/* Callbacks for block device models */ -typedef struct BlockDevOps { - /* - * Runs when virtual media changed (monitor commands eject, change) - * Argument load is true on load and false on eject. - * Beware: doesn't run when a host device's physical media - * changes. Sure would be useful if it did. - * Device models with removable media must implement this callback. - */ - void (*change_media_cb)(void *opaque, bool load); - /* - * Runs when an eject request is issued from the monitor, the tray - * is closed, and the medium is locked. - * Device models that do not implement is_medium_locked will not need - * this callback. Device models that can lock the medium or tray might - * want to implement the callback and unlock the tray when "force" is - * true, even if they do not support eject requests. - */ - void (*eject_request_cb)(void *opaque, bool force); - /* - * Is the virtual tray open? - * Device models implement this only when the device has a tray. - */ - bool (*is_tray_open)(void *opaque); - /* - * Is the virtual medium locked into the device? - * Device models implement this only when device has such a lock. - */ - bool (*is_medium_locked)(void *opaque); - /* - * Runs when the size changed (e.g. monitor command block_resize) - */ - void (*resize_cb)(void *opaque); -} BlockDevOps; - typedef enum { BDRV_REQ_COPY_ON_READ = 0x1, BDRV_REQ_ZERO_WRITE = 0x2, @@ -230,16 +195,6 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state); void bdrv_reopen_abort(BDRVReopenState *reopen_state); void bdrv_close(BlockDriverState *bs); void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify); -int bdrv_attach_dev(BlockDriverState *bs, void *dev); -void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev); -void bdrv_detach_dev(BlockDriverState *bs, void *dev); -void *bdrv_get_attached_dev(BlockDriverState *bs); -void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops, - void *opaque); -void bdrv_dev_eject_request(BlockDriverState *bs, bool force); -bool bdrv_dev_has_removable_media(BlockDriverState *bs); -bool bdrv_dev_is_tray_open(BlockDriverState *bs); -bool bdrv_dev_is_medium_locked(BlockDriverState *bs); int bdrv_read(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors); int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num, diff --git a/include/block/block_int.h b/include/block/block_int.h index e8e33a8b43..8898c6c51b 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -326,11 +326,6 @@ struct BlockDriverState { BlockBackend *blk; /* owning backend, if any */ - void *dev; /* attached device model, if any */ - /* TODO change to DeviceState when all users are qdevified */ - const BlockDevOps *dev_ops; - void *dev_opaque; - AioContext *aio_context; /* event loop used for fd handlers, timers, etc */ /* long-running tasks intended to always use the same AioContext as this * BDS may register themselves in this list to be notified of changes @@ -587,4 +582,11 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target, BlockCompletionFunc *cb, void *opaque, Error **errp); +void blk_dev_change_media_cb(BlockBackend *blk, bool load); +bool blk_dev_has_removable_media(BlockBackend *blk); +void blk_dev_eject_request(BlockBackend *blk, bool force); +bool blk_dev_is_tray_open(BlockBackend *blk); +bool blk_dev_is_medium_locked(BlockBackend *blk); +void blk_dev_resize_cb(BlockBackend *blk); + #endif /* BLOCK_INT_H */ diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h index f63817a7cc..52d13c1c0e 100644 --- a/include/sysemu/block-backend.h +++ b/include/sysemu/block-backend.h @@ -25,6 +25,41 @@ */ #include "block/block.h" +/* Callbacks for block device models */ +typedef struct BlockDevOps { + /* + * Runs when virtual media changed (monitor commands eject, change) + * Argument load is true on load and false on eject. + * Beware: doesn't run when a host device's physical media + * changes. Sure would be useful if it did. + * Device models with removable media must implement this callback. + */ + void (*change_media_cb)(void *opaque, bool load); + /* + * Runs when an eject request is issued from the monitor, the tray + * is closed, and the medium is locked. + * Device models that do not implement is_medium_locked will not need + * this callback. Device models that can lock the medium or tray might + * want to implement the callback and unlock the tray when "force" is + * true, even if they do not support eject requests. + */ + void (*eject_request_cb)(void *opaque, bool force); + /* + * Is the virtual tray open? + * Device models implement this only when the device has a tray. + */ + bool (*is_tray_open)(void *opaque); + /* + * Is the virtual medium locked into the device? + * Device models implement this only when device has such a lock. + */ + bool (*is_medium_locked)(void *opaque); + /* + * Runs when the size changed (e.g. monitor command block_resize) + */ + void (*resize_cb)(void *opaque); +} BlockDevOps; + BlockBackend *blk_new(const char *name, Error **errp); BlockBackend *blk_new_with_bs(const char *name, Error **errp); void blk_ref(BlockBackend *blk); From 84ebe3755f88be4c3733e997641fafd050a58810 Mon Sep 17 00:00:00 2001 From: Markus Armbruster Date: Tue, 7 Oct 2014 13:59:26 +0200 Subject: [PATCH 28/28] block: Make device model's references to BlockBackend strong MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Doesn't make a difference just yet, but it's the right thing to do. Signed-off-by: Markus Armbruster Reviewed-by: Benoît Canet Reviewed-by: Kevin Wolf Reviewed-by: Max Reitz Signed-off-by: Kevin Wolf --- block/block-backend.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/block/block-backend.c b/block/block-backend.c index bdcbac674a..d0692b18e9 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -257,6 +257,7 @@ int blk_attach_dev(BlockBackend *blk, void *dev) if (blk->dev) { return -EBUSY; } + blk_ref(blk); blk->dev = dev; bdrv_iostatus_reset(blk->bs); @@ -290,6 +291,7 @@ void blk_detach_dev(BlockBackend *blk, void *dev) blk->dev_opaque = NULL; bdrv_set_guest_block_size(blk->bs, 512); qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION); + blk_unref(blk); } /*