The following changes since commit 98bfaac788be0ca63d7d010c8d4ba100ff1d8278:

Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2017-09-01-v3' into staging (2017-09-04 13:28:09 +0100)

are available in the git repository at:

for you to fetch changes up to 83a8c775a8bf134eb18a719322939b74a818d750:

qcow2: move qcow2_store_persistent_dirty_bitmaps() before cache flushing (2017-09-06 14:40:18 +0200)

Block layer patches

Daniel P. Berrange (1):

block: document semantics of bdrv_co_preadv|pwritev

Eric Blake (2):

qcow: Change signature of get_cluster_offset()

qcow: Check failure of bdrv_getlength() and bdrv_truncate()

Manos Pitsidianakis (10):

block: pass bdrv_* methods to bs->file by default in block filters

block: remove unused bdrv_media_changed

block: remove bdrv_truncate callback in blkdebug

block: add default implementations for bdrv_co_get_block_status()

block: move ThrottleGroup membership to ThrottleGroupMember

block: add aio_context field in ThrottleGroupMember

block: tidy ThrottleGroupMember initializations

block: convert ThrottleGroup to object with QOM

block: add throttle block filter driver

qemu-iotests: add 184 for throttle filter driver

Pavel Butsykin (1):

qcow2: move qcow2_store_persistent_dirty_bitmaps() before cache flushing

qapi/block-core.json | 66 +++-

include/block/block.h | 1 -

include/block/block_int.h | 56 ++-

include/block/throttle-groups.h | 52 ++-

include/qemu/throttle-options.h | 60 +++-

include/qemu/throttle.h | 3 +

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

block.c | 35 +-

block/blkdebug.c | 20 +-

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

block/commit.c | 12 +-

block/io.c | 26 ++

block/mirror.c | 12 +-

block/qapi.c | 8 +-

block/qcow.c | 153 ++++----

block/qcow2.c | 16 +-

block/raw-format.c | 6 -

block/throttle-groups.c | 750 ++++++++++++++++++++++++++++++----------

block/throttle.c | 237 +++++++++++++

blockdev.c | 4 +-

tests/test-throttle.c | 111 +++---

util/throttle.c | 151 ++++++++

block/Makefile.objs | 1 +

tests/qemu-iotests/184 | 205 +++++++++++

tests/qemu-iotests/184.out | 302 ++++++++++++++++

26 files changed, 1917 insertions(+), 453 deletions(-)

create mode 100644 block/throttle.c

create mode 100755 tests/qemu-iotests/184

create mode 100644 tests/qemu-iotests/184.out

From: Manos Pitsidianakis <el13635@mail.ntua.gr>

Move the CoMutex and CoQueue inits inside throttle_group_register_tgm()

which is called whenever a ThrottleGroupMember is initialized. There's

no need for them to be separate.

Reviewed-by: Alberto Garcia <berto@igalia.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Manos Pitsidianakis <el13635@mail.ntua.gr>

block/block-backend.c | 3 ---

block/throttle-groups.c | 3 +++

2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/block/block-backend.c b/block/block-backend.c

--- a/block/block-backend.c

+++ b/block/block-backend.c

@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm)

blk->shared_perm = shared_perm;

blk_set_enable_write_cache(blk, true);

- qemu_co_mutex_init(&blk->public.throttle_group_member.throttled_reqs_lock);

- qemu_co_queue_init(&blk->public.throttle_group_member.throttled_reqs[0]);

- qemu_co_queue_init(&blk->public.throttle_group_member.throttled_reqs[1]);

block_acct_init(&blk->stats);

notifier_list_init(&blk->remove_bs_notifiers);

diff --git a/block/throttle-groups.c b/block/throttle-groups.c

index XXXXXXX..XXXXXXX 100644

--- a/block/throttle-groups.c

+++ b/block/throttle-groups.c

@@ -XXX,XX +XXX,XX @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm,

read_timer_cb,

write_timer_cb,

tgm);

