system/qemu
system/qemu
1
0
Fork 0
mirror of https://gitlab.com/qemu-project/qemu synced 2024-07-21 18:34:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

thread-posix: use monotonic clock for QemuCond and QemuSemaphore

Browse source 
Use CLOCK_MONOTONIC, so the timeout isn't affected by changes to
the system time. It depends on the pthread_condattr_setclock(),
while some systems(e.g. mac os) does not support it, so the behavior
won't change in these systems.

Signed-off-by: Longpeng(Mike) <longpeng2@huawei.com>
Message-Id: <20220222090507.2028-3-longpeng2@huawei.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Longpeng(Mike) 2022-02-22 17:05:05 +08:00 committed by Paolo Bonzini
parent f9fc8932b1
commit 657ac98b58
2 changed files with 57 additions and 7 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
meson.build
View file

@ -1780,6 +1780,17 @@ config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_pre
pthread_create(&thread, 0, f, 0); pthread_create(&thread, 0, f, 0);
return 0; return 0;
}''', dependencies: threads)) }''', dependencies: threads))
config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
#include <pthread.h>
#include <time.h>
int main(void)
{
pthread_condattr_t attr
pthread_condattr_init(&attr);
pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
return 0;
}''', dependencies: threads))
config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + ''' config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
#include <sys/signalfd.h> #include <sys/signalfd.h>

53
util/qemu-thread-posix.c
View file

@ -38,12 +38,20 @@ static void error_exit(int err, const char *msg)
abort(); abort();
} }
static inline clockid_t qemu_timedwait_clockid(void)
{
#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
return CLOCK_MONOTONIC;
#else
return CLOCK_REALTIME;
#endif
}
static void compute_abs_deadline(struct timespec *ts, int ms) static void compute_abs_deadline(struct timespec *ts, int ms)
{ {
struct timeval tv; clock_gettime(qemu_timedwait_clockid(), ts);
gettimeofday(&tv, NULL); ts->tv_nsec += (ms % 1000) * 1000000;
ts->tv_nsec = tv.tv_usec * 1000 + (ms % 1000) * 1000000; ts->tv_sec += ms / 1000;
ts->tv_sec = tv.tv_sec + ms / 1000;
if (ts->tv_nsec >= 1000000000) { if (ts->tv_nsec >= 1000000000) {
ts->tv_sec++; ts->tv_sec++;
ts->tv_nsec -= 1000000000; ts->tv_nsec -= 1000000000;
@ -147,11 +155,27 @@ void qemu_rec_mutex_unlock_impl(QemuRecMutex *mutex, const char *file, int line)
void qemu_cond_init(QemuCond *cond) void qemu_cond_init(QemuCond *cond)
{ {
pthread_condattr_t attr;
int err; int err;
err = pthread_cond_init(&cond->cond, NULL); err = pthread_condattr_init(&attr);
if (err) if (err) {
error_exit(err, __func__); error_exit(err, __func__);
}
#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
err = pthread_condattr_setclock(&attr, qemu_timedwait_clockid());
if (err) {
error_exit(err, __func__);
}
#endif
err = pthread_cond_init(&cond->cond, &attr);
if (err) {
error_exit(err, __func__);
}
err = pthread_condattr_destroy(&attr);
if (err) {
error_exit(err, __func__);
}
cond->initialized = true; cond->initialized = true;
} }
@ -217,16 +241,31 @@ bool qemu_cond_timedwait_impl(QemuCond *cond, QemuMutex *mutex, int ms,
void qemu_sem_init(QemuSemaphore *sem, int init) void qemu_sem_init(QemuSemaphore *sem, int init)
{ {
pthread_condattr_t attr;
int rc; int rc;
rc = pthread_mutex_init(&sem->lock, NULL); rc = pthread_mutex_init(&sem->lock, NULL);
if (rc != 0) { if (rc != 0) {
error_exit(rc, __func__); error_exit(rc, __func__);
} }
rc = pthread_cond_init(&sem->cond, NULL); rc = pthread_condattr_init(&attr);
if (rc != 0) { if (rc != 0) {
error_exit(rc, __func__); error_exit(rc, __func__);
} }
#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
rc = pthread_condattr_setclock(&attr, qemu_timedwait_clockid());
if (rc != 0) {
error_exit(rc, __func__);
}
#endif
rc = pthread_cond_init(&sem->cond, &attr);
if (rc != 0) {
error_exit(rc, __func__);
}
rc = pthread_condattr_destroy(&attr);
if (rc < 0) {
error_exit(rc, __func__);
}
if (init < 0) { if (init < 0) {
error_exit(EINVAL, __func__); error_exit(EINVAL, __func__);
} }