qemu

throttle-groups.c (30160B)

---

 /*
  * 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);