ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

block: Simplify block_set_io_throttle 

Now that we can support boxed commands, use it to greatly
reduce the number of parameters (and likelihood of getting
out of sync) when adjusting throttle parameters.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-Id: <1468468228-27827-11-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
This commit is contained in:
Eric Blake 2016-07-13 21:50:21 -06:00 committed by Markus Armbruster
parent c818408e44
commit 4dc9397b62
3 changed files with 66 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
blockdev.c
View File

@ -2634,49 +2634,17 @@ fail:
} }
/* throttling disk I/O limits */ /* throttling disk I/O limits */
void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp)
int64_t bps_wr,
int64_t iops,
int64_t iops_rd,
int64_t iops_wr,
bool has_bps_max,
int64_t bps_max,
bool has_bps_rd_max,
int64_t bps_rd_max,
bool has_bps_wr_max,
int64_t bps_wr_max,
bool has_iops_max,
int64_t iops_max,
bool has_iops_rd_max,
int64_t iops_rd_max,
bool has_iops_wr_max,
int64_t iops_wr_max,
bool has_bps_max_length,
int64_t bps_max_length,
bool has_bps_rd_max_length,
int64_t bps_rd_max_length,
bool has_bps_wr_max_length,
int64_t bps_wr_max_length,
bool has_iops_max_length,
int64_t iops_max_length,
bool has_iops_rd_max_length,
int64_t iops_rd_max_length,
bool has_iops_wr_max_length,
int64_t iops_wr_max_length,
bool has_iops_size,
int64_t iops_size,
bool has_group,
const char *group, Error **errp)
{ {
ThrottleConfig cfg; ThrottleConfig cfg;
BlockDriverState *bs; BlockDriverState *bs;
BlockBackend *blk; BlockBackend *blk;
AioContext *aio_context; AioContext *aio_context;
blk = blk_by_name(device); blk = blk_by_name(arg->device);
if (!blk) { if (!blk) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"Device '%s' not found", device); "Device '%s' not found", arg->device);
return; return;
} }
@ -2685,59 +2653,59 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
bs = blk_bs(blk); bs = blk_bs(blk);
if (!bs) { if (!bs) {
error_setg(errp, "Device '%s' has no medium", device); error_setg(errp, "Device '%s' has no medium", arg->device);
goto out; goto out;
} }
throttle_config_init(&cfg); throttle_config_init(&cfg);
cfg.buckets[THROTTLE_BPS_TOTAL].avg = bps; cfg.buckets[THROTTLE_BPS_TOTAL].avg = arg->bps;
cfg.buckets[THROTTLE_BPS_READ].avg = bps_rd; cfg.buckets[THROTTLE_BPS_READ].avg = arg->bps_rd;
cfg.buckets[THROTTLE_BPS_WRITE].avg = bps_wr; cfg.buckets[THROTTLE_BPS_WRITE].avg = arg->bps_wr;
cfg.buckets[THROTTLE_OPS_TOTAL].avg = iops; cfg.buckets[THROTTLE_OPS_TOTAL].avg = arg->iops;
cfg.buckets[THROTTLE_OPS_READ].avg = iops_rd; cfg.buckets[THROTTLE_OPS_READ].avg = arg->iops_rd;
cfg.buckets[THROTTLE_OPS_WRITE].avg = iops_wr; cfg.buckets[THROTTLE_OPS_WRITE].avg = arg->iops_wr;
if (has_bps_max) { if (arg->has_bps_max) {
cfg.buckets[THROTTLE_BPS_TOTAL].max = bps_max; cfg.buckets[THROTTLE_BPS_TOTAL].max = arg->bps_max;
} }
if (has_bps_rd_max) { if (arg->has_bps_rd_max) {
cfg.buckets[THROTTLE_BPS_READ].max = bps_rd_max; cfg.buckets[THROTTLE_BPS_READ].max = arg->bps_rd_max;
} }
if (has_bps_wr_max) { if (arg->has_bps_wr_max) {
cfg.buckets[THROTTLE_BPS_WRITE].max = bps_wr_max; cfg.buckets[THROTTLE_BPS_WRITE].max = arg->bps_wr_max;
} }
if (has_iops_max) { if (arg->has_iops_max) {
cfg.buckets[THROTTLE_OPS_TOTAL].max = iops_max; cfg.buckets[THROTTLE_OPS_TOTAL].max = arg->iops_max;
} }
if (has_iops_rd_max) { if (arg->has_iops_rd_max) {
cfg.buckets[THROTTLE_OPS_READ].max = iops_rd_max; cfg.buckets[THROTTLE_OPS_READ].max = arg->iops_rd_max;
} }
if (has_iops_wr_max) { if (arg->has_iops_wr_max) {
cfg.buckets[THROTTLE_OPS_WRITE].max = iops_wr_max; cfg.buckets[THROTTLE_OPS_WRITE].max = arg->iops_wr_max;
} }
if (has_bps_max_length) { if (arg->has_bps_max_length) {
cfg.buckets[THROTTLE_BPS_TOTAL].burst_length = bps_max_length; cfg.buckets[THROTTLE_BPS_TOTAL].burst_length = arg->bps_max_length;
} }
if (has_bps_rd_max_length) { if (arg->has_bps_rd_max_length) {
cfg.buckets[THROTTLE_BPS_READ].burst_length = bps_rd_max_length; cfg.buckets[THROTTLE_BPS_READ].burst_length = arg->bps_rd_max_length;
} }
if (has_bps_wr_max_length) { if (arg->has_bps_wr_max_length) {
cfg.buckets[THROTTLE_BPS_WRITE].burst_length = bps_wr_max_length; cfg.buckets[THROTTLE_BPS_WRITE].burst_length = arg->bps_wr_max_length;
} }
if (has_iops_max_length) { if (arg->has_iops_max_length) {
cfg.buckets[THROTTLE_OPS_TOTAL].burst_length = iops_max_length; cfg.buckets[THROTTLE_OPS_TOTAL].burst_length = arg->iops_max_length;
} }
if (has_iops_rd_max_length) { if (arg->has_iops_rd_max_length) {
cfg.buckets[THROTTLE_OPS_READ].burst_length = iops_rd_max_length; cfg.buckets[THROTTLE_OPS_READ].burst_length = arg->iops_rd_max_length;
} }
if (has_iops_wr_max_length) { if (arg->has_iops_wr_max_length) {
cfg.buckets[THROTTLE_OPS_WRITE].burst_length = iops_wr_max_length; cfg.buckets[THROTTLE_OPS_WRITE].burst_length = arg->iops_wr_max_length;
} }
if (has_iops_size) { if (arg->has_iops_size) {
cfg.op_size = iops_size; cfg.op_size = arg->iops_size;
} }
if (!throttle_is_valid(&cfg, errp)) { if (!throttle_is_valid(&cfg, errp)) {
@ -2748,9 +2716,10 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
/* Enable I/O limits if they're not enabled yet, otherwise /* Enable I/O limits if they're not enabled yet, otherwise
* just update the throttling group. */ * just update the throttling group. */
if (!blk_get_public(blk)->throttle_state) { if (!blk_get_public(blk)->throttle_state) {
blk_io_limits_enable(blk, has_group ? group : device); blk_io_limits_enable(blk,
} else if (has_group) { arg->has_group ? arg->group : arg->device);
blk_io_limits_update_group(blk, group); } else if (arg->has_group) {
blk_io_limits_update_group(blk, arg->group);
} }
/* Set the new throttling configuration */ /* Set the new throttling configuration */
blk_set_io_limits(blk, &cfg); blk_set_io_limits(blk, &cfg);

45
hmp.c
View File

@ -1439,42 +1439,17 @@ void hmp_change(Monitor *mon, const QDict *qdict)
void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict) void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
{ {
Error *err = NULL; Error *err = NULL;
BlockIOThrottle throttle = {
.device = (char *) qdict_get_str(qdict, "device"),
.bps = qdict_get_int(qdict, "bps"),
.bps_rd = qdict_get_int(qdict, "bps_rd"),
.bps_wr = qdict_get_int(qdict, "bps_wr"),
.iops = qdict_get_int(qdict, "iops"),
.iops_rd = qdict_get_int(qdict, "iops_rd"),
.iops_wr = qdict_get_int(qdict, "iops_wr"),
};
qmp_block_set_io_throttle(qdict_get_str(qdict, "device"), qmp_block_set_io_throttle(&throttle, &err);
qdict_get_int(qdict, "bps"),
qdict_get_int(qdict, "bps_rd"),
qdict_get_int(qdict, "bps_wr"),
qdict_get_int(qdict, "iops"),
qdict_get_int(qdict, "iops_rd"),
qdict_get_int(qdict, "iops_wr"),
false, /* no burst max via HMP */
0,
false,
0,
false,
0,
false,
0,
false,
0,
false,
0,
false, /* no burst length via HMP */
0,
false,
0,
false,
0,
false,
0,
false,
0,
false,
0,
false, /* No default I/O size */
0,
false,
NULL, &err);
hmp_handle_error(mon, &err); hmp_handle_error(mon, &err);
} }

20
qapi/block-core.json
View File

@ -1330,6 +1330,21 @@
# the device will be removed from its group and the rest of its # the device will be removed from its group and the rest of its
# members will not be affected. The 'group' parameter is ignored. # members will not be affected. The 'group' parameter is ignored.
# #
# See BlockIOThrottle for parameter descriptions.
#
# Returns: Nothing on success
# If @device is not a valid block device, DeviceNotFound
#
# Since: 1.1
##
{ 'command': 'block_set_io_throttle', 'boxed': true,
'data': 'BlockIOThrottle' }
##
# BlockIOThrottle
#
# A set of parameters describing block throttling.
#
# @device: The name of the device # @device: The name of the device
# #
# @bps: total throughput limit in bytes per second # @bps: total throughput limit in bytes per second
@ -1396,12 +1411,9 @@
# #
# @group: #optional throttle group name (Since 2.4) # @group: #optional throttle group name (Since 2.4)
# #
# Returns: Nothing on success
# If @device is not a valid block device, DeviceNotFound
#
# Since: 1.1 # Since: 1.1
## ##
{ 'command': 'block_set_io_throttle', { 'struct': 'BlockIOThrottle',
'data': { 'device': 'str', 'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int', 'data': { 'device': 'str', 'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int',
'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int', 'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int',
'*bps_max': 'int', '*bps_rd_max': 'int', '*bps_max': 'int', '*bps_rd_max': 'int',