+ qemu_co_mutex_init(&tgm->throttled_reqs_lock);

+ qemu_co_queue_init(&tgm->throttled_reqs[0]);

+ qemu_co_queue_init(&tgm->throttled_reqs[1]);

qemu_mutex_unlock(&tg->lock);

}

2.13.5

From: Manos Pitsidianakis <el13635@mail.ntua.gr>

The following functions fail if bs->drv is a filter and does not

implement them:

bdrv_probe_blocksizes

bdrv_probe_geometry

bdrv_truncate

bdrv_has_zero_init

bdrv_get_info

Instead, the call should be passed to bs->file if it exists, to allow

filter drivers to support those methods without implementing them. This

commit makes `drv->is_filter = true` imply that these callbacks will be

forwarded to bs->file by default, so disabling support for these

functions must be done explicitly.

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Manos Pitsidianakis <el13635@mail.ntua.gr>

include/block/block_int.h | 6 +++++-

block.c | 21 +++++++++++++++++++--

2 files changed, 24 insertions(+), 3 deletions(-)

const char *format_name;

int instance_size;

- /* set to true if the BlockDriver is a block filter */

+ /* set to true if the BlockDriver is a block filter. Block filters pass

+ * certain callbacks that refer to data (see block.c) to their bs->file if

+ * the driver doesn't implement them. Drivers that do not wish to forward

+ * must implement them and return -ENOTSUP.

bool is_filter;

/* for snapshots block filter like Quorum can implement the

* following recursive callback.

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

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)

if (drv && drv->bdrv_probe_blocksizes) {

return drv->bdrv_probe_blocksizes(bs, bsz);

+ } else if (drv && drv->is_filter && bs->file) {

+ return bdrv_probe_blocksizes(bs->file->bs, bsz);

return -ENOTSUP;

@@ -XXX,XX +XXX,XX @@ int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)

if (drv && drv->bdrv_probe_geometry) {

return drv->bdrv_probe_geometry(bs, geo);

+ } else if (drv && drv->is_filter && bs->file) {

+ return bdrv_probe_geometry(bs->file->bs, geo);

}

return -ENOTSUP;

@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,

assert(child->perm & BLK_PERM_RESIZE);

+ /* if bs->drv == NULL, bs is closed, so there's nothing to do here */

if (!drv) {

error_setg(errp, "No medium inserted");

return -ENOMEDIUM;

}

if (!drv->bdrv_truncate) {

+ if (bs->file && drv->is_filter) {

+ return bdrv_truncate(bs->file, offset, prealloc, errp);

error_setg(errp, "Image format driver does not support resize");

return -ENOTSUP;

}

@@ -XXX,XX +XXX,XX @@ int bdrv_has_zero_init(BlockDriverState *bs)

if (bs->drv->bdrv_has_zero_init) {

return bs->drv->bdrv_has_zero_init(bs);

}

+ if (bs->file && bs->drv->is_filter) {

+ return bdrv_has_zero_init(bs->file->bs);

+ }

/* safe default */

2.13.5

From: Eric Blake <eblake@redhat.com>

Omitting the check for whether bdrv_getlength() and bdrv_truncate()

failed meant that it was theoretically possible to return an

incorrect offset to the caller. More likely, conditions for either

of these functions to fail would also cause one of our other calls

(such as bdrv_pread() or bdrv_pwrite_sync()) to also fail, but

auditing that we are safe is difficult compared to just patching

things to always forward on the error rather than ignoring it.

Use osdep.h macros instead of open-coded rounding while in the

area.

Reported-by: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Eric Blake <eblake@redhat.com>

block/qcow.c | 30 ++++++++++++++++++++++--------

1 file changed, 22 insertions(+), 8 deletions(-)

{

BDRVQcowState *s = bs->opaque;

int min_index, i, j, l1_index, l2_index, ret;

- uint64_t l2_offset, *l2_table, cluster_offset, tmp;

+ int64_t l2_offset;

+ uint64_t *l2_table, cluster_offset, tmp;

uint32_t min_count;

int new_l2_table;

@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,

return 0;

/* allocate a new l2 entry */

l2_offset = bdrv_getlength(bs->file->bs);

+ if (l2_offset < 0) {

+ return l2_offset;

+ }

/* round to cluster size */

- l2_offset = (l2_offset + s->cluster_size - 1) & ~(s->cluster_size - 1);

+ l2_offset = QEMU_ALIGN_UP(l2_offset, s->cluster_size);

/* update the L1 entry */

s->l1_table[l1_index] = l2_offset;

tmp = cpu_to_be64(l2_offset);

@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,

return -EIO;

cluster_offset = bdrv_getlength(bs->file->bs);

- cluster_offset = (cluster_offset + s->cluster_size - 1) &

- ~(s->cluster_size - 1);

+ if ((int64_t) cluster_offset < 0) {

+ return cluster_offset;

+ }

+ cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);

/* write the cluster content */

ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,

s->cluster_size);

