2017-08-25 16:20:27 +03:00
|
|
|
/*
|
|
|
|
* QEMU block throttling filter driver infrastructure
|
|
|
|
*
|
|
|
|
* Copyright (c) 2017 Manos Pitsidianakis
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 or
|
|
|
|
* (at your option) version 3 of the License.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include "block/throttle-groups.h"
|
2019-05-23 17:35:07 +03:00
|
|
|
#include "qemu/module.h"
|
2018-02-01 14:18:46 +03:00
|
|
|
#include "qemu/option.h"
|
2017-08-25 16:20:27 +03:00
|
|
|
#include "qemu/throttle-options.h"
|
|
|
|
#include "qapi/error.h"
|
|
|
|
|
|
|
|
static QemuOptsList throttle_opts = {
|
|
|
|
.name = "throttle",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(throttle_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = QEMU_OPT_THROTTLE_GROUP_NAME,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Name of the throttle group",
|
|
|
|
},
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
/*
|
|
|
|
* If this function succeeds then the throttle group name is stored in
|
|
|
|
* @group and must be freed by the caller.
|
|
|
|
* If there's an error then @group remains unmodified.
|
|
|
|
*/
|
|
|
|
static int throttle_parse_options(QDict *options, char **group, Error **errp)
|
2017-08-25 16:20:27 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
const char *group_name;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
QemuOpts *opts = qemu_opts_create(&throttle_opts, NULL, 0, &error_abort);
|
|
|
|
|
|
|
|
qemu_opts_absorb_qdict(opts, options, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fin;
|
|
|
|
}
|
|
|
|
|
|
|
|
group_name = qemu_opt_get(opts, QEMU_OPT_THROTTLE_GROUP_NAME);
|
|
|
|
if (!group_name) {
|
|
|
|
error_setg(errp, "Please specify a throttle group");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fin;
|
|
|
|
} else if (!throttle_group_exists(group_name)) {
|
|
|
|
error_setg(errp, "Throttle group '%s' does not exist", group_name);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fin;
|
|
|
|
}
|
|
|
|
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
*group = g_strdup(group_name);
|
2017-08-25 16:20:27 +03:00
|
|
|
ret = 0;
|
|
|
|
fin:
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int throttle_open(BlockDriverState *bs, QDict *options,
|
|
|
|
int flags, Error **errp)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
char *group;
|
|
|
|
int ret;
|
2017-08-25 16:20:27 +03:00
|
|
|
|
2020-05-13 14:05:36 +03:00
|
|
|
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
|
|
|
|
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
|
|
|
|
false, errp);
|
2017-08-25 16:20:27 +03:00
|
|
|
if (!bs->file) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2018-04-21 16:29:26 +03:00
|
|
|
bs->supported_write_flags = bs->file->bs->supported_write_flags |
|
|
|
|
BDRV_REQ_WRITE_UNCHANGED;
|
|
|
|
bs->supported_zero_flags = bs->file->bs->supported_zero_flags |
|
|
|
|
BDRV_REQ_WRITE_UNCHANGED;
|
2017-08-25 16:20:27 +03:00
|
|
|
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
ret = throttle_parse_options(options, &group, errp);
|
|
|
|
if (ret == 0) {
|
|
|
|
/* Register membership to group with name group_name */
|
|
|
|
throttle_group_register_tgm(tgm, group, bdrv_get_aio_context(bs));
|
|
|
|
g_free(group);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2017-08-25 16:20:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void throttle_close(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
throttle_group_unregister_tgm(tgm);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int64_t throttle_getlength(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
return bdrv_getlength(bs->file->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn throttle_co_preadv(BlockDriverState *bs,
|
|
|
|
uint64_t offset, uint64_t bytes,
|
|
|
|
QEMUIOVector *qiov, int flags)
|
|
|
|
{
|
|
|
|
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
throttle_group_co_io_limits_intercept(tgm, bytes, false);
|
|
|
|
|
|
|
|
return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn throttle_co_pwritev(BlockDriverState *bs,
|
|
|
|
uint64_t offset, uint64_t bytes,
|
|
|
|
QEMUIOVector *qiov, int flags)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
throttle_group_co_io_limits_intercept(tgm, bytes, true);
|
|
|
|
|
|
|
|
return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn throttle_co_pwrite_zeroes(BlockDriverState *bs,
|
|
|
|
int64_t offset, int bytes,
|
|
|
|
BdrvRequestFlags flags)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
throttle_group_co_io_limits_intercept(tgm, bytes, true);
|
|
|
|
|
|
|
|
return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn throttle_co_pdiscard(BlockDriverState *bs,
|
|
|
|
int64_t offset, int bytes)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
throttle_group_co_io_limits_intercept(tgm, bytes, true);
|
|
|
|
|
2018-07-10 09:31:17 +03:00
|
|
|
return bdrv_co_pdiscard(bs->file, offset, bytes);
|
2017-08-25 16:20:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int throttle_co_flush(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
return bdrv_co_flush(bs->file->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void throttle_detach_aio_context(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
throttle_group_detach_aio_context(tgm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void throttle_attach_aio_context(BlockDriverState *bs,
|
|
|
|
AioContext *new_context)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
throttle_group_attach_aio_context(tgm, new_context);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int throttle_reopen_prepare(BDRVReopenState *reopen_state,
|
|
|
|
BlockReopenQueue *queue, Error **errp)
|
|
|
|
{
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
int ret;
|
|
|
|
char *group = NULL;
|
2017-08-25 16:20:27 +03:00
|
|
|
|
|
|
|
assert(reopen_state != NULL);
|
|
|
|
assert(reopen_state->bs != NULL);
|
|
|
|
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
ret = throttle_parse_options(reopen_state->options, &group, errp);
|
|
|
|
reopen_state->opaque = group;
|
|
|
|
return ret;
|
2017-08-25 16:20:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void throttle_reopen_commit(BDRVReopenState *reopen_state)
|
|
|
|
{
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
BlockDriverState *bs = reopen_state->bs;
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
char *group = reopen_state->opaque;
|
|
|
|
|
|
|
|
assert(group);
|
2017-08-25 16:20:27 +03:00
|
|
|
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
if (strcmp(group, throttle_group_get_name(tgm))) {
|
|
|
|
throttle_group_unregister_tgm(tgm);
|
|
|
|
throttle_group_register_tgm(tgm, group, bdrv_get_aio_context(bs));
|
|
|
|
}
|
|
|
|
g_free(reopen_state->opaque);
|
2017-08-25 16:20:27 +03:00
|
|
|
reopen_state->opaque = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void throttle_reopen_abort(BDRVReopenState *reopen_state)
|
|
|
|
{
|
throttle: Fix crash on reopen
The throttle block filter can be reopened, and with this it is
possible to change the throttle group that the filter belongs to.
The way the code does that is the following:
- On throttle_reopen_prepare(): create a new ThrottleGroupMember
and attach it to the new throttle group.
- On throttle_reopen_commit(): detach the old ThrottleGroupMember,
delete it and replace it with the new one.
The problem with this is that by replacing the ThrottleGroupMember the
previous value of io_limits_disabled is lost, causing an assertion
failure in throttle_co_drain_end().
This problem can be reproduced by reopening a throttle node:
$QEMU -monitor stdio
-object throttle-group,id=tg0,x-iops-total=1000 \
-blockdev node-name=hd0,driver=qcow2,file.driver=file,file.filename=hd.qcow2 \
-blockdev node-name=root,driver=throttle,throttle-group=tg0,file=hd0,read-only=on
(qemu) block_stream root
block/throttle.c:214: throttle_co_drain_end: Assertion `tgm->io_limits_disabled' failed.
Since we only want to change the throttle group on reopen there's no
need to create a ThrottleGroupMember and discard the old one. It's
easier if we simply detach it from its current group and attach it to
the new one.
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 20180608151536.7378-1-berto@igalia.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
2018-06-08 18:15:36 +03:00
|
|
|
g_free(reopen_state->opaque);
|
2017-08-25 16:20:27 +03:00
|
|
|
reopen_state->opaque = NULL;
|
|
|
|
}
|
|
|
|
|
2017-09-23 14:14:11 +03:00
|
|
|
static void coroutine_fn throttle_co_drain_begin(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
if (atomic_fetch_inc(&tgm->io_limits_disabled) == 0) {
|
|
|
|
throttle_group_restart_tgm(tgm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void coroutine_fn throttle_co_drain_end(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
ThrottleGroupMember *tgm = bs->opaque;
|
|
|
|
assert(tgm->io_limits_disabled);
|
|
|
|
atomic_dec(&tgm->io_limits_disabled);
|
|
|
|
}
|
|
|
|
|
2019-02-01 22:29:25 +03:00
|
|
|
static const char *const throttle_strong_runtime_opts[] = {
|
|
|
|
QEMU_OPT_THROTTLE_GROUP_NAME,
|
|
|
|
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2017-08-25 16:20:27 +03:00
|
|
|
static BlockDriver bdrv_throttle = {
|
|
|
|
.format_name = "throttle",
|
|
|
|
.instance_size = sizeof(ThrottleGroupMember),
|
|
|
|
|
2018-03-13 01:07:51 +03:00
|
|
|
.bdrv_open = throttle_open,
|
2017-08-25 16:20:27 +03:00
|
|
|
.bdrv_close = throttle_close,
|
|
|
|
.bdrv_co_flush = throttle_co_flush,
|
|
|
|
|
2020-05-13 14:05:39 +03:00
|
|
|
.bdrv_child_perm = bdrv_default_perms,
|
2017-08-25 16:20:27 +03:00
|
|
|
|
|
|
|
.bdrv_getlength = throttle_getlength,
|
|
|
|
|
|
|
|
.bdrv_co_preadv = throttle_co_preadv,
|
|
|
|
.bdrv_co_pwritev = throttle_co_pwritev,
|
|
|
|
|
|
|
|
.bdrv_co_pwrite_zeroes = throttle_co_pwrite_zeroes,
|
|
|
|
.bdrv_co_pdiscard = throttle_co_pdiscard,
|
|
|
|
|
|
|
|
.bdrv_attach_aio_context = throttle_attach_aio_context,
|
|
|
|
.bdrv_detach_aio_context = throttle_detach_aio_context,
|
|
|
|
|
|
|
|
.bdrv_reopen_prepare = throttle_reopen_prepare,
|
|
|
|
.bdrv_reopen_commit = throttle_reopen_commit,
|
|
|
|
.bdrv_reopen_abort = throttle_reopen_abort,
|
2018-02-13 23:26:43 +03:00
|
|
|
.bdrv_co_block_status = bdrv_co_block_status_from_file,
|
2017-08-25 16:20:27 +03:00
|
|
|
|
2017-09-23 14:14:11 +03:00
|
|
|
.bdrv_co_drain_begin = throttle_co_drain_begin,
|
|
|
|
.bdrv_co_drain_end = throttle_co_drain_end,
|
|
|
|
|
2017-08-25 16:20:27 +03:00
|
|
|
.is_filter = true,
|
2019-02-01 22:29:25 +03:00
|
|
|
.strong_runtime_opts = throttle_strong_runtime_opts,
|
2017-08-25 16:20:27 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static void bdrv_throttle_init(void)
|
|
|
|
{
|
|
|
|
bdrv_register(&bdrv_throttle);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_init(bdrv_throttle_init);
|