1 #ifndef QEMU_THREAD_H 2 #define QEMU_THREAD_H 3 4 #include "qemu/processor.h" 5 #include "qemu/atomic.h" 6 7 typedef struct QemuMutex QemuMutex; 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 #define QEMU_THREAD_JOINABLE 0 21 #define QEMU_THREAD_DETACHED 1 22 23 void qemu_mutex_init(QemuMutex *mutex); 24 void qemu_mutex_destroy(QemuMutex *mutex); 25 void qemu_mutex_lock(QemuMutex *mutex); 26 int qemu_mutex_trylock(QemuMutex *mutex); 27 void qemu_mutex_unlock(QemuMutex *mutex); 28 29 /* Prototypes for other functions are in thread-posix.h/thread-win32.h. */ 30 void qemu_rec_mutex_init(QemuRecMutex *mutex); 31 32 void qemu_cond_init(QemuCond *cond); 33 void qemu_cond_destroy(QemuCond *cond); 34 35 /* 36 * IMPORTANT: The implementation does not guarantee that pthread_cond_signal 37 * and pthread_cond_broadcast can be called except while the same mutex is 38 * held as in the corresponding pthread_cond_wait calls! 39 */ 40 void qemu_cond_signal(QemuCond *cond); 41 void qemu_cond_broadcast(QemuCond *cond); 42 void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex); 43 44 void qemu_sem_init(QemuSemaphore *sem, int init); 45 void qemu_sem_post(QemuSemaphore *sem); 46 void qemu_sem_wait(QemuSemaphore *sem); 47 int qemu_sem_timedwait(QemuSemaphore *sem, int ms); 48 void qemu_sem_destroy(QemuSemaphore *sem); 49 50 void qemu_event_init(QemuEvent *ev, bool init); 51 void qemu_event_set(QemuEvent *ev); 52 void qemu_event_reset(QemuEvent *ev); 53 void qemu_event_wait(QemuEvent *ev); 54 void qemu_event_destroy(QemuEvent *ev); 55 56 void qemu_thread_create(QemuThread *thread, const char *name, 57 void *(*start_routine)(void *), 58 void *arg, int mode); 59 void *qemu_thread_join(QemuThread *thread); 60 void qemu_thread_get_self(QemuThread *thread); 61 bool qemu_thread_is_self(QemuThread *thread); 62 void qemu_thread_exit(void *retval); 63 void qemu_thread_naming(bool enable); 64 65 struct Notifier; 66 void qemu_thread_atexit_add(struct Notifier *notifier); 67 void qemu_thread_atexit_remove(struct Notifier *notifier); 68 69 typedef struct QemuSpin { 70 int value; 71 } QemuSpin; 72 73 static inline void qemu_spin_init(QemuSpin *spin) 74 { 75 __sync_lock_release(&spin->value); 76 } 77 78 static inline void qemu_spin_lock(QemuSpin *spin) 79 { 80 while (unlikely(__sync_lock_test_and_set(&spin->value, true))) { 81 while (atomic_read(&spin->value)) { 82 cpu_relax(); 83 } 84 } 85 } 86 87 static inline bool qemu_spin_trylock(QemuSpin *spin) 88 { 89 return __sync_lock_test_and_set(&spin->value, true); 90 } 91 92 static inline bool qemu_spin_locked(QemuSpin *spin) 93 { 94 return atomic_read(&spin->value); 95 } 96 97 static inline void qemu_spin_unlock(QemuSpin *spin) 98 { 99 __sync_lock_release(&spin->value); 100 } 101 102 struct QemuLockCnt { 103 #ifndef CONFIG_LINUX 104 QemuMutex mutex; 105 #endif 106 unsigned count; 107 }; 108 109 /** 110 * qemu_lockcnt_init: initialize a QemuLockcnt 111 * @lockcnt: the lockcnt to initialize 112 * 113 * Initialize lockcnt's counter to zero and prepare its mutex 114 * for usage. 115 */ 116 void qemu_lockcnt_init(QemuLockCnt *lockcnt); 117 118 /** 119 * qemu_lockcnt_destroy: destroy a QemuLockcnt 120 * @lockcnt: the lockcnt to destruct 121 * 122 * Destroy lockcnt's mutex. 123 */ 124 void qemu_lockcnt_destroy(QemuLockCnt *lockcnt); 125 126 /** 127 * qemu_lockcnt_inc: increment a QemuLockCnt's counter 128 * @lockcnt: the lockcnt to operate on 129 * 130 * If the lockcnt's count is zero, wait for critical sections 131 * to finish and increment lockcnt's count to 1. If the count 132 * is not zero, just increment it. 133 * 134 * Because this function can wait on the mutex, it must not be 135 * called while the lockcnt's mutex is held by the current thread. 136 * For the same reason, qemu_lockcnt_inc can also contribute to 137 * AB-BA deadlocks. This is a sample deadlock scenario: 138 * 139 * thread 1 thread 2 140 * ------------------------------------------------------- 141 * qemu_lockcnt_lock(&lc1); 142 * qemu_lockcnt_lock(&lc2); 143 * qemu_lockcnt_inc(&lc2); 144 * qemu_lockcnt_inc(&lc1); 145 */ 146 void qemu_lockcnt_inc(QemuLockCnt *lockcnt); 147 148 /** 149 * qemu_lockcnt_dec: decrement a QemuLockCnt's counter 150 * @lockcnt: the lockcnt to operate on 151 */ 152 void qemu_lockcnt_dec(QemuLockCnt *lockcnt); 153 154 /** 155 * qemu_lockcnt_dec_and_lock: decrement a QemuLockCnt's counter and 156 * possibly lock it. 157 * @lockcnt: the lockcnt to operate on 158 * 159 * Decrement lockcnt's count. If the new count is zero, lock 160 * the mutex and return true. Otherwise, return false. 161 */ 162 bool qemu_lockcnt_dec_and_lock(QemuLockCnt *lockcnt); 163 164 /** 165 * qemu_lockcnt_dec_if_lock: possibly decrement a QemuLockCnt's counter and 166 * lock it. 167 * @lockcnt: the lockcnt to operate on 168 * 169 * If the count is 1, decrement the count to zero, lock 170 * the mutex and return true. Otherwise, return false. 171 */ 172 bool qemu_lockcnt_dec_if_lock(QemuLockCnt *lockcnt); 173 174 /** 175 * qemu_lockcnt_lock: lock a QemuLockCnt's mutex. 176 * @lockcnt: the lockcnt to operate on 177 * 178 * Remember that concurrent visits are not blocked unless the count is 179 * also zero. You can use qemu_lockcnt_count to check for this inside a 180 * critical section. 181 */ 182 void qemu_lockcnt_lock(QemuLockCnt *lockcnt); 183 184 /** 185 * qemu_lockcnt_unlock: release a QemuLockCnt's mutex. 186 * @lockcnt: the lockcnt to operate on. 187 */ 188 void qemu_lockcnt_unlock(QemuLockCnt *lockcnt); 189 190 /** 191 * qemu_lockcnt_inc_and_unlock: combined unlock/increment on a QemuLockCnt. 192 * @lockcnt: the lockcnt to operate on. 193 * 194 * This is the same as 195 * 196 * qemu_lockcnt_unlock(lockcnt); 197 * qemu_lockcnt_inc(lockcnt); 198 * 199 * but more efficient. 200 */ 201 void qemu_lockcnt_inc_and_unlock(QemuLockCnt *lockcnt); 202 203 /** 204 * qemu_lockcnt_count: query a LockCnt's count. 205 * @lockcnt: the lockcnt to query. 206 * 207 * Note that the count can change at any time. Still, while the 208 * lockcnt is locked, one can usefully check whether the count 209 * is non-zero. 210 */ 211 unsigned qemu_lockcnt_count(QemuLockCnt *lockcnt); 212 213 #endif 214