@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,

} else {

cluster_offset = bdrv_getlength(bs->file->bs);

+ if ((int64_t) cluster_offset < 0) {

+ return cluster_offset;

+ }

if (allocate == 1) {

/* round to cluster size */

- cluster_offset = (cluster_offset + s->cluster_size - 1) &

- ~(s->cluster_size - 1);

- bdrv_truncate(bs->file, cluster_offset + s->cluster_size,

- PREALLOC_MODE_OFF, NULL);

+ cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);

+ if (cluster_offset + s->cluster_size > INT64_MAX) {

+ return -E2BIG;

+ }

+ ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,

+ PREALLOC_MODE_OFF, NULL);

+ if (ret < 0) {

+ return ret;

+ }

/* if encrypted, we must initialize the cluster

content which won't be written */

if (bs->encrypted &&

2.13.5

From: Manos Pitsidianakis <el13635@mail.ntua.gr>

This commit eliminates the 1:1 relationship between BlockBackend and

throttle group state. Users will be able to create multiple throttle

nodes, each with its own throttle group state, in the future. The

throttle group state cannot be per-BlockBackend anymore, it must be

per-throttle node. This is done by gathering ThrottleGroup membership

details from BlockBackendPublic into ThrottleGroupMember and refactoring

existing code to use the structure.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Manos Pitsidianakis <el13635@mail.ntua.gr>

include/block/throttle-groups.h | 39 +++++-

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

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

block/qapi.c | 8 +-

block/throttle-groups.c | 288 ++++++++++++++++++++--------------------

blockdev.c | 4 +-

tests/test-throttle.c | 53 ++++----

7 files changed, 252 insertions(+), 226 deletions(-)

diff --git a/include/block/throttle-groups.h b/include/block/throttle-groups.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/throttle-groups.h

+++ b/include/block/throttle-groups.h

@@ -XXX,XX +XXX,XX @@

#include "qemu/throttle.h"

#include "block/block_int.h"

-const char *throttle_group_get_name(BlockBackend *blk);

+/* The ThrottleGroupMember structure indicates membership in a ThrottleGroup

+ * and holds related data.

+ */

+

+typedef struct ThrottleGroupMember {

+ /* throttled_reqs_lock protects the CoQueues for throttled requests. */

+ CoMutex throttled_reqs_lock;

+ CoQueue throttled_reqs[2];

+

+ /* Nonzero if the I/O limits are currently being ignored; generally

+ * it is zero. Accessed with atomic operations.

+ */

+ unsigned int io_limits_disabled;

+

+ /* The following fields are protected by the ThrottleGroup lock.

+ * See the ThrottleGroup documentation for details.

+ * throttle_state tells us if I/O limits are configured. */

+ ThrottleState *throttle_state;

+ ThrottleTimers throttle_timers;

+ unsigned pending_reqs[2];

+ QLIST_ENTRY(ThrottleGroupMember) round_robin;

+

+} ThrottleGroupMember;

+

+const char *throttle_group_get_name(ThrottleGroupMember *tgm);

ThrottleState *throttle_group_incref(const char *name);

void throttle_group_unref(ThrottleState *ts);

-void throttle_group_config(BlockBackend *blk, ThrottleConfig *cfg);

-void throttle_group_get_config(BlockBackend *blk, ThrottleConfig *cfg);

+void throttle_group_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg);

