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/main-loop.h"
30 #include "qemu/queue.h"
31 #include "qemu/thread.h"
32 #include "sysemu/qtest.h"
33 #include "qapi/error.h"
34 #include "qapi/qapi-visit-block-core.h"
35 #include "qom/object.h"
36 #include "qom/object_interfaces.h"
38 static void throttle_group_obj_init(Object
*obj
);
39 static void throttle_group_obj_complete(UserCreatable
*obj
, Error
**errp
);
40 static void timer_cb(ThrottleGroupMember
*tgm
, bool is_write
);
42 /* The ThrottleGroup structure (with its ThrottleState) is shared
43 * among different ThrottleGroupMembers and it's independent from
44 * AioContext, so in order to use it from different threads it needs
47 * This locking is however handled internally in this file, so it's
48 * transparent to outside users.
50 * The whole ThrottleGroup structure is private and invisible to
51 * outside users, that only use it through its ThrottleState.
53 * In addition to the ThrottleGroup structure, ThrottleGroupMember has
54 * fields that need to be accessed by other members of the group and
55 * therefore also need to be protected by this lock. Once a
56 * ThrottleGroupMember is registered in a group those fields can be accessed
57 * by other threads any time.
59 * Again, all this is handled internally and is mostly transparent to
60 * the outside. The 'throttle_timers' field however has an additional
61 * constraint because it may be temporarily invalid (see for example
62 * blk_set_aio_context()). Therefore in this file a thread will
63 * access some other ThrottleGroupMember's timers only after verifying that
64 * that ThrottleGroupMember has throttled requests in the queue.
66 struct ThrottleGroup
{
69 /* refuse individual property change if initialization is complete */
71 char *name
; /* This is constant during the lifetime of the group */
73 QemuMutex lock
; /* This lock protects the following four fields */
75 QLIST_HEAD(, ThrottleGroupMember
) head
;
76 ThrottleGroupMember
*tokens
[2];
77 bool any_timer_armed
[2];
78 QEMUClockType clock_type
;
80 /* This field is protected by the global QEMU mutex */
81 QTAILQ_ENTRY(ThrottleGroup
) list
;
84 /* This is protected by the global QEMU mutex */
85 static QTAILQ_HEAD(, ThrottleGroup
) throttle_groups
=
86 QTAILQ_HEAD_INITIALIZER(throttle_groups
);
89 /* This function reads throttle_groups and must be called under the global
92 static ThrottleGroup
*throttle_group_by_name(const char *name
)
96 /* Look for an existing group with that name */
97 QTAILQ_FOREACH(iter
, &throttle_groups
, list
) {
98 if (!g_strcmp0(name
, iter
->name
)) {
106 /* This function reads throttle_groups and must be called under the global
109 bool throttle_group_exists(const char *name
)
111 return throttle_group_by_name(name
) != NULL
;
114 /* Increments the reference count of a ThrottleGroup given its name.
116 * If no ThrottleGroup is found with the given name a new one is
119 * This function edits throttle_groups and must be called under the global
122 * @name: the name of the ThrottleGroup
123 * @ret: the ThrottleState member of the ThrottleGroup
125 ThrottleState
*throttle_group_incref(const char *name
)
127 ThrottleGroup
*tg
= NULL
;
129 /* Look for an existing group with that name */
130 tg
= throttle_group_by_name(name
);
133 object_ref(OBJECT(tg
));
135 /* Create a new one if not found */
136 /* new ThrottleGroup obj will have a refcnt = 1 */
137 tg
= THROTTLE_GROUP(object_new(TYPE_THROTTLE_GROUP
));
138 tg
->name
= g_strdup(name
);
139 throttle_group_obj_complete(USER_CREATABLE(tg
), &error_abort
);
145 /* Decrease the reference count of a ThrottleGroup.
147 * When the reference count reaches zero the ThrottleGroup is
150 * This function edits throttle_groups and must be called under the global
153 * @ts: The ThrottleGroup to unref, given by its ThrottleState member
155 void throttle_group_unref(ThrottleState
*ts
)
157 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
158 object_unref(OBJECT(tg
));
161 /* Get the name from a ThrottleGroupMember's group. The name (and the pointer)
162 * is guaranteed to remain constant during the lifetime of the group.
164 * @tgm: a ThrottleGroupMember
165 * @ret: the name of the group.
167 const char *throttle_group_get_name(ThrottleGroupMember
*tgm
)
169 ThrottleGroup
*tg
= container_of(tgm
->throttle_state
, ThrottleGroup
, ts
);
173 /* Return the next ThrottleGroupMember in the round-robin sequence, simulating
176 * This assumes that tg->lock is held.
178 * @tgm: the current ThrottleGroupMember
179 * @ret: the next ThrottleGroupMember in the sequence
181 static ThrottleGroupMember
*throttle_group_next_tgm(ThrottleGroupMember
*tgm
)
183 ThrottleState
*ts
= tgm
->throttle_state
;
184 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
185 ThrottleGroupMember
*next
= QLIST_NEXT(tgm
, round_robin
);
188 next
= QLIST_FIRST(&tg
->head
);
195 * Return whether a ThrottleGroupMember has pending requests.
197 * This assumes that tg->lock is held.
199 * @tgm: the ThrottleGroupMember
200 * @is_write: the type of operation (read/write)
201 * @ret: whether the ThrottleGroupMember has pending requests.
203 static inline bool tgm_has_pending_reqs(ThrottleGroupMember
*tgm
,
206 return tgm
->pending_reqs
[is_write
];
209 /* Return the next ThrottleGroupMember in the round-robin sequence with pending
212 * This assumes that tg->lock is held.
214 * @tgm: the current ThrottleGroupMember
215 * @is_write: the type of operation (read/write)
216 * @ret: the next ThrottleGroupMember with pending requests, or tgm if
219 static ThrottleGroupMember
*next_throttle_token(ThrottleGroupMember
*tgm
,
222 ThrottleState
*ts
= tgm
->throttle_state
;
223 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
224 ThrottleGroupMember
*token
, *start
;
226 /* If this member has its I/O limits disabled then it means that
227 * it's being drained. Skip the round-robin search and return tgm
228 * immediately if it has pending requests. Otherwise we could be
229 * forcing it to wait for other member's throttled requests. */
230 if (tgm_has_pending_reqs(tgm
, is_write
) &&
231 qatomic_read(&tgm
->io_limits_disabled
)) {
235 start
= token
= tg
->tokens
[is_write
];
237 /* get next bs round in round robin style */
238 token
= throttle_group_next_tgm(token
);
239 while (token
!= start
&& !tgm_has_pending_reqs(token
, is_write
)) {
240 token
= throttle_group_next_tgm(token
);
243 /* If no IO are queued for scheduling on the next round robin token
244 * then decide the token is the current tgm because chances are
245 * the current tgm got the current request queued.
247 if (token
== start
&& !tgm_has_pending_reqs(token
, is_write
)) {
251 /* Either we return the original TGM, or one with pending requests */
252 assert(token
== tgm
|| tgm_has_pending_reqs(token
, is_write
));
257 /* Check if the next I/O request for a ThrottleGroupMember needs to be
258 * throttled or not. If there's no timer set in this group, set one and update
259 * the token accordingly.
261 * This assumes that tg->lock is held.
263 * @tgm: the current ThrottleGroupMember
264 * @is_write: the type of operation (read/write)
265 * @ret: whether the I/O request needs to be throttled or not
267 static bool throttle_group_schedule_timer(ThrottleGroupMember
*tgm
,
270 ThrottleState
*ts
= tgm
->throttle_state
;
271 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
272 ThrottleTimers
*tt
= &tgm
->throttle_timers
;
273 ThrottleDirection direction
= is_write
? THROTTLE_WRITE
: THROTTLE_READ
;
276 if (qatomic_read(&tgm
->io_limits_disabled
)) {
280 /* Check if any of the timers in this group is already armed */
281 if (tg
->any_timer_armed
[is_write
]) {
285 must_wait
= throttle_schedule_timer(ts
, tt
, direction
);
287 /* If a timer just got armed, set tgm as the current token */
289 tg
->tokens
[is_write
] = tgm
;
290 tg
->any_timer_armed
[is_write
] = true;
296 /* Start the next pending I/O request for a ThrottleGroupMember. Return whether
297 * any request was actually pending.
299 * @tgm: the current ThrottleGroupMember
300 * @is_write: the type of operation (read/write)
302 static bool coroutine_fn
throttle_group_co_restart_queue(ThrottleGroupMember
*tgm
,
307 qemu_co_mutex_lock(&tgm
->throttled_reqs_lock
);
308 ret
= qemu_co_queue_next(&tgm
->throttled_reqs
[is_write
]);
309 qemu_co_mutex_unlock(&tgm
->throttled_reqs_lock
);
314 /* Look for the next pending I/O request and schedule it.
316 * This assumes that tg->lock is held.
318 * @tgm: the current ThrottleGroupMember
319 * @is_write: the type of operation (read/write)
321 static void schedule_next_request(ThrottleGroupMember
*tgm
, bool is_write
)
323 ThrottleState
*ts
= tgm
->throttle_state
;
324 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
326 ThrottleGroupMember
*token
;
328 /* Check if there's any pending request to schedule next */
329 token
= next_throttle_token(tgm
, is_write
);
330 if (!tgm_has_pending_reqs(token
, is_write
)) {
334 /* Set a timer for the request if it needs to be throttled */
335 must_wait
= throttle_group_schedule_timer(token
, is_write
);
337 /* If it doesn't have to wait, queue it for immediate execution */
339 /* Give preference to requests from the current tgm */
340 if (qemu_in_coroutine() &&
341 throttle_group_co_restart_queue(tgm
, is_write
)) {
344 ThrottleTimers
*tt
= &token
->throttle_timers
;
345 int64_t now
= qemu_clock_get_ns(tg
->clock_type
);
346 timer_mod(tt
->timers
[is_write
], now
);
347 tg
->any_timer_armed
[is_write
] = true;
349 tg
->tokens
[is_write
] = token
;
353 /* Check if an I/O request needs to be throttled, wait and set a timer
354 * if necessary, and schedule the next request using a round robin
357 * @tgm: the current ThrottleGroupMember
358 * @bytes: the number of bytes for this I/O
359 * @is_write: the type of operation (read/write)
361 void coroutine_fn
throttle_group_co_io_limits_intercept(ThrottleGroupMember
*tgm
,
366 ThrottleGroupMember
*token
;
367 ThrottleGroup
*tg
= container_of(tgm
->throttle_state
, ThrottleGroup
, ts
);
368 ThrottleDirection direction
= is_write
? THROTTLE_WRITE
: THROTTLE_READ
;
372 qemu_mutex_lock(&tg
->lock
);
374 /* First we check if this I/O has to be throttled. */
375 token
= next_throttle_token(tgm
, is_write
);
376 must_wait
= throttle_group_schedule_timer(token
, is_write
);
378 /* Wait if there's a timer set or queued requests of this type */
379 if (must_wait
|| tgm
->pending_reqs
[is_write
]) {
380 tgm
->pending_reqs
[is_write
]++;
381 qemu_mutex_unlock(&tg
->lock
);
382 qemu_co_mutex_lock(&tgm
->throttled_reqs_lock
);
383 qemu_co_queue_wait(&tgm
->throttled_reqs
[is_write
],
384 &tgm
->throttled_reqs_lock
);
385 qemu_co_mutex_unlock(&tgm
->throttled_reqs_lock
);
386 qemu_mutex_lock(&tg
->lock
);
387 tgm
->pending_reqs
[is_write
]--;
390 /* The I/O will be executed, so do the accounting */
391 throttle_account(tgm
->throttle_state
, direction
, bytes
);
393 /* Schedule the next request */
394 schedule_next_request(tgm
, is_write
);
396 qemu_mutex_unlock(&tg
->lock
);
400 ThrottleGroupMember
*tgm
;
404 static void coroutine_fn
throttle_group_restart_queue_entry(void *opaque
)
406 RestartData
*data
= opaque
;
407 ThrottleGroupMember
*tgm
= data
->tgm
;
408 ThrottleState
*ts
= tgm
->throttle_state
;
409 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
410 bool is_write
= data
->is_write
;
413 empty_queue
= !throttle_group_co_restart_queue(tgm
, is_write
);
415 /* If the request queue was empty then we have to take care of
416 * scheduling the next one */
418 qemu_mutex_lock(&tg
->lock
);
419 schedule_next_request(tgm
, is_write
);
420 qemu_mutex_unlock(&tg
->lock
);
425 qatomic_dec(&tgm
->restart_pending
);
429 static void throttle_group_restart_queue(ThrottleGroupMember
*tgm
, bool is_write
)
432 RestartData
*rd
= g_new0(RestartData
, 1);
435 rd
->is_write
= is_write
;
437 /* This function is called when a timer is fired or when
438 * throttle_group_restart_tgm() is called. Either way, there can
439 * be no timer pending on this tgm at this point */
440 assert(!timer_pending(tgm
->throttle_timers
.timers
[is_write
]));
442 qatomic_inc(&tgm
->restart_pending
);
444 co
= qemu_coroutine_create(throttle_group_restart_queue_entry
, rd
);
445 aio_co_enter(tgm
->aio_context
, co
);
448 void throttle_group_restart_tgm(ThrottleGroupMember
*tgm
)
452 if (tgm
->throttle_state
) {
453 for (i
= 0; i
< 2; i
++) {
454 QEMUTimer
*t
= tgm
->throttle_timers
.timers
[i
];
455 if (timer_pending(t
)) {
456 /* If there's a pending timer on this tgm, fire it now */
460 /* Else run the next request from the queue manually */
461 throttle_group_restart_queue(tgm
, i
);
467 /* Update the throttle configuration for a particular group. Similar
468 * to throttle_config(), but guarantees atomicity within the
471 * @tgm: a ThrottleGroupMember that is a member of the group
472 * @cfg: the configuration to set
474 void throttle_group_config(ThrottleGroupMember
*tgm
, ThrottleConfig
*cfg
)
476 ThrottleState
*ts
= tgm
->throttle_state
;
477 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
478 qemu_mutex_lock(&tg
->lock
);
479 throttle_config(ts
, tg
->clock_type
, cfg
);
480 qemu_mutex_unlock(&tg
->lock
);
482 throttle_group_restart_tgm(tgm
);
485 /* Get the throttle configuration from a particular group. Similar to
486 * throttle_get_config(), but guarantees atomicity within the
489 * @tgm: a ThrottleGroupMember that is a member of the group
490 * @cfg: the configuration will be written here
492 void throttle_group_get_config(ThrottleGroupMember
*tgm
, ThrottleConfig
*cfg
)
494 ThrottleState
*ts
= tgm
->throttle_state
;
495 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
496 qemu_mutex_lock(&tg
->lock
);
497 throttle_get_config(ts
, cfg
);
498 qemu_mutex_unlock(&tg
->lock
);
501 /* ThrottleTimers callback. This wakes up a request that was waiting
502 * because it had been throttled.
504 * @tgm: the ThrottleGroupMember whose request had been throttled
505 * @is_write: the type of operation (read/write)
507 static void timer_cb(ThrottleGroupMember
*tgm
, bool is_write
)
509 ThrottleState
*ts
= tgm
->throttle_state
;
510 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
512 /* The timer has just been fired, so we can update the flag */
513 qemu_mutex_lock(&tg
->lock
);
514 tg
->any_timer_armed
[is_write
] = false;
515 qemu_mutex_unlock(&tg
->lock
);
517 /* Run the request that was waiting for this timer */
518 throttle_group_restart_queue(tgm
, is_write
);
521 static void read_timer_cb(void *opaque
)
523 timer_cb(opaque
, false);
526 static void write_timer_cb(void *opaque
)
528 timer_cb(opaque
, true);
531 /* Register a ThrottleGroupMember from the throttling group, also initializing
532 * its timers and updating its throttle_state pointer to point to it. If a
533 * throttling group with that name does not exist yet, it will be created.
535 * This function edits throttle_groups and must be called under the global
538 * @tgm: the ThrottleGroupMember to insert
539 * @groupname: the name of the group
540 * @ctx: the AioContext to use
542 void throttle_group_register_tgm(ThrottleGroupMember
*tgm
,
543 const char *groupname
,
547 ThrottleState
*ts
= throttle_group_incref(groupname
);
548 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
550 tgm
->throttle_state
= ts
;
551 tgm
->aio_context
= ctx
;
552 qatomic_set(&tgm
->restart_pending
, 0);
554 QEMU_LOCK_GUARD(&tg
->lock
);
555 /* If the ThrottleGroup is new set this ThrottleGroupMember as the token */
556 for (i
= 0; i
< 2; i
++) {
557 if (!tg
->tokens
[i
]) {
562 QLIST_INSERT_HEAD(&tg
->head
, tgm
, round_robin
);
564 throttle_timers_init(&tgm
->throttle_timers
,
570 qemu_co_mutex_init(&tgm
->throttled_reqs_lock
);
571 qemu_co_queue_init(&tgm
->throttled_reqs
[0]);
572 qemu_co_queue_init(&tgm
->throttled_reqs
[1]);
575 /* Unregister a ThrottleGroupMember from its group, removing it from the list,
576 * destroying the timers and setting the throttle_state pointer to NULL.
578 * The ThrottleGroupMember must not have pending throttled requests, so the
579 * caller has to drain them first.
581 * The group will be destroyed if it's empty after this operation.
583 * @tgm the ThrottleGroupMember to remove
585 void throttle_group_unregister_tgm(ThrottleGroupMember
*tgm
)
587 ThrottleState
*ts
= tgm
->throttle_state
;
588 ThrottleGroup
*tg
= container_of(ts
, ThrottleGroup
, ts
);
589 ThrottleGroupMember
*token
;
593 /* Discard already unregistered tgm */
597 /* Wait for throttle_group_restart_queue_entry() coroutines to finish */
598 AIO_WAIT_WHILE(tgm
->aio_context
, qatomic_read(&tgm
->restart_pending
) > 0);
600 WITH_QEMU_LOCK_GUARD(&tg
->lock
) {
601 for (i
= 0; i
< 2; i
++) {
602 assert(tgm
->pending_reqs
[i
] == 0);
603 assert(qemu_co_queue_empty(&tgm
->throttled_reqs
[i
]));
604 assert(!timer_pending(tgm
->throttle_timers
.timers
[i
]));
605 if (tg
->tokens
[i
] == tgm
) {
606 token
= throttle_group_next_tgm(tgm
);
607 /* Take care of the case where this is the last tgm in the group */
611 tg
->tokens
[i
] = token
;
615 /* remove the current tgm from the list */
616 QLIST_REMOVE(tgm
, round_robin
);
617 throttle_timers_destroy(&tgm
->throttle_timers
);
620 throttle_group_unref(&tg
->ts
);
621 tgm
->throttle_state
= NULL
;
624 void throttle_group_attach_aio_context(ThrottleGroupMember
*tgm
,
625 AioContext
*new_context
)
627 ThrottleTimers
*tt
= &tgm
->throttle_timers
;
628 throttle_timers_attach_aio_context(tt
, new_context
);
629 tgm
->aio_context
= new_context
;
632 void throttle_group_detach_aio_context(ThrottleGroupMember
*tgm
)
634 ThrottleGroup
*tg
= container_of(tgm
->throttle_state
, ThrottleGroup
, ts
);
635 ThrottleTimers
*tt
= &tgm
->throttle_timers
;
638 /* Requests must have been drained */
639 assert(tgm
->pending_reqs
[0] == 0 && tgm
->pending_reqs
[1] == 0);
640 assert(qemu_co_queue_empty(&tgm
->throttled_reqs
[0]));
641 assert(qemu_co_queue_empty(&tgm
->throttled_reqs
[1]));
643 /* Kick off next ThrottleGroupMember, if necessary */
644 WITH_QEMU_LOCK_GUARD(&tg
->lock
) {
645 for (i
= 0; i
< 2; i
++) {
646 if (timer_pending(tt
->timers
[i
])) {
647 tg
->any_timer_armed
[i
] = false;
648 schedule_next_request(tgm
, i
);
653 throttle_timers_detach_aio_context(tt
);
654 tgm
->aio_context
= NULL
;
657 #undef THROTTLE_OPT_PREFIX
658 #define THROTTLE_OPT_PREFIX "x-"
660 /* Helper struct and array for QOM property setter/getter */
672 static ThrottleParamInfo properties
[] = {
674 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL
,
675 THROTTLE_OPS_TOTAL
, AVG
,
678 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX
,
679 THROTTLE_OPS_TOTAL
, MAX
,
682 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_TOTAL_MAX_LENGTH
,
683 THROTTLE_OPS_TOTAL
, BURST_LENGTH
,
686 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ
,
687 THROTTLE_OPS_READ
, AVG
,
690 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX
,
691 THROTTLE_OPS_READ
, MAX
,
694 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_READ_MAX_LENGTH
,
695 THROTTLE_OPS_READ
, BURST_LENGTH
,
698 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE
,
699 THROTTLE_OPS_WRITE
, AVG
,
702 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX
,
703 THROTTLE_OPS_WRITE
, MAX
,
706 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_WRITE_MAX_LENGTH
,
707 THROTTLE_OPS_WRITE
, BURST_LENGTH
,
710 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL
,
711 THROTTLE_BPS_TOTAL
, AVG
,
714 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX
,
715 THROTTLE_BPS_TOTAL
, MAX
,
718 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_TOTAL_MAX_LENGTH
,
719 THROTTLE_BPS_TOTAL
, BURST_LENGTH
,
722 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ
,
723 THROTTLE_BPS_READ
, AVG
,
726 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX
,
727 THROTTLE_BPS_READ
, MAX
,
730 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_READ_MAX_LENGTH
,
731 THROTTLE_BPS_READ
, BURST_LENGTH
,
734 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE
,
735 THROTTLE_BPS_WRITE
, AVG
,
738 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX
,
739 THROTTLE_BPS_WRITE
, MAX
,
742 THROTTLE_OPT_PREFIX QEMU_OPT_BPS_WRITE_MAX_LENGTH
,
743 THROTTLE_BPS_WRITE
, BURST_LENGTH
,
746 THROTTLE_OPT_PREFIX QEMU_OPT_IOPS_SIZE
,
751 /* This function edits throttle_groups and must be called under the global
753 static void throttle_group_obj_init(Object
*obj
)
755 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
757 tg
->clock_type
= QEMU_CLOCK_REALTIME
;
758 if (qtest_enabled()) {
759 /* For testing block IO throttling only */
760 tg
->clock_type
= QEMU_CLOCK_VIRTUAL
;
762 tg
->is_initialized
= false;
763 qemu_mutex_init(&tg
->lock
);
764 throttle_init(&tg
->ts
);
765 QLIST_INIT(&tg
->head
);
768 /* This function edits throttle_groups and must be called under the global
770 static void throttle_group_obj_complete(UserCreatable
*obj
, Error
**errp
)
772 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
775 /* set group name to object id if it exists */
776 if (!tg
->name
&& tg
->parent_obj
.parent
) {
777 tg
->name
= g_strdup(object_get_canonical_path_component(OBJECT(obj
)));
779 /* We must have a group name at this point */
782 /* error if name is duplicate */
783 if (throttle_group_exists(tg
->name
)) {
784 error_setg(errp
, "A group with this name already exists");
789 throttle_get_config(&tg
->ts
, &cfg
);
790 if (!throttle_is_valid(&cfg
, errp
)) {
793 throttle_config(&tg
->ts
, tg
->clock_type
, &cfg
);
794 QTAILQ_INSERT_TAIL(&throttle_groups
, tg
, list
);
795 tg
->is_initialized
= true;
798 /* This function edits throttle_groups and must be called under the global
800 static void throttle_group_obj_finalize(Object
*obj
)
802 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
803 if (tg
->is_initialized
) {
804 QTAILQ_REMOVE(&throttle_groups
, tg
, list
);
806 qemu_mutex_destroy(&tg
->lock
);
810 static void throttle_group_set(Object
*obj
, Visitor
*v
, const char * name
,
811 void *opaque
, Error
**errp
)
814 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
816 ThrottleParamInfo
*info
= opaque
;
819 /* If we have finished initialization, don't accept individual property
820 * changes through QOM. Throttle configuration limits must be set in one
821 * transaction, as certain combinations are invalid.
823 if (tg
->is_initialized
) {
824 error_setg(errp
, "Property cannot be set after initialization");
828 if (!visit_type_int64(v
, name
, &value
, errp
)) {
832 error_setg(errp
, "Property values cannot be negative");
837 switch (info
->category
) {
839 cfg
->buckets
[info
->type
].avg
= value
;
842 cfg
->buckets
[info
->type
].max
= value
;
845 if (value
> UINT_MAX
) {
846 error_setg(errp
, "%s value must be in the" "range [0, %u]",
847 info
->name
, UINT_MAX
);
850 cfg
->buckets
[info
->type
].burst_length
= value
;
853 cfg
->op_size
= value
;
858 static void throttle_group_get(Object
*obj
, Visitor
*v
, const char *name
,
859 void *opaque
, Error
**errp
)
861 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
863 ThrottleParamInfo
*info
= opaque
;
866 throttle_get_config(&tg
->ts
, &cfg
);
867 switch (info
->category
) {
869 value
= cfg
.buckets
[info
->type
].avg
;
872 value
= cfg
.buckets
[info
->type
].max
;
875 value
= cfg
.buckets
[info
->type
].burst_length
;
882 visit_type_int64(v
, name
, &value
, errp
);
885 static void throttle_group_set_limits(Object
*obj
, Visitor
*v
,
886 const char *name
, void *opaque
,
890 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
892 ThrottleLimits
*argp
;
893 Error
*local_err
= NULL
;
895 if (!visit_type_ThrottleLimits(v
, name
, &argp
, errp
)) {
898 qemu_mutex_lock(&tg
->lock
);
899 throttle_get_config(&tg
->ts
, &cfg
);
900 throttle_limits_to_config(argp
, &cfg
, &local_err
);
904 throttle_config(&tg
->ts
, tg
->clock_type
, &cfg
);
907 qemu_mutex_unlock(&tg
->lock
);
908 qapi_free_ThrottleLimits(argp
);
909 error_propagate(errp
, local_err
);
913 static void throttle_group_get_limits(Object
*obj
, Visitor
*v
,
914 const char *name
, void *opaque
,
917 ThrottleGroup
*tg
= THROTTLE_GROUP(obj
);
919 ThrottleLimits arg
= { 0 };
920 ThrottleLimits
*argp
= &arg
;
922 qemu_mutex_lock(&tg
->lock
);
923 throttle_get_config(&tg
->ts
, &cfg
);
924 qemu_mutex_unlock(&tg
->lock
);
926 throttle_config_to_limits(&cfg
, argp
);
928 visit_type_ThrottleLimits(v
, name
, &argp
, errp
);
931 static bool throttle_group_can_be_deleted(UserCreatable
*uc
)
933 return OBJECT(uc
)->ref
== 1;
936 static void throttle_group_obj_class_init(ObjectClass
*klass
, void *class_data
)
939 UserCreatableClass
*ucc
= USER_CREATABLE_CLASS(klass
);
941 ucc
->complete
= throttle_group_obj_complete
;
942 ucc
->can_be_deleted
= throttle_group_can_be_deleted
;
944 /* individual properties */
945 for (i
= 0; i
< sizeof(properties
) / sizeof(ThrottleParamInfo
); i
++) {
946 object_class_property_add(klass
,
951 NULL
, &properties
[i
]);
955 object_class_property_add(klass
,
956 "limits", "ThrottleLimits",
957 throttle_group_get_limits
,
958 throttle_group_set_limits
,
962 static const TypeInfo throttle_group_info
= {
963 .name
= TYPE_THROTTLE_GROUP
,
964 .parent
= TYPE_OBJECT
,
965 .class_init
= throttle_group_obj_class_init
,
966 .instance_size
= sizeof(ThrottleGroup
),
967 .instance_init
= throttle_group_obj_init
,
968 .instance_finalize
= throttle_group_obj_finalize
,
969 .interfaces
= (InterfaceInfo
[]) {
970 { TYPE_USER_CREATABLE
},
975 static void throttle_groups_init(void)
977 type_register_static(&throttle_group_info
);
980 type_init(throttle_groups_init
);