2 * QEMU block throttling group infrastructure
4 * Copyright (C) Nodalink, EURL. 2014
5 * Copyright (C) Igalia, S.L. 2015
8 * BenoƮt Canet <benoit.canet@nodalink.com>
9 * Alberto Garcia <berto@igalia.com>
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.
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.
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/>.
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"
37 static void throttle_group_obj_init(Object
*obj
);
38 static void throttle_group_obj_complete(UserCreatable
*obj
, Error
**errp
);
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
45 * This locking is however handled internally in this file, so it's
46 * transparent to outside users.
48 * The whole ThrottleGroup structure is private and invisible to
49 * outside users, that only use it through its ThrottleState.
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.
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.
64 typedef struct ThrottleGroup
{
67 /* refuse individual property change if initialization is complete */
69 char *name
; /* This is constant during the lifetime of the group */
71 QemuMutex lock
; /* This lock protects the following four fields */
73 QLIST_HEAD(, ThrottleGroupMember
) head
;
74 ThrottleGroupMember
*tokens
[2];
75 bool any_timer_armed
[2];
76 QEMUClockType clock_type
;
78 /* This field is protected by the global QEMU mutex */
79 QTAILQ_ENTRY(ThrottleGroup
) list
;
82 /* This is protected by the global QEMU mutex */
83 static QTAILQ_HEAD(, ThrottleGroup
) throttle_groups
=
84 QTAILQ_HEAD_INITIALIZER(throttle_groups
);
87 /* This function reads throttle_groups and must be called under the global
90 static ThrottleGroup
*throttle_group_by_name(const char *name
)
94 /* Look for an existing group with that name */
95 QTAILQ_FOREACH(iter
, &throttle_groups
, list
) {
96 if (!g_strcmp0(name
, iter
->name
)) {
104 /* This function reads throttle_groups and must be called under the global
107 bool throttle_group_exists(const char *name
)
109 return throttle_group_by_name(name
) != NULL
;
112 /* Increments the reference count of a ThrottleGroup given its name.
114 * If no ThrottleGroup is found with the given name a new one is
117 * This function edits throttle_groups and must be called under the global
120 * @name: the name of the ThrottleGroup
121 * @ret: the ThrottleState member of the ThrottleGroup
123 ThrottleState
*throttle_group_incref(const char *name
)
125 ThrottleGroup
*tg
= NULL
;
127 /* Look for an existing group with that name */
128 tg
= throttle_group_by_name(name
);
131 object_ref(OBJECT(tg
));
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
);
143 /* Decrease the reference count of a ThrottleGroup.
145 * When the reference count reaches zero the ThrottleGroup is
148 * This function edits throttle_groups and must be called under the global
151 * @ts: The ThrottleGroup to unref, given by its ThrottleState member
153 void throttle_group_unref(ThrottleState
*ts
)
155 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
156 object_unref(OBJECT(tg
));
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.
162 * @tgm: a ThrottleGroupMember
163 * @ret: the name of the group.
165 const char *throttle_group_get_name(ThrottleGroupMember
*tgm
)
167 ThrottleGroup
*tg
= container_of(tgm
->throttle_state
, ThrottleGroup
, ts
);
171 /* Return the next ThrottleGroupMember in the round-robin sequence, simulating
174 * This assumes that tg->lock is held.
176 * @tgm: the current ThrottleGroupMember
177 * @ret: the next ThrottleGroupMember in the sequence
179 static ThrottleGroupMember
*throttle_group_next_tgm(ThrottleGroupMember
*tgm
)
181 ThrottleState
*ts
= tgm
->throttle_state
;
182 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
183 ThrottleGroupMember
*next
= QLIST_NEXT(tgm
, round_robin
);
186 next
= QLIST_FIRST(&tg
->head
);
193 * Return whether a ThrottleGroupMember has pending requests.
195 * This assumes that tg->lock is held.
197 * @tgm: the ThrottleGroupMember
198 * @is_write: the type of operation (read/write)
199 * @ret: whether the ThrottleGroupMember has pending requests.
201 static inline bool tgm_has_pending_reqs(ThrottleGroupMember
*tgm
,
204 return tgm
->pending_reqs
[is_write
];
207 /* Return the next ThrottleGroupMember in the round-robin sequence with pending
210 * This assumes that tg->lock is held.
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
217 static ThrottleGroupMember
*next_throttle_token(ThrottleGroupMember
*tgm
,
220 ThrottleState
*ts
= tgm
->throttle_state
;
221 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
222 ThrottleGroupMember
*token
, *start
;
224 start
= token
= tg
->tokens
[is_write
];
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
);
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.
236 if (token
== start
&& !tgm_has_pending_reqs(token
, is_write
)) {
240 /* Either we return the original TGM, or one with pending requests */
241 assert(token
== tgm
|| tgm_has_pending_reqs(token
, is_write
));
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.
250 * This assumes that tg->lock is held.
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
256 static bool throttle_group_schedule_timer(ThrottleGroupMember
*tgm
,
259 ThrottleState
*ts
= tgm
->throttle_state
;
260 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
261 ThrottleTimers
*tt
= &tgm
->throttle_timers
;
264 if (atomic_read(&tgm
->io_limits_disabled
)) {
268 /* Check if any of the timers in this group is already armed */
269 if (tg
->any_timer_armed
[is_write
]) {
273 must_wait
= throttle_schedule_timer(ts
, tt
, is_write
);
275 /* If a timer just got armed, set tgm as the current token */
277 tg
->tokens
[is_write
] = tgm
;
278 tg
->any_timer_armed
[is_write
] = true;
284 /* Start the next pending I/O request for a ThrottleGroupMember. Return whether
285 * any request was actually pending.
287 * @tgm: the current ThrottleGroupMember
288 * @is_write: the type of operation (read/write)
290 static bool coroutine_fn
throttle_group_co_restart_queue(ThrottleGroupMember
*tgm
,
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
);
302 /* Look for the next pending I/O request and schedule it.
304 * This assumes that tg->lock is held.
306 * @tgm: the current ThrottleGroupMember
307 * @is_write: the type of operation (read/write)
309 static void schedule_next_request(ThrottleGroupMember
*tgm
, bool is_write
)
311 ThrottleState
*ts
= tgm
->throttle_state
;
312 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
314 ThrottleGroupMember
*token
;
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
)) {
322 /* Set a timer for the request if it needs to be throttled */
323 must_wait
= throttle_group_schedule_timer(token
, is_write
);
325 /* If it doesn't have to wait, queue it for immediate execution */
327 /* Give preference to requests from the current tgm */
328 if (qemu_in_coroutine() &&
329 throttle_group_co_restart_queue(tgm
, is_write
)) {
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;
337 tg
->tokens
[is_write
] = token
;
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
345 * @tgm: the current ThrottleGroupMember
346 * @bytes: the number of bytes for this I/O
347 * @is_write: the type of operation (read/write)
349 void coroutine_fn
throttle_group_co_io_limits_intercept(ThrottleGroupMember
*tgm
,
354 ThrottleGroupMember
*token
;
355 ThrottleGroup
*tg
= container_of(tgm
->throttle_state
, ThrottleGroup
, ts
);
356 qemu_mutex_lock(&tg
->lock
);
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
);
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
]--;
374 /* The I/O will be executed, so do the accounting */
375 throttle_account(tgm
->throttle_state
, is_write
, bytes
);
377 /* Schedule the next request */
378 schedule_next_request(tgm
, is_write
);
380 qemu_mutex_unlock(&tg
->lock
);
384 ThrottleGroupMember
*tgm
;
388 static void coroutine_fn
throttle_group_restart_queue_entry(void *opaque
)
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
;
397 empty_queue
= !throttle_group_co_restart_queue(tgm
, is_write
);
399 /* If the request queue was empty then we have to take care of
400 * scheduling the next one */
402 qemu_mutex_lock(&tg
->lock
);
403 schedule_next_request(tgm
, is_write
);
404 qemu_mutex_unlock(&tg
->lock
);
408 static void throttle_group_restart_queue(ThrottleGroupMember
*tgm
, bool is_write
)
416 co
= qemu_coroutine_create(throttle_group_restart_queue_entry
, &rd
);
417 aio_co_enter(tgm
->aio_context
, co
);
420 void throttle_group_restart_tgm(ThrottleGroupMember
*tgm
)
422 if (tgm
->throttle_state
) {
423 throttle_group_restart_queue(tgm
, 0);
424 throttle_group_restart_queue(tgm
, 1);
428 /* Update the throttle configuration for a particular group. Similar
429 * to throttle_config(), but guarantees atomicity within the
432 * @tgm: a ThrottleGroupMember that is a member of the group
433 * @cfg: the configuration to set
435 void throttle_group_config(ThrottleGroupMember
*tgm
, ThrottleConfig
*cfg
)
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
);
443 throttle_group_restart_tgm(tgm
);
446 /* Get the throttle configuration from a particular group. Similar to
447 * throttle_get_config(), but guarantees atomicity within the
450 * @tgm: a ThrottleGroupMember that is a member of the group
451 * @cfg: the configuration will be written here
453 void throttle_group_get_config(ThrottleGroupMember
*tgm
, ThrottleConfig
*cfg
)
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
);
462 /* ThrottleTimers callback. This wakes up a request that was waiting
463 * because it had been throttled.
465 * @tgm: the ThrottleGroupMember whose request had been throttled
466 * @is_write: the type of operation (read/write)
468 static void timer_cb(ThrottleGroupMember
*tgm
, bool is_write
)
470 ThrottleState
*ts
= tgm
->throttle_state
;
471 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
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
);
478 /* Run the request that was waiting for this timer */
479 throttle_group_restart_queue(tgm
, is_write
);
482 static void read_timer_cb(void *opaque
)
484 timer_cb(opaque
, false);
487 static void write_timer_cb(void *opaque
)
489 timer_cb(opaque
, true);
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.
496 * This function edits throttle_groups and must be called under the global
499 * @tgm: the ThrottleGroupMember to insert
500 * @groupname: the name of the group
501 * @ctx: the AioContext to use
503 void throttle_group_register_tgm(ThrottleGroupMember
*tgm
,
504 const char *groupname
,
508 ThrottleState
*ts
= throttle_group_incref(groupname
);
509 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
511 tgm
->throttle_state
= ts
;
512 tgm
->aio_context
= ctx
;
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
]) {
522 QLIST_INSERT_HEAD(&tg
->head
, tgm
, round_robin
);
524 throttle_timers_init(&tgm
->throttle_timers
,
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]);
534 qemu_mutex_unlock(&tg
->lock
);
537 /* Unregister a ThrottleGroupMember from its group, removing it from the list,
538 * destroying the timers and setting the throttle_state pointer to NULL.
540 * The ThrottleGroupMember must not have pending throttled requests, so the
541 * caller has to drain them first.
543 * The group will be destroyed if it's empty after this operation.
545 * @tgm the ThrottleGroupMember to remove
547 void throttle_group_unregister_tgm(ThrottleGroupMember
*tgm
)
549 ThrottleState
*ts
= tgm
->throttle_state
;
550 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
551 ThrottleGroupMember
*token
;
555 /* Discard already unregistered tgm */
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]));
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 */
571 tg
->tokens
[i
] = token
;
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
);
580 throttle_group_unref(&tg
->ts
);
581 tgm
->throttle_state
= NULL
;
584 void throttle_group_attach_aio_context(ThrottleGroupMember
*tgm
,
585 AioContext
*new_context
)
587 ThrottleTimers
*tt
= &tgm
->throttle_timers
;
588 throttle_timers_attach_aio_context(tt
, new_context
);
589 tgm
->aio_context
= new_context
;
592 void throttle_group_detach_aio_context(ThrottleGroupMember
*tgm
)
594 ThrottleTimers
*tt
= &tgm
->throttle_timers
;
595 throttle_timers_detach_aio_context(tt
);
596 tgm
->aio_context
= NULL
;
599 #undef THROTTLE_OPT_PREFIX
600 #define THROTTLE_OPT_PREFIX "x-"
602 /* Helper struct and array for QOM property setter/getter */
614 static ThrottleParamInfo properties
[] = {
616 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL
,
617 THROTTLE_OPS_TOTAL
, AVG
,
620 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX
,
621 THROTTLE_OPS_TOTAL
, MAX
,
624 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX_LENGTH
,
625 THROTTLE_OPS_TOTAL
, BURST_LENGTH
,
628 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ
,
629 THROTTLE_OPS_READ
, AVG
,
632 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX
,
633 THROTTLE_OPS_READ
, MAX
,
636 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX_LENGTH
,
637 THROTTLE_OPS_READ
, BURST_LENGTH
,
640 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE
,
641 THROTTLE_OPS_WRITE
, AVG
,
644 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX
,
645 THROTTLE_OPS_WRITE
, MAX
,
648 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX_LENGTH
,
649 THROTTLE_OPS_WRITE
, BURST_LENGTH
,
652 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL
,
653 THROTTLE_BPS_TOTAL
, AVG
,
656 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX
,
657 THROTTLE_BPS_TOTAL
, MAX
,
660 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX_LENGTH
,
661 THROTTLE_BPS_TOTAL
, BURST_LENGTH
,
664 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ
,
665 THROTTLE_BPS_READ
, AVG
,
668 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX
,
669 THROTTLE_BPS_READ
, MAX
,
672 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX_LENGTH
,
673 THROTTLE_BPS_READ
, BURST_LENGTH
,
676 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE
,
677 THROTTLE_BPS_WRITE
, AVG
,
680 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX
,
681 THROTTLE_BPS_WRITE
, MAX
,
684 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX_LENGTH
,
685 THROTTLE_BPS_WRITE
, BURST_LENGTH
,
688 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_SIZE
,
693 /* This function edits throttle_groups and must be called under the global
695 static void throttle_group_obj_init(Object
*obj
)
697 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
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
;
704 tg
->is_initialized
= false;
705 qemu_mutex_init(&tg
->lock
);
706 throttle_init(&tg
->ts
);
707 QLIST_INIT(&tg
->head
);
710 /* This function edits throttle_groups and must be called under the global
712 static void throttle_group_obj_complete(UserCreatable
*obj
, Error
**errp
)
714 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
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
));
721 /* We must have a group name at this point */
724 /* error if name is duplicate */
725 if (throttle_group_exists(tg
->name
)) {
726 error_setg(errp
, "A group with this name already exists");
731 throttle_get_config(&tg
->ts
, &cfg
);
732 if (!throttle_is_valid(&cfg
, errp
)) {
735 throttle_config(&tg
->ts
, tg
->clock_type
, &cfg
);
736 QTAILQ_INSERT_TAIL(&throttle_groups
, tg
, list
);
737 tg
->is_initialized
= true;
740 /* This function edits throttle_groups and must be called under the global
742 static void throttle_group_obj_finalize(Object
*obj
)
744 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
745 if (tg
->is_initialized
) {
746 QTAILQ_REMOVE(&throttle_groups
, tg
, list
);
748 qemu_mutex_destroy(&tg
->lock
);
752 static void throttle_group_set(Object
*obj
, Visitor
*v
, const char * name
,
753 void *opaque
, Error
**errp
)
756 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
758 ThrottleParamInfo
*info
= opaque
;
759 Error
*local_err
= NULL
;
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.
766 if (tg
->is_initialized
) {
767 error_setg(&local_err
, "Property cannot be set after initialization");
771 visit_type_int64(v
, name
, &value
, &local_err
);
776 error_setg(&local_err
, "Property values cannot be negative");
781 switch (info
->category
) {
783 cfg
->buckets
[info
->type
].avg
= value
;
786 cfg
->buckets
[info
->type
].max
= value
;
789 if (value
> UINT_MAX
) {
790 error_setg(&local_err
, "%s value must be in the"
791 "range [0, %u]", info
->name
, UINT_MAX
);
794 cfg
->buckets
[info
->type
].burst_length
= value
;
797 cfg
->op_size
= value
;
802 error_propagate(errp
, local_err
);
807 static void throttle_group_get(Object
*obj
, Visitor
*v
, const char *name
,
808 void *opaque
, Error
**errp
)
810 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
812 ThrottleParamInfo
*info
= opaque
;
815 throttle_get_config(&tg
->ts
, &cfg
);
816 switch (info
->category
) {
818 value
= cfg
.buckets
[info
->type
].avg
;
821 value
= cfg
.buckets
[info
->type
].max
;
824 value
= cfg
.buckets
[info
->type
].burst_length
;
831 visit_type_int64(v
, name
, &value
, errp
);
834 static void throttle_group_set_limits(Object
*obj
, Visitor
*v
,
835 const char *name
, void *opaque
,
839 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
841 ThrottleLimits arg
= { 0 };
842 ThrottleLimits
*argp
= &arg
;
843 Error
*local_err
= NULL
;
845 visit_type_ThrottleLimits(v
, name
, &argp
, &local_err
);
849 qemu_mutex_lock(&tg
->lock
);
850 throttle_get_config(&tg
->ts
, &cfg
);
851 throttle_limits_to_config(argp
, &cfg
, &local_err
);
855 throttle_config(&tg
->ts
, tg
->clock_type
, &cfg
);
858 qemu_mutex_unlock(&tg
->lock
);
860 error_propagate(errp
, local_err
);
864 static void throttle_group_get_limits(Object
*obj
, Visitor
*v
,
865 const char *name
, void *opaque
,
868 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
870 ThrottleLimits arg
= { 0 };
871 ThrottleLimits
*argp
= &arg
;
873 qemu_mutex_lock(&tg
->lock
);
874 throttle_get_config(&tg
->ts
, &cfg
);
875 qemu_mutex_unlock(&tg
->lock
);
877 throttle_config_to_limits(&cfg
, argp
);
879 visit_type_ThrottleLimits(v
, name
, &argp
, errp
);
882 static bool throttle_group_can_be_deleted(UserCreatable
*uc
)
884 return OBJECT(uc
)->ref
== 1;
887 static void throttle_group_obj_class_init(ObjectClass
*klass
, void *class_data
)
890 UserCreatableClass
*ucc
= USER_CREATABLE_CLASS(klass
);
892 ucc
->complete
= throttle_group_obj_complete
;
893 ucc
->can_be_deleted
= throttle_group_can_be_deleted
;
895 /* individual properties */
896 for (i
= 0; i
< sizeof(properties
) / sizeof(ThrottleParamInfo
); i
++) {
897 object_class_property_add(klass
,
902 NULL
, &properties
[i
],
907 object_class_property_add(klass
,
908 "limits", "ThrottleLimits",
909 throttle_group_get_limits
,
910 throttle_group_set_limits
,
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
},
928 static void throttle_groups_init(void)
930 type_register_static(&throttle_group_info
);
933 type_init(throttle_groups_init
);