block/throttle-groups.c

   1 /*
   2  * QEMU block throttling group infrastructure
   3  *
   4  * Copyright (C) Nodalink, EURL. 2014
   5  * Copyright (C) Igalia, S.L. 2015
   6  *
   7  * Authors:
   8  *   Benoît Canet <benoit.canet@nodalink.com>
   9  *   Alberto Garcia <berto@igalia.com>
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License as
  13  * published by the Free Software Foundation; either version 2 or
  14  * (at your option) version 3 of the License.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "sysemu/block-backend.h"
  27 #include "block/throttle-groups.h"
  28 #include "qemu/throttle-options.h"
  29 #include "qemu/queue.h"
  30 #include "qemu/thread.h"
  31 #include "sysemu/qtest.h"
  32 #include "qapi/error.h"
  33 #include "qapi-visit.h"
  34 #include "qom/object.h"
  35 #include "qom/object_interfaces.h"
  36
  37 static void throttle_group_obj_init(Object *obj);
  38 static void throttle_group_obj_complete(UserCreatable *obj, Error **errp);
  39
  40 /* The ThrottleGroup structure (with its ThrottleState) is shared
  41  * among different ThrottleGroupMembers and it's independent from
  42  * AioContext, so in order to use it from different threads it needs
  43  * its own locking.
  44  *
  45  * This locking is however handled internally in this file, so it's
  46  * transparent to outside users.
  47  *
  48  * The whole ThrottleGroup structure is private and invisible to
  49  * outside users, that only use it through its ThrottleState.
  50  *
  51  * In addition to the ThrottleGroup structure, ThrottleGroupMember has
  52  * fields that need to be accessed by other members of the group and
  53  * therefore also need to be protected by this lock. Once a
  54  * ThrottleGroupMember is registered in a group those fields can be accessed
  55  * by other threads any time.
  56  *
  57  * Again, all this is handled internally and is mostly transparent to
  58  * the outside. The 'throttle_timers' field however has an additional
  59  * constraint because it may be temporarily invalid (see for example
  60  * blk_set_aio_context()). Therefore in this file a thread will
  61  * access some other ThrottleGroupMember's timers only after verifying that
  62  * that ThrottleGroupMember has throttled requests in the queue.
  63  */
  64 typedef struct ThrottleGroup {
  65     Object parent_obj;
  66
  67     /* refuse individual property change if initialization is complete */
  68     bool is_initialized;
  69     char *name; /* This is constant during the lifetime of the group */
  70
  71     QemuMutex lock; /* This lock protects the following four fields */
  72     ThrottleState ts;
  73     QLIST_HEAD(, ThrottleGroupMember) head;
  74     ThrottleGroupMember *tokens[2];
  75     bool any_timer_armed[2];
  76     QEMUClockType clock_type;
  77
  78     /* This field is protected by the global QEMU mutex */
  79     QTAILQ_ENTRY(ThrottleGroup) list;
  80 } ThrottleGroup;
  81
  82 /* This is protected by the global QEMU mutex */
  83 static QTAILQ_HEAD(, ThrottleGroup) throttle_groups =
  84     QTAILQ_HEAD_INITIALIZER(throttle_groups);
  85
  86
  87 /* This function reads throttle_groups and must be called under the global
  88  * mutex.
  89  */
  90 static ThrottleGroup *throttle_group_by_name(const char *name)
  91 {
  92     ThrottleGroup *iter;
  93
  94     /* Look for an existing group with that name */
  95     QTAILQ_FOREACH(iter, &throttle_groups, list) {
  96         if (!g_strcmp0(name, iter->name)) {
  97             return iter;
  98         }
  99     }
 100
 101     return NULL;
 102 }
 103
 104 /* This function reads throttle_groups and must be called under the global
 105  * mutex.
 106  */
 107 bool throttle_group_exists(const char *name)
 108 {
 109     return throttle_group_by_name(name) != NULL;
 110 }
 111
 112 /* Increments the reference count of a ThrottleGroup given its name.
 113  *
 114  * If no ThrottleGroup is found with the given name a new one is
 115  * created.
 116  *
 117  * This function edits throttle_groups and must be called under the global
 118  * mutex.
 119  *
 120  * @name: the name of the ThrottleGroup
 121  * @ret:  the ThrottleState member of the ThrottleGroup
 122  */
 123 ThrottleState *throttle_group_incref(const char *name)
 124 {
 125     ThrottleGroup *tg = NULL;
 126
 127     /* Look for an existing group with that name */
 128     tg = throttle_group_by_name(name);
 129
 130     if (tg) {
 131         object_ref(OBJECT(tg));
 132     } else {
 133         /* Create a new one if not found */
 134         /* new ThrottleGroup obj will have a refcnt = 1 */
 135         tg = THROTTLE_GROUP(object_new(TYPE_THROTTLE_GROUP));
 136         tg->name = g_strdup(name);
 137         throttle_group_obj_complete(USER_CREATABLE(tg), &error_abort);
 138     }
 139
 140     return &tg->ts;
 141 }
 142
 143 /* Decrease the reference count of a ThrottleGroup.
 144  *
 145  * When the reference count reaches zero the ThrottleGroup is
 146  * destroyed.
 147  *
 148  * This function edits throttle_groups and must be called under the global
 149  * mutex.
 150  *
 151  * @ts:  The ThrottleGroup to unref, given by its ThrottleState member
 152  */
 153 void throttle_group_unref(ThrottleState *ts)
 154 {
 155     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 156     object_unref(OBJECT(tg));
 157 }
 158
 159 /* Get the name from a ThrottleGroupMember's group. The name (and the pointer)
 160  * is guaranteed to remain constant during the lifetime of the group.
 161  *
 162  * @tgm:  a ThrottleGroupMember
 163  * @ret:  the name of the group.
 164  */
 165 const char *throttle_group_get_name(ThrottleGroupMember *tgm)
 166 {
 167     ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
 168     return tg->name;
 169 }
 170
 171 /* Return the next ThrottleGroupMember in the round-robin sequence, simulating
 172  * a circular list.
 173  *
 174  * This assumes that tg->lock is held.
 175  *
 176  * @tgm: the current ThrottleGroupMember
 177  * @ret: the next ThrottleGroupMember in the sequence
 178  */
 179 static ThrottleGroupMember *throttle_group_next_tgm(ThrottleGroupMember *tgm)
 180 {
 181     ThrottleState *ts = tgm->throttle_state;
 182     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 183     ThrottleGroupMember *next = QLIST_NEXT(tgm, round_robin);
 184
 185     if (!next) {
 186         next = QLIST_FIRST(&tg->head);
 187     }
 188
 189     return next;
 190 }
 191
 192 /*
 193  * Return whether a ThrottleGroupMember has pending requests.
 194  *
 195  * This assumes that tg->lock is held.
 196  *
 197  * @tgm:        the ThrottleGroupMember
 198  * @is_write:   the type of operation (read/write)
 199  * @ret:        whether the ThrottleGroupMember has pending requests.
 200  */
 201 static inline bool tgm_has_pending_reqs(ThrottleGroupMember *tgm,
 202                                         bool is_write)
 203 {
 204     return tgm->pending_reqs[is_write];
 205 }
 206
 207 /* Return the next ThrottleGroupMember in the round-robin sequence with pending
 208  * I/O requests.
 209  *
 210  * This assumes that tg->lock is held.
 211  *
 212  * @tgm:       the current ThrottleGroupMember
 213  * @is_write:  the type of operation (read/write)
 214  * @ret:       the next ThrottleGroupMember with pending requests, or tgm if
 215  *             there is none.
 216  */
 217 static ThrottleGroupMember *next_throttle_token(ThrottleGroupMember *tgm,
 218                                                 bool is_write)
 219 {
 220     ThrottleState *ts = tgm->throttle_state;
 221     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 222     ThrottleGroupMember *token, *start;
 223
 224     start = token = tg->tokens[is_write];
 225
 226     /* get next bs round in round robin style */
 227     token = throttle_group_next_tgm(token);
 228     while (token != start && !tgm_has_pending_reqs(token, is_write)) {
 229         token = throttle_group_next_tgm(token);
 230     }
 231
 232     /* If no IO are queued for scheduling on the next round robin token
 233      * then decide the token is the current tgm because chances are
 234      * the current tgm got the current request queued.
 235      */
 236     if (token == start && !tgm_has_pending_reqs(token, is_write)) {
 237         token = tgm;
 238     }
 239
 240     /* Either we return the original TGM, or one with pending requests */
 241     assert(token == tgm || tgm_has_pending_reqs(token, is_write));
 242
 243     return token;
 244 }
 245
 246 /* Check if the next I/O request for a ThrottleGroupMember needs to be
 247  * throttled or not. If there's no timer set in this group, set one and update
 248  * the token accordingly.
 249  *
 250  * This assumes that tg->lock is held.
 251  *
 252  * @tgm:        the current ThrottleGroupMember
 253  * @is_write:   the type of operation (read/write)
 254  * @ret:        whether the I/O request needs to be throttled or not
 255  */
 256 static bool throttle_group_schedule_timer(ThrottleGroupMember *tgm,
 257                                           bool is_write)
 258 {
 259     ThrottleState *ts = tgm->throttle_state;
 260     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 261     ThrottleTimers *tt = &tgm->throttle_timers;
 262     bool must_wait;
 263
 264     if (atomic_read(&tgm->io_limits_disabled)) {
 265         return false;
 266     }
 267
 268     /* Check if any of the timers in this group is already armed */
 269     if (tg->any_timer_armed[is_write]) {
 270         return true;
 271     }
 272
 273     must_wait = throttle_schedule_timer(ts, tt, is_write);
 274
 275     /* If a timer just got armed, set tgm as the current token */
 276     if (must_wait) {
 277         tg->tokens[is_write] = tgm;
 278         tg->any_timer_armed[is_write] = true;
 279     }
 280
 281     return must_wait;
 282 }
 283
 284 /* Start the next pending I/O request for a ThrottleGroupMember. Return whether
 285  * any request was actually pending.
 286  *
 287  * @tgm:       the current ThrottleGroupMember
 288  * @is_write:  the type of operation (read/write)
 289  */
 290 static bool coroutine_fn throttle_group_co_restart_queue(ThrottleGroupMember *tgm,
 291                                                          bool is_write)
 292 {
 293     bool ret;
 294
 295     qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
 296     ret = qemu_co_queue_next(&tgm->throttled_reqs[is_write]);
 297     qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
 298
 299     return ret;
 300 }
 301
 302 /* Look for the next pending I/O request and schedule it.
 303  *
 304  * This assumes that tg->lock is held.
 305  *
 306  * @tgm:       the current ThrottleGroupMember
 307  * @is_write:  the type of operation (read/write)
 308  */
 309 static void schedule_next_request(ThrottleGroupMember *tgm, bool is_write)
 310 {
 311     ThrottleState *ts = tgm->throttle_state;
 312     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 313     bool must_wait;
 314     ThrottleGroupMember *token;
 315
 316     /* Check if there's any pending request to schedule next */
 317     token = next_throttle_token(tgm, is_write);
 318     if (!tgm_has_pending_reqs(token, is_write)) {
 319         return;
 320     }
 321
 322     /* Set a timer for the request if it needs to be throttled */
 323     must_wait = throttle_group_schedule_timer(token, is_write);
 324
 325     /* If it doesn't have to wait, queue it for immediate execution */
 326     if (!must_wait) {
 327         /* Give preference to requests from the current tgm */
 328         if (qemu_in_coroutine() &&
 329             throttle_group_co_restart_queue(tgm, is_write)) {
 330             token = tgm;
 331         } else {
 332             ThrottleTimers *tt = &token->throttle_timers;
 333             int64_t now = qemu_clock_get_ns(tg->clock_type);
 334             timer_mod(tt->timers[is_write], now);
 335             tg->any_timer_armed[is_write] = true;
 336         }
 337         tg->tokens[is_write] = token;
 338     }
 339 }
 340
 341 /* Check if an I/O request needs to be throttled, wait and set a timer
 342  * if necessary, and schedule the next request using a round robin
 343  * algorithm.
 344  *
 345  * @tgm:       the current ThrottleGroupMember
 346  * @bytes:     the number of bytes for this I/O
 347  * @is_write:  the type of operation (read/write)
 348  */
 349 void coroutine_fn throttle_group_co_io_limits_intercept(ThrottleGroupMember *tgm,
 350                                                         unsigned int bytes,
 351                                                         bool is_write)
 352 {
 353     bool must_wait;
 354     ThrottleGroupMember *token;
 355     ThrottleGroup *tg = container_of(tgm->throttle_state, ThrottleGroup, ts);
 356     qemu_mutex_lock(&tg->lock);
 357
 358     /* First we check if this I/O has to be throttled. */
 359     token = next_throttle_token(tgm, is_write);
 360     must_wait = throttle_group_schedule_timer(token, is_write);
 361
 362     /* Wait if there's a timer set or queued requests of this type */
 363     if (must_wait || tgm->pending_reqs[is_write]) {
 364         tgm->pending_reqs[is_write]++;
 365         qemu_mutex_unlock(&tg->lock);
 366         qemu_co_mutex_lock(&tgm->throttled_reqs_lock);
 367         qemu_co_queue_wait(&tgm->throttled_reqs[is_write],
 368                            &tgm->throttled_reqs_lock);
 369         qemu_co_mutex_unlock(&tgm->throttled_reqs_lock);
 370         qemu_mutex_lock(&tg->lock);
 371         tgm->pending_reqs[is_write]--;
 372     }
 373
 374     /* The I/O will be executed, so do the accounting */
 375     throttle_account(tgm->throttle_state, is_write, bytes);
 376
 377     /* Schedule the next request */
 378     schedule_next_request(tgm, is_write);
 379
 380     qemu_mutex_unlock(&tg->lock);
 381 }
 382
 383 typedef struct {
 384     ThrottleGroupMember *tgm;
 385     bool is_write;
 386 } RestartData;
 387
 388 static void coroutine_fn throttle_group_restart_queue_entry(void *opaque)
 389 {
 390     RestartData *data = opaque;
 391     ThrottleGroupMember *tgm = data->tgm;
 392     ThrottleState *ts = tgm->throttle_state;
 393     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 394     bool is_write = data->is_write;
 395     bool empty_queue;
 396
 397     empty_queue = !throttle_group_co_restart_queue(tgm, is_write);
 398
 399     /* If the request queue was empty then we have to take care of
 400      * scheduling the next one */
 401     if (empty_queue) {
 402         qemu_mutex_lock(&tg->lock);
 403         schedule_next_request(tgm, is_write);
 404         qemu_mutex_unlock(&tg->lock);
 405     }
 406 }
 407
 408 static void throttle_group_restart_queue(ThrottleGroupMember *tgm, bool is_write)
 409 {
 410     Coroutine *co;
 411     RestartData rd = {
 412         .tgm = tgm,
 413         .is_write = is_write
 414     };
 415
 416     co = qemu_coroutine_create(throttle_group_restart_queue_entry, &rd);
 417     aio_co_enter(tgm->aio_context, co);
 418 }
 419
 420 void throttle_group_restart_tgm(ThrottleGroupMember *tgm)
 421 {
 422     if (tgm->throttle_state) {
 423         throttle_group_restart_queue(tgm, 0);
 424         throttle_group_restart_queue(tgm, 1);
 425     }
 426 }
 427
 428 /* Update the throttle configuration for a particular group. Similar
 429  * to throttle_config(), but guarantees atomicity within the
 430  * throttling group.
 431  *
 432  * @tgm:    a ThrottleGroupMember that is a member of the group
 433  * @cfg: the configuration to set
 434  */
 435 void throttle_group_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg)
 436 {
 437     ThrottleState *ts = tgm->throttle_state;
 438     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 439     qemu_mutex_lock(&tg->lock);
 440     throttle_config(ts, tg->clock_type, cfg);
 441     qemu_mutex_unlock(&tg->lock);
 442
 443     throttle_group_restart_tgm(tgm);
 444 }
 445
 446 /* Get the throttle configuration from a particular group. Similar to
 447  * throttle_get_config(), but guarantees atomicity within the
 448  * throttling group.
 449  *
 450  * @tgm:    a ThrottleGroupMember that is a member of the group
 451  * @cfg: the configuration will be written here
 452  */
 453 void throttle_group_get_config(ThrottleGroupMember *tgm, ThrottleConfig *cfg)
 454 {
 455     ThrottleState *ts = tgm->throttle_state;
 456     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 457     qemu_mutex_lock(&tg->lock);
 458     throttle_get_config(ts, cfg);
 459     qemu_mutex_unlock(&tg->lock);
 460 }
 461
 462 /* ThrottleTimers callback. This wakes up a request that was waiting
 463  * because it had been throttled.
 464  *
 465  * @tgm:       the ThrottleGroupMember whose request had been throttled
 466  * @is_write:  the type of operation (read/write)
 467  */
 468 static void timer_cb(ThrottleGroupMember *tgm, bool is_write)
 469 {
 470     ThrottleState *ts = tgm->throttle_state;
 471     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 472
 473     /* The timer has just been fired, so we can update the flag */
 474     qemu_mutex_lock(&tg->lock);
 475     tg->any_timer_armed[is_write] = false;
 476     qemu_mutex_unlock(&tg->lock);
 477
 478     /* Run the request that was waiting for this timer */
 479     throttle_group_restart_queue(tgm, is_write);
 480 }
 481
 482 static void read_timer_cb(void *opaque)
 483 {
 484     timer_cb(opaque, false);
 485 }
 486
 487 static void write_timer_cb(void *opaque)
 488 {
 489     timer_cb(opaque, true);
 490 }
 491
 492 /* Register a ThrottleGroupMember from the throttling group, also initializing
 493  * its timers and updating its throttle_state pointer to point to it. If a
 494  * throttling group with that name does not exist yet, it will be created.
 495  *
 496  * This function edits throttle_groups and must be called under the global
 497  * mutex.
 498  *
 499  * @tgm:       the ThrottleGroupMember to insert
 500  * @groupname: the name of the group
 501  * @ctx:       the AioContext to use
 502  */
 503 void throttle_group_register_tgm(ThrottleGroupMember *tgm,
 504                                  const char *groupname,
 505                                  AioContext *ctx)
 506 {
 507     int i;
 508     ThrottleState *ts = throttle_group_incref(groupname);
 509     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 510
 511     tgm->throttle_state = ts;
 512     tgm->aio_context = ctx;
 513
 514     qemu_mutex_lock(&tg->lock);
 515     /* If the ThrottleGroup is new set this ThrottleGroupMember as the token */
 516     for (i = 0; i < 2; i++) {
 517         if (!tg->tokens[i]) {
 518             tg->tokens[i] = tgm;
 519         }
 520     }
 521
 522     QLIST_INSERT_HEAD(&tg->head, tgm, round_robin);
 523
 524     throttle_timers_init(&tgm->throttle_timers,
 525                          tgm->aio_context,
 526                          tg->clock_type,
 527                          read_timer_cb,
 528                          write_timer_cb,
 529                          tgm);
 530     qemu_co_mutex_init(&tgm->throttled_reqs_lock);
 531     qemu_co_queue_init(&tgm->throttled_reqs[0]);
 532     qemu_co_queue_init(&tgm->throttled_reqs[1]);
 533
 534     qemu_mutex_unlock(&tg->lock);
 535 }
 536
 537 /* Unregister a ThrottleGroupMember from its group, removing it from the list,
 538  * destroying the timers and setting the throttle_state pointer to NULL.
 539  *
 540  * The ThrottleGroupMember must not have pending throttled requests, so the
 541  * caller has to drain them first.
 542  *
 543  * The group will be destroyed if it's empty after this operation.
 544  *
 545  * @tgm the ThrottleGroupMember to remove
 546  */
 547 void throttle_group_unregister_tgm(ThrottleGroupMember *tgm)
 548 {
 549     ThrottleState *ts = tgm->throttle_state;
 550     ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts);
 551     ThrottleGroupMember *token;
 552     int i;
 553
 554     if (!ts) {
 555         /* Discard already unregistered tgm */
 556         return;
 557     }
 558
 559     assert(tgm->pending_reqs[0] == 0 && tgm->pending_reqs[1] == 0);
 560     assert(qemu_co_queue_empty(&tgm->throttled_reqs[0]));
 561     assert(qemu_co_queue_empty(&tgm->throttled_reqs[1]));
 562
 563     qemu_mutex_lock(&tg->lock);
 564     for (i = 0; i < 2; i++) {
 565         if (tg->tokens[i] == tgm) {
 566             token = throttle_group_next_tgm(tgm);
 567             /* Take care of the case where this is the last tgm in the group */
 568             if (token == tgm) {
 569                 token = NULL;
 570             }
 571             tg->tokens[i] = token;
 572         }
 573     }
 574
 575     /* remove the current tgm from the list */
 576     QLIST_REMOVE(tgm, round_robin);
 577     throttle_timers_destroy(&tgm->throttle_timers);
 578     qemu_mutex_unlock(&tg->lock);
 579
 580     throttle_group_unref(&tg->ts);
 581     tgm->throttle_state = NULL;
 582 }
 583
 584 void throttle_group_attach_aio_context(ThrottleGroupMember *tgm,
 585                                        AioContext *new_context)
 586 {
 587     ThrottleTimers *tt = &tgm->throttle_timers;
 588     throttle_timers_attach_aio_context(tt, new_context);
 589     tgm->aio_context = new_context;
 590 }
 591
 592 void throttle_group_detach_aio_context(ThrottleGroupMember *tgm)
 593 {
 594     ThrottleTimers *tt = &tgm->throttle_timers;
 595     throttle_timers_detach_aio_context(tt);
 596     tgm->aio_context = NULL;
 597 }
 598
 599 #undef THROTTLE_OPT_PREFIX
 600 #define THROTTLE_OPT_PREFIX "x-"
 601
 602 /* Helper struct and array for QOM property setter/getter */
 603 typedef struct {
 604     const char *name;
 605     BucketType type;
 606     enum {
 607         AVG,
 608         MAX,
 609         BURST_LENGTH,
 610         IOPS_SIZE,
 611     } category;
 612 } ThrottleParamInfo;
 613
 614 static ThrottleParamInfo properties[] = {
 615     {
 616         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL,
 617         THROTTLE_OPS_TOTAL, AVG,
 618     },
 619     {
 620         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX,
 621         THROTTLE_OPS_TOTAL, MAX,
 622     },
 623     {
 624         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX_LENGTH,
 625         THROTTLE_OPS_TOTAL, BURST_LENGTH,
 626     },
 627     {
 628         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ,
 629         THROTTLE_OPS_READ, AVG,
 630     },
 631     {
 632         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX,
 633         THROTTLE_OPS_READ, MAX,
 634     },
 635     {
 636         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX_LENGTH,
 637         THROTTLE_OPS_READ, BURST_LENGTH,
 638     },
 639     {
 640         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE,
 641         THROTTLE_OPS_WRITE, AVG,
 642     },
 643     {
 644         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX,
 645         THROTTLE_OPS_WRITE, MAX,
 646     },
 647     {
 648         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX_LENGTH,
 649         THROTTLE_OPS_WRITE, BURST_LENGTH,
 650     },
 651     {
 652         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL,
 653         THROTTLE_BPS_TOTAL, AVG,
 654     },
 655     {
 656         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX,
 657         THROTTLE_BPS_TOTAL, MAX,
 658     },
 659     {
 660         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX_LENGTH,
 661         THROTTLE_BPS_TOTAL, BURST_LENGTH,
 662     },
 663     {
 664         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ,
 665         THROTTLE_BPS_READ, AVG,
 666     },
 667     {
 668         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX,
 669         THROTTLE_BPS_READ, MAX,
 670     },
 671     {
 672         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX_LENGTH,
 673         THROTTLE_BPS_READ, BURST_LENGTH,
 674     },
 675     {
 676         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE,
 677         THROTTLE_BPS_WRITE, AVG,
 678     },
 679     {
 680         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX,
 681         THROTTLE_BPS_WRITE, MAX,
 682     },
 683     {
 684         THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX_LENGTH,
 685         THROTTLE_BPS_WRITE, BURST_LENGTH,
 686     },
 687     {
 688         THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_SIZE,
 689         0, IOPS_SIZE,
 690     }
 691 };
 692
 693 /* This function edits throttle_groups and must be called under the global
 694  * mutex */
 695 static void throttle_group_obj_init(Object *obj)
 696 {
 697     ThrottleGroup *tg = THROTTLE_GROUP(obj);
 698
 699     tg->clock_type = QEMU_CLOCK_REALTIME;
 700     if (qtest_enabled()) {
 701         /* For testing block IO throttling only */
 702         tg->clock_type = QEMU_CLOCK_VIRTUAL;
 703     }
 704     tg->is_initialized = false;
 705     qemu_mutex_init(&tg->lock);
 706     throttle_init(&tg->ts);
 707     QLIST_INIT(&tg->head);
 708 }
 709
 710 /* This function edits throttle_groups and must be called under the global
 711  * mutex */
 712 static void throttle_group_obj_complete(UserCreatable *obj, Error **errp)
 713 {
 714     ThrottleGroup *tg = THROTTLE_GROUP(obj);
 715     ThrottleConfig cfg;
 716
 717     /* set group name to object id if it exists */
 718     if (!tg->name && tg->parent_obj.parent) {
 719         tg->name = object_get_canonical_path_component(OBJECT(obj));
 720     }
 721     /* We must have a group name at this point */
 722     assert(tg->name);
 723
 724     /* error if name is duplicate */
 725     if (throttle_group_exists(tg->name)) {
 726         error_setg(errp, "A group with this name already exists");
 727         return;
 728     }
 729
 730     /* check validity */
 731     throttle_get_config(&tg->ts, &cfg);
 732     if (!throttle_is_valid(&cfg, errp)) {
 733         return;
 734     }
 735     throttle_config(&tg->ts, tg->clock_type, &cfg);
 736     QTAILQ_INSERT_TAIL(&throttle_groups, tg, list);
 737     tg->is_initialized = true;
 738 }
 739
 740 /* This function edits throttle_groups and must be called under the global
 741  * mutex */
 742 static void throttle_group_obj_finalize(Object *obj)
 743 {
 744     ThrottleGroup *tg = THROTTLE_GROUP(obj);
 745     if (tg->is_initialized) {
 746         QTAILQ_REMOVE(&throttle_groups, tg, list);
 747     }
 748     qemu_mutex_destroy(&tg->lock);
 749     g_free(tg->name);
 750 }
 751
 752 static void throttle_group_set(Object *obj, Visitor *v, const char * name,
 753                                void *opaque, Error **errp)
 754
 755 {
 756     ThrottleGroup *tg = THROTTLE_GROUP(obj);
 757     ThrottleConfig *cfg;
 758     ThrottleParamInfo *info = opaque;
 759     Error *local_err = NULL;
 760     int64_t value;
 761
 762     /* If we have finished initialization, don't accept individual property
 763      * changes through QOM. Throttle configuration limits must be set in one
 764      * transaction, as certain combinations are invalid.
 765      */
 766     if (tg->is_initialized) {
 767         error_setg(&local_err, "Property cannot be set after initialization");
 768         goto ret;
 769     }
 770
 771     visit_type_int64(v, name, &value, &local_err);
 772     if (local_err) {
 773         goto ret;
 774     }
 775     if (value < 0) {
 776         error_setg(&local_err, "Property values cannot be negative");
 777         goto ret;
 778     }
 779
 780     cfg = &tg->ts.cfg;
 781     switch (info->category) {
 782     case AVG:
 783         cfg->buckets[info->type].avg = value;
 784         break;
 785     case MAX:
 786         cfg->buckets[info->type].max = value;
 787         break;
 788     case BURST_LENGTH:
 789         if (value > UINT_MAX) {
 790             error_setg(&local_err, "%s value must be in the"
 791                        "range [0, %u]", info->name, UINT_MAX);
 792             goto ret;
 793         }
 794         cfg->buckets[info->type].burst_length = value;
 795         break;
 796     case IOPS_SIZE:
 797         cfg->op_size = value;
 798         break;
 799     }
 800
 801 ret:
 802     error_propagate(errp, local_err);
 803     return;
 804
 805 }
 806
 807 static void throttle_group_get(Object *obj, Visitor *v, const char *name,
 808                                void *opaque, Error **errp)
 809 {
 810     ThrottleGroup *tg = THROTTLE_GROUP(obj);
 811     ThrottleConfig cfg;
 812     ThrottleParamInfo *info = opaque;
 813     int64_t value;
 814
 815     throttle_get_config(&tg->ts, &cfg);
 816     switch (info->category) {
 817     case AVG:
 818         value = cfg.buckets[info->type].avg;
 819         break;
 820     case MAX:
 821         value = cfg.buckets[info->type].max;
 822         break;
 823     case BURST_LENGTH:
 824         value = cfg.buckets[info->type].burst_length;
 825         break;
 826     case IOPS_SIZE:
 827         value = cfg.op_size;
 828         break;
 829     }
 830
 831     visit_type_int64(v, name, &value, errp);
 832 }
 833
 834 static void throttle_group_set_limits(Object *obj, Visitor *v,
 835                                       const char *name, void *opaque,
 836                                       Error **errp)
 837
 838 {
 839     ThrottleGroup *tg = THROTTLE_GROUP(obj);
 840     ThrottleConfig cfg;
 841     ThrottleLimits arg = { 0 };
 842     ThrottleLimits *argp = &arg;
 843     Error *local_err = NULL;
 844
 845     visit_type_ThrottleLimits(v, name, &argp, &local_err);
 846     if (local_err) {
 847         goto ret;
 848     }
 849     qemu_mutex_lock(&tg->lock);
 850     throttle_get_config(&tg->ts, &cfg);
 851     throttle_limits_to_config(argp, &cfg, &local_err);
 852     if (local_err) {
 853         goto unlock;
 854     }
 855     throttle_config(&tg->ts, tg->clock_type, &cfg);
 856
 857 unlock:
 858     qemu_mutex_unlock(&tg->lock);
 859 ret:
 860     error_propagate(errp, local_err);
 861     return;
 862 }
 863
 864 static void throttle_group_get_limits(Object *obj, Visitor *v,
 865                                       const char *name, void *opaque,
 866                                       Error **errp)
 867 {
 868     ThrottleGroup *tg = THROTTLE_GROUP(obj);
 869     ThrottleConfig cfg;
 870     ThrottleLimits arg = { 0 };
 871     ThrottleLimits *argp = &arg;
 872
 873     qemu_mutex_lock(&tg->lock);
 874     throttle_get_config(&tg->ts, &cfg);
 875     qemu_mutex_unlock(&tg->lock);
 876
 877     throttle_config_to_limits(&cfg, argp);
 878
 879     visit_type_ThrottleLimits(v, name, &argp, errp);
 880 }
 881
 882 static bool throttle_group_can_be_deleted(UserCreatable *uc)
 883 {
 884     return OBJECT(uc)->ref == 1;
 885 }
 886
 887 static void throttle_group_obj_class_init(ObjectClass *klass, void *class_data)
 888 {
 889     size_t i = 0;
 890     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
 891
 892     ucc->complete = throttle_group_obj_complete;
 893     ucc->can_be_deleted = throttle_group_can_be_deleted;
 894
 895     /* individual properties */
 896     for (i = 0; i < sizeof(properties) / sizeof(ThrottleParamInfo); i++) {
 897         object_class_property_add(klass,
 898                                   properties[i].name,
 899                                   "int",
 900                                   throttle_group_get,
 901                                   throttle_group_set,
 902                                   NULL, &properties[i],
 903                                   &error_abort);
 904     }
 905
 906     /* ThrottleLimits */
 907     object_class_property_add(klass,
 908                               "limits", "ThrottleLimits",
 909                               throttle_group_get_limits,
 910                               throttle_group_set_limits,
 911                               NULL, NULL,
 912                               &error_abort);
 913 }
 914
 915 static const TypeInfo throttle_group_info = {
 916     .name = TYPE_THROTTLE_GROUP,
 917     .parent = TYPE_OBJECT,
 918     .class_init = throttle_group_obj_class_init,
 919     .instance_size = sizeof(ThrottleGroup),
 920     .instance_init = throttle_group_obj_init,
 921     .instance_finalize = throttle_group_obj_finalize,
 922     .interfaces = (InterfaceInfo[]) {
 923         { TYPE_USER_CREATABLE },
 924         { }
 925     },
 926 };
 927
 928 static void throttle_groups_init(void)
 929 {
 930     type_register_static(&throttle_group_info);
 931 }
 932
 933 type_init(throttle_groups_init);