]>
Commit | Line | Data |
---|---|---|
2ff1f2e3 AG |
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 | ||
80c71a24 | 25 | #include "qemu/osdep.h" |
31dce3cc | 26 | #include "sysemu/block-backend.h" |
2ff1f2e3 | 27 | #include "block/throttle-groups.h" |
76f4afb4 AG |
28 | #include "qemu/queue.h" |
29 | #include "qemu/thread.h" | |
30 | #include "sysemu/qtest.h" | |
2ff1f2e3 AG |
31 | |
32 | /* The ThrottleGroup structure (with its ThrottleState) is shared | |
27ccdd52 | 33 | * among different BlockBackends and it's independent from |
2ff1f2e3 AG |
34 | * AioContext, so in order to use it from different threads it needs |
35 | * its own locking. | |
36 | * | |
37 | * This locking is however handled internally in this file, so it's | |
d87d01e1 | 38 | * transparent to outside users. |
2ff1f2e3 AG |
39 | * |
40 | * The whole ThrottleGroup structure is private and invisible to | |
41 | * outside users, that only use it through its ThrottleState. | |
42 | * | |
27ccdd52 | 43 | * In addition to the ThrottleGroup structure, BlockBackendPublic has |
2ff1f2e3 | 44 | * fields that need to be accessed by other members of the group and |
27ccdd52 KW |
45 | * therefore also need to be protected by this lock. Once a |
46 | * BlockBackend is registered in a group those fields can be accessed | |
47 | * by other threads any time. | |
2ff1f2e3 AG |
48 | * |
49 | * Again, all this is handled internally and is mostly transparent to | |
50 | * the outside. The 'throttle_timers' field however has an additional | |
51 | * constraint because it may be temporarily invalid (see for example | |
52 | * bdrv_set_aio_context()). Therefore in this file a thread will | |
27ccdd52 KW |
53 | * access some other BlockBackend's timers only after verifying that |
54 | * that BlockBackend has throttled requests in the queue. | |
2ff1f2e3 AG |
55 | */ |
56 | typedef struct ThrottleGroup { | |
57 | char *name; /* This is constant during the lifetime of the group */ | |
58 | ||
59 | QemuMutex lock; /* This lock protects the following four fields */ | |
60 | ThrottleState ts; | |
31dce3cc KW |
61 | QLIST_HEAD(, BlockBackendPublic) head; |
62 | BlockBackend *tokens[2]; | |
2ff1f2e3 AG |
63 | bool any_timer_armed[2]; |
64 | ||
65 | /* These two are protected by the global throttle_groups_lock */ | |
66 | unsigned refcount; | |
67 | QTAILQ_ENTRY(ThrottleGroup) list; | |
68 | } ThrottleGroup; | |
69 | ||
70 | static QemuMutex throttle_groups_lock; | |
71 | static QTAILQ_HEAD(, ThrottleGroup) throttle_groups = | |
72 | QTAILQ_HEAD_INITIALIZER(throttle_groups); | |
73 | ||
74 | /* Increments the reference count of a ThrottleGroup given its name. | |
75 | * | |
76 | * If no ThrottleGroup is found with the given name a new one is | |
77 | * created. | |
78 | * | |
79 | * @name: the name of the ThrottleGroup | |
973f2ddf | 80 | * @ret: the ThrottleState member of the ThrottleGroup |
2ff1f2e3 | 81 | */ |
973f2ddf | 82 | ThrottleState *throttle_group_incref(const char *name) |
2ff1f2e3 AG |
83 | { |
84 | ThrottleGroup *tg = NULL; | |
85 | ThrottleGroup *iter; | |
86 | ||
87 | qemu_mutex_lock(&throttle_groups_lock); | |
88 | ||
89 | /* Look for an existing group with that name */ | |
90 | QTAILQ_FOREACH(iter, &throttle_groups, list) { | |
91 | if (!strcmp(name, iter->name)) { | |
92 | tg = iter; | |
93 | break; | |
94 | } | |
95 | } | |
96 | ||
97 | /* Create a new one if not found */ | |
98 | if (!tg) { | |
99 | tg = g_new0(ThrottleGroup, 1); | |
100 | tg->name = g_strdup(name); | |
101 | qemu_mutex_init(&tg->lock); | |
102 | throttle_init(&tg->ts); | |
103 | QLIST_INIT(&tg->head); | |
104 | ||
105 | QTAILQ_INSERT_TAIL(&throttle_groups, tg, list); | |
106 | } | |
107 | ||
108 | tg->refcount++; | |
109 | ||
110 | qemu_mutex_unlock(&throttle_groups_lock); | |
111 | ||
973f2ddf | 112 | return &tg->ts; |
2ff1f2e3 AG |
113 | } |
114 | ||
115 | /* Decrease the reference count of a ThrottleGroup. | |
116 | * | |
117 | * When the reference count reaches zero the ThrottleGroup is | |
118 | * destroyed. | |
119 | * | |
973f2ddf | 120 | * @ts: The ThrottleGroup to unref, given by its ThrottleState member |
2ff1f2e3 | 121 | */ |
973f2ddf | 122 | void throttle_group_unref(ThrottleState *ts) |
2ff1f2e3 | 123 | { |
973f2ddf HR |
124 | ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); |
125 | ||
2ff1f2e3 AG |
126 | qemu_mutex_lock(&throttle_groups_lock); |
127 | if (--tg->refcount == 0) { | |
128 | QTAILQ_REMOVE(&throttle_groups, tg, list); | |
129 | qemu_mutex_destroy(&tg->lock); | |
130 | g_free(tg->name); | |
131 | g_free(tg); | |
132 | } | |
133 | qemu_mutex_unlock(&throttle_groups_lock); | |
134 | } | |
135 | ||
49d2165d KW |
136 | /* Get the name from a BlockBackend's ThrottleGroup. The name (and the pointer) |
137 | * is guaranteed to remain constant during the lifetime of the group. | |
2ff1f2e3 | 138 | * |
49d2165d | 139 | * @blk: a BlockBackend that is member of a throttling group |
2ff1f2e3 AG |
140 | * @ret: the name of the group. |
141 | */ | |
49d2165d | 142 | const char *throttle_group_get_name(BlockBackend *blk) |
2ff1f2e3 | 143 | { |
27ccdd52 KW |
144 | BlockBackendPublic *blkp = blk_get_public(blk); |
145 | ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); | |
2ff1f2e3 AG |
146 | return tg->name; |
147 | } | |
148 | ||
31dce3cc KW |
149 | /* Return the next BlockBackend in the round-robin sequence, simulating a |
150 | * circular list. | |
2ff1f2e3 AG |
151 | * |
152 | * This assumes that tg->lock is held. | |
153 | * | |
31dce3cc KW |
154 | * @blk: the current BlockBackend |
155 | * @ret: the next BlockBackend in the sequence | |
2ff1f2e3 | 156 | */ |
31dce3cc | 157 | static BlockBackend *throttle_group_next_blk(BlockBackend *blk) |
2ff1f2e3 | 158 | { |
27ccdd52 KW |
159 | BlockBackendPublic *blkp = blk_get_public(blk); |
160 | ThrottleState *ts = blkp->throttle_state; | |
2ff1f2e3 | 161 | ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); |
27ccdd52 | 162 | BlockBackendPublic *next = QLIST_NEXT(blkp, round_robin); |
2ff1f2e3 AG |
163 | |
164 | if (!next) { | |
31dce3cc | 165 | next = QLIST_FIRST(&tg->head); |
2ff1f2e3 AG |
166 | } |
167 | ||
31dce3cc | 168 | return blk_by_public(next); |
2ff1f2e3 AG |
169 | } |
170 | ||
31dce3cc KW |
171 | /* Return the next BlockBackend in the round-robin sequence with pending I/O |
172 | * requests. | |
76f4afb4 AG |
173 | * |
174 | * This assumes that tg->lock is held. | |
175 | * | |
31dce3cc | 176 | * @blk: the current BlockBackend |
76f4afb4 | 177 | * @is_write: the type of operation (read/write) |
31dce3cc KW |
178 | * @ret: the next BlockBackend with pending requests, or blk if there is |
179 | * none. | |
76f4afb4 | 180 | */ |
31dce3cc | 181 | static BlockBackend *next_throttle_token(BlockBackend *blk, bool is_write) |
76f4afb4 | 182 | { |
27ccdd52 KW |
183 | BlockBackendPublic *blkp = blk_get_public(blk); |
184 | ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); | |
31dce3cc | 185 | BlockBackend *token, *start; |
76f4afb4 AG |
186 | |
187 | start = token = tg->tokens[is_write]; | |
188 | ||
189 | /* get next bs round in round robin style */ | |
31dce3cc | 190 | token = throttle_group_next_blk(token); |
27ccdd52 | 191 | while (token != start && !blkp->pending_reqs[is_write]) { |
31dce3cc | 192 | token = throttle_group_next_blk(token); |
76f4afb4 AG |
193 | } |
194 | ||
195 | /* If no IO are queued for scheduling on the next round robin token | |
196 | * then decide the token is the current bs because chances are | |
197 | * the current bs get the current request queued. | |
198 | */ | |
27ccdd52 | 199 | if (token == start && !blkp->pending_reqs[is_write]) { |
31dce3cc | 200 | token = blk; |
76f4afb4 AG |
201 | } |
202 | ||
203 | return token; | |
204 | } | |
205 | ||
31dce3cc KW |
206 | /* Check if the next I/O request for a BlockBackend needs to be throttled or |
207 | * not. If there's no timer set in this group, set one and update the token | |
208 | * accordingly. | |
76f4afb4 AG |
209 | * |
210 | * This assumes that tg->lock is held. | |
211 | * | |
31dce3cc | 212 | * @blk: the current BlockBackend |
76f4afb4 AG |
213 | * @is_write: the type of operation (read/write) |
214 | * @ret: whether the I/O request needs to be throttled or not | |
215 | */ | |
31dce3cc | 216 | static bool throttle_group_schedule_timer(BlockBackend *blk, bool is_write) |
76f4afb4 | 217 | { |
27ccdd52 KW |
218 | BlockBackendPublic *blkp = blk_get_public(blk); |
219 | ThrottleState *ts = blkp->throttle_state; | |
220 | ThrottleTimers *tt = &blkp->throttle_timers; | |
76f4afb4 AG |
221 | ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); |
222 | bool must_wait; | |
223 | ||
27ccdd52 | 224 | if (blkp->io_limits_disabled) { |
ce0f1412 PB |
225 | return false; |
226 | } | |
227 | ||
76f4afb4 AG |
228 | /* Check if any of the timers in this group is already armed */ |
229 | if (tg->any_timer_armed[is_write]) { | |
230 | return true; | |
231 | } | |
232 | ||
233 | must_wait = throttle_schedule_timer(ts, tt, is_write); | |
234 | ||
31dce3cc | 235 | /* If a timer just got armed, set blk as the current token */ |
76f4afb4 | 236 | if (must_wait) { |
31dce3cc | 237 | tg->tokens[is_write] = blk; |
76f4afb4 AG |
238 | tg->any_timer_armed[is_write] = true; |
239 | } | |
240 | ||
241 | return must_wait; | |
242 | } | |
243 | ||
244 | /* Look for the next pending I/O request and schedule it. | |
245 | * | |
246 | * This assumes that tg->lock is held. | |
247 | * | |
31dce3cc | 248 | * @blk: the current BlockBackend |
76f4afb4 AG |
249 | * @is_write: the type of operation (read/write) |
250 | */ | |
31dce3cc | 251 | static void schedule_next_request(BlockBackend *blk, bool is_write) |
76f4afb4 | 252 | { |
27ccdd52 KW |
253 | BlockBackendPublic *blkp = blk_get_public(blk); |
254 | ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); | |
76f4afb4 | 255 | bool must_wait; |
31dce3cc | 256 | BlockBackend *token; |
76f4afb4 AG |
257 | |
258 | /* Check if there's any pending request to schedule next */ | |
31dce3cc | 259 | token = next_throttle_token(blk, is_write); |
27ccdd52 | 260 | if (!blkp->pending_reqs[is_write]) { |
76f4afb4 AG |
261 | return; |
262 | } | |
263 | ||
264 | /* Set a timer for the request if it needs to be throttled */ | |
265 | must_wait = throttle_group_schedule_timer(token, is_write); | |
266 | ||
267 | /* If it doesn't have to wait, queue it for immediate execution */ | |
268 | if (!must_wait) { | |
27ccdd52 | 269 | /* Give preference to requests from the current blk */ |
76f4afb4 | 270 | if (qemu_in_coroutine() && |
27ccdd52 | 271 | qemu_co_queue_next(&blkp->throttled_reqs[is_write])) { |
31dce3cc | 272 | token = blk; |
76f4afb4 | 273 | } else { |
27ccdd52 | 274 | ThrottleTimers *tt = &blkp->throttle_timers; |
76f4afb4 AG |
275 | int64_t now = qemu_clock_get_ns(tt->clock_type); |
276 | timer_mod(tt->timers[is_write], now + 1); | |
277 | tg->any_timer_armed[is_write] = true; | |
278 | } | |
279 | tg->tokens[is_write] = token; | |
280 | } | |
281 | } | |
282 | ||
283 | /* Check if an I/O request needs to be throttled, wait and set a timer | |
284 | * if necessary, and schedule the next request using a round robin | |
285 | * algorithm. | |
286 | * | |
287 | * @bs: the current BlockDriverState | |
288 | * @bytes: the number of bytes for this I/O | |
289 | * @is_write: the type of operation (read/write) | |
290 | */ | |
291 | void coroutine_fn throttle_group_co_io_limits_intercept(BlockDriverState *bs, | |
292 | unsigned int bytes, | |
293 | bool is_write) | |
294 | { | |
295 | bool must_wait; | |
31dce3cc | 296 | BlockBackend *token; |
76f4afb4 | 297 | |
27ccdd52 KW |
298 | BlockBackend *blk = bs->blk; |
299 | BlockBackendPublic *blkp = blk_get_public(blk); | |
300 | ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); | |
76f4afb4 AG |
301 | qemu_mutex_lock(&tg->lock); |
302 | ||
303 | /* First we check if this I/O has to be throttled. */ | |
27ccdd52 | 304 | token = next_throttle_token(blk, is_write); |
76f4afb4 AG |
305 | must_wait = throttle_group_schedule_timer(token, is_write); |
306 | ||
307 | /* Wait if there's a timer set or queued requests of this type */ | |
27ccdd52 KW |
308 | if (must_wait || blkp->pending_reqs[is_write]) { |
309 | blkp->pending_reqs[is_write]++; | |
76f4afb4 | 310 | qemu_mutex_unlock(&tg->lock); |
27ccdd52 | 311 | qemu_co_queue_wait(&blkp->throttled_reqs[is_write]); |
76f4afb4 | 312 | qemu_mutex_lock(&tg->lock); |
27ccdd52 | 313 | blkp->pending_reqs[is_write]--; |
76f4afb4 AG |
314 | } |
315 | ||
316 | /* The I/O will be executed, so do the accounting */ | |
27ccdd52 | 317 | throttle_account(blkp->throttle_state, is_write, bytes); |
76f4afb4 AG |
318 | |
319 | /* Schedule the next request */ | |
27ccdd52 | 320 | schedule_next_request(blk, is_write); |
76f4afb4 AG |
321 | |
322 | qemu_mutex_unlock(&tg->lock); | |
323 | } | |
324 | ||
27ccdd52 | 325 | void throttle_group_restart_blk(BlockBackend *blk) |
a72f6414 | 326 | { |
27ccdd52 | 327 | BlockBackendPublic *blkp = blk_get_public(blk); |
a72f6414 PB |
328 | int i; |
329 | ||
330 | for (i = 0; i < 2; i++) { | |
27ccdd52 | 331 | while (qemu_co_enter_next(&blkp->throttled_reqs[i])) { |
a72f6414 PB |
332 | ; |
333 | } | |
334 | } | |
335 | } | |
336 | ||
2ff1f2e3 AG |
337 | /* Update the throttle configuration for a particular group. Similar |
338 | * to throttle_config(), but guarantees atomicity within the | |
339 | * throttling group. | |
340 | * | |
341 | * @bs: a BlockDriverState that is member of the group | |
342 | * @cfg: the configuration to set | |
343 | */ | |
344 | void throttle_group_config(BlockDriverState *bs, ThrottleConfig *cfg) | |
345 | { | |
27ccdd52 KW |
346 | BlockBackendPublic *blkp = blk_get_public(bs->blk); |
347 | ThrottleTimers *tt = &blkp->throttle_timers; | |
348 | ThrottleState *ts = blkp->throttle_state; | |
2ff1f2e3 AG |
349 | ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); |
350 | qemu_mutex_lock(&tg->lock); | |
2ff1f2e3 | 351 | /* throttle_config() cancels the timers */ |
2f388b93 AG |
352 | if (timer_pending(tt->timers[0])) { |
353 | tg->any_timer_armed[0] = false; | |
354 | } | |
355 | if (timer_pending(tt->timers[1])) { | |
356 | tg->any_timer_armed[1] = false; | |
357 | } | |
358 | throttle_config(ts, tt, cfg); | |
2ff1f2e3 | 359 | qemu_mutex_unlock(&tg->lock); |
a72f6414 | 360 | |
27ccdd52 KW |
361 | qemu_co_enter_next(&blkp->throttled_reqs[0]); |
362 | qemu_co_enter_next(&blkp->throttled_reqs[1]); | |
2ff1f2e3 AG |
363 | } |
364 | ||
365 | /* Get the throttle configuration from a particular group. Similar to | |
366 | * throttle_get_config(), but guarantees atomicity within the | |
367 | * throttling group. | |
368 | * | |
369 | * @bs: a BlockDriverState that is member of the group | |
370 | * @cfg: the configuration will be written here | |
371 | */ | |
372 | void throttle_group_get_config(BlockDriverState *bs, ThrottleConfig *cfg) | |
373 | { | |
27ccdd52 KW |
374 | BlockBackendPublic *blkp = blk_get_public(bs->blk); |
375 | ThrottleState *ts = blkp->throttle_state; | |
2ff1f2e3 AG |
376 | ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); |
377 | qemu_mutex_lock(&tg->lock); | |
378 | throttle_get_config(ts, cfg); | |
379 | qemu_mutex_unlock(&tg->lock); | |
380 | } | |
381 | ||
76f4afb4 AG |
382 | /* ThrottleTimers callback. This wakes up a request that was waiting |
383 | * because it had been throttled. | |
384 | * | |
27ccdd52 | 385 | * @blk: the BlockBackend whose request had been throttled |
76f4afb4 AG |
386 | * @is_write: the type of operation (read/write) |
387 | */ | |
27ccdd52 | 388 | static void timer_cb(BlockBackend *blk, bool is_write) |
76f4afb4 | 389 | { |
27ccdd52 KW |
390 | BlockBackendPublic *blkp = blk_get_public(blk); |
391 | ThrottleState *ts = blkp->throttle_state; | |
76f4afb4 AG |
392 | ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); |
393 | bool empty_queue; | |
394 | ||
395 | /* The timer has just been fired, so we can update the flag */ | |
396 | qemu_mutex_lock(&tg->lock); | |
397 | tg->any_timer_armed[is_write] = false; | |
398 | qemu_mutex_unlock(&tg->lock); | |
399 | ||
400 | /* Run the request that was waiting for this timer */ | |
27ccdd52 | 401 | empty_queue = !qemu_co_enter_next(&blkp->throttled_reqs[is_write]); |
76f4afb4 AG |
402 | |
403 | /* If the request queue was empty then we have to take care of | |
404 | * scheduling the next one */ | |
405 | if (empty_queue) { | |
406 | qemu_mutex_lock(&tg->lock); | |
27ccdd52 | 407 | schedule_next_request(blk, is_write); |
76f4afb4 AG |
408 | qemu_mutex_unlock(&tg->lock); |
409 | } | |
410 | } | |
411 | ||
412 | static void read_timer_cb(void *opaque) | |
413 | { | |
414 | timer_cb(opaque, false); | |
415 | } | |
416 | ||
417 | static void write_timer_cb(void *opaque) | |
418 | { | |
419 | timer_cb(opaque, true); | |
420 | } | |
421 | ||
31dce3cc KW |
422 | /* Register a BlockBackend in the throttling group, also initializing its |
423 | * timers and updating its throttle_state pointer to point to it. If a | |
424 | * throttling group with that name does not exist yet, it will be created. | |
2ff1f2e3 | 425 | * |
31dce3cc | 426 | * @blk: the BlockBackend to insert |
2ff1f2e3 AG |
427 | * @groupname: the name of the group |
428 | */ | |
31dce3cc | 429 | void throttle_group_register_blk(BlockBackend *blk, const char *groupname) |
2ff1f2e3 AG |
430 | { |
431 | int i; | |
27ccdd52 | 432 | BlockBackendPublic *blkp = blk_get_public(blk); |
973f2ddf HR |
433 | ThrottleState *ts = throttle_group_incref(groupname); |
434 | ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); | |
76f4afb4 AG |
435 | int clock_type = QEMU_CLOCK_REALTIME; |
436 | ||
437 | if (qtest_enabled()) { | |
438 | /* For testing block IO throttling only */ | |
439 | clock_type = QEMU_CLOCK_VIRTUAL; | |
440 | } | |
2ff1f2e3 | 441 | |
27ccdd52 | 442 | blkp->throttle_state = ts; |
2ff1f2e3 AG |
443 | |
444 | qemu_mutex_lock(&tg->lock); | |
31dce3cc | 445 | /* If the ThrottleGroup is new set this BlockBackend as the token */ |
2ff1f2e3 AG |
446 | for (i = 0; i < 2; i++) { |
447 | if (!tg->tokens[i]) { | |
31dce3cc | 448 | tg->tokens[i] = blk; |
2ff1f2e3 AG |
449 | } |
450 | } | |
451 | ||
27ccdd52 | 452 | QLIST_INSERT_HEAD(&tg->head, blkp, round_robin); |
76f4afb4 | 453 | |
27ccdd52 KW |
454 | throttle_timers_init(&blkp->throttle_timers, |
455 | blk_get_aio_context(blk), | |
76f4afb4 AG |
456 | clock_type, |
457 | read_timer_cb, | |
458 | write_timer_cb, | |
27ccdd52 | 459 | blk); |
76f4afb4 | 460 | |
2ff1f2e3 AG |
461 | qemu_mutex_unlock(&tg->lock); |
462 | } | |
463 | ||
31dce3cc KW |
464 | /* Unregister a BlockBackend from its group, removing it from the list, |
465 | * destroying the timers and setting the throttle_state pointer to NULL. | |
2ff1f2e3 | 466 | * |
31dce3cc KW |
467 | * The BlockBackend must not have pending throttled requests, so the caller has |
468 | * to drain them first. | |
5ac72418 | 469 | * |
2ff1f2e3 AG |
470 | * The group will be destroyed if it's empty after this operation. |
471 | * | |
31dce3cc | 472 | * @blk: the BlockBackend to remove |
2ff1f2e3 | 473 | */ |
31dce3cc | 474 | void throttle_group_unregister_blk(BlockBackend *blk) |
2ff1f2e3 | 475 | { |
27ccdd52 KW |
476 | BlockBackendPublic *blkp = blk_get_public(blk); |
477 | ThrottleGroup *tg = container_of(blkp->throttle_state, ThrottleGroup, ts); | |
2ff1f2e3 AG |
478 | int i; |
479 | ||
27ccdd52 KW |
480 | assert(blkp->pending_reqs[0] == 0 && blkp->pending_reqs[1] == 0); |
481 | assert(qemu_co_queue_empty(&blkp->throttled_reqs[0])); | |
482 | assert(qemu_co_queue_empty(&blkp->throttled_reqs[1])); | |
5ac72418 | 483 | |
2ff1f2e3 AG |
484 | qemu_mutex_lock(&tg->lock); |
485 | for (i = 0; i < 2; i++) { | |
31dce3cc KW |
486 | if (tg->tokens[i] == blk) { |
487 | BlockBackend *token = throttle_group_next_blk(blk); | |
27ccdd52 | 488 | /* Take care of the case where this is the last blk in the group */ |
31dce3cc | 489 | if (token == blk) { |
2ff1f2e3 AG |
490 | token = NULL; |
491 | } | |
492 | tg->tokens[i] = token; | |
493 | } | |
494 | } | |
495 | ||
27ccdd52 KW |
496 | /* remove the current blk from the list */ |
497 | QLIST_REMOVE(blkp, round_robin); | |
498 | throttle_timers_destroy(&blkp->throttle_timers); | |
2ff1f2e3 AG |
499 | qemu_mutex_unlock(&tg->lock); |
500 | ||
973f2ddf | 501 | throttle_group_unref(&tg->ts); |
27ccdd52 | 502 | blkp->throttle_state = NULL; |
2ff1f2e3 AG |
503 | } |
504 | ||
505 | static void throttle_groups_init(void) | |
506 | { | |
507 | qemu_mutex_init(&throttle_groups_lock); | |
508 | } | |
509 | ||
510 | block_init(throttle_groups_init); |