1 #ifndef QEMU_THREAD_H 2 #define QEMU_THREAD_H 3 4 #include "qemu/processor.h" 5 #include "qemu/atomic.h" 6 #include "qemu/clang-tsa.h" 7 8 typedef struct QemuCond QemuCond; 9 typedef struct QemuSemaphore QemuSemaphore; 10 typedef struct QemuEvent QemuEvent; 11 typedef struct QemuLockCnt QemuLockCnt; 12 typedef struct QemuThread QemuThread; 13 14 #ifdef _WIN32 15 #include "qemu/thread-win32.h" 16 #else 17 #include "qemu/thread-posix.h" 18 #endif 19 20 /* include QSP header once QemuMutex, QemuCond etc. are defined */ 21 #include "qemu/qsp.h" 22 23 #define QEMU_THREAD_JOINABLE 0 24 #define QEMU_THREAD_DETACHED 1 25 26 void qemu_mutex_init(QemuMutex *mutex); 27 void qemu_mutex_destroy(QemuMutex *mutex); 28 int TSA_NO_TSA qemu_mutex_trylock_impl(QemuMutex *mutex, const char *file, 29 const int line); 30 void TSA_NO_TSA qemu_mutex_lock_impl(QemuMutex *mutex, const char *file, 31 const int line); 32 void TSA_NO_TSA qemu_mutex_unlock_impl(QemuMutex *mutex, const char *file, 33 const int line); 34 35 void qemu_rec_mutex_init(QemuRecMutex *mutex); 36 void qemu_rec_mutex_destroy(QemuRecMutex *mutex); 37 void qemu_rec_mutex_lock_impl(QemuRecMutex *mutex, const char *file, int line); 38 int qemu_rec_mutex_trylock_impl(QemuRecMutex *mutex, const char *file, int line); 39 void qemu_rec_mutex_unlock_impl(QemuRecMutex *mutex, const char *file, int line); 40 41 typedef void (*QemuMutexLockFunc)(QemuMutex *m, const char *f, int l); 42 typedef int (*QemuMutexTrylockFunc)(QemuMutex *m, const char *f, int l); 43 typedef void (*QemuRecMutexLockFunc)(QemuRecMutex *m, const char *f, int l); 44 typedef int (*QemuRecMutexTrylockFunc)(QemuRecMutex *m, const char *f, int l); 45 typedef void (*QemuCondWaitFunc)(QemuCond *c, QemuMutex *m, const char *f, 46 int l); 47 typedef bool (*QemuCondTimedWaitFunc)(QemuCond *c, QemuMutex *m, int ms, 48 const char *f, int l); 49 50 extern QemuMutexLockFunc bql_mutex_lock_func; 51 extern QemuMutexLockFunc qemu_mutex_lock_func; 52 extern QemuMutexTrylockFunc qemu_mutex_trylock_func; 53 extern QemuRecMutexLockFunc qemu_rec_mutex_lock_func; 54 extern QemuRecMutexTrylockFunc qemu_rec_mutex_trylock_func; 55 extern QemuCondWaitFunc qemu_cond_wait_func; 56 extern QemuCondTimedWaitFunc qemu_cond_timedwait_func; 57 58 /* convenience macros to bypass the profiler */ 59 #define qemu_mutex_lock__raw(m) \ 60 qemu_mutex_lock_impl(m, __FILE__, __LINE__) 61 #define qemu_mutex_trylock__raw(m) \ 62 qemu_mutex_trylock_impl(m, __FILE__, __LINE__) 63 64 #ifdef __COVERITY__ 65 /* 66 * Coverity is severely confused by the indirect function calls, 67 * hide them. 68 */ 69 #define qemu_mutex_lock(m) \ 70 qemu_mutex_lock_impl(m, __FILE__, __LINE__) 71 #define qemu_mutex_trylock(m) \ 72 qemu_mutex_trylock_impl(m, __FILE__, __LINE__) 73 #define qemu_rec_mutex_lock(m) \ 74 qemu_rec_mutex_lock_impl(m, __FILE__, __LINE__) 75 #define qemu_rec_mutex_trylock(m) \ 76 qemu_rec_mutex_trylock_impl(m, __FILE__, __LINE__) 77 #define qemu_cond_wait(c, m) \ 78 qemu_cond_wait_impl(c, m, __FILE__, __LINE__) 79 #define qemu_cond_timedwait(c, m, ms) \ 80 qemu_cond_timedwait_impl(c, m, ms, __FILE__, __LINE__) 81 #else 82 #define qemu_mutex_lock(m) ({ \ 83 QemuMutexLockFunc _f = qatomic_read(&qemu_mutex_lock_func); \ 84 _f(m, __FILE__, __LINE__); \ 85 }) 86 87 #define qemu_mutex_trylock(m) ({ \ 88 QemuMutexTrylockFunc _f = qatomic_read(&qemu_mutex_trylock_func); \ 89 _f(m, __FILE__, __LINE__); \ 90 }) 91 92 #define qemu_rec_mutex_lock(m) ({ \ 93 QemuRecMutexLockFunc _f = qatomic_read(&qemu_rec_mutex_lock_func);\ 94 _f(m, __FILE__, __LINE__); \ 95 }) 96 97 #define qemu_rec_mutex_trylock(m) ({ \ 98 QemuRecMutexTrylockFunc _f; \ 99 _f = qatomic_read(&qemu_rec_mutex_trylock_func); \ 100 _f(m, __FILE__, __LINE__); \ 101 }) 102 103 #define qemu_cond_wait(c, m) ({ \ 104 QemuCondWaitFunc _f = qatomic_read(&qemu_cond_wait_func); \ 105 _f(c, m, __FILE__, __LINE__); \ 106 }) 107 108 #define qemu_cond_timedwait(c, m, ms) ({ \ 109 QemuCondTimedWaitFunc _f = qatomic_read(&qemu_cond_timedwait_func);\ 110 _f(c, m, ms, __FILE__, __LINE__); \ 111 }) 112 #endif 113 114 #define qemu_mutex_unlock(mutex) \ 115 qemu_mutex_unlock_impl(mutex, __FILE__, __LINE__) 116 117 #define qemu_rec_mutex_unlock(mutex) \ 118 qemu_rec_mutex_unlock_impl(mutex, __FILE__, __LINE__) 119 120 static inline void (qemu_mutex_lock)(QemuMutex *mutex) 121 { 122 qemu_mutex_lock(mutex); 123 } 124 125 static inline int (qemu_mutex_trylock)(QemuMutex *mutex) 126 { 127 return qemu_mutex_trylock(mutex); 128 } 129 130 static inline void (qemu_mutex_unlock)(QemuMutex *mutex) 131 { 132 qemu_mutex_unlock(mutex); 133 } 134 135 static inline void (qemu_rec_mutex_lock)(QemuRecMutex *mutex) 136 { 137 qemu_rec_mutex_lock(mutex); 138 } 139 140 static inline int (qemu_rec_mutex_trylock)(QemuRecMutex *mutex) 141 { 142 return qemu_rec_mutex_trylock(mutex); 143 } 144 145 static inline void (qemu_rec_mutex_unlock)(QemuRecMutex *mutex) 146 { 147 qemu_rec_mutex_unlock(mutex); 148 } 149 150 void qemu_cond_init(QemuCond *cond); 151 void qemu_cond_destroy(QemuCond *cond); 152 153 /* 154 * IMPORTANT: The implementation does not guarantee that pthread_cond_signal 155 * and pthread_cond_broadcast can be called except while the same mutex is 156 * held as in the corresponding pthread_cond_wait calls! 157 */ 158 void qemu_cond_signal(QemuCond *cond); 159 void qemu_cond_broadcast(QemuCond *cond); 160 void TSA_NO_TSA qemu_cond_wait_impl(QemuCond *cond, QemuMutex *mutex, 161 const char *file, const int line); 162 bool qemu_cond_timedwait_impl(QemuCond *cond, QemuMutex *mutex, int ms, 163 const char *file, const int line); 164 165 static inline void (qemu_cond_wait)(QemuCond *cond, QemuMutex *mutex) 166 { 167 qemu_cond_wait(cond, mutex); 168 } 169 170 /* Returns true if timeout has not expired, and false otherwise */ 171 static inline bool (qemu_cond_timedwait)(QemuCond *cond, QemuMutex *mutex, 172 int ms) 173 { 174 return qemu_cond_timedwait(cond, mutex, ms); 175 } 176 177 void qemu_sem_init(QemuSemaphore *sem, int init); 178 void qemu_sem_post(QemuSemaphore *sem); 179 void qemu_sem_wait(QemuSemaphore *sem); 180 int qemu_sem_timedwait(QemuSemaphore *sem, int ms); 181 void qemu_sem_destroy(QemuSemaphore *sem); 182 183 void qemu_event_init(QemuEvent *ev, bool init); 184 void qemu_event_set(QemuEvent *ev); 185 void qemu_event_reset(QemuEvent *ev); 186 void qemu_event_wait(QemuEvent *ev); 187 void qemu_event_destroy(QemuEvent *ev); 188 189 void qemu_thread_create(QemuThread *thread, const char *name, 190 void *(*start_routine)(void *), 191 void *arg, int mode); 192 int qemu_thread_set_affinity(QemuThread *thread, unsigned long *host_cpus, 193 unsigned long nbits); 194 int qemu_thread_get_affinity(QemuThread *thread, unsigned long **host_cpus, 195 unsigned long *nbits); 196 void *qemu_thread_join(QemuThread *thread); 197 void qemu_thread_get_self(QemuThread *thread); 198 bool qemu_thread_is_self(QemuThread *thread); 199 G_NORETURN void qemu_thread_exit(void *retval); 200 void qemu_thread_naming(bool enable); 201 202 struct Notifier; 203 /** 204 * qemu_thread_atexit_add: 205 * @notifier: Notifier to add 206 * 207 * Add the specified notifier to a list which will be run via 208 * notifier_list_notify() when this thread exits (either by calling 209 * qemu_thread_exit() or by returning from its start_routine). 210 * The usual usage is that the caller passes a Notifier which is 211 * a per-thread variable; it can then use the callback to free 212 * other per-thread data. 213 * 214 * If the thread exits as part of the entire process exiting, 215 * it is unspecified whether notifiers are called or not. 216 */ 217 void qemu_thread_atexit_add(struct Notifier *notifier); 218 /** 219 * qemu_thread_atexit_remove: 220 * @notifier: Notifier to remove 221 * 222 * Remove the specified notifier from the thread-exit notification 223 * list. It is not valid to try to remove a notifier which is not 224 * on the list. 225 */ 226 void qemu_thread_atexit_remove(struct Notifier *notifier); 227 228 #ifdef CONFIG_TSAN 229 #include <sanitizer/tsan_interface.h> 230 #endif 231 232 struct QemuSpin { 233 int value; 234 }; 235 236 static inline void qemu_spin_init(QemuSpin *spin) 237 { 238 qatomic_set(&spin->value, 0); 239 #ifdef CONFIG_TSAN 240 __tsan_mutex_create(spin, __tsan_mutex_not_static); 241 #endif 242 } 243 244 static inline void qemu_spin_destroy(QemuSpin *spin) 245 { 246 #ifdef CONFIG_TSAN 247 __tsan_mutex_destroy(spin, __tsan_mutex_not_static); 248 #endif 249 } 250 251 static inline void qemu_spin_lock(QemuSpin *spin) 252 { 253 #ifdef CONFIG_TSAN 254 __tsan_mutex_pre_lock(spin, 0); 255 #endif 256 while (unlikely(qatomic_xchg(&spin->value, 1))) { 257 while (qatomic_read(&spin->value)) { 258 cpu_relax(); 259 } 260 } 261 #ifdef CONFIG_TSAN 262 __tsan_mutex_post_lock(spin, 0, 0); 263 #endif 264 } 265 266 static inline bool qemu_spin_trylock(QemuSpin *spin) 267 { 268 #ifdef CONFIG_TSAN 269 __tsan_mutex_pre_lock(spin, __tsan_mutex_try_lock); 270 #endif 271 bool busy = qatomic_xchg(&spin->value, true); 272 #ifdef CONFIG_TSAN 273 unsigned flags = __tsan_mutex_try_lock; 274 flags |= busy ? __tsan_mutex_try_lock_failed : 0; 275 __tsan_mutex_post_lock(spin, flags, 0); 276 #endif 277 return busy; 278 } 279 280 static inline bool qemu_spin_locked(QemuSpin *spin) 281 { 282 return qatomic_read(&spin->value); 283 } 284 285 static inline void qemu_spin_unlock(QemuSpin *spin) 286 { 287 #ifdef CONFIG_TSAN 288 __tsan_mutex_pre_unlock(spin, 0); 289 #endif 290 qatomic_store_release(&spin->value, 0); 291 #ifdef CONFIG_TSAN 292 __tsan_mutex_post_unlock(spin, 0); 293 #endif 294 } 295 296 struct QemuLockCnt { 297 #ifndef CONFIG_LINUX 298 QemuMutex mutex; 299 #endif 300 unsigned count; 301 }; 302 303 /** 304 * qemu_lockcnt_init: initialize a QemuLockcnt 305 * @lockcnt: the lockcnt to initialize 306 * 307 * Initialize lockcnt's counter to zero and prepare its mutex 308 * for usage. 309 */ 310 void qemu_lockcnt_init(QemuLockCnt *lockcnt); 311 312 /** 313 * qemu_lockcnt_destroy: destroy a QemuLockcnt 314 * @lockcnt: the lockcnt to destruct 315 * 316 * Destroy lockcnt's mutex. 317 */ 318 void qemu_lockcnt_destroy(QemuLockCnt *lockcnt); 319 320 /** 321 * qemu_lockcnt_inc: increment a QemuLockCnt's counter 322 * @lockcnt: the lockcnt to operate on 323 * 324 * If the lockcnt's count is zero, wait for critical sections 325 * to finish and increment lockcnt's count to 1. If the count 326 * is not zero, just increment it. 327 * 328 * Because this function can wait on the mutex, it must not be 329 * called while the lockcnt's mutex is held by the current thread. 330 * For the same reason, qemu_lockcnt_inc can also contribute to 331 * AB-BA deadlocks. This is a sample deadlock scenario: 332 * 333 * thread 1 thread 2 334 * ------------------------------------------------------- 335 * qemu_lockcnt_lock(&lc1); 336 * qemu_lockcnt_lock(&lc2); 337 * qemu_lockcnt_inc(&lc2); 338 * qemu_lockcnt_inc(&lc1); 339 */ 340 void qemu_lockcnt_inc(QemuLockCnt *lockcnt); 341 342 /** 343 * qemu_lockcnt_dec: decrement a QemuLockCnt's counter 344 * @lockcnt: the lockcnt to operate on 345 */ 346 void qemu_lockcnt_dec(QemuLockCnt *lockcnt); 347 348 /** 349 * qemu_lockcnt_dec_and_lock: decrement a QemuLockCnt's counter and 350 * possibly lock it. 351 * @lockcnt: the lockcnt to operate on 352 * 353 * Decrement lockcnt's count. If the new count is zero, lock 354 * the mutex and return true. Otherwise, return false. 355 */ 356 bool qemu_lockcnt_dec_and_lock(QemuLockCnt *lockcnt); 357 358 /** 359 * qemu_lockcnt_dec_if_lock: possibly decrement a QemuLockCnt's counter and 360 * lock it. 361 * @lockcnt: the lockcnt to operate on 362 * 363 * If the count is 1, decrement the count to zero, lock 364 * the mutex and return true. Otherwise, return false. 365 */ 366 bool qemu_lockcnt_dec_if_lock(QemuLockCnt *lockcnt); 367 368 /** 369 * qemu_lockcnt_lock: lock a QemuLockCnt's mutex. 370 * @lockcnt: the lockcnt to operate on 371 * 372 * Remember that concurrent visits are not blocked unless the count is 373 * also zero. You can use qemu_lockcnt_count to check for this inside a 374 * critical section. 375 */ 376 void qemu_lockcnt_lock(QemuLockCnt *lockcnt); 377 378 /** 379 * qemu_lockcnt_unlock: release a QemuLockCnt's mutex. 380 * @lockcnt: the lockcnt to operate on. 381 */ 382 void qemu_lockcnt_unlock(QemuLockCnt *lockcnt); 383 384 /** 385 * qemu_lockcnt_inc_and_unlock: combined unlock/increment on a QemuLockCnt. 386 * @lockcnt: the lockcnt to operate on. 387 * 388 * This is the same as 389 * 390 * qemu_lockcnt_unlock(lockcnt); 391 * qemu_lockcnt_inc(lockcnt); 392 * 393 * but more efficient. 394 */ 395 void qemu_lockcnt_inc_and_unlock(QemuLockCnt *lockcnt); 396 397 /** 398 * qemu_lockcnt_count: query a LockCnt's count. 399 * @lockcnt: the lockcnt to query. 400 * 401 * Note that the count can change at any time. Still, while the 402 * lockcnt is locked, one can usefully check whether the count 403 * is non-zero. 404 */ 405 unsigned qemu_lockcnt_count(QemuLockCnt *lockcnt); 406 407 #endif 408