+void throttle_group_get_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg);

-void throttle_group_register_blk(BlockBackend *blk, const char *groupname);

-void throttle_group_unregister_blk(BlockBackend *blk);

-void throttle_group_restart_blk(BlockBackend *blk);

+void throttle_group_register_tgm(ThrottleGroupMember *tgm,

+ const char *groupname);

+void throttle_group_unregister_tgm(ThrottleGroupMember *tgm);

+void throttle_group_restart_tgm(ThrottleGroupMember *tgm);

-void coroutine_fn throttle_group_co_io_limits_intercept(BlockBackend *blk,

+void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm,

unsigned int bytes,

bool is_write);

@@ -XXX,XX +XXX,XX @@ typedef struct BlockDevOps {

/* This struct is embedded in (the private) BlockBackend struct and contains

* fields that must be public. This is in particular for QLIST_ENTRY() and

- * friends so that BlockBackends can be kept in lists outside block-backend.c */

+ * friends so that BlockBackends can be kept in lists outside block-backend.c

+ * */

typedef struct BlockBackendPublic {

- /* throttled_reqs_lock protects the CoQueues for throttled requests. */

- CoMutex throttled_reqs_lock;

- CoQueue throttled_reqs[2];

-

- /* Nonzero if the I/O limits are currently being ignored; generally

- * it is zero. Accessed with atomic operations.

- */

- unsigned int io_limits_disabled;

-

- /* The following fields are protected by the ThrottleGroup lock.

- * See the ThrottleGroup documentation for details.

- * throttle_state tells us if I/O limits are configured. */

- ThrottleState *throttle_state;

- ThrottleTimers throttle_timers;

- unsigned pending_reqs[2];

- QLIST_ENTRY(BlockBackendPublic) round_robin;

+ ThrottleGroupMember throttle_group_member;

} BlockBackendPublic;

BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm);

@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm)

blk->shared_perm = shared_perm;

blk_set_enable_write_cache(blk, true);

- qemu_co_mutex_init(&blk->public.throttled_reqs_lock);

- qemu_co_queue_init(&blk->public.throttled_reqs[0]);

- qemu_co_queue_init(&blk->public.throttled_reqs[1]);

+ qemu_co_mutex_init(&blk->public.throttle_group_member.throttled_reqs_lock);

+ qemu_co_queue_init(&blk->public.throttle_group_member.throttled_reqs[0]);

+ qemu_co_queue_init(&blk->public.throttle_group_member.throttled_reqs[1]);

block_acct_init(&blk->stats);

notifier_list_init(&blk->remove_bs_notifiers);

@@ -XXX,XX +XXX,XX @@ static void blk_delete(BlockBackend *blk)

assert(!blk->refcnt);

assert(!blk->name);

assert(!blk->dev);

- if (blk->public.throttle_state) {

+ if (blk->public.throttle_group_member.throttle_state) {

blk_io_limits_disable(blk);

}

if (blk->root) {

@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_by_public(BlockBackendPublic *public)

*/

void blk_remove_bs(BlockBackend *blk)

+ ThrottleTimers *tt;

+

notifier_list_notify(&blk->remove_bs_notifiers, blk);

- if (blk->public.throttle_state) {

- throttle_timers_detach_aio_context(&blk->public.throttle_timers);

+ if (blk->public.throttle_group_member.throttle_state) {

+ tt = &blk->public.throttle_group_member.throttle_timers;

+ throttle_timers_detach_aio_context(tt);

}

blk_update_root_state(blk);

@@ -XXX,XX +XXX,XX @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)

bdrv_ref(bs);

notifier_list_notify(&blk->insert_bs_notifiers, blk);

- if (blk->public.throttle_state) {

+ if (blk->public.throttle_group_member.throttle_state) {

throttle_timers_attach_aio_context(

- &blk->public.throttle_timers, bdrv_get_aio_context(bs));

+ &blk->public.throttle_group_member.throttle_timers,

+ bdrv_get_aio_context(bs));

}

return 0;

@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,

bdrv_inc_in_flight(bs);

/* throttling disk I/O */

- if (blk->public.throttle_state) {

- throttle_group_co_io_limits_intercept(blk, bytes, false);

+ if (blk->public.throttle_group_member.throttle_state) {

+ throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,

+ bytes, false);

}

ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags);

@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,

}

