mirror of
https://github.com/qemu/qemu.git
synced 2024-12-05 09:43:44 +08:00
801625e69d
The function is called from 64bit io handlers, and bytes is just passed to throttle_account() which is 64bit too (unsigned though). So, let's convert intermediate argument to 64bit too. This patch is a first in the 64-bit-blocklayer series, so we are generally moving to int64_t for both offset and bytes parameters on all io paths. Main motivation is realization of 64-bit write_zeroes operation for fast zeroing large disk chunks, up to the whole disk. We chose signed type, to be consistent with off_t (which is signed) and with possibility for signed return type (where negative value means error). Patch-correctness audit by Eric Blake: Caller has 32-bit, this patch now causes widening which is safe: block/block-backend.c: blk_do_preadv() passes 'unsigned int' block/block-backend.c: blk_do_pwritev_part() passes 'unsigned int' block/throttle.c: throttle_co_pwrite_zeroes() passes 'int' block/throttle.c: throttle_co_pdiscard() passes 'int' Caller has 64-bit, this patch fixes potential bug where pre-patch could narrow, except it's easy enough to trace that callers are still capped at 2G actions: block/throttle.c: throttle_co_preadv() passes 'uint64_t' block/throttle.c: throttle_co_pwritev() passes 'uint64_t' Implementation in question: block/throttle-groups.c throttle_group_co_io_limits_intercept() takes 'unsigned int bytes' and uses it: argument to util/throttle.c throttle_account(uint64_t) All safe: it patches a latent bug, and does not introduce any 64-bit gotchas once throttle_co_p{read,write}v are relaxed, and assuming throttle_account() is not buggy. Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> Reviewed-by: Eric Blake <eblake@redhat.com> Reviewed-by: Alberto Garcia <berto@igalia.com> Message-Id: <20201211183934.169161-7-vsementsov@virtuozzo.com> Signed-off-by: Eric Blake <eblake@redhat.com>
979 lines
30 KiB
C
979 lines
30 KiB
C
/*
|
|
* QEMU block throttling group infrastructure
|
|
*
|
|
* Copyright (C) Nodalink, EURL. 2014
|
|
* Copyright (C) Igalia, S.L. 2015
|
|
*
|
|
* Authors:
|
|
* Benoît Canet <benoit.canet@nodalink.com>
|
|
* Alberto Garcia <berto@igalia.com>
|
|
*
|
|
* 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 "sysemu/block-backend.h"
|
|
#include "block/throttle-groups.h"
|
|
#include "qemu/throttle-options.h"
|
|
#include "qemu/main-loop.h"
|
|
#include "qemu/queue.h"
|
|
#include "qemu/thread.h"
|
|
#include "sysemu/qtest.h"
|
|
#include "qapi/error.h"
|
|
#include "qapi/qapi-visit-block-core.h"
|
|
#include "qom/object.h"
|
|
#include "qom/object_interfaces.h"
|
|
|
|
static void throttle_group_obj_init(Object *obj);
|
|
static void throttle_group_obj_complete(UserCreatable *obj, Error **errp);
|
|
static void timer_cb(ThrottleGroupMember *tgm, bool is_write);
|
|
|
|
/* The ThrottleGroup structure (with its ThrottleState) is shared
|
|
* among different ThrottleGroupMembers and it's independent from
|
|
* AioContext, so in order to use it from different threads it needs
|
|
* its own locking.
|
|
*
|
|
* This locking is however handled internally in this file, so it's
|
|
* transparent to outside users.
|
|
*
|
|
* The whole ThrottleGroup structure is private and invisible to
|
|
* outside users, that only use it through its ThrottleState.
|
|
*
|
|
* 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
|
|
* 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 ThrottleGroupMember's timers only after verifying that
|
|
* that ThrottleGroupMember has throttled requests in the queue.
|
|
*/
|
|
struct ThrottleGroup {
|
|
Object parent_obj;
|
|
|
|
/* refuse individual property change if initialization is complete */
|
|
bool is_initialized;
|
|
char *name; /* This is constant during the lifetime of the group */
|
|
|
|
QemuMutex lock; /* This lock protects the following four fields */
|
|
ThrottleState ts;
|
|
QLIST_HEAD(, ThrottleGroupMember) head;
|
|
ThrottleGroupMember *tokens[2];
|
|
bool any_timer_armed[2];
|
|
QEMUClockType clock_type;
|
|
|
|
/* This field is protected by the global QEMU mutex */
|
|
QTAILQ_ENTRY(ThrottleGroup) list;
|
|
};
|
|
|
|
/* This is protected by the global QEMU mutex */
|
|
static QTAILQ_HEAD(, ThrottleGroup) throttle_groups =
|
|
QTAILQ_HEAD_INITIALIZER(throttle_groups);
|
|
|
|
|
|
/* This function reads throttle_groups and must be called under the global
|
|
* mutex.
|
|
*/
|
|
static ThrottleGroup *throttle_group_by_name(const char *name)
|
|
{
|
|
ThrottleGroup *iter;
|
|
|
|
/* Look for an existing group with that name */
|
|
QTAILQ_FOREACH(iter, &throttle_groups, list) {
|
|
if (!g_strcmp0(name, iter->name)) {
|
|
return iter;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* This function reads throttle_groups and must be called under the global
|
|
* mutex.
|
|
*/
|
|
bool throttle_group_exists(const char *name)
|
|
{
|
|
return throttle_group_by_name(name) != NULL;
|
|
}
|
|
|
|
/* Increments the reference count of a ThrottleGroup given its name.
|
|
*
|
|
* If no ThrottleGroup is found with the given name a new one is
|
|
* created.
|
|
*
|
|
* This function edits throttle_groups and must be called under the global
|
|
* mutex.
|
|
*
|
|
* @name: the name of the ThrottleGroup
|
|
* @ret: the ThrottleState member of the ThrottleGroup
|
|
*/
|
|
ThrottleState *throttle_group_incref(const char *name)
|
|
{
|
|
ThrottleGroup *tg = NULL;
|
|
|
|
/* Look for an existing group with that name */
|
|
tg = throttle_group_by_name(name);
|
|
|
|
if (tg) {
|
|
object_ref(OBJECT(tg));
|
|
} else {
|
|
/* Create a new one if not found */
|
|
/* new ThrottleGroup obj will have a refcnt = 1 */
|
|
tg = THROTTLE_GROUP(object_new(TYPE_THROTTLE_GROUP));
|
|
tg->name = g_strdup(name);
|
|
throttle_group_obj_complete(USER_CREATABLE(tg), &error_abort);
|
|
}
|
|
|
|
return &tg->ts;
|
|
}
|
|
|
|
/* Decrease the reference count of a ThrottleGroup.
|
|
*
|
|
* When the reference count reaches zero the ThrottleGroup is
|
|
* destroyed.
|
|
*
|
|
* This function edits throttle_groups and must be called under the global
|
|
* mutex.
|
|
*
|
|
* @ts: The ThrottleGroup to unref, given by its ThrottleState member
|
|
*/
|
|
void throttle_group_unref(ThrottleState *ts)
|
|
{
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
object_unref(OBJECT(tg));
|
|
}
|
|
|
|
/* Get the name from a ThrottleGroupMember's group. The name (and the pointer)
|
|
* is guaranteed to remain constant during the lifetime of the group.
|
|
*
|
|
* @tgm: a ThrottleGroupMember
|
|
* @ret: the name of the group.
|
|
*/
|
|
const char *throttle_group_get_name(ThrottleGroupMember *tgm)
|
|
{
|
|
ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
|
|
return tg->name;
|
|
}
|
|
|
|
/* Return the next ThrottleGroupMember in the round-robin sequence, simulating
|
|
* a circular list.
|
|
*
|
|
* This assumes that tg->lock is held.
|
|
*
|
|
* @tgm: the current ThrottleGroupMember
|
|
* @ret: the next ThrottleGroupMember in the sequence
|
|
*/
|
|
static ThrottleGroupMember *throttle_group_next_tgm(ThrottleGroupMember *tgm)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
ThrottleGroupMember *next = QLIST_NEXT(tgm, round_robin);
|
|
|
|
if (!next) {
|
|
next = QLIST_FIRST(&tg->head);
|
|
}
|
|
|
|
return next;
|
|
}
|
|
|
|
/*
|
|
* Return whether a ThrottleGroupMember has pending requests.
|
|
*
|
|
* This assumes that tg->lock is held.
|
|
*
|
|
* @tgm: the ThrottleGroupMember
|
|
* @is_write: the type of operation (read/write)
|
|
* @ret: whether the ThrottleGroupMember has pending requests.
|
|
*/
|
|
static inline bool tgm_has_pending_reqs(ThrottleGroupMember *tgm,
|
|
bool is_write)
|
|
{
|
|
return tgm->pending_reqs[is_write];
|
|
}
|
|
|
|
/* Return the next ThrottleGroupMember in the round-robin sequence with pending
|
|
* I/O requests.
|
|
*
|
|
* This assumes that tg->lock is held.
|
|
*
|
|
* @tgm: the current ThrottleGroupMember
|
|
* @is_write: the type of operation (read/write)
|
|
* @ret: the next ThrottleGroupMember with pending requests, or tgm if
|
|
* there is none.
|
|
*/
|
|
static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
|
|
bool is_write)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
ThrottleGroupMember *token, *start;
|
|
|
|
/* If this member has its I/O limits disabled then it means that
|
|
* it's being drained. Skip the round-robin search and return tgm
|
|
* immediately if it has pending requests. Otherwise we could be
|
|
* forcing it to wait for other member's throttled requests. */
|
|
if (tgm_has_pending_reqs(tgm, is_write) &&
|
|
qatomic_read(&tgm->io_limits_disabled)) {
|
|
return tgm;
|
|
}
|
|
|
|
start = token = tg->tokens[is_write];
|
|
|
|
/* get next bs round in round robin style */
|
|
token = throttle_group_next_tgm(token);
|
|
while (token != start && !tgm_has_pending_reqs(token, is_write)) {
|
|
token = throttle_group_next_tgm(token);
|
|
}
|
|
|
|
/* If no IO are queued for scheduling on the next round robin token
|
|
* then decide the token is the current tgm because chances are
|
|
* the current tgm got the current request queued.
|
|
*/
|
|
if (token == start && !tgm_has_pending_reqs(token, is_write)) {
|
|
token = tgm;
|
|
}
|
|
|
|
/* Either we return the original TGM, or one with pending requests */
|
|
assert(token == tgm || tgm_has_pending_reqs(token, is_write));
|
|
|
|
return token;
|
|
}
|
|
|
|
/* Check if the next I/O request for a ThrottleGroupMember needs to be
|
|
* throttled or not. If there's no timer set in this group, set one and update
|
|
* the token accordingly.
|
|
*
|
|
* This assumes that tg->lock is held.
|
|
*
|
|
* @tgm: the current ThrottleGroupMember
|
|
* @is_write: the type of operation (read/write)
|
|
* @ret: whether the I/O request needs to be throttled or not
|
|
*/
|
|
static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
|
|
bool is_write)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
ThrottleTimers *tt = &tgm->throttle_timers;
|
|
bool must_wait;
|
|
|
|
if (qatomic_read(&tgm->io_limits_disabled)) {
|
|
return false;
|
|
}
|
|
|
|
/* Check if any of the timers in this group is already armed */
|
|
if (tg->any_timer_armed[is_write]) {
|
|
return true;
|
|
}
|
|
|
|
must_wait = throttle_schedule_timer(ts, tt, is_write);
|
|
|
|
/* If a timer just got armed, set tgm as the current token */
|
|
if (must_wait) {
|
|
tg->tokens[is_write] = tgm;
|
|
tg->any_timer_armed[is_write] = true;
|
|
}
|
|
|
|
return must_wait;
|
|
}
|
|
|
|
/* Start the next pending I/O request for a ThrottleGroupMember. Return whether
|
|
* any request was actually pending.
|
|
*
|
|
* @tgm: the current ThrottleGroupMember
|
|
* @is_write: the type of operation (read/write)
|
|
*/
|
|
static bool coroutine_fn throttle_group_co_restart_queue(ThrottleGroupMember *tgm,
|
|
bool is_write)
|
|
{
|
|
bool ret;
|
|
|
|
qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
|
|
ret = qemu_co_queue_next(&tgm->throttled_reqs[is_write]);
|
|
qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Look for the next pending I/O request and schedule it.
|
|
*
|
|
* This assumes that tg->lock is held.
|
|
*
|
|
* @tgm: the current ThrottleGroupMember
|
|
* @is_write: the type of operation (read/write)
|
|
*/
|
|
static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
bool must_wait;
|
|
ThrottleGroupMember *token;
|
|
|
|
/* Check if there's any pending request to schedule next */
|
|
token = next_throttle_token(tgm, is_write);
|
|
if (!tgm_has_pending_reqs(token, is_write)) {
|
|
return;
|
|
}
|
|
|
|
/* Set a timer for the request if it needs to be throttled */
|
|
must_wait = throttle_group_schedule_timer(token, is_write);
|
|
|
|
/* If it doesn't have to wait, queue it for immediate execution */
|
|
if (!must_wait) {
|
|
/* Give preference to requests from the current tgm */
|
|
if (qemu_in_coroutine() &&
|
|
throttle_group_co_restart_queue(tgm, is_write)) {
|
|
token = tgm;
|
|
} else {
|
|
ThrottleTimers *tt = &token->throttle_timers;
|
|
int64_t now = qemu_clock_get_ns(tg->clock_type);
|
|
timer_mod(tt->timers[is_write], now);
|
|
tg->any_timer_armed[is_write] = true;
|
|
}
|
|
tg->tokens[is_write] = token;
|
|
}
|
|
}
|
|
|
|
/* Check if an I/O request needs to be throttled, wait and set a timer
|
|
* if necessary, and schedule the next request using a round robin
|
|
* algorithm.
|
|
*
|
|
* @tgm: the current ThrottleGroupMember
|
|
* @bytes: the number of bytes for this I/O
|
|
* @is_write: the type of operation (read/write)
|
|
*/
|
|
void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm,
|
|
int64_t bytes,
|
|
bool is_write)
|
|
{
|
|
bool must_wait;
|
|
ThrottleGroupMember *token;
|
|
ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
|
|
|
|
assert(bytes >= 0);
|
|
|
|
qemu_mutex_lock(&tg->lock);
|
|
|
|
/* First we check if this I/O has to be throttled. */
|
|
token = next_throttle_token(tgm, is_write);
|
|
must_wait = throttle_group_schedule_timer(token, is_write);
|
|
|
|
/* Wait if there's a timer set or queued requests of this type */
|
|
if (must_wait || tgm->pending_reqs[is_write]) {
|
|
tgm->pending_reqs[is_write]++;
|
|
qemu_mutex_unlock(&tg->lock);
|
|
qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
|
|
qemu_co_queue_wait(&tgm->throttled_reqs[is_write],
|
|
&tgm->throttled_reqs_lock);
|
|
qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
|
|
qemu_mutex_lock(&tg->lock);
|
|
tgm->pending_reqs[is_write]--;
|
|
}
|
|
|
|
/* The I/O will be executed, so do the accounting */
|
|
throttle_account(tgm->throttle_state, is_write, bytes);
|
|
|
|
/* Schedule the next request */
|
|
schedule_next_request(tgm, is_write);
|
|
|
|
qemu_mutex_unlock(&tg->lock);
|
|
}
|
|
|
|
typedef struct {
|
|
ThrottleGroupMember *tgm;
|
|
bool is_write;
|
|
} RestartData;
|
|
|
|
static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
|
|
{
|
|
RestartData *data = opaque;
|
|
ThrottleGroupMember *tgm = data->tgm;
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
bool is_write = data->is_write;
|
|
bool empty_queue;
|
|
|
|
empty_queue = !throttle_group_co_restart_queue(tgm, is_write);
|
|
|
|
/* If the request queue was empty then we have to take care of
|
|
* scheduling the next one */
|
|
if (empty_queue) {
|
|
qemu_mutex_lock(&tg->lock);
|
|
schedule_next_request(tgm, is_write);
|
|
qemu_mutex_unlock(&tg->lock);
|
|
}
|
|
|
|
g_free(data);
|
|
|
|
qatomic_dec(&tgm->restart_pending);
|
|
aio_wait_kick();
|
|
}
|
|
|
|
static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write)
|
|
{
|
|
Coroutine *co;
|
|
RestartData *rd = g_new0(RestartData, 1);
|
|
|
|
rd->tgm = tgm;
|
|
rd->is_write = is_write;
|
|
|
|
/* This function is called when a timer is fired or when
|
|
* throttle_group_restart_tgm() is called. Either way, there can
|
|
* be no timer pending on this tgm at this point */
|
|
assert(!timer_pending(tgm->throttle_timers.timers[is_write]));
|
|
|
|
qatomic_inc(&tgm->restart_pending);
|
|
|
|
co = qemu_coroutine_create(throttle_group_restart_queue_entry, rd);
|
|
aio_co_enter(tgm->aio_context, co);
|
|
}
|
|
|
|
void throttle_group_restart_tgm(ThrottleGroupMember *tgm)
|
|
{
|
|
int i;
|
|
|
|
if (tgm->throttle_state) {
|
|
for (i = 0; i < 2; i++) {
|
|
QEMUTimer *t = tgm->throttle_timers.timers[i];
|
|
if (timer_pending(t)) {
|
|
/* If there's a pending timer on this tgm, fire it now */
|
|
timer_del(t);
|
|
timer_cb(tgm, i);
|
|
} else {
|
|
/* Else run the next request from the queue manually */
|
|
throttle_group_restart_queue(tgm, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Update the throttle configuration for a particular group. Similar
|
|
* to throttle_config(), but guarantees atomicity within the
|
|
* throttling group.
|
|
*
|
|
* @tgm: a ThrottleGroupMember that is a member of the group
|
|
* @cfg: the configuration to set
|
|
*/
|
|
void throttle_group_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
qemu_mutex_lock(&tg->lock);
|
|
throttle_config(ts, tg->clock_type, cfg);
|
|
qemu_mutex_unlock(&tg->lock);
|
|
|
|
throttle_group_restart_tgm(tgm);
|
|
}
|
|
|
|
/* Get the throttle configuration from a particular group. Similar to
|
|
* throttle_get_config(), but guarantees atomicity within the
|
|
* throttling group.
|
|
*
|
|
* @tgm: a ThrottleGroupMember that is a member of the group
|
|
* @cfg: the configuration will be written here
|
|
*/
|
|
void throttle_group_get_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
qemu_mutex_lock(&tg->lock);
|
|
throttle_get_config(ts, cfg);
|
|
qemu_mutex_unlock(&tg->lock);
|
|
}
|
|
|
|
/* ThrottleTimers callback. This wakes up a request that was waiting
|
|
* because it had been throttled.
|
|
*
|
|
* @tgm: the ThrottleGroupMember whose request had been throttled
|
|
* @is_write: the type of operation (read/write)
|
|
*/
|
|
static void timer_cb(ThrottleGroupMember *tgm, bool is_write)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
|
|
/* The timer has just been fired, so we can update the flag */
|
|
qemu_mutex_lock(&tg->lock);
|
|
tg->any_timer_armed[is_write] = false;
|
|
qemu_mutex_unlock(&tg->lock);
|
|
|
|
/* Run the request that was waiting for this timer */
|
|
throttle_group_restart_queue(tgm, is_write);
|
|
}
|
|
|
|
static void read_timer_cb(void *opaque)
|
|
{
|
|
timer_cb(opaque, false);
|
|
}
|
|
|
|
static void write_timer_cb(void *opaque)
|
|
{
|
|
timer_cb(opaque, true);
|
|
}
|
|
|
|
/* Register a ThrottleGroupMember from the throttling group, also initializing
|
|
* its timers and updating its throttle_state pointer to point to it. If a
|
|
* throttling group with that name does not exist yet, it will be created.
|
|
*
|
|
* This function edits throttle_groups and must be called under the global
|
|
* mutex.
|
|
*
|
|
* @tgm: the ThrottleGroupMember to insert
|
|
* @groupname: the name of the group
|
|
* @ctx: the AioContext to use
|
|
*/
|
|
void throttle_group_register_tgm(ThrottleGroupMember *tgm,
|
|
const char *groupname,
|
|
AioContext *ctx)
|
|
{
|
|
int i;
|
|
ThrottleState *ts = throttle_group_incref(groupname);
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
|
|
tgm->throttle_state = ts;
|
|
tgm->aio_context = ctx;
|
|
qatomic_set(&tgm->restart_pending, 0);
|
|
|
|
QEMU_LOCK_GUARD(&tg->lock);
|
|
/* If the ThrottleGroup is new set this ThrottleGroupMember as the token */
|
|
for (i = 0; i < 2; i++) {
|
|
if (!tg->tokens[i]) {
|
|
tg->tokens[i] = tgm;
|
|
}
|
|
}
|
|
|
|
QLIST_INSERT_HEAD(&tg->head, tgm, round_robin);
|
|
|
|
throttle_timers_init(&tgm->throttle_timers,
|
|
tgm->aio_context,
|
|
tg->clock_type,
|
|
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]);
|
|
}
|
|
|
|
/* Unregister a ThrottleGroupMember from its group, removing it from the list,
|
|
* destroying the timers and setting the throttle_state pointer to NULL.
|
|
*
|
|
* The ThrottleGroupMember must not have pending throttled requests, so the
|
|
* caller has to drain them first.
|
|
*
|
|
* The group will be destroyed if it's empty after this operation.
|
|
*
|
|
* @tgm the ThrottleGroupMember to remove
|
|
*/
|
|
void throttle_group_unregister_tgm(ThrottleGroupMember *tgm)
|
|
{
|
|
ThrottleState *ts = tgm->throttle_state;
|
|
ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
|
|
ThrottleGroupMember *token;
|
|
int i;
|
|
|
|
if (!ts) {
|
|
/* Discard already unregistered tgm */
|
|
return;
|
|
}
|
|
|
|
/* Wait for throttle_group_restart_queue_entry() coroutines to finish */
|
|
AIO_WAIT_WHILE(tgm->aio_context, qatomic_read(&tgm->restart_pending) > 0);
|
|
|
|
WITH_QEMU_LOCK_GUARD(&tg->lock) {
|
|
for (i = 0; i < 2; i++) {
|
|
assert(tgm->pending_reqs[i] == 0);
|
|
assert(qemu_co_queue_empty(&tgm->throttled_reqs[i]));
|
|
assert(!timer_pending(tgm->throttle_timers.timers[i]));
|
|
if (tg->tokens[i] == tgm) {
|
|
token = throttle_group_next_tgm(tgm);
|
|
/* Take care of the case where this is the last tgm in the group */
|
|
if (token == tgm) {
|
|
token = NULL;
|
|
}
|
|
tg->tokens[i] = token;
|
|
}
|
|
}
|
|
|
|
/* remove the current tgm from the list */
|
|
QLIST_REMOVE(tgm, round_robin);
|
|
throttle_timers_destroy(&tgm->throttle_timers);
|
|
}
|
|
|
|
throttle_group_unref(&tg->ts);
|
|
tgm->throttle_state = NULL;
|
|
}
|
|
|
|
void throttle_group_attach_aio_context(ThrottleGroupMember *tgm,
|
|
AioContext *new_context)
|
|
{
|
|
ThrottleTimers *tt = &tgm->throttle_timers;
|
|
throttle_timers_attach_aio_context(tt, new_context);
|
|
tgm->aio_context = new_context;
|
|
}
|
|
|
|
void throttle_group_detach_aio_context(ThrottleGroupMember *tgm)
|
|
{
|
|
ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
|
|
ThrottleTimers *tt = &tgm->throttle_timers;
|
|
int i;
|
|
|
|
/* Requests must have been drained */
|
|
assert(tgm->pending_reqs[0] == 0 && tgm->pending_reqs[1] == 0);
|
|
assert(qemu_co_queue_empty(&tgm->throttled_reqs[0]));
|
|
assert(qemu_co_queue_empty(&tgm->throttled_reqs[1]));
|
|
|
|
/* Kick off next ThrottleGroupMember, if necessary */
|
|
WITH_QEMU_LOCK_GUARD(&tg->lock) {
|
|
for (i = 0; i < 2; i++) {
|
|
if (timer_pending(tt->timers[i])) {
|
|
tg->any_timer_armed[i] = false;
|
|
schedule_next_request(tgm, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
throttle_timers_detach_aio_context(tt);
|
|
tgm->aio_context = NULL;
|
|
}
|
|
|
|
#undef THROTTLE_OPT_PREFIX
|
|
#define THROTTLE_OPT_PREFIX "x-"
|
|
|
|
/* Helper struct and array for QOM property setter/getter */
|
|
typedef struct {
|
|
const char *name;
|
|
BucketType type;
|
|
enum {
|
|
AVG,
|
|
MAX,
|
|
BURST_LENGTH,
|
|
IOPS_SIZE,
|
|
} category;
|
|
} ThrottleParamInfo;
|
|
|
|
static ThrottleParamInfo properties[] = {
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL,
|
|
THROTTLE_OPS_TOTAL, AVG,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX,
|
|
THROTTLE_OPS_TOTAL, MAX,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX_LENGTH,
|
|
THROTTLE_OPS_TOTAL, BURST_LENGTH,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ,
|
|
THROTTLE_OPS_READ, AVG,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX,
|
|
THROTTLE_OPS_READ, MAX,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX_LENGTH,
|
|
THROTTLE_OPS_READ, BURST_LENGTH,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE,
|
|
THROTTLE_OPS_WRITE, AVG,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX,
|
|
THROTTLE_OPS_WRITE, MAX,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX_LENGTH,
|
|
THROTTLE_OPS_WRITE, BURST_LENGTH,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL,
|
|
THROTTLE_BPS_TOTAL, AVG,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX,
|
|
THROTTLE_BPS_TOTAL, MAX,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX_LENGTH,
|
|
THROTTLE_BPS_TOTAL, BURST_LENGTH,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ,
|
|
THROTTLE_BPS_READ, AVG,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX,
|
|
THROTTLE_BPS_READ, MAX,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX_LENGTH,
|
|
THROTTLE_BPS_READ, BURST_LENGTH,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE,
|
|
THROTTLE_BPS_WRITE, AVG,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX,
|
|
THROTTLE_BPS_WRITE, MAX,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX_LENGTH,
|
|
THROTTLE_BPS_WRITE, BURST_LENGTH,
|
|
},
|
|
{
|
|
THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_SIZE,
|
|
0, IOPS_SIZE,
|
|
}
|
|
};
|
|
|
|
/* This function edits throttle_groups and must be called under the global
|
|
* mutex */
|
|
static void throttle_group_obj_init(Object *obj)
|
|
{
|
|
ThrottleGroup *tg = THROTTLE_GROUP(obj);
|
|
|
|
tg->clock_type = QEMU_CLOCK_REALTIME;
|
|
if (qtest_enabled()) {
|
|
/* For testing block IO throttling only */
|
|
tg->clock_type = QEMU_CLOCK_VIRTUAL;
|
|
}
|
|
tg->is_initialized = false;
|
|
qemu_mutex_init(&tg->lock);
|
|
throttle_init(&tg->ts);
|
|
QLIST_INIT(&tg->head);
|
|
}
|
|
|
|
/* This function edits throttle_groups and must be called under the global
|
|
* mutex */
|
|
static void throttle_group_obj_complete(UserCreatable *obj, Error **errp)
|
|
{
|
|
ThrottleGroup *tg = THROTTLE_GROUP(obj);
|
|
ThrottleConfig cfg;
|
|
|
|
/* set group name to object id if it exists */
|
|
if (!tg->name && tg->parent_obj.parent) {
|
|
tg->name = g_strdup(object_get_canonical_path_component(OBJECT(obj)));
|
|
}
|
|
/* We must have a group name at this point */
|
|
assert(tg->name);
|
|
|
|
/* error if name is duplicate */
|
|
if (throttle_group_exists(tg->name)) {
|
|
error_setg(errp, "A group with this name already exists");
|
|
return;
|
|
}
|
|
|
|
/* check validity */
|
|
throttle_get_config(&tg->ts, &cfg);
|
|
if (!throttle_is_valid(&cfg, errp)) {
|
|
return;
|
|
}
|
|
throttle_config(&tg->ts, tg->clock_type, &cfg);
|
|
QTAILQ_INSERT_TAIL(&throttle_groups, tg, list);
|
|
tg->is_initialized = true;
|
|
}
|
|
|
|
/* This function edits throttle_groups and must be called under the global
|
|
* mutex */
|
|
static void throttle_group_obj_finalize(Object *obj)
|
|
{
|
|
ThrottleGroup *tg = THROTTLE_GROUP(obj);
|
|
if (tg->is_initialized) {
|
|
QTAILQ_REMOVE(&throttle_groups, tg, list);
|
|
}
|
|
qemu_mutex_destroy(&tg->lock);
|
|
g_free(tg->name);
|
|
}
|
|
|
|
static void throttle_group_set(Object *obj, Visitor *v, const char * name,
|
|
void *opaque, Error **errp)
|
|
|
|
{
|
|
ThrottleGroup *tg = THROTTLE_GROUP(obj);
|
|
ThrottleConfig *cfg;
|
|
ThrottleParamInfo *info = opaque;
|
|
int64_t value;
|
|
|
|
/* If we have finished initialization, don't accept individual property
|
|
* changes through QOM. Throttle configuration limits must be set in one
|
|
* transaction, as certain combinations are invalid.
|
|
*/
|
|
if (tg->is_initialized) {
|
|
error_setg(errp, "Property cannot be set after initialization");
|
|
return;
|
|
}
|
|
|
|
if (!visit_type_int64(v, name, &value, errp)) {
|
|
return;
|
|
}
|
|
if (value < 0) {
|
|
error_setg(errp, "Property values cannot be negative");
|
|
return;
|
|
}
|
|
|
|
cfg = &tg->ts.cfg;
|
|
switch (info->category) {
|
|
case AVG:
|
|
cfg->buckets[info->type].avg = value;
|
|
break;
|
|
case MAX:
|
|
cfg->buckets[info->type].max = value;
|
|
break;
|
|
case BURST_LENGTH:
|
|
if (value > UINT_MAX) {
|
|
error_setg(errp, "%s value must be in the" "range [0, %u]",
|
|
info->name, UINT_MAX);
|
|
return;
|
|
}
|
|
cfg->buckets[info->type].burst_length = value;
|
|
break;
|
|
case IOPS_SIZE:
|
|
cfg->op_size = value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void throttle_group_get(Object *obj, Visitor *v, const char *name,
|
|
void *opaque, Error **errp)
|
|
{
|
|
ThrottleGroup *tg = THROTTLE_GROUP(obj);
|
|
ThrottleConfig cfg;
|
|
ThrottleParamInfo *info = opaque;
|
|
int64_t value;
|
|
|
|
throttle_get_config(&tg->ts, &cfg);
|
|
switch (info->category) {
|
|
case AVG:
|
|
value = cfg.buckets[info->type].avg;
|
|
break;
|
|
case MAX:
|
|
value = cfg.buckets[info->type].max;
|
|
break;
|
|
case BURST_LENGTH:
|
|
value = cfg.buckets[info->type].burst_length;
|
|
break;
|
|
case IOPS_SIZE:
|
|
value = cfg.op_size;
|
|
break;
|
|
}
|
|
|
|
visit_type_int64(v, name, &value, errp);
|
|
}
|
|
|
|
static void throttle_group_set_limits(Object *obj, Visitor *v,
|
|
const char *name, void *opaque,
|
|
Error **errp)
|
|
|
|
{
|
|
ThrottleGroup *tg = THROTTLE_GROUP(obj);
|
|
ThrottleConfig cfg;
|
|
ThrottleLimits *argp;
|
|
Error *local_err = NULL;
|
|
|
|
if (!visit_type_ThrottleLimits(v, name, &argp, errp)) {
|
|
return;
|
|
}
|
|
qemu_mutex_lock(&tg->lock);
|
|
throttle_get_config(&tg->ts, &cfg);
|
|
throttle_limits_to_config(argp, &cfg, &local_err);
|
|
if (local_err) {
|
|
goto unlock;
|
|
}
|
|
throttle_config(&tg->ts, tg->clock_type, &cfg);
|
|
|
|
unlock:
|
|
qemu_mutex_unlock(&tg->lock);
|
|
qapi_free_ThrottleLimits(argp);
|
|
error_propagate(errp, local_err);
|
|
return;
|
|
}
|
|
|
|
static void throttle_group_get_limits(Object *obj, Visitor *v,
|
|
const char *name, void *opaque,
|
|
Error **errp)
|
|
{
|
|
ThrottleGroup *tg = THROTTLE_GROUP(obj);
|
|
ThrottleConfig cfg;
|
|
ThrottleLimits arg = { 0 };
|
|
ThrottleLimits *argp = &arg;
|
|
|
|
qemu_mutex_lock(&tg->lock);
|
|
throttle_get_config(&tg->ts, &cfg);
|
|
qemu_mutex_unlock(&tg->lock);
|
|
|
|
throttle_config_to_limits(&cfg, argp);
|
|
|
|
visit_type_ThrottleLimits(v, name, &argp, errp);
|
|
}
|
|
|
|
static bool throttle_group_can_be_deleted(UserCreatable *uc)
|
|
{
|
|
return OBJECT(uc)->ref == 1;
|
|
}
|
|
|
|
static void throttle_group_obj_class_init(ObjectClass *klass, void *class_data)
|
|
{
|
|
size_t i = 0;
|
|
UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
|
|
|
|
ucc->complete = throttle_group_obj_complete;
|
|
ucc->can_be_deleted = throttle_group_can_be_deleted;
|
|
|
|
/* individual properties */
|
|
for (i = 0; i < sizeof(properties) / sizeof(ThrottleParamInfo); i++) {
|
|
object_class_property_add(klass,
|
|
properties[i].name,
|
|
"int",
|
|
throttle_group_get,
|
|
throttle_group_set,
|
|
NULL, &properties[i]);
|
|
}
|
|
|
|
/* ThrottleLimits */
|
|
object_class_property_add(klass,
|
|
"limits", "ThrottleLimits",
|
|
throttle_group_get_limits,
|
|
throttle_group_set_limits,
|
|
NULL, NULL);
|
|
}
|
|
|
|
static const TypeInfo throttle_group_info = {
|
|
.name = TYPE_THROTTLE_GROUP,
|
|
.parent = TYPE_OBJECT,
|
|
.class_init = throttle_group_obj_class_init,
|
|
.instance_size = sizeof(ThrottleGroup),
|
|
.instance_init = throttle_group_obj_init,
|
|
.instance_finalize = throttle_group_obj_finalize,
|
|
.interfaces = (InterfaceInfo[]) {
|
|
{ TYPE_USER_CREATABLE },
|
|
{ }
|
|
},
|
|
};
|
|
|
|
static void throttle_groups_init(void)
|
|
{
|
|
type_register_static(&throttle_group_info);
|
|
}
|
|
|
|
type_init(throttle_groups_init);
|