From bb756eebdac6fd24e8919e2c43f7d2c8c4091f59 Mon Sep 17 00:00:00 2001 From: RajithaY Date: Tue, 25 Apr 2017 03:31:15 -0700 Subject: Adding qemu as a submodule of KVMFORNFV This Patch includes the changes to add qemu as a submodule to kvmfornfv repo and make use of the updated latest qemu for the execution of all testcase Change-Id: I1280af507a857675c7f81d30c95255635667bdd7 Signed-off-by:RajithaY --- qemu/block/throttle-groups.c | 483 ------------------------------------------- 1 file changed, 483 deletions(-) delete mode 100644 qemu/block/throttle-groups.c (limited to 'qemu/block/throttle-groups.c') diff --git a/qemu/block/throttle-groups.c b/qemu/block/throttle-groups.c deleted file mode 100644 index 4920e0949..000000000 --- a/qemu/block/throttle-groups.c +++ /dev/null @@ -1,483 +0,0 @@ -/* - * QEMU block throttling group infrastructure - * - * Copyright (C) Nodalink, EURL. 2014 - * Copyright (C) Igalia, S.L. 2015 - * - * Authors: - * Benoît Canet - * Alberto Garcia - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation; either version 2 or - * (at your option) version 3 of the License. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, see . - */ - -#include "qemu/osdep.h" -#include "block/throttle-groups.h" -#include "qemu/queue.h" -#include "qemu/thread.h" -#include "sysemu/qtest.h" - -/* The ThrottleGroup structure (with its ThrottleState) is shared - * among different BlockDriverState and it's independent from - * AioContext, so in order to use it from different threads it needs - * its own locking. - * - * This locking is however handled internally in this file, so it's - * transparent to outside users. - * - * The whole ThrottleGroup structure is private and invisible to - * outside users, that only use it through its ThrottleState. - * - * In addition to the ThrottleGroup structure, BlockDriverState has - * fields that need to be accessed by other members of the group and - * therefore also need to be protected by this lock. Once a BDS is - * registered in a group those fields can be accessed by other threads - * any time. - * - * Again, all this is handled internally and is mostly transparent to - * the outside. The 'throttle_timers' field however has an additional - * constraint because it may be temporarily invalid (see for example - * bdrv_set_aio_context()). Therefore in this file a thread will - * access some other BDS's timers only after verifying that that BDS - * has throttled requests in the queue. - */ -typedef struct ThrottleGroup { - char *name; /* This is constant during the lifetime of the group */ - - QemuMutex lock; /* This lock protects the following four fields */ - ThrottleState ts; - QLIST_HEAD(, BlockDriverState) head; - BlockDriverState *tokens[2]; - bool any_timer_armed[2]; - - /* These two are protected by the global throttle_groups_lock */ - unsigned refcount; - QTAILQ_ENTRY(ThrottleGroup) list; -} ThrottleGroup; - -static QemuMutex throttle_groups_lock; -static QTAILQ_HEAD(, ThrottleGroup) throttle_groups = - QTAILQ_HEAD_INITIALIZER(throttle_groups); - -/* Increments the reference count of a ThrottleGroup given its name. - * - * If no ThrottleGroup is found with the given name a new one is - * created. - * - * @name: the name of the ThrottleGroup - * @ret: the ThrottleState member of the ThrottleGroup - */ -ThrottleState *throttle_group_incref(const char *name) -{ - ThrottleGroup *tg = NULL; - ThrottleGroup *iter; - - qemu_mutex_lock(&throttle_groups_lock); - - /* Look for an existing group with that name */ - QTAILQ_FOREACH(iter, &throttle_groups, list) { - if (!strcmp(name, iter->name)) { - tg = iter; - break; - } - } - - /* Create a new one if not found */ - if (!tg) { - tg = g_new0(ThrottleGroup, 1); - tg->name = g_strdup(name); - qemu_mutex_init(&tg->lock); - throttle_init(&tg->ts); - QLIST_INIT(&tg->head); - - QTAILQ_INSERT_TAIL(&throttle_groups, tg, list); - } - - tg->refcount++; - - qemu_mutex_unlock(&throttle_groups_lock); - - return &tg->ts; -} - -/* Decrease the reference count of a ThrottleGroup. - * - * When the reference count reaches zero the ThrottleGroup is - * destroyed. - * - * @ts: The ThrottleGroup to unref, given by its ThrottleState member - */ -void throttle_group_unref(ThrottleState *ts) -{ - ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - - qemu_mutex_lock(&throttle_groups_lock); - if (--tg->refcount == 0) { - QTAILQ_REMOVE(&throttle_groups, tg, list); - qemu_mutex_destroy(&tg->lock); - g_free(tg->name); - g_free(tg); - } - qemu_mutex_unlock(&throttle_groups_lock); -} - -/* Get the name from a BlockDriverState's ThrottleGroup. The name (and - * the pointer) is guaranteed to remain constant during the lifetime - * of the group. - * - * @bs: a BlockDriverState that is member of a throttling group - * @ret: the name of the group. - */ -const char *throttle_group_get_name(BlockDriverState *bs) -{ - ThrottleGroup *tg = container_of(bs->throttle_state, ThrottleGroup, ts); - return tg->name; -} - -/* Return the next BlockDriverState in the round-robin sequence, - * simulating a circular list. - * - * This assumes that tg->lock is held. - * - * @bs: the current BlockDriverState - * @ret: the next BlockDriverState in the sequence - */ -static BlockDriverState *throttle_group_next_bs(BlockDriverState *bs) -{ - ThrottleState *ts = bs->throttle_state; - ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - BlockDriverState *next = QLIST_NEXT(bs, round_robin); - - if (!next) { - return QLIST_FIRST(&tg->head); - } - - return next; -} - -/* Return the next BlockDriverState in the round-robin sequence with - * pending I/O requests. - * - * This assumes that tg->lock is held. - * - * @bs: the current BlockDriverState - * @is_write: the type of operation (read/write) - * @ret: the next BlockDriverState with pending requests, or bs - * if there is none. - */ -static BlockDriverState *next_throttle_token(BlockDriverState *bs, - bool is_write) -{ - ThrottleGroup *tg = container_of(bs->throttle_state, ThrottleGroup, ts); - BlockDriverState *token, *start; - - start = token = tg->tokens[is_write]; - - /* get next bs round in round robin style */ - token = throttle_group_next_bs(token); - while (token != start && !token->pending_reqs[is_write]) { - token = throttle_group_next_bs(token); - } - - /* If no IO are queued for scheduling on the next round robin token - * then decide the token is the current bs because chances are - * the current bs get the current request queued. - */ - if (token == start && !token->pending_reqs[is_write]) { - token = bs; - } - - return token; -} - -/* Check if the next I/O request for a BlockDriverState needs to be - * throttled or not. If there's no timer set in this group, set one - * and update the token accordingly. - * - * This assumes that tg->lock is held. - * - * @bs: the current BlockDriverState - * @is_write: the type of operation (read/write) - * @ret: whether the I/O request needs to be throttled or not - */ -static bool throttle_group_schedule_timer(BlockDriverState *bs, - bool is_write) -{ - ThrottleState *ts = bs->throttle_state; - ThrottleTimers *tt = &bs->throttle_timers; - ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - bool must_wait; - - /* Check if any of the timers in this group is already armed */ - if (tg->any_timer_armed[is_write]) { - return true; - } - - must_wait = throttle_schedule_timer(ts, tt, is_write); - - /* If a timer just got armed, set bs as the current token */ - if (must_wait) { - tg->tokens[is_write] = bs; - tg->any_timer_armed[is_write] = true; - } - - return must_wait; -} - -/* Look for the next pending I/O request and schedule it. - * - * This assumes that tg->lock is held. - * - * @bs: the current BlockDriverState - * @is_write: the type of operation (read/write) - */ -static void schedule_next_request(BlockDriverState *bs, bool is_write) -{ - ThrottleGroup *tg = container_of(bs->throttle_state, ThrottleGroup, ts); - bool must_wait; - BlockDriverState *token; - - /* Check if there's any pending request to schedule next */ - token = next_throttle_token(bs, is_write); - if (!token->pending_reqs[is_write]) { - return; - } - - /* Set a timer for the request if it needs to be throttled */ - must_wait = throttle_group_schedule_timer(token, is_write); - - /* If it doesn't have to wait, queue it for immediate execution */ - if (!must_wait) { - /* Give preference to requests from the current bs */ - if (qemu_in_coroutine() && - qemu_co_queue_next(&bs->throttled_reqs[is_write])) { - token = bs; - } else { - ThrottleTimers *tt = &token->throttle_timers; - int64_t now = qemu_clock_get_ns(tt->clock_type); - timer_mod(tt->timers[is_write], now + 1); - tg->any_timer_armed[is_write] = true; - } - tg->tokens[is_write] = token; - } -} - -/* Check if an I/O request needs to be throttled, wait and set a timer - * if necessary, and schedule the next request using a round robin - * algorithm. - * - * @bs: the current BlockDriverState - * @bytes: the number of bytes for this I/O - * @is_write: the type of operation (read/write) - */ -void coroutine_fn throttle_group_co_io_limits_intercept(BlockDriverState *bs, - unsigned int bytes, - bool is_write) -{ - bool must_wait; - BlockDriverState *token; - - ThrottleGroup *tg = container_of(bs->throttle_state, ThrottleGroup, ts); - qemu_mutex_lock(&tg->lock); - - /* First we check if this I/O has to be throttled. */ - token = next_throttle_token(bs, is_write); - must_wait = throttle_group_schedule_timer(token, is_write); - - /* Wait if there's a timer set or queued requests of this type */ - if (must_wait || bs->pending_reqs[is_write]) { - bs->pending_reqs[is_write]++; - qemu_mutex_unlock(&tg->lock); - qemu_co_queue_wait(&bs->throttled_reqs[is_write]); - qemu_mutex_lock(&tg->lock); - bs->pending_reqs[is_write]--; - } - - /* The I/O will be executed, so do the accounting */ - throttle_account(bs->throttle_state, is_write, bytes); - - /* Schedule the next request */ - schedule_next_request(bs, is_write); - - qemu_mutex_unlock(&tg->lock); -} - -/* Update the throttle configuration for a particular group. Similar - * to throttle_config(), but guarantees atomicity within the - * throttling group. - * - * @bs: a BlockDriverState that is member of the group - * @cfg: the configuration to set - */ -void throttle_group_config(BlockDriverState *bs, ThrottleConfig *cfg) -{ - ThrottleTimers *tt = &bs->throttle_timers; - ThrottleState *ts = bs->throttle_state; - ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - qemu_mutex_lock(&tg->lock); - /* throttle_config() cancels the timers */ - if (timer_pending(tt->timers[0])) { - tg->any_timer_armed[0] = false; - } - if (timer_pending(tt->timers[1])) { - tg->any_timer_armed[1] = false; - } - throttle_config(ts, tt, cfg); - qemu_mutex_unlock(&tg->lock); -} - -/* Get the throttle configuration from a particular group. Similar to - * throttle_get_config(), but guarantees atomicity within the - * throttling group. - * - * @bs: a BlockDriverState that is member of the group - * @cfg: the configuration will be written here - */ -void throttle_group_get_config(BlockDriverState *bs, ThrottleConfig *cfg) -{ - ThrottleState *ts = bs->throttle_state; - ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - qemu_mutex_lock(&tg->lock); - throttle_get_config(ts, cfg); - qemu_mutex_unlock(&tg->lock); -} - -/* ThrottleTimers callback. This wakes up a request that was waiting - * because it had been throttled. - * - * @bs: the BlockDriverState whose request had been throttled - * @is_write: the type of operation (read/write) - */ -static void timer_cb(BlockDriverState *bs, bool is_write) -{ - ThrottleState *ts = bs->throttle_state; - ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - bool empty_queue; - - /* The timer has just been fired, so we can update the flag */ - qemu_mutex_lock(&tg->lock); - tg->any_timer_armed[is_write] = false; - qemu_mutex_unlock(&tg->lock); - - /* Run the request that was waiting for this timer */ - empty_queue = !qemu_co_enter_next(&bs->throttled_reqs[is_write]); - - /* If the request queue was empty then we have to take care of - * scheduling the next one */ - if (empty_queue) { - qemu_mutex_lock(&tg->lock); - schedule_next_request(bs, is_write); - qemu_mutex_unlock(&tg->lock); - } -} - -static void read_timer_cb(void *opaque) -{ - timer_cb(opaque, false); -} - -static void write_timer_cb(void *opaque) -{ - timer_cb(opaque, true); -} - -/* Register a BlockDriverState in the throttling group, also - * initializing its timers and updating its throttle_state pointer to - * point to it. If a throttling group with that name does not exist - * yet, it will be created. - * - * @bs: the BlockDriverState to insert - * @groupname: the name of the group - */ -void throttle_group_register_bs(BlockDriverState *bs, const char *groupname) -{ - int i; - ThrottleState *ts = throttle_group_incref(groupname); - ThrottleGroup *tg = container_of(ts, ThrottleGroup, ts); - int clock_type = QEMU_CLOCK_REALTIME; - - if (qtest_enabled()) { - /* For testing block IO throttling only */ - clock_type = QEMU_CLOCK_VIRTUAL; - } - - bs->throttle_state = ts; - - qemu_mutex_lock(&tg->lock); - /* If the ThrottleGroup is new set this BlockDriverState as the token */ - for (i = 0; i < 2; i++) { - if (!tg->tokens[i]) { - tg->tokens[i] = bs; - } - } - - QLIST_INSERT_HEAD(&tg->head, bs, round_robin); - - throttle_timers_init(&bs->throttle_timers, - bdrv_get_aio_context(bs), - clock_type, - read_timer_cb, - write_timer_cb, - bs); - - qemu_mutex_unlock(&tg->lock); -} - -/* Unregister a BlockDriverState from its group, removing it from the - * list, destroying the timers and setting the throttle_state pointer - * to NULL. - * - * The BlockDriverState must not have pending throttled requests, so - * the caller has to drain them first. - * - * The group will be destroyed if it's empty after this operation. - * - * @bs: the BlockDriverState to remove - */ -void throttle_group_unregister_bs(BlockDriverState *bs) -{ - ThrottleGroup *tg = container_of(bs->throttle_state, ThrottleGroup, ts); - int i; - - assert(bs->pending_reqs[0] == 0 && bs->pending_reqs[1] == 0); - assert(qemu_co_queue_empty(&bs->throttled_reqs[0])); - assert(qemu_co_queue_empty(&bs->throttled_reqs[1])); - - qemu_mutex_lock(&tg->lock); - for (i = 0; i < 2; i++) { - if (tg->tokens[i] == bs) { - BlockDriverState *token = throttle_group_next_bs(bs); - /* Take care of the case where this is the last bs in the group */ - if (token == bs) { - token = NULL; - } - tg->tokens[i] = token; - } - } - - /* remove the current bs from the list */ - QLIST_REMOVE(bs, round_robin); - throttle_timers_destroy(&bs->throttle_timers); - qemu_mutex_unlock(&tg->lock); - - throttle_group_unref(&tg->ts); - bs->throttle_state = NULL; -} - -static void throttle_groups_init(void) -{ - qemu_mutex_init(&throttle_groups_lock); -} - -block_init(throttle_groups_init); -- cgit 1.2.3-korg