bdrv_inc_in_flight(bs);

-

/* throttling disk I/O */

- if (blk->public.throttle_state) {

- throttle_group_co_io_limits_intercept(blk, bytes, true);

+ if (blk->public.throttle_group_member.throttle_state) {

+ throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member,

+ bytes, true);

}

if (!blk->enable_write_cache) {

@@ -XXX,XX +XXX,XX @@ static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)

void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)

{

BlockDriverState *bs = blk_bs(blk);

+ ThrottleTimers *tt;

if (bs) {

- if (blk->public.throttle_state) {

- throttle_timers_detach_aio_context(&blk->public.throttle_timers);

+ if (blk->public.throttle_group_member.throttle_state) {

+ tt = &blk->public.throttle_group_member.throttle_timers;

+ throttle_timers_detach_aio_context(tt);

}

bdrv_set_aio_context(bs, new_context);

- if (blk->public.throttle_state) {

- throttle_timers_attach_aio_context(&blk->public.throttle_timers,

- new_context);

+ if (blk->public.throttle_group_member.throttle_state) {

+ tt = &blk->public.throttle_group_member.throttle_timers;

+ throttle_timers_attach_aio_context(tt, new_context);

}

}

@@ -XXX,XX +XXX,XX @@ int blk_commit_all(void)

/* throttling disk I/O limits */

void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)

{

- throttle_group_config(blk, cfg);

+ throttle_group_config(&blk->public.throttle_group_member, cfg);

void blk_io_limits_disable(BlockBackend *blk)

{

- assert(blk->public.throttle_state);

+ assert(blk->public.throttle_group_member.throttle_state);

bdrv_drained_begin(blk_bs(blk));

- throttle_group_unregister_blk(blk);

+ throttle_group_unregister_tgm(&blk->public.throttle_group_member);

bdrv_drained_end(blk_bs(blk));

}

/* should be called before blk_set_io_limits if a limit is set */

void blk_io_limits_enable(BlockBackend *blk, const char *group)

{

- assert(!blk->public.throttle_state);

- throttle_group_register_blk(blk, group);

+ assert(!blk->public.throttle_group_member.throttle_state);

+ throttle_group_register_tgm(&blk->public.throttle_group_member, group);

}

void blk_io_limits_update_group(BlockBackend *blk, const char *group)

{

/* this BB is not part of any group */

- if (!blk->public.throttle_state) {

+ if (!blk->public.throttle_group_member.throttle_state) {

return;

}

/* this BB is a part of the same group than the one we want */

- if (!g_strcmp0(throttle_group_get_name(blk), group)) {

+ if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member),

+ group)) {

return;

}

@@ -XXX,XX +XXX,XX @@ static void blk_root_drained_begin(BdrvChild *child)

/* Note that blk->root may not be accessible here yet if we are just

* attaching to a BlockDriverState that is drained. Use child instead. */

- if (atomic_fetch_inc(&blk->public.io_limits_disabled) == 0) {

- throttle_group_restart_blk(blk);

+ if (atomic_fetch_inc(&blk->public.throttle_group_member.io_limits_disabled) == 0) {

+ throttle_group_restart_tgm(&blk->public.throttle_group_member);

}

}

@@ -XXX,XX +XXX,XX @@ static void blk_root_drained_end(BdrvChild *child)

BlockBackend *blk = child->opaque;

assert(blk->quiesce_counter);

- assert(blk->public.io_limits_disabled);

- atomic_dec(&blk->public.io_limits_disabled);

+ assert(blk->public.throttle_group_member.io_limits_disabled);

+ atomic_dec(&blk->public.throttle_group_member.io_limits_disabled);

if (--blk->quiesce_counter == 0) {

if (blk->dev_ops && blk->dev_ops->drained_end) {

diff --git a/block/qapi.c b/block/qapi.c

index XXXXXXX..XXXXXXX 100644

--- a/block/qapi.c

+++ b/block/qapi.c

@@ -XXX,XX +XXX,XX @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,

info->detect_zeroes = bs->detect_zeroes;

- if (blk && blk_get_public(blk)->throttle_state) {

+ if (blk && blk_get_public(blk)->throttle_group_member.throttle_state) {

ThrottleConfig cfg;

+ BlockBackendPublic *blkp = blk_get_public(blk);

- throttle_group_get_config(blk, &cfg);

+ throttle_group_get_config(&blkp->throttle_group_member, &cfg);

info->bps = cfg.buckets[THROTTLE_BPS_TOTAL].avg;

info->bps_rd = cfg.buckets[THROTTLE_BPS_READ].avg;

@@ -XXX,XX +XXX,XX @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,

info->iops_size = cfg.op_size;

info->has_group = true;

- info->group = g_strdup(throttle_group_get_name(blk));

+ info->group =

+ g_strdup(throttle_group_get_name(&blkp->throttle_group_member));

}

info->write_threshold = bdrv_write_threshold_get(bs);

diff --git a/block/throttle-groups.c b/block/throttle-groups.c

index XXXXXXX..XXXXXXX 100644

--- a/block/throttle-groups.c

+++ b/block/throttle-groups.c

@@ -XXX,XX +XXX,XX @@

#include "sysemu/qtest.h"

/* The ThrottleGroup structure (with its ThrottleState) is shared

- * among different BlockBackends and it's independent from

+ * among different ThrottleGroupMembers and it's independent from

* AioContext, so in order to use it from different threads it needs

* its own locking.

*

@@ -XXX,XX +XXX,XX @@

* The whole ThrottleGroup structure is private and invisible to

* outside users, that only use it through its ThrottleState.

*

- * In addition to the ThrottleGroup structure, BlockBackendPublic has

+ * In addition to the ThrottleGroup structure, ThrottleGroupMember has

* fields that need to be accessed by other members of the group and

* therefore also need to be protected by this lock. Once a

- * BlockBackend is registered in a group those fields can be accessed

+ * ThrottleGroupMember is registered in a group those fields can be accessed

* by other threads any time.

*

* Again, all this is handled internally and is mostly transparent to

* the outside. The 'throttle_timers' field however has an additional

* constraint because it may be temporarily invalid (see for example

* blk_set_aio_context()). Therefore in this file a thread will

- * access some other BlockBackend's timers only after verifying that

- * that BlockBackend has throttled requests in the queue.

+ * access some other ThrottleGroupMember's timers only after verifying that

+ * that ThrottleGroupMember has throttled requests in the queue.

*/

typedef struct ThrottleGroup {

char *name; /* This is constant during the lifetime of the group */

QemuMutex lock; /* This lock protects the following four fields */

ThrottleState ts;

- QLIST_HEAD(, BlockBackendPublic) head;

- BlockBackend *tokens[2];

+ QLIST_HEAD(, ThrottleGroupMember) head;

+ ThrottleGroupMember *tokens[2];

bool any_timer_armed[2];

QEMUClockType clock_type;

@@ -XXX,XX +XXX,XX @@ void throttle_group_unref(ThrottleState *ts)

qemu_mutex_unlock(&throttle_groups_lock);

}

-/* Get the name from a BlockBackend's ThrottleGroup. The name (and the pointer)

+/* Get the name from a ThrottleGroupMember's group. The name (and the pointer)