friedkiwi/qemu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "rcu: Unify force quiescent state"

Browse Source 
This reverts commit 55d98e3ede.

The commit introduced a regression in the replay functional test
on alpha (tests/functional/alpha/test_replay.py), that causes CI
failures regularly. Thus revert this change until someone has
figured out what is going wrong here.

Buglink: https://gitlab.com/qemu-project/qemu/-/issues/3197
Reviewed-by: Akihiko Odaki <odaki@rsg.ci.i.u-tokyo.ac.jp>
Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-ID: <20260209120336.41454-1-thuth@redhat.com>
This commit is contained in:
Thomas Huth
2026-02-09 13:03:36 +01:00
parent 00ebc44514
commit ddb4d9d174
1 changed files with 28 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
util/rcu.c
View File

@@ -43,14 +43,10 @@
#define RCU_GP_LOCKED (1UL << 0)
#define RCU_GP_CTR (1UL << 1)
#define RCU_CALL_MIN_SIZE 30
unsigned long rcu_gp_ctr = RCU_GP_LOCKED;
QemuEvent rcu_gp_event;
static int in_drain_call_rcu;
static int rcu_call_count;
static QemuMutex rcu_registry_lock;
static QemuMutex rcu_sync_lock;
@@ -80,29 +76,15 @@ static void wait_for_readers(void)
{
ThreadList qsreaders = QLIST_HEAD_INITIALIZER(qsreaders);
struct rcu_reader_data *index, *tmp;
int sleeps = 0;
bool forced = false;
for (;;) {
/*
* Force the grace period to end and wait for it if any of the
* following heuristical conditions are satisfied:
* - A decent number of callbacks piled up.
* - It timed out.
* - It is in a drain_call_rcu() call.
*
* Otherwise, periodically poll the grace period, hoping it ends
* promptly.
/* We want to be notified of changes made to rcu_gp_ongoing
* while we walk the list.
*/
if (!forced &&
(qatomic_read(&rcu_call_count) >= RCU_CALL_MIN_SIZE ||
sleeps >= 5 || qatomic_read(&in_drain_call_rcu))) {
forced = true;
qemu_event_reset(&rcu_gp_event);
QLIST_FOREACH(index, &registry, node) {
notifier_list_notify(&index->force_rcu, NULL);
qatomic_set(&index->waiting, true);
}
QLIST_FOREACH(index, &registry, node) {
qatomic_set(&index->waiting, true);
}
/* Here, order the stores to index->waiting before the loads of
@@ -124,6 +106,8 @@ static void wait_for_readers(void)
* get some extra futex wakeups.
*/
qatomic_set(&index->waiting, false);
} else if (qatomic_read(&in_drain_call_rcu)) {
notifier_list_notify(&index->force_rcu, NULL);
}
}
@@ -131,8 +115,7 @@ static void wait_for_readers(void)
break;
}
/*
* Sleep for a while and try again.
/* Wait for one thread to report a quiescent state and try again.
* Release rcu_registry_lock, so rcu_(un)register_thread() doesn't
* wait too much time.
*
@@ -150,20 +133,7 @@ static void wait_for_readers(void)
* rcu_registry_lock is released.
*/
qemu_mutex_unlock(&rcu_registry_lock);
if (forced) {
qemu_event_wait(&rcu_gp_event);
/*
* We want to be notified of changes made to rcu_gp_ongoing
* while we walk the list.
*/
qemu_event_reset(&rcu_gp_event);
} else {
g_usleep(10000);
sleeps++;
}
qemu_event_wait(&rcu_gp_event);
qemu_mutex_lock(&rcu_registry_lock);
}
@@ -203,11 +173,15 @@ void synchronize_rcu(void)
}
}
#define RCU_CALL_MIN_SIZE 30
/* Multi-producer, single-consumer queue based on urcu/static/wfqueue.h
* from liburcu. Note that head is only used by the consumer.
*/
static struct rcu_head dummy;
static struct rcu_head *head = &dummy, **tail = &dummy.next;
static int rcu_call_count;
static QemuEvent rcu_call_ready_event;
static void enqueue(struct rcu_head *node)
@@ -285,27 +259,30 @@ static void *call_rcu_thread(void *opaque)
rcu_register_thread();
for (;;) {
int n;
int tries = 0;
int n = qatomic_read(&rcu_call_count);
/*
/* Heuristically wait for a decent number of callbacks to pile up.
* Fetch rcu_call_count now, we only must process elements that were
* added before synchronize_rcu() starts.
*/
for (;;) {
qemu_event_reset(&rcu_call_ready_event);
n = qatomic_read(&rcu_call_count);
if (n) {
break;
}
while (n == 0 || (n < RCU_CALL_MIN_SIZE && ++tries <= 5)) {
g_usleep(10000);
if (n == 0) {
qemu_event_reset(&rcu_call_ready_event);
n = qatomic_read(&rcu_call_count);
if (n == 0) {
#if defined(CONFIG_MALLOC_TRIM)
malloc_trim(4 * 1024 * 1024);
malloc_trim(4 * 1024 * 1024);
#endif
qemu_event_wait(&rcu_call_ready_event);
qemu_event_wait(&rcu_call_ready_event);
}
}
n = qatomic_read(&rcu_call_count);
}
synchronize_rcu();
qatomic_sub(&rcu_call_count, n);
synchronize_rcu();
bql_lock();
while (n > 0) {
node = try_dequeue();