[PATCH 0/6] MR6307: Draft: wine: Use atomic locks insted pthread_mutex v2.

[Grigory Vasilyev (＠h0tc0d3)]

I'm not sure about the need for this solution, so it's a **DRAFT**. For me it is an academic interest to check whether atomic locks will give advantages over pthread_mutex in games. Need to think about tests that can actually be measured.

Before build need define `USE_AFL`.

```bash
export CFLAGS="${CFLAGS} -DUSE_AFL"
```

Old: https://gitlab.winehq.org/wine/wine/-/merge_requests/6031

v2 Changes: 
- Implemented different types of mutexes, and converted the code to use gcc extensions instead of C11.
- Added tests and implemented as a separate library for testing. For tests, need to disable cpufreq scheduler and any power management, otherwise the tests will be unstable. https://github.com/h0tc0d3/afl
- Depending on the processor, a regular mutex can be slightly faster or slightly slower. The recursive mutex used in ntdll is more than 2 times faster, and slightly faster with a simple lock-unlock.

TODO:
- Condvar and RWlocks. With condvar there is a problem of preemption of lower priority threads by a higher priority thread. PI mutex allows to avoid this and takes into account the order, but works much slower. It is not yet entirely clear which condvar is better to use in wine. https://sourceware.org/bugzilla/show_bug.cgi?id=11588 https://static.lwn.net/images/conf/rtlws11/papers/proc/p10.pd

- Try to speed up windows synchronization primitives. At this point, I don't quite understand how this works and why the ntsync implementation uses server and vanilla wine doesn't. I would appreciate any help if it would be possible to improve the performance of synchronization primitives by implementing atomic structures.

[PATCH 1/6] include: Define custom mutex macroses.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 include/Makefile.in  |   1 +
 include/wine/afl.h   | 589 +++++++++++++++++++++++++++++++++++++++++++
 include/wine/mutex.h |  69 +++++
 3 files changed, 659 insertions(+)
 create mode 100644 include/wine/afl.h
 create mode 100644 include/wine/mutex.h

diff --git a/include/Makefile.in b/include/Makefile.in
index bbf28cfc87e..84742dded5c 100644
--- a/include/Makefile.in
+++ b/include/Makefile.in
@@ -920,6 +920,7 @@ SOURCES = \
    wine/mmsystem16.h \
    wine/mscvpdb.h \
    wine/mssign.h \
+	wine/mutex.h \
    wine/nsi.h \
    wine/orpc.idl \
    wine/plugplay.idl \
diff --git a/include/wine/afl.h b/include/wine/afl.h
new file mode 100644
index 00000000000..a37932e3860
--- /dev/null
+++ b/include/wine/afl.h
@@ -0,0 +1,589 @@
+#ifndef __AFL_H
+#define __AFL_H
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <stdatomic.h>
+#include <sys/types.h>
+#include <sys/syscall.h>
+#include <linux/futex.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ * Allow the compiler to optimize for the case where paths of execution including that statement
+ * are more or less likely than any alternative path of execution that does not include such a statement.
+ *
+ * Example:
+ *
+ * int f1(uint32_t *val) {
+ *
+ *     uint32_t lock;
+ *
+ *     __atomic_load(val, &lock, __ATOMIC_RELAXED);
+ *
+ *     if(__likely(lock == 1))
+ *         goto success;
+ *
+ *     asm volatile("movq $100, %%rcx;rep nop;" ::: "rcx", "memory");
+ *
+ * success:
+ *     return 0;
+ * }
+ *
+ * -------------------------
+ *
+ *     movl    (%rdi), %eax
+ *     cmpl    $1, %eax
+ *     jne     .not_success
+ *     xorl    %eax, %eax
+ *     retq
+ *
+ * .not_success:
+ *     movq    $100, %rcx
+ *     rep     nop
+ *     xorl    %eax, %eax
+ *     retq
+ *
+ * -------------------------
+ *
+ * int f2(uint32_t *val) {
+ *
+ *     uint32_t lock;
+ *
+ *     __atomic_load(val, &lock, __ATOMIC_RELAXED);
+ *
+ *     if(__unlikely(lock == 1))
+ *         goto success;
+ *
+ *     asm volatile("movq $100, %%rcx;rep nop;" ::: "rcx", "memory");
+ *
+ * success:
+ *     return 0;
+ * }
+ *
+ * -------------------------
+ *
+ *     movl    (%rdi), %eax
+ *     cmpl    $1, %eax
+ *     je      .success
+ *     movq    $100, %rcx
+ *     rep     nop
+ *
+ * .success:
+ *     xorl    %eax, %eax
+ *     retq
+ *
+ */
+#define __afl_unlikely(condition) __builtin_expect((condition), 0)
+#define __afl_likely(condition) __builtin_expect((condition), 1)
+
+/*
+ * Debug Atomic Fast Locks
+ */
+#ifdef AFL_DEBUG
+#define __afl_debug(condition, text)                                       \
+    if (__afl_unlikely(condition)) {                                       \
+        fprintf(stderr, "[ERROR] (%s:%d) %s\n", __FILE__, __LINE__, text); \
+    }
+#define __afl_syscall_check_errors(ret)                                                  \
+    if (__afl_unlikely(ret <= -4095)) {                                                  \
+        fprintf(stderr, "[ERROR] (%s:%d) syscall error: %d\n", __FILE__, __LINE__, ret); \
+    }
+#else
+#define __afl_debug(condition, text)
+#define __afl_syscall_check_errors(ret)
+#endif
+
+/*
+ * Pause Thread
+ *
+ * Improves the performance of spin-wait loops. When executing a "spin-wait loop",
+ * processors will suffer a severe performance penalty when exiting the loop because it detects a possible memory order violation.
+ * The PAUSE instruction provides a hint to the processor that the code sequence is a spin-wait loop.
+ * The processor uses this hint to avoid the memory order violation in most situations,
+ * which greatly improves processor performance. For this reason,
+ * it is recommended that a PAUSE instruction be placed in all spin-wait loops.
+ *
+ * An additional function of the PAUSE instruction is to reduce the power consumed by a processor while executing a spin loop.
+ * A processor can execute a spin-wait loop extremely quickly,
+ * causing the processor to consume a lot of power while it waits for the resource it is spinning on to become available.
+ * Inserting a pause instruction in a spin-wait loop greatly reduces the processor`s power consumption.
+ */
+#if defined(__x86_64__) || defined(__amd64__) || defined(__i386__) || defined(__i486__) || defined(__i586__) \
+  || defined(__i686__)
+#define __afl_pause asm volatile("pause" ::: "memory")
+#elif defined(__aarch64__)
+#define __afl_pause asm volatile("yield" ::: "memory")
+else
+#include <sched.h>
+#define __afl_pause sched_yield()
+#endif
+
+#define AFL_TID_MASK 0x3FFFFFFF // Thread ID bit mask
+
+/*
+ * Thread-local storage (TLS) - Thread Pointer
+ */
+#if (__GNUC__ > 11) || (__clang_major__ >= 14) || (__GNUC__ == 11 && __GNUC_MINOR__ >= 1)
+#define __afl_thread_pointer(tp) tp = (uintptr_t) __builtin_thread_pointer()
+#elif defined(__x86_64__) || defined(__amd64__)
+#define __afl_thread_pointer(tp) asm volatile("movl %%fs:0, %0" : "=r"(tp))
+#elif defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__)
+#define __afl_thread_pointer(tp) asm volatile("movl %%gs:0, %0" : "=r"(tp))
+#elif defined(__aarch64__)
+#define __afl_thread_pointer(tp) asm volatile("mrs %0, tpidr_el0" : "=r"(tp))
+#else
+#error Compiler or platform not support TLS
+#endif
+
+static inline uint32_t __afl_thread_pointer_tid(void)
+{
+    uint32_t ret;
+    __afl_thread_pointer(ret);
+    return ret & AFL_TID_MASK;
+}
+
+/*
+ * Create Memory Barrier
+ */
+#define __afl_memory_barrier asm volatile("" ::: "memory")
+
+/*
+ * Call system calls directly. This helps to save some CPU cycles.
+ */
+#if defined(__x86_64__) || defined(__amd64__)
+static inline int32_t __afl_syscall(int64_t number, int64_t p1, int64_t p2, int64_t p3, int64_t p4)
+{
+    int32_t ret;
+    register int64_t r8 __asm__("r8")   = 0;
+    register int64_t r9 __asm__("r9")   = 0;
+    register int64_t r10 __asm__("r10") = p4;
+    asm volatile("syscall"
+                 : "=a"(ret)
+                 : "a"(number), "D"(p1), "S"(p2), "d"(p3), "r"(r10), "r"(r8), "r"(r9)
+                 : "rcx", "r11", "memory");
+    __afl_syscall_check_errors(ret);
+    return ret;
+}
+#elif defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__)
+static inline int32_t __afl_syscall(int32_t number, int32_t p1, int32_t p2, int32_t p3, int32_t p4)
+{
+    int32_t ret;
+#if !defined(__PIC__)
+    asm volatile("call *%%gs:16" : "=a"(ret) : "a"(number), "b"(p1), "c"(p2), "d"(p3), "S"(p4) : "memory");
+#else
+    asm volatile("xchg %%ebx, %%edi;\n"
+                 "call *%%gs:16;\n"
+                 "xchg %%ebx,%%edi;\n"
+                 : "=a"(ret)
+                 : "a"(number), "D"(p1), "c"(p2), "d"(p3), "S"(p4)
+                 : "memory");
+#endif
+    __afl_syscall_check_errors(ret);
+    return ret;
+}
+#elif defined(__aarch64__)
+static inline int64_t __afl_syscall(int64_t number, int64_t p1, int64_t p2, int64_t p3, int64_t p4)
+{
+    register int64_t x8 __asm__("x8") = number;
+    register int64_t x0 __asm__("x0") = p1;
+    register int64_t x1 __asm__("x1") = p2;
+    register int64_t x2 __asm__("x2") = p3;
+    register int64_t x3 __asm__("x3") = p4;
+    register int64_t x4 __asm__("x4") = 0;
+    register int64_t x5 __asm__("x5") = 0;
+    asm volatile("svc 0" : "=r"(x0) : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4), "r"(x5) : "cc", "memory");
+    __afl_syscall_check_errors(x0);
+    return x0;
+}
+#else
+#define __afl_syscall(number, p1, p2, p3, p4) syscall(number, p1, p2, p3, p4)
+#endif
+
+/*
+ * Caches the syscall gettid and stores Thread ID in TLS.
+ * This improves performance and reduces the number of system calls.
+ */
+static inline uint32_t __afl_gettid(void)
+{
+    static __thread uint32_t tid;
+
+    if (__afl_likely(tid))
+        return tid;
+
+    tid = __afl_syscall(__NR_gettid, 0, 0, 0, 0) & AFL_TID_MASK;
+
+    return tid;
+}
+
+enum __afl_state
+{
+    AFL_UNLOCKED = 0, // Unlocked
+    AFL_LOCKED   = 1  // Locked
+};
+
+#define AFL_HAVE_WAITERS 0x80000000 // Lock have waiters bit mask
+
+#define __AFL_ALIGN __attribute__((aligned(64))) // Most processors have a cache line size of 64 bytes
+
+/*
+ * Spinlock
+ */
+typedef __AFL_ALIGN uint32_t afl_spinlock_t;
+
+static inline int afl_spin_init(afl_spinlock_t *spinlock, int shared)
+{
+    (void) shared;
+    __atomic_store_n(spinlock, AFL_UNLOCKED, __ATOMIC_RELEASE);
+    return 0;
+}
+
+static inline int afl_spin_lock(afl_spinlock_t *spinlock)
+{
+    uint32_t lock;
+
+    if (__afl_likely(!__atomic_exchange_n(spinlock, AFL_LOCKED, __ATOMIC_ACQUIRE)))
+        return 0;
+
+loop:
+    __afl_pause;
+    lock = __atomic_exchange_n(spinlock, AFL_LOCKED, __ATOMIC_ACQUIRE);
+    if (lock != AFL_UNLOCKED)
+        goto loop;
+
+    return 0;
+}
+
+static inline int afl_spin_unlock(afl_spinlock_t *spinlock)
+{
+    __atomic_store_n(spinlock, AFL_UNLOCKED, __ATOMIC_RELEASE);
+    return 0;
+}
+
+static inline int afl_spin_owner_lock(afl_spinlock_t *spinlock)
+{
+    uint32_t lock;
+    uint32_t tid = __afl_thread_pointer_tid();
+
+    __atomic_load(spinlock, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(tid == (lock & AFL_TID_MASK), "An attempt was made to lock already owned spinlock.");
+
+    if (__afl_unlikely(tid == (lock & AFL_TID_MASK)))
+        return EDEADLOCK;
+
+loop:
+    lock = AFL_UNLOCKED;
+    if (__atomic_compare_exchange_n(spinlock, &lock, tid, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
+        return 0;
+    __afl_pause;
+    goto loop;
+
+    return 0;
+}
+
+static inline int afl_spin_owner_unlock(afl_spinlock_t *spinlock)
+{
+    uint32_t lock = 0;
+    uint32_t tid  = __afl_thread_pointer_tid();
+
+    __atomic_load(spinlock, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(tid != (lock & AFL_TID_MASK), "An attempt was made to unlock a spinlock from a non-owner thread.");
+
+    if (__afl_unlikely(tid != (lock & AFL_TID_MASK)))
+        return EPERM;
+
+    __atomic_store_n(spinlock, AFL_UNLOCKED, __ATOMIC_RELEASE);
+
+    return 0;
+}
+
+static inline int afl_spin_destroy(afl_spinlock_t *spinlock)
+{
+    __atomic_store_n(spinlock, AFL_UNLOCKED, __ATOMIC_RELEASE);
+    return 0;
+}
+
+/*
+ * Mutex
+ */
+typedef __AFL_ALIGN uint32_t afl_mutex_t;
+
+#define AFL_MUTEX_INIT 0
+
+static inline int afl_mutex_lock(afl_mutex_t *mutex)
+{
+    uint32_t lock;
+
+    __atomic_load(mutex, &lock, __ATOMIC_RELAXED);
+
+    if (lock & AFL_HAVE_WAITERS)
+        goto futex;
+
+    lock = AFL_UNLOCKED;
+    if (__afl_likely(__atomic_compare_exchange_n(mutex, &lock, AFL_LOCKED, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)))
+        return 0;
+
+    if (!(lock & AFL_HAVE_WAITERS))
+        __atomic_compare_exchange_n(mutex, &lock, AFL_LOCKED | AFL_HAVE_WAITERS, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
+
+    while (lock != AFL_UNLOCKED) {
+    futex:
+        __afl_syscall(__NR_futex, (intptr_t) mutex, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, AFL_LOCKED | AFL_HAVE_WAITERS, 0);
+        lock = __atomic_exchange_n(mutex, AFL_LOCKED | AFL_HAVE_WAITERS, __ATOMIC_ACQUIRE);
+    }
+
+    return 0;
+}
+
+static inline int afl_mutex_unlock(afl_mutex_t *mutex)
+{
+    uint32_t lock;
+
+    __atomic_load(mutex, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(lock == AFL_UNLOCKED, "An attempt was made to unlock an unlocked mutex.");
+
+    if (__atomic_exchange_n(mutex, AFL_UNLOCKED, __ATOMIC_ACQUIRE) & AFL_HAVE_WAITERS)
+        __afl_syscall(__NR_futex, (intptr_t) mutex, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1, 0);
+
+    return 0;
+}
+
+static inline int afl_mutex_owner_lock(afl_mutex_t *mutex)
+{
+    uint32_t lock;
+    uint32_t tid = __afl_thread_pointer_tid();
+
+    __atomic_load(mutex, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(tid == (lock & AFL_TID_MASK), "An attempt was made to lock already owned mutex.");
+
+    if (__afl_unlikely(tid == (lock & AFL_TID_MASK)))
+        return EDEADLOCK;
+
+    if (__afl_likely(!lock && __atomic_compare_exchange_n(mutex, &lock, tid, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)))
+        return 0;
+
+try_lock:
+    if (!(lock & AFL_HAVE_WAITERS)) {
+        lock = __atomic_or_fetch(mutex, AFL_HAVE_WAITERS, __ATOMIC_ACQUIRE);
+        if (lock == AFL_HAVE_WAITERS
+            && __atomic_compare_exchange_n(mutex, &lock, tid | AFL_HAVE_WAITERS, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
+            return 0;
+    }
+
+    __afl_syscall(__NR_futex, (intptr_t) mutex, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, lock, 0);
+    lock = AFL_UNLOCKED;
+    if (!__atomic_compare_exchange_n(mutex, &lock, tid | AFL_HAVE_WAITERS, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
+        goto try_lock;
+
+    return 0;
+}
+
+static inline int afl_mutex_owner_unlock(afl_mutex_t *mutex)
+{
+    uint32_t lock;
+    uint32_t tid = __afl_thread_pointer_tid();
+
+    __atomic_load(mutex, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(tid != (lock & AFL_TID_MASK), "An attempt was made to unlock a mutex from a non-owner thread.");
+
+    if (__afl_unlikely(tid != (lock & AFL_TID_MASK)))
+        return EPERM;
+
+    if (__atomic_exchange_n(mutex, AFL_UNLOCKED, __ATOMIC_ACQUIRE) & AFL_HAVE_WAITERS)
+        __afl_syscall(__NR_futex, (intptr_t) mutex, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1, 0);
+
+    return 0;
+}
+
+static inline int afl_mutex_pi_lock(afl_mutex_t *mutex)
+{
+    uint32_t lock;
+    uint32_t tid = __afl_gettid();
+
+    __atomic_load(mutex, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(tid == (lock & AFL_TID_MASK), "An attempt was made to lock already owned mutex.");
+
+    if (__afl_unlikely(tid == (lock & AFL_TID_MASK)))
+        return EDEADLOCK;
+
+    if (lock || (!lock && !__atomic_compare_exchange_n(mutex, &lock, tid, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)))
+        __afl_syscall(__NR_futex, (intptr_t) mutex, FUTEX_LOCK_PI | FUTEX_PRIVATE_FLAG, 0, 0);
+
+    return 0;
+}
+
+static inline int afl_mutex_pi_unlock(afl_mutex_t *mutex)
+{
+    uint32_t lock;
+    uint32_t tid = __afl_gettid();
+
+    __atomic_load(mutex, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(tid != (lock & AFL_TID_MASK), "An attempt was made to unlock a mutex from a non-owner thread.");
+
+    if (__afl_unlikely(tid != (lock & AFL_TID_MASK)))
+        return EPERM;
+
+    if (!__atomic_compare_exchange_n(mutex, &tid, AFL_UNLOCKED, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
+        __afl_syscall(__NR_futex, (intptr_t) mutex, FUTEX_UNLOCK_PI | FUTEX_PRIVATE_FLAG, 0, 0);
+
+    return 0;
+}
+
+static inline int afl_mutex_destroy(afl_mutex_t *mutex)
+{
+    __atomic_store_n(mutex, AFL_UNLOCKED, __ATOMIC_RELEASE);
+    return 0;
+}
+
+/*
+ * Recursive Mutex
+ */
+typedef struct
+{
+    __attribute__((aligned(8))) uint32_t lock;
+    size_t count;
+} __AFL_ALIGN afl_mutex_recursive_t;
+
+static inline int afl_mutex_recursive_init(afl_mutex_recursive_t *mutex)
+{
+    __atomic_store_n(&mutex->lock, AFL_UNLOCKED, __ATOMIC_RELEASE);
+    mutex->count = 0;
+
+    return 0;
+}
+
+static inline int afl_mutex_recursive_lock(afl_mutex_recursive_t *mutex)
+{
+    uint32_t lock;
+    uint32_t tid = __afl_thread_pointer_tid();
+
+    __atomic_load(&mutex->lock, &lock, __ATOMIC_RELAXED);
+
+    if (__afl_likely(
+          !lock && __atomic_compare_exchange_n(&mutex->lock, &lock, tid, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)
+        ))
+        goto success;
+
+    if (__afl_likely(tid == (lock & AFL_TID_MASK))) {
+        __afl_debug(
+          mutex->count + 1 == 0,
+          "Recusive mutex counter overflow. "
+          "This is not an error, but please check that the EAGAIN return value is being processed correctly."
+        );
+        if (__afl_unlikely(mutex->count + 1 == 0))
+            return EAGAIN;
+        mutex->count++;
+        return 0;
+    }
+
+try_lock:
+    if (!(lock & AFL_HAVE_WAITERS)) {
+        lock = __atomic_or_fetch(&mutex->lock, AFL_HAVE_WAITERS, __ATOMIC_ACQUIRE);
+        if (lock == AFL_HAVE_WAITERS
+            && __atomic_compare_exchange_n(
+              &mutex->lock, &lock, tid | AFL_HAVE_WAITERS, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED
+            ))
+            goto success;
+    }
+
+    __afl_syscall(__NR_futex, (intptr_t) &mutex->lock, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, lock, 0);
+    lock = AFL_UNLOCKED;
+    if (!__atomic_compare_exchange_n(&mutex->lock, &lock, tid | AFL_HAVE_WAITERS, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
+        goto try_lock;
+
+success:
+    mutex->count = 1;
+
+    return 0;
+}
+
+static inline int afl_mutex_recursive_unlock(afl_mutex_recursive_t *mutex)
+{
+    uint32_t lock;
+    uint32_t tid = __afl_thread_pointer_tid();
+
+    __atomic_load(&mutex->lock, &lock, __ATOMIC_RELAXED);
+
+    __afl_debug(tid != (lock & AFL_TID_MASK), "An attempt was made to unlock a mutex from a non-owner thread.");
+
+    if (__afl_unlikely(tid != (lock & AFL_TID_MASK)))
+        return EPERM;
+
+    __afl_debug(mutex->count == 0, "An attempt was made to unlock an unlocked recursive mutex.");
+
+    if (--mutex->count == 0 && (__atomic_exchange_n(&mutex->lock, AFL_UNLOCKED, __ATOMIC_ACQUIRE) & AFL_HAVE_WAITERS))
+        __afl_syscall(__NR_futex, (intptr_t) &mutex->lock, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1, 0);
+
+    return 0;
+}
+
+static inline int afl_mutex_recursive_destroy(afl_mutex_recursive_t *mutex)
+{
+    __atomic_store_n(&mutex->lock, AFL_UNLOCKED, __ATOMIC_RELEASE);
+    mutex->count = 0;
+
+    return 0;
+}
+
+/*
+ * Once
+ */
+typedef __AFL_ALIGN uint32_t afl_once_t;
+
+#define AFL_SUCCESS 0x40000000 // Once init success, just return
+
+#define AFL_ONCE_INIT 0
+
+static inline int afl_once(afl_once_t *once, void (*init)(void))
+{
+    uint32_t lock;
+
+    __atomic_load(once, &lock, __ATOMIC_RELAXED);
+
+    if (__afl_likely(lock & AFL_SUCCESS))
+        return 0;
+
+try_lock:
+    lock = AFL_UNLOCKED;
+    if (__atomic_compare_exchange_n(once, &lock, AFL_LOCKED, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
+        init();
+
+        if (__atomic_exchange_n(once, AFL_SUCCESS, __ATOMIC_ACQUIRE) & AFL_HAVE_WAITERS)
+            __afl_syscall(__NR_futex, (intptr_t) once, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, INT32_MAX, 0);
+
+        return 0;
+    }
+
+    if (lock & AFL_SUCCESS)
+        return 0;
+
+    lock = AFL_LOCKED;
+    if (__atomic_compare_exchange_n(once, &lock, AFL_LOCKED | AFL_HAVE_WAITERS, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
+        __afl_syscall(__NR_futex, (intptr_t) once, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, AFL_LOCKED | AFL_HAVE_WAITERS, 0);
+
+    if (!(lock & AFL_SUCCESS))
+        goto try_lock;
+
+    return 0;
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* __AFL_H */
diff --git a/include/wine/mutex.h b/include/wine/mutex.h
new file mode 100644
index 00000000000..0642c4dfe40
--- /dev/null
+++ b/include/wine/mutex.h
@@ -0,0 +1,69 @@
+#ifndef __WINE_WINE_MUTEX_H
+#define __WINE_WINE_MUTEX_H
+
+#ifdef USE_AFL
+
+#include "afl.h"
+
+#define WINE_SPINLOCK_TYPE afl_spinlock_t
+#define WINE_MUTEX_TYPE afl_mutex_t
+#define WINE_MUTEX_RECURSIVE_TYPE afl_mutex_recursive_t
+#define WINE_ONCE_TYPE afl_once_t
+
+#define WINE_SPIN_INIT(__SPINLOCK__, __SHARED__) afl_spin_init(__SPINLOCK__, __SHARED__)
+#define WINE_SPIN_LOCK(__SPINLOCK__) afl_spin_lock(__SPINLOCK__)
+#define WINE_SPIN_UNLOCK(__SPINLOCK__) afl_spin_unlock(__SPINLOCK__)
+#define WINE_SPIN_DESTROY(__SPINLOCK__) afl_spin_destroy(__SPINLOCK__)
+
+#define WINE_MUTEX_INIT AFL_MUTEX_INIT
+#define WINE_MUTEX_LOCK(__MUTEX__) afl_mutex_lock(__MUTEX__)
+#define WINE_MUTEX_UNLOCK(__MUTEX__) afl_mutex_unlock(__MUTEX__)
+#define WINE_MUTEX_DESTROY(__MUTEX__) afl_mutex_destroy(__MUTEX__)
+
+#define WINE_MUTEX_RECURSIVE_INIT(__MUTEX__) afl_mutex_recursive_init(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_LOCK(__MUTEX__) afl_mutex_recursive_lock(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_UNLOCK(__MUTEX__) afl_mutex_recursive_unlock(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_DESTROY(__MUTEX__) afl_mutex_recursive_destroy(__MUTEX__)
+
+#define WINE_ONCE_INIT AFL_ONCE_INIT;
+#define WINE_ONCE(__ONCE__, __FUNCTION__) afl_once(__ONCE__, __FUNCTION__)
+
+#else
+
+#error USE_AFL is not defined!
+
+#include "pthread.h"
+
+#define WINE_SPINLOCK_TYPE pthread_spinlock_t
+#define WINE_MUTEX_TYPE pthread_mutex_t
+#define WINE_MUTEX_RECURSIVE_TYPE pthread_mutex_t
+#define WINE_ONCE_TYPE pthread_once_t
+
+#define WINE_SPIN_INIT(__SPINLOCK__, __SHARED__) pthread_spin_init(__SPINLOCK__, __SHARED__)
+#define WINE_SPIN_LOCK(__SPINLOCK__) pthread_spin_lock(__SPINLOCK__)
+#define WINE_SPIN_UNLOCK(__SPINLOCK__) pthread_spin_unlock(__SPINLOCK__)
+#define WINE_SPIN_DESTROY(__SPINLOCK__) pthread_spin_destroy(__SPINLOCK__)
+
+#define WINE_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
+#define WINE_MUTEX_LOCK(__MUTEX__) pthread_mutex_owner_lock(__MUTEX__)
+#define WINE_MUTEX_UNLOCK(__MUTEX__) pthread_mutex_owner_unlock(__MUTEX__)
+#define WINE_MUTEX_DESTROY(__MUTEX__) pthread_mutex_destroy(__MUTEX__)
+
+#define WINE_MUTEX_RECURSIVE_INIT(__MUTEX__)                       \
+    do {                                                           \
+        pthread_mutexattr_t attr;                                  \
+        pthread_mutexattr_init(&attr);                             \
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); \
+        pthread_mutex_init(__MUTEX__, &attr);                      \
+        pthread_mutexattr_destroy(&attr);                          \
+    } while (0)
+#define WINE_MUTEX_RECURSIVE_LOCK(__MUTEX__) pthread_mutex_lock(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_UNLOCK(__MUTEX__) pthread_mutex_unlock(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_DESTROY(__MUTEX__) pthread_mutex_destroy(__MUTEX__)
+
+#define WINE_ONCE_INIT PTHREAD_ONCE_INIT;
+#define WINE_ONCE(__ONCE__, __FUNCTION__) pthread_once(__ONCE__, __FUNCTION__)
+
+#endif
+
+#endif /* __WINE_WINE_MUTEX_H */

[PATCH 2/6] winewayland: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 dlls/winewayland.drv/display.c          |  4 +--
 dlls/winewayland.drv/opengl.c           | 42 +++++++++++------------
 dlls/winewayland.drv/vulkan.c           |  6 ++--
 dlls/winewayland.drv/wayland.c          | 16 ++++-----
 dlls/winewayland.drv/wayland_keyboard.c | 44 ++++++++++++-------------
 dlls/winewayland.drv/wayland_output.c   | 12 +++----
 dlls/winewayland.drv/wayland_pointer.c  | 40 +++++++++++-----------
 dlls/winewayland.drv/wayland_surface.c  | 22 ++++++++-----
 dlls/winewayland.drv/waylanddrv.h       | 11 ++++---
 dlls/winewayland.drv/window.c           | 40 +++++++++++-----------
 dlls/winewayland.drv/window_surface.c   |  4 +--
 11 files changed, 123 insertions(+), 118 deletions(-)

diff --git a/dlls/winewayland.drv/display.c b/dlls/winewayland.drv/display.c
index 9b4ebe7cdc1..8380f689fe6 100644
--- a/dlls/winewayland.drv/display.c
+++ b/dlls/winewayland.drv/display.c
@@ -275,7 +275,7 @@ UINT WAYLAND_UpdateDisplayDevices(const struct gdi_device_manager *device_manage

wl_array_init(&output_info_array);

-    pthread_mutex_lock(&process_wayland.output_mutex);
+    WINE_MUTEX_LOCK(&process_wayland.output_mutex);

wl_list_for_each(output, &process_wayland.output_list, link)
     {
@@ -300,7 +300,7 @@ UINT WAYLAND_UpdateDisplayDevices(const struct gdi_device_manager *device_manage

wl_array_release(&output_info_array);

-    pthread_mutex_unlock(&process_wayland.output_mutex);
+    WINE_MUTEX_UNLOCK(&process_wayland.output_mutex);

return STATUS_SUCCESS;
 }
diff --git a/dlls/winewayland.drv/opengl.c b/dlls/winewayland.drv/opengl.c
index 994154968b3..2d8843fb2ac 100644
--- a/dlls/winewayland.drv/opengl.c
+++ b/dlls/winewayland.drv/opengl.c
@@ -74,7 +74,7 @@ DECL_FUNCPTR(eglSwapInterval);
 DECL_FUNCPTR(glClear);
 #undef DECL_FUNCPTR

-static pthread_mutex_t gl_object_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE gl_object_mutex = WINE_MUTEX_INIT;
 static struct list gl_drawables = LIST_INIT(gl_drawables);
 static struct list gl_contexts = LIST_INIT(gl_contexts);

@@ -120,10 +120,10 @@ static struct wayland_gl_drawable *wayland_gl_drawable_get(HWND hwnd)
 {
     struct wayland_gl_drawable *ret;

-    pthread_mutex_lock(&gl_object_mutex);
+    WINE_MUTEX_LOCK(&gl_object_mutex);
     if ((ret = find_drawable_for_hwnd(hwnd)))
         ret = wayland_gl_drawable_acquire(ret);
-    pthread_mutex_unlock(&gl_object_mutex);
+    WINE_MUTEX_UNLOCK(&gl_object_mutex);

return ret;
 }
@@ -141,7 +141,7 @@ static void wayland_gl_drawable_release(struct wayland_gl_drawable *gl)
         if (wayland_client_surface_release(gl->client) && wayland_surface)
             wayland_surface->client = NULL;

-        if (wayland_surface) pthread_mutex_unlock(&wayland_surface->mutex);
+        if (wayland_surface) WINE_MUTEX_UNLOCK(&wayland_surface->mutex);
     }

free(gl);
@@ -174,7 +174,7 @@ static struct wayland_gl_drawable *wayland_gl_drawable_create(HWND hwnd, int for
                         wayland_surface->window.client_rect.top;
         if (client_width == 0 || client_height == 0)
             client_width = client_height = 1;
-        pthread_mutex_unlock(&wayland_surface->mutex);
+        WINE_MUTEX_UNLOCK(&wayland_surface->mutex);
     }
     else if ((wayland_surface = wayland_surface_create(0)))
     {
@@ -227,7 +227,7 @@ static void wayland_update_gl_drawable(HWND hwnd, struct wayland_gl_drawable *ne
 {
     struct wayland_gl_drawable *old;

-    pthread_mutex_lock(&gl_object_mutex);
+    WINE_MUTEX_LOCK(&gl_object_mutex);

if ((old = find_drawable_for_hwnd(hwnd))) list_remove(&old->entry);
     if (new) list_add_head(&gl_drawables, &new->entry);
@@ -237,7 +237,7 @@ static void wayland_update_gl_drawable(HWND hwnd, struct wayland_gl_drawable *ne
         new->swap_interval = old->swap_interval;
     }

-    pthread_mutex_unlock(&gl_object_mutex);
+    WINE_MUTEX_UNLOCK(&gl_object_mutex);

if (old) wayland_gl_drawable_release(old);
 }
@@ -260,7 +260,7 @@ static void wayland_gl_drawable_sync_size(struct wayland_gl_drawable *gl)

wl_egl_window_resize(gl->wl_egl_window, client_width, client_height, 0, 0);

-        pthread_mutex_unlock(&wayland_surface->mutex);
+        WINE_MUTEX_UNLOCK(&wayland_surface->mutex);
     }
 }

@@ -281,7 +281,7 @@ static void wayland_gl_drawable_sync_surface_state(struct wayland_gl_drawable *g
         wl_surface_commit(wayland_surface->wl_surface);
     }

-    pthread_mutex_unlock(&wayland_surface->mutex);
+    WINE_MUTEX_UNLOCK(&wayland_surface->mutex);
 }

static BOOL wgl_context_make_current(struct wgl_context *ctx, HWND draw_hwnd,
@@ -303,7 +303,7 @@ static BOOL wgl_context_make_current(struct wgl_context *ctx, HWND draw_hwnd,
      * perform any pending resizes before calling it. */
     if (draw) wayland_gl_drawable_sync_size(draw);

-    pthread_mutex_lock(&gl_object_mutex);
+    WINE_MUTEX_LOCK(&gl_object_mutex);

ret = p_eglMakeCurrent(egl_display,
                            draw ? draw->surface : EGL_NO_SURFACE,
@@ -325,7 +325,7 @@ static BOOL wgl_context_make_current(struct wgl_context *ctx, HWND draw_hwnd,
         old_read = read;
     }

-    pthread_mutex_unlock(&gl_object_mutex);
+    WINE_MUTEX_UNLOCK(&gl_object_mutex);

if (old_draw) wayland_gl_drawable_release(old_draw);
     if (old_read) wayland_gl_drawable_release(old_read);
@@ -400,7 +400,7 @@ static void wgl_context_refresh(struct wgl_context *ctx)
     BOOL refresh = FALSE;
     struct wayland_gl_drawable *old_draw = NULL, *old_read = NULL;

-    pthread_mutex_lock(&gl_object_mutex);
+    WINE_MUTEX_LOCK(&gl_object_mutex);

if (ctx->new_draw)
     {
@@ -422,7 +422,7 @@ static void wgl_context_refresh(struct wgl_context *ctx)
         if (ctx->draw) p_eglSwapInterval(egl_display, ctx->draw->swap_interval);
     }

-    pthread_mutex_unlock(&gl_object_mutex);
+    WINE_MUTEX_UNLOCK(&gl_object_mutex);

if (old_draw) wayland_gl_drawable_release(old_draw);
     if (old_read) wayland_gl_drawable_release(old_read);
@@ -492,9 +492,9 @@ static struct wgl_context *create_context(HDC hdc, struct wgl_context *share,
                                       share ? share->context : EGL_NO_CONTEXT,
                                       ctx->attribs);

-    pthread_mutex_lock(&gl_object_mutex);
+    WINE_MUTEX_LOCK(&gl_object_mutex);
     list_add_head(&gl_contexts, &ctx->entry);
-    pthread_mutex_unlock(&gl_object_mutex);
+    WINE_MUTEX_UNLOCK(&gl_object_mutex);

TRACE("ctx=%p egl_context=%p\n", ctx, ctx->context);

@@ -535,9 +535,9 @@ static struct wgl_context *wayland_wglCreateContextAttribsARB(HDC hdc,

static BOOL wayland_wglDeleteContext(struct wgl_context *ctx)
 {
-    pthread_mutex_lock(&gl_object_mutex);
+    WINE_MUTEX_LOCK(&gl_object_mutex);
     list_remove(&ctx->entry);
-    pthread_mutex_unlock(&gl_object_mutex);
+    WINE_MUTEX_UNLOCK(&gl_object_mutex);
     p_eglDestroyContext(egl_display, ctx->context);
     if (ctx->draw) wayland_gl_drawable_release(ctx->draw);
     if (ctx->read) wayland_gl_drawable_release(ctx->read);
@@ -696,12 +696,12 @@ static BOOL wayland_wglSwapIntervalEXT(int interval)

/* Lock to protect against concurrent access to drawable swap_interval
      * from wayland_update_gl_drawable */
-    pthread_mutex_lock(&gl_object_mutex);
+    WINE_MUTEX_LOCK(&gl_object_mutex);
     if ((ret = p_eglSwapInterval(egl_display, interval)))
         ctx->draw->swap_interval = interval;
     else
         RtlSetLastWin32Error(ERROR_DC_NOT_FOUND);
-    pthread_mutex_unlock(&gl_object_mutex);
+    WINE_MUTEX_UNLOCK(&gl_object_mutex);

return ret;
 }
@@ -1067,9 +1067,9 @@ err:

static BOOL has_opengl(void)
 {
-    static pthread_once_t init_once = PTHREAD_ONCE_INIT;
+    static WINE_ONCE_TYPE init_once = WINE_ONCE_INIT;

-    return !pthread_once(&init_once, init_opengl) && egl_handle;
+    return !WINE_ONCE(&init_once, init_opengl) && egl_handle;
 }

static struct opengl_funcs opengl_funcs =
diff --git a/dlls/winewayland.drv/vulkan.c b/dlls/winewayland.drv/vulkan.c
index 16084175013..6416a11bbba 100644
--- a/dlls/winewayland.drv/vulkan.c
+++ b/dlls/winewayland.drv/vulkan.c
@@ -73,7 +73,7 @@ static void wine_vk_surface_destroy(struct wayland_client_surface *client)
         wayland_surface->client = NULL;
     }

-    if (wayland_surface) pthread_mutex_unlock(&wayland_surface->mutex);
+    if (wayland_surface) WINE_MUTEX_UNLOCK(&wayland_surface->mutex);
 }

static VkResult wayland_vulkan_surface_create(HWND hwnd, VkInstance instance, VkSurfaceKHR *surface, void **private)
@@ -93,7 +93,7 @@ static VkResult wayland_vulkan_surface_create(HWND hwnd, VkInstance instance, Vk
     }

client = wayland_surface_get_client(wayland_surface);
-    pthread_mutex_unlock(&wayland_surface->mutex);
+    WINE_MUTEX_UNLOCK(&wayland_surface->mutex);

if (!client)
     {
@@ -153,7 +153,7 @@ static void wayland_vulkan_surface_presented(HWND hwnd, VkResult result)
             wl_surface_commit(wayland_surface->wl_surface);
         }

-        pthread_mutex_unlock(&wayland_surface->mutex);
+        WINE_MUTEX_UNLOCK(&wayland_surface->mutex);
     }
 }

diff --git a/dlls/winewayland.drv/wayland.c b/dlls/winewayland.drv/wayland.c
index c94b35e173c..d5dc4bcfa00 100644
--- a/dlls/winewayland.drv/wayland.c
+++ b/dlls/winewayland.drv/wayland.c
@@ -34,11 +34,11 @@ WINE_DEFAULT_DEBUG_CHANNEL(waylanddrv);

struct wayland process_wayland =
 {
-    .seat.mutex = PTHREAD_MUTEX_INITIALIZER,
-    .keyboard.mutex = PTHREAD_MUTEX_INITIALIZER,
-    .pointer.mutex = PTHREAD_MUTEX_INITIALIZER,
+    .seat.mutex = WINE_MUTEX_INIT,
+    .keyboard.mutex = WINE_MUTEX_INIT,
+    .pointer.mutex = WINE_MUTEX_INIT,
     .output_list = {&process_wayland.output_list, &process_wayland.output_list},
-    .output_mutex = PTHREAD_MUTEX_INITIALIZER
+    .output_mutex = WINE_MUTEX_INIT
 };

/**********************************************************************
@@ -137,12 +137,12 @@ static void registry_handle_global(void *data, struct wl_registry *registry,
             WARN("Only a single seat is currently supported, ignoring additional seats.\n");
             return;
         }
-        pthread_mutex_lock(&seat->mutex);
+        WINE_MUTEX_LOCK(&seat->mutex);
         seat->wl_seat = wl_registry_bind(registry, id, &wl_seat_interface,
                                          version < 5 ? version : 5);
         seat->global_id = id;
         wl_seat_add_listener(seat->wl_seat, &seat_listener, NULL);
-        pthread_mutex_unlock(&seat->mutex);
+        WINE_MUTEX_UNLOCK(&seat->mutex);
     }
     else if (strcmp(interface, "wp_viewporter") == 0)
     {
@@ -189,11 +189,11 @@ static void registry_handle_global_remove(void *data, struct wl_registry *regist
     {
         TRACE("removing seat\n");
         if (process_wayland.pointer.wl_pointer) wayland_pointer_deinit();
-        pthread_mutex_lock(&seat->mutex);
+        WINE_MUTEX_LOCK(&seat->mutex);
         wl_seat_release(seat->wl_seat);
         seat->wl_seat = NULL;
         seat->global_id = 0;
-        pthread_mutex_unlock(&seat->mutex);
+        WINE_MUTEX_UNLOCK(&seat->mutex);
     }
 }

diff --git a/dlls/winewayland.drv/wayland_keyboard.c b/dlls/winewayland.drv/wayland_keyboard.c
index 5c2fe15273e..8563c53763c 100644
--- a/dlls/winewayland.drv/wayland_keyboard.c
+++ b/dlls/winewayland.drv/wayland_keyboard.c
@@ -69,7 +69,7 @@ struct layout
     };
 };

-static pthread_mutex_t xkb_layouts_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE xkb_layouts_mutex = WINE_MUTEX_INIT;
 static struct list xkb_layouts = LIST_INIT(xkb_layouts);

/* These are only used from the wayland event thread and don't need locking */
@@ -578,7 +578,7 @@ static void set_current_xkb_group(xkb_layout_index_t xkb_group)
     struct layout *layout;
     HKL hkl;

-    pthread_mutex_lock(&xkb_layouts_mutex);
+    WINE_MUTEX_LOCK(&xkb_layouts_mutex);

LIST_FOR_EACH_ENTRY(layout, &xkb_layouts, struct layout, entry)
         if (layout->xkb_group == xkb_group) break;
@@ -590,7 +590,7 @@ static void set_current_xkb_group(xkb_layout_index_t xkb_group)
         hkl = keyboard_hkl;
     }

-    pthread_mutex_unlock(&xkb_layouts_mutex);
+    WINE_MUTEX_UNLOCK(&xkb_layouts_mutex);

if (hkl == keyboard_hkl) return;
     keyboard_hkl = hkl;
@@ -654,9 +654,9 @@ static HWND wayland_keyboard_get_focused_hwnd(void)
     struct wayland_keyboard *keyboard = &process_wayland.keyboard;
     HWND hwnd;

-    pthread_mutex_lock(&keyboard->mutex);
+    WINE_MUTEX_LOCK(&keyboard->mutex);
     hwnd = keyboard->focused_hwnd;
-    pthread_mutex_unlock(&keyboard->mutex);
+    WINE_MUTEX_UNLOCK(&keyboard->mutex);

return hwnd;
 }
@@ -694,7 +694,7 @@ static void keyboard_handle_keymap(void *data, struct wl_keyboard *wl_keyboard,
         return;
     }

-    pthread_mutex_lock(&xkb_layouts_mutex);
+    WINE_MUTEX_LOCK(&xkb_layouts_mutex);

LIST_FOR_EACH_ENTRY_SAFE(entry, next, &xkb_layouts, struct layout, entry)
     {
@@ -721,14 +721,14 @@ static void keyboard_handle_keymap(void *data, struct wl_keyboard *wl_keyboard,
         add_xkb_layout(buffer, xkb_keymap, xkb_group, lang);
     }

-    pthread_mutex_unlock(&xkb_layouts_mutex);
+    WINE_MUTEX_UNLOCK(&xkb_layouts_mutex);

if ((xkb_state = xkb_state_new(xkb_keymap)))
     {
-        pthread_mutex_lock(&keyboard->mutex);
+        WINE_MUTEX_LOCK(&keyboard->mutex);
         xkb_state_unref(keyboard->xkb_state);
         keyboard->xkb_state = xkb_state;
-        pthread_mutex_unlock(&keyboard->mutex);
+        WINE_MUTEX_UNLOCK(&keyboard->mutex);

set_current_xkb_group(0);
     }
@@ -751,9 +751,9 @@ static void keyboard_handle_enter(void *data, struct wl_keyboard *wl_keyboard,
     hwnd = wl_surface_get_user_data(wl_surface);
     TRACE("serial=%u hwnd=%p\n", serial, hwnd);

-    pthread_mutex_lock(&keyboard->mutex);
+    WINE_MUTEX_LOCK(&keyboard->mutex);
     keyboard->focused_hwnd = hwnd;
-    pthread_mutex_unlock(&keyboard->mutex);
+    WINE_MUTEX_UNLOCK(&keyboard->mutex);

NtUserPostMessage(keyboard->focused_hwnd, WM_INPUTLANGCHANGEREQUEST, 0 /*FIXME*/,
                       (LPARAM)keyboard_hkl);
@@ -766,7 +766,7 @@ static void keyboard_handle_enter(void *data, struct wl_keyboard *wl_keyboard,
          * are in the same non-current thread. */
         if (surface->window.managed)
             NtUserPostMessage(hwnd, WM_WAYLAND_SET_FOREGROUND, 0, 0);
-        pthread_mutex_unlock(&surface->mutex);
+        WINE_MUTEX_UNLOCK(&surface->mutex);
     }
 }

@@ -783,10 +783,10 @@ static void keyboard_handle_leave(void *data, struct wl_keyboard *wl_keyboard,
     hwnd = wl_surface_get_user_data(wl_surface);
     TRACE("serial=%u hwnd=%p\n", serial, hwnd);

-    pthread_mutex_lock(&keyboard->mutex);
+    WINE_MUTEX_LOCK(&keyboard->mutex);
     if (keyboard->focused_hwnd == hwnd)
         keyboard->focused_hwnd = NULL;
-    pthread_mutex_unlock(&keyboard->mutex);
+    WINE_MUTEX_UNLOCK(&keyboard->mutex);

/* The spec for the leave event tells us to treat all keys as released,
      * and for any key repetition to stop. */
@@ -841,10 +841,10 @@ static void keyboard_handle_modifiers(void *data, struct wl_keyboard *wl_keyboar
     TRACE("serial=%u mods_depressed=%#x mods_latched=%#x mods_locked=%#x xkb_group=%d stub!\n",
           serial, mods_depressed, mods_latched, mods_locked, xkb_group);

-    pthread_mutex_lock(&keyboard->mutex);
+    WINE_MUTEX_LOCK(&keyboard->mutex);
     xkb_state_update_mask(keyboard->xkb_state, mods_depressed, mods_latched,
                           mods_locked, 0, 0, xkb_group);
-    pthread_mutex_unlock(&keyboard->mutex);
+    WINE_MUTEX_UNLOCK(&keyboard->mutex);

set_current_xkb_group(xkb_group);

@@ -901,10 +901,10 @@ void wayland_keyboard_init(struct wl_keyboard *wl_keyboard)
     }

NtUserCallOneParam(TRUE, NtUserCallOneParam_SetKeyboardAutoRepeat);
-    pthread_mutex_lock(&keyboard->mutex);
+    WINE_MUTEX_LOCK(&keyboard->mutex);
     keyboard->wl_keyboard = wl_keyboard;
     keyboard->xkb_context = xkb_context;
-    pthread_mutex_unlock(&keyboard->mutex);
+    WINE_MUTEX_UNLOCK(&keyboard->mutex);
     wl_keyboard_add_listener(keyboard->wl_keyboard, &keyboard_listener, NULL);
 }

@@ -915,7 +915,7 @@ void wayland_keyboard_deinit(void)
 {
     struct wayland_keyboard *keyboard = &process_wayland.keyboard;

-    pthread_mutex_lock(&keyboard->mutex);
+    WINE_MUTEX_LOCK(&keyboard->mutex);
     if (keyboard->wl_keyboard)
     {
         wl_keyboard_destroy(keyboard->wl_keyboard);
@@ -931,7 +931,7 @@ void wayland_keyboard_deinit(void)
         xkb_state_unref(keyboard->xkb_state);
         keyboard->xkb_state = NULL;
     }
-    pthread_mutex_unlock(&keyboard->mutex);
+    WINE_MUTEX_UNLOCK(&keyboard->mutex);

if (rxkb_context)
     {
@@ -949,14 +949,14 @@ const KBDTABLES *WAYLAND_KbdLayerDescriptor(HKL hkl)

TRACE("hkl=%p\n", hkl);

-    pthread_mutex_lock(&xkb_layouts_mutex);
+    WINE_MUTEX_LOCK(&xkb_layouts_mutex);

LIST_FOR_EACH_ENTRY(layout, &xkb_layouts, struct layout, entry)
         if (hkl == get_layout_hkl(layout, LOWORD(hkl))) break;
     if (&layout->entry == &xkb_layouts) layout = NULL;
     else xkb_layout_addref(layout);

-    pthread_mutex_unlock(&xkb_layouts_mutex);
+    WINE_MUTEX_UNLOCK(&xkb_layouts_mutex);

if (!layout)
     {
diff --git a/dlls/winewayland.drv/wayland_output.c b/dlls/winewayland.drv/wayland_output.c
index f76881a1770..85d854c3678 100644
--- a/dlls/winewayland.drv/wayland_output.c
+++ b/dlls/winewayland.drv/wayland_output.c
@@ -133,7 +133,7 @@ static void wayland_output_done(struct wayland_output *output)
     struct wayland_output_mode *mode;

/* Update current state from pending state. */
-    pthread_mutex_lock(&process_wayland.output_mutex);
+    WINE_MUTEX_LOCK(&process_wayland.output_mutex);

if (output->pending_flags & WAYLAND_OUTPUT_CHANGED_MODES)
     {
@@ -177,7 +177,7 @@ static void wayland_output_done(struct wayland_output *output)
         output->current.logical_h = output->current.current_mode->height;
     }

-    pthread_mutex_unlock(&process_wayland.output_mutex);
+    WINE_MUTEX_UNLOCK(&process_wayland.output_mutex);

TRACE("name=%s logical=%d,%d+%dx%d\n",
           output->current.name, output->current.logical_x, output->current.logical_y,
@@ -343,9 +343,9 @@ BOOL wayland_output_create(uint32_t id, uint32_t version)
     if (process_wayland.zxdg_output_manager_v1)
         wayland_output_use_xdg_extension(output);

-    pthread_mutex_lock(&process_wayland.output_mutex);
+    WINE_MUTEX_LOCK(&process_wayland.output_mutex);
     wl_list_insert(process_wayland.output_list.prev, &output->link);
-    pthread_mutex_unlock(&process_wayland.output_mutex);
+    WINE_MUTEX_UNLOCK(&process_wayland.output_mutex);

return TRUE;

@@ -367,9 +367,9 @@ static void wayland_output_state_deinit(struct wayland_output_state *state)
  */
 void wayland_output_destroy(struct wayland_output *output)
 {
-    pthread_mutex_lock(&process_wayland.output_mutex);
+    WINE_MUTEX_LOCK(&process_wayland.output_mutex);
     wl_list_remove(&output->link);
-    pthread_mutex_unlock(&process_wayland.output_mutex);
+    WINE_MUTEX_UNLOCK(&process_wayland.output_mutex);

wayland_output_state_deinit(&output->pending);
     wayland_output_state_deinit(&output->current);
diff --git a/dlls/winewayland.drv/wayland_pointer.c b/dlls/winewayland.drv/wayland_pointer.c
index 1d8acaeabd2..59b682a4ffe 100644
--- a/dlls/winewayland.drv/wayland_pointer.c
+++ b/dlls/winewayland.drv/wayland_pointer.c
@@ -39,9 +39,9 @@ static HWND wayland_pointer_get_focused_hwnd(void)
     struct wayland_pointer *pointer = &process_wayland.pointer;
     HWND hwnd;

-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     hwnd = pointer->focused_hwnd;
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);

return hwnd;
 }
@@ -72,7 +72,7 @@ static void pointer_handle_motion_internal(wl_fixed_t sx, wl_fixed_t sy)
     if (screen.y >= window_rect->bottom) screen.y = window_rect->bottom - 1;
     else if (screen.y < window_rect->top) screen.y = window_rect->top;

-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);

/* Hardware input events are in physical coordinates. */
     if (!NtUserLogicalToPerMonitorDPIPhysicalPoint(hwnd, &screen)) return;
@@ -116,10 +116,10 @@ static void pointer_handle_enter(void *data, struct wl_pointer *wl_pointer,

TRACE("hwnd=%p\n", hwnd);

-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     pointer->focused_hwnd = hwnd;
     pointer->enter_serial = serial;
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);

/* The cursor is undefined at every enter, so we set it again with
      * the latest information we have. */
@@ -140,10 +140,10 @@ static void pointer_handle_leave(void *data, struct wl_pointer *wl_pointer,

TRACE("hwnd=%p\n", wl_surface_get_user_data(wl_surface));

-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     pointer->focused_hwnd = NULL;
     pointer->enter_serial = 0;
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);
 }

static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer,
@@ -178,10 +178,10 @@ static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer,

if (state == WL_POINTER_BUTTON_STATE_RELEASED) input.mi.dwFlags <<= 1;

-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     pointer->button_serial = state == WL_POINTER_BUTTON_STATE_PRESSED ?
                              serial : 0;
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);

TRACE("hwnd=%p button=%#x state=%u\n", hwnd, button, state);

@@ -270,7 +270,7 @@ static void relative_pointer_v1_relative_motion(void *data,
                                      wl_fixed_to_double(dy),
                                      (int *)&screen.x, (int *)&screen.y);

-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);

/* We clip the relative motion within the window rectangle so that
      * the NtUserLogicalToPerMonitorDPIPhysicalPoint calls later succeed.
@@ -329,11 +329,11 @@ void wayland_pointer_init(struct wl_pointer *wl_pointer)
 {
     struct wayland_pointer *pointer = &process_wayland.pointer;

-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     pointer->wl_pointer = wl_pointer;
     pointer->focused_hwnd = NULL;
     pointer->enter_serial = 0;
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);
     wl_pointer_add_listener(pointer->wl_pointer, &pointer_listener, NULL);
 }

@@ -341,7 +341,7 @@ void wayland_pointer_deinit(void)
 {
     struct wayland_pointer *pointer = &process_wayland.pointer;

-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     if (pointer->zwp_confined_pointer_v1)
     {
         zwp_confined_pointer_v1_destroy(pointer->zwp_confined_pointer_v1);
@@ -361,7 +361,7 @@ void wayland_pointer_deinit(void)
     pointer->wl_pointer = NULL;
     pointer->focused_hwnd = NULL;
     pointer->enter_serial = 0;
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);
 }

/***********************************************************************
@@ -680,14 +680,14 @@ static void wayland_set_cursor(HWND hwnd, HCURSOR hcursor, BOOL use_hcursor)
         if (use_hcursor) surface->hcursor = hcursor;
         else hcursor = surface->hcursor;
         use_hcursor = TRUE;
-        pthread_mutex_unlock(&surface->mutex);
+        WINE_MUTEX_UNLOCK(&surface->mutex);
     }
     else
     {
         scale = 1.0;
     }

-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     if (pointer->focused_hwnd == hwnd)
     {
         if (use_hcursor) wayland_pointer_update_cursor_buffer(hcursor, scale);
@@ -700,7 +700,7 @@ static void wayland_set_cursor(HWND hwnd, HCURSOR hcursor, BOOL use_hcursor)
         wl_display_flush(process_wayland.wl_display);
         reapply_clip = TRUE;
     }
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);

/* Reapply cursor clip since cursor visibility affects pointer constraint
      * behavior. */
@@ -911,17 +911,17 @@ BOOL WAYLAND_ClipCursor(const RECT *clip, BOOL reset)
         wl_surface = surface->wl_surface;
         if (clip) wayland_surface_calc_confine(surface, clip, &confine_rect);
         covers_vscreen = wayland_surface_client_covers_vscreen(surface);
-        pthread_mutex_unlock(&surface->mutex);
+        WINE_MUTEX_UNLOCK(&surface->mutex);
     }

/* Since we are running in the context of the foreground thread we know
     * that the wl_surface of the foreground HWND will not be invalidated,
     * so we can access it without having the surface lock. */
-    pthread_mutex_lock(&pointer->mutex);
+    WINE_MUTEX_LOCK(&pointer->mutex);
     wayland_pointer_update_constraint(wl_surface,
                                       (clip && wl_surface) ? &confine_rect : NULL,
                                       covers_vscreen);
-    pthread_mutex_unlock(&pointer->mutex);
+    WINE_MUTEX_UNLOCK(&pointer->mutex);

wl_display_flush(process_wayland.wl_display);

diff --git a/dlls/winewayland.drv/wayland_surface.c b/dlls/winewayland.drv/wayland_surface.c
index a2699d66e51..8b7d9c81e31 100644
--- a/dlls/winewayland.drv/wayland_surface.c
+++ b/dlls/winewayland.drv/wayland_surface.c
@@ -60,7 +60,7 @@ static void xdg_surface_handle_configure(void *data, struct xdg_surface *xdg_sur
         if (should_post) NtUserPostMessage(hwnd, WM_WAYLAND_CONFIGURE, 0, 0);
     }

-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);

/* Flush the window surface in case there is content that we weren't
      * able to flush before due to the lack of the initial configure. */
@@ -120,7 +120,7 @@ static void xdg_toplevel_handle_configure(void *data,
         surface->pending.state = config_state;
     }

-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);
 }

static void xdg_toplevel_handle_close(void *data, struct xdg_toplevel *xdg_toplevel)
@@ -152,7 +152,11 @@ struct wayland_surface *wayland_surface_create(HWND hwnd)

TRACE("surface=%p\n", surface);

+#ifdef USE_AFL
+    __atomic_store_n(&surface->mutex, 0, __ATOMIC_RELEASE);
+#else
     pthread_mutex_init(&surface->mutex, NULL);
+#endif

surface->hwnd = hwnd;
     surface->wl_surface = wl_compositor_create_surface(process_wayland.wl_compositor);
@@ -186,7 +190,7 @@ err:
  */
 void wayland_surface_destroy(struct wayland_surface *surface)
 {
-    pthread_mutex_lock(&process_wayland.pointer.mutex);
+    WINE_MUTEX_LOCK(&process_wayland.pointer.mutex);
     if (process_wayland.pointer.focused_hwnd == surface->hwnd)
     {
         process_wayland.pointer.focused_hwnd = NULL;
@@ -194,14 +198,14 @@ void wayland_surface_destroy(struct wayland_surface *surface)
     }
     if (process_wayland.pointer.constraint_hwnd == surface->hwnd)
         wayland_pointer_clear_constraint();
-    pthread_mutex_unlock(&process_wayland.pointer.mutex);
+    WINE_MUTEX_UNLOCK(&process_wayland.pointer.mutex);

-    pthread_mutex_lock(&process_wayland.keyboard.mutex);
+    WINE_MUTEX_LOCK(&process_wayland.keyboard.mutex);
     if (process_wayland.keyboard.focused_hwnd == surface->hwnd)
         process_wayland.keyboard.focused_hwnd = NULL;
-    pthread_mutex_unlock(&process_wayland.keyboard.mutex);
+    WINE_MUTEX_UNLOCK(&process_wayland.keyboard.mutex);

-    pthread_mutex_lock(&surface->mutex);
+    WINE_MUTEX_LOCK(&surface->mutex);

if (surface->wp_viewport)
     {
@@ -227,14 +231,14 @@ void wayland_surface_destroy(struct wayland_surface *surface)
         surface->wl_surface = NULL;
     }

-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);

if (surface->latest_window_buffer)
         wayland_shm_buffer_unref(surface->latest_window_buffer);

wl_display_flush(process_wayland.wl_display);

-    pthread_mutex_destroy(&surface->mutex);
+    WINE_MUTEX_DESTROY(&surface->mutex);

free(surface);
 }
diff --git a/dlls/winewayland.drv/waylanddrv.h b/dlls/winewayland.drv/waylanddrv.h
index 1a2eeeecb93..c0a8b9eafea 100644
--- a/dlls/winewayland.drv/waylanddrv.h
+++ b/dlls/winewayland.drv/waylanddrv.h
@@ -41,6 +41,7 @@
 #include "wine/gdi_driver.h"
 #include "wine/list.h"
 #include "wine/rbtree.h"
+#include "wine/mutex.h"

#include "unixlib.h"

@@ -79,7 +80,7 @@ struct wayland_keyboard
     struct xkb_context *xkb_context;
     struct xkb_state *xkb_state;
     HWND focused_hwnd;
-    pthread_mutex_t mutex;
+    WINE_MUTEX_TYPE mutex;
 };

struct wayland_cursor
@@ -101,14 +102,14 @@ struct wayland_pointer
     uint32_t enter_serial;
     uint32_t button_serial;
     struct wayland_cursor cursor;
-    pthread_mutex_t mutex;
+    WINE_MUTEX_TYPE mutex;
 };

struct wayland_seat
 {
     struct wl_seat *wl_seat;
     uint32_t global_id;
-    pthread_mutex_t mutex;
+    WINE_MUTEX_TYPE mutex;
 };

struct wayland
@@ -130,7 +131,7 @@ struct wayland
     struct wayland_pointer pointer;
     struct wl_list output_list;
     /* Protects the output_list and the wayland_output.current states. */
-    pthread_mutex_t output_mutex;
+    WINE_MUTEX_TYPE output_mutex;
 };

struct wayland_output_mode
@@ -196,7 +197,7 @@ struct wayland_surface
     struct xdg_surface *xdg_surface;
     struct xdg_toplevel *xdg_toplevel;
     struct wp_viewport *wp_viewport;
-    pthread_mutex_t mutex;
+    WINE_MUTEX_TYPE mutex;
     struct wayland_surface_config pending, requested, processing, current;
     struct wayland_shm_buffer *latest_window_buffer;
     BOOL resizing;
diff --git a/dlls/winewayland.drv/window.c b/dlls/winewayland.drv/window.c
index e8d6b770496..fceb357b36b 100644
--- a/dlls/winewayland.drv/window.c
+++ b/dlls/winewayland.drv/window.c
@@ -68,7 +68,7 @@ static int wayland_win_data_cmp_rb(const void *key,
     return 0;
 }

-static pthread_mutex_t win_data_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE win_data_mutex = WINE_MUTEX_INIT;
 static struct rb_tree win_data_rb = { wayland_win_data_cmp_rb };

/***********************************************************************
@@ -95,7 +95,7 @@ static struct wayland_win_data *wayland_win_data_create(HWND hwnd,
     data->window_rect = *window_rect;
     data->client_rect = *client_rect;

-    pthread_mutex_lock(&win_data_mutex);
+    WINE_MUTEX_LOCK(&win_data_mutex);

/* Check that another thread hasn't already created the wayland_win_data. */
     if ((rb_entry = rb_get(&win_data_rb, hwnd)))
@@ -120,7 +120,7 @@ static void wayland_win_data_destroy(struct wayland_win_data *data)

rb_remove(&win_data_rb, &data->entry);

-    pthread_mutex_unlock(&win_data_mutex);
+    WINE_MUTEX_UNLOCK(&win_data_mutex);

if (data->window_surface)
     {
@@ -140,12 +140,12 @@ struct wayland_win_data *wayland_win_data_get(HWND hwnd)
 {
     struct rb_entry *rb_entry;

-    pthread_mutex_lock(&win_data_mutex);
+    WINE_MUTEX_LOCK(&win_data_mutex);

if ((rb_entry = rb_get(&win_data_rb, hwnd)))
         return RB_ENTRY_VALUE(rb_entry, struct wayland_win_data, entry);

-    pthread_mutex_unlock(&win_data_mutex);
+    WINE_MUTEX_UNLOCK(&win_data_mutex);

return NULL;
 }
@@ -158,7 +158,7 @@ struct wayland_win_data *wayland_win_data_get(HWND hwnd)
 void wayland_win_data_release(struct wayland_win_data *data)
 {
     assert(data);
-    pthread_mutex_unlock(&win_data_mutex);
+    WINE_MUTEX_UNLOCK(&win_data_mutex);
 }

static void wayland_win_data_get_config(struct wayland_win_data *data,
@@ -225,7 +225,7 @@ static void wayland_win_data_update_wayland_surface(struct wayland_win_data *dat
     visible = (NtUserGetWindowLongW(data->hwnd, GWL_STYLE) & WS_VISIBLE) == WS_VISIBLE;
     xdg_visible = surface->xdg_toplevel != NULL;

-    pthread_mutex_lock(&surface->mutex);
+    WINE_MUTEX_LOCK(&surface->mutex);

if (visible != xdg_visible)
     {
@@ -248,7 +248,7 @@ static void wayland_win_data_update_wayland_surface(struct wayland_win_data *dat

wayland_win_data_get_config(data, &surface->window);

-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);

if (data->window_surface)
         wayland_window_surface_update_wayland_surface(data->window_surface, visible_rect, surface);
@@ -267,7 +267,7 @@ static void wayland_win_data_update_wayland_state(struct wayland_win_data *data)
     struct wayland_surface *surface = data->wayland_surface;
     BOOL processing_config;

-    pthread_mutex_lock(&surface->mutex);
+    WINE_MUTEX_LOCK(&surface->mutex);

if (!surface->xdg_toplevel) goto out;

@@ -313,7 +313,7 @@ static void wayland_win_data_update_wayland_state(struct wayland_win_data *data)
     }

out:
-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);
     wl_display_flush(process_wayland.wl_display);
 }

@@ -488,14 +488,14 @@ static void wayland_configure_window(HWND hwnd)
     if (!surface->xdg_toplevel)
     {
         TRACE("missing xdg_toplevel, returning\n");
-        pthread_mutex_unlock(&surface->mutex);
+        WINE_MUTEX_UNLOCK(&surface->mutex);
         return;
     }

if (!surface->requested.serial)
     {
         TRACE("requested configure event already handled, returning\n");
-        pthread_mutex_unlock(&surface->mutex);
+        WINE_MUTEX_UNLOCK(&surface->mutex);
         return;
     }

@@ -557,7 +557,7 @@ static void wayland_configure_window(HWND hwnd)
     wayland_surface_coords_to_window(surface, width, height,
                                      &window_width, &window_height);

-    pthread_mutex_unlock(&surface->mutex);
+    WINE_MUTEX_UNLOCK(&surface->mutex);

TRACE("processing=%dx%d,%#x\n", width, height, state);

@@ -643,7 +643,7 @@ void WAYLAND_SetWindowText(HWND hwnd, LPCWSTR text)
     if (surface)
     {
         if (surface->xdg_toplevel) wayland_surface_set_title(surface, text);
-        pthread_mutex_unlock(&surface->mutex);
+        WINE_MUTEX_UNLOCK(&surface->mutex);
     }
 }

@@ -661,18 +661,18 @@ LRESULT WAYLAND_SysCommand(HWND hwnd, WPARAM wparam, LPARAM lparam)
     TRACE("cmd=%lx hwnd=%p, %lx, %lx\n",
           (long)command, hwnd, (long)wparam, lparam);

-    pthread_mutex_lock(&process_wayland.pointer.mutex);
+    WINE_MUTEX_LOCK(&process_wayland.pointer.mutex);
     if (process_wayland.pointer.focused_hwnd == hwnd)
         button_serial = process_wayland.pointer.button_serial;
     else
         button_serial = 0;
-    pthread_mutex_unlock(&process_wayland.pointer.mutex);
+    WINE_MUTEX_UNLOCK(&process_wayland.pointer.mutex);

if (command == SC_MOVE || command == SC_SIZE)
     {
         if ((surface = wayland_surface_lock_hwnd(hwnd)))
         {
-            pthread_mutex_lock(&process_wayland.seat.mutex);
+            WINE_MUTEX_LOCK(&process_wayland.seat.mutex);
             wl_seat = process_wayland.seat.wl_seat;
             if (wl_seat && surface->xdg_toplevel && button_serial)
             {
@@ -686,8 +686,8 @@ LRESULT WAYLAND_SysCommand(HWND hwnd, WPARAM wparam, LPARAM lparam)
                                         hittest_to_resize_edge(wparam & 0x0f));
                 }
             }
-            pthread_mutex_unlock(&process_wayland.seat.mutex);
-            pthread_mutex_unlock(&surface->mutex);
+            WINE_MUTEX_UNLOCK(&process_wayland.seat.mutex);
+            WINE_MUTEX_UNLOCK(&surface->mutex);
             ret = 0;
         }
     }
@@ -706,7 +706,7 @@ struct wayland_surface *wayland_surface_lock_hwnd(HWND hwnd)

if (!data) return NULL;

-    if ((surface = data->wayland_surface)) pthread_mutex_lock(&surface->mutex);
+    if ((surface = data->wayland_surface)) WINE_MUTEX_LOCK(&surface->mutex);

wayland_win_data_release(data);

diff --git a/dlls/winewayland.drv/window_surface.c b/dlls/winewayland.drv/window_surface.c
index e0c00dfb28f..8934b867824 100644
--- a/dlls/winewayland.drv/window_surface.c
+++ b/dlls/winewayland.drv/window_surface.c
@@ -386,7 +386,7 @@ static BOOL wayland_window_surface_flush(struct window_surface *window_surface,

wayland_shm_buffer_copy_data(shm_buffer, color_bits, &surface_rect, copy_from_window_region);

-    pthread_mutex_lock(&wws->wayland_surface->mutex);
+    WINE_MUTEX_LOCK(&wws->wayland_surface->mutex);
     if (wayland_surface_reconfigure(wws->wayland_surface))
     {
         wayland_surface_attach_shm(wws->wayland_surface, shm_buffer,
@@ -398,7 +398,7 @@ static BOOL wayland_window_surface_flush(struct window_surface *window_surface,
     {
         TRACE("Wayland surface not configured yet, not flushing\n");
     }
-    pthread_mutex_unlock(&wws->wayland_surface->mutex);
+    WINE_MUTEX_UNLOCK(&wws->wayland_surface->mutex);
     wl_display_flush(process_wayland.wl_display);

NtGdiSetRectRgn(shm_buffer->damage_region, 0, 0, 0, 0);

[PATCH 3/6] ntdll: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 dlls/ntdll/unix/cdrom.c         |  26 +++---
 dlls/ntdll/unix/file.c          |  46 +++++-----
 dlls/ntdll/unix/server.c        |  28 +++++--
 dlls/ntdll/unix/signal_i386.c   |   2 +-
 dlls/ntdll/unix/signal_x86_64.c |   2 +-
 dlls/ntdll/unix/system.c        |  12 +--
 dlls/ntdll/unix/unix_private.h  |  22 +++--
 dlls/ntdll/unix/virtual.c       | 144 ++++++++++++++++----------------
 8 files changed, 147 insertions(+), 135 deletions(-)

diff --git a/dlls/ntdll/unix/cdrom.c b/dlls/ntdll/unix/cdrom.c
index 9e651414e9a..2127e3f56e8 100644
--- a/dlls/ntdll/unix/cdrom.c
+++ b/dlls/ntdll/unix/cdrom.c
@@ -290,7 +290,7 @@ struct cdrom_cache {
 #define MAX_CACHE_ENTRIES       5
 static struct cdrom_cache cdrom_cache[MAX_CACHE_ENTRIES];

-static pthread_mutex_t cache_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE cache_mutex = WINE_MUTEX_INIT;

/* Proposed media change function: not really needed at this time */
 /* This is a 1 or 0 type of function */
@@ -551,9 +551,9 @@ static NTSTATUS CDROM_SyncCache(int dev, int fd)

static void CDROM_ClearCacheEntry(int dev)
 {
-    mutex_lock( &cache_mutex );
+    WINENTDLL_MUTEX_LOCK( &cache_mutex );
     cdrom_cache[dev].toc_good = 0;
-    mutex_unlock( &cache_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &cache_mutex );
 }

@@ -659,7 +659,7 @@ static NTSTATUS CDROM_Open(int fd, int* dev)

if (fstat(fd, &st) == -1) return errno_to_status( errno );

-    mutex_lock( &cache_mutex );
+    WINENTDLL_MUTEX_LOCK( &cache_mutex );
     for (*dev = 0; *dev < MAX_CACHE_ENTRIES; (*dev)++)
     {
         if (empty == -1 &&
@@ -680,7 +680,7 @@ static NTSTATUS CDROM_Open(int fd, int* dev)
             cdrom_cache[*dev].inode   = st.st_ino;
         }
     }
-    mutex_unlock( &cache_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &cache_mutex );

TRACE("%d, %d\n", *dev, fd);
     return ret;
@@ -832,13 +832,13 @@ static NTSTATUS CDROM_ReadTOC(int dev, int fd, CDROM_TOC* toc)
     if (dev < 0 || dev >= MAX_CACHE_ENTRIES)
         return STATUS_INVALID_PARAMETER;

-    mutex_lock( &cache_mutex );
+    WINENTDLL_MUTEX_LOCK( &cache_mutex );
     if (cdrom_cache[dev].toc_good || !(ret = CDROM_SyncCache(dev, fd)))
     {
         *toc = cdrom_cache[dev].toc;
         ret = STATUS_SUCCESS;
     }
-    mutex_unlock( &cache_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &cache_mutex );
     return ret;
 }

@@ -918,7 +918,7 @@ static NTSTATUS CDROM_ReadQChannel(int dev, int fd, const CDROM_SUB_Q_DATA_FORMA
     switch (fmt->Format)
     {
     case IOCTL_CDROM_CURRENT_POSITION:
-        mutex_lock( &cache_mutex );
+        WINENTDLL_MUTEX_LOCK( &cache_mutex );
    if (hdr->AudioStatus==AUDIO_STATUS_IN_PROGRESS) {
           data->CurrentPosition.FormatCode = IOCTL_CDROM_CURRENT_POSITION;
           data->CurrentPosition.Control = sc.cdsc_ctrl;
@@ -943,7 +943,7 @@ static NTSTATUS CDROM_ReadQChannel(int dev, int fd, const CDROM_SUB_Q_DATA_FORMA
      cdrom_cache[dev].CurrentPosition.Header = *hdr; /* Preserve header info */
      data->CurrentPosition = cdrom_cache[dev].CurrentPosition;
    }
-        mutex_unlock( &cache_mutex );
+        WINENTDLL_MUTEX_UNLOCK( &cache_mutex );
         break;
     case IOCTL_CDROM_MEDIA_CATALOG:
         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
@@ -1029,7 +1029,7 @@ static NTSTATUS CDROM_ReadQChannel(int dev, int fd, const CDROM_SUB_Q_DATA_FORMA
     switch (fmt->Format)
     {
     case IOCTL_CDROM_CURRENT_POSITION:
-        mutex_lock( &cache_mutex );
+        WINENTDLL_MUTEX_LOCK( &cache_mutex );
    if (hdr->AudioStatus==AUDIO_STATUS_IN_PROGRESS) {
           data->CurrentPosition.FormatCode = IOCTL_CDROM_CURRENT_POSITION;
           data->CurrentPosition.Control = sc.what.position.control;
@@ -1051,7 +1051,7 @@ static NTSTATUS CDROM_ReadQChannel(int dev, int fd, const CDROM_SUB_Q_DATA_FORMA
      cdrom_cache[dev].CurrentPosition.Header = *hdr; /* Preserve header info */
      data->CurrentPosition = cdrom_cache[dev].CurrentPosition;
    }
-        mutex_unlock( &cache_mutex );
+        WINENTDLL_MUTEX_UNLOCK( &cache_mutex );
         break;
     case IOCTL_CDROM_MEDIA_CATALOG:
         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
@@ -1240,7 +1240,7 @@ static NTSTATUS CDROM_SeekAudioMSF(int dev, int fd, const CDROM_SEEK_AUDIO_MSF*
     if (i <= toc.FirstTrack || i > toc.LastTrack+1)
       return STATUS_INVALID_PARAMETER;
     i--;
-    mutex_lock( &cache_mutex );
+    WINENTDLL_MUTEX_LOCK( &cache_mutex );
     cp = &cdrom_cache[dev].CurrentPosition;
     cp->FormatCode = IOCTL_CDROM_CURRENT_POSITION;
     cp->Control = toc.TrackData[i-toc.FirstTrack].Control;
@@ -1254,7 +1254,7 @@ static NTSTATUS CDROM_SeekAudioMSF(int dev, int fd, const CDROM_SEEK_AUDIO_MSF*
     frame -= FRAME_OF_TOC(toc,i);
     cp->TrackRelativeAddress[0] = 0;
     MSF_OF_FRAME(cp->TrackRelativeAddress[1], frame);
-    mutex_unlock( &cache_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &cache_mutex );

/* If playing, then issue a seek command, otherwise do nothing */
 #ifdef linux
diff --git a/dlls/ntdll/unix/file.c b/dlls/ntdll/unix/file.c
index ca95dd347eb..bdac6d2daa3 100644
--- a/dlls/ntdll/unix/file.c
+++ b/dlls/ntdll/unix/file.c
@@ -243,8 +243,8 @@ static mode_t start_umask;
 /* at some point we may want to allow Winelib apps to set this */
 static const BOOL is_case_sensitive = FALSE;

-static pthread_mutex_t dir_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t mnt_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE dir_mutex = WINE_MUTEX_INIT;
+static WINE_MUTEX_TYPE mnt_mutex = WINE_MUTEX_INIT;

/* check if a given Unicode char is OK in a DOS short name */
 static inline BOOL is_invalid_dos_char( WCHAR ch )
@@ -884,7 +884,7 @@ static char *get_default_drive_device( const char *root )
     if (res == -1) res = stat( root, &st );
     if (res == -1) return NULL;

-    mutex_lock( &mnt_mutex );
+    WINENTDLL_MUTEX_LOCK( &mnt_mutex );

#ifdef __ANDROID__
     if ((f = fopen( "/proc/mounts", "r" )))
@@ -906,7 +906,7 @@ static char *get_default_drive_device( const char *root )
     }
 #endif
     if (device) ret = strdup( device );
-    mutex_unlock( &mnt_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &mnt_mutex );

#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__ ) || defined(__DragonFly__)
     char *device = NULL;
@@ -923,14 +923,14 @@ static char *get_default_drive_device( const char *root )
     if (res == -1) res = stat( root, &st );
     if (res == -1) return NULL;

-    mutex_lock( &mnt_mutex );
+    WINENTDLL_MUTEX_LOCK( &mnt_mutex );

/* The FreeBSD parse_mount_entries doesn't require a file argument, so just
      * pass NULL.  Leave the argument in for symmetry.
      */
     device = parse_mount_entries( NULL, st.st_dev, st.st_ino );
     if (device) ret = strdup( device );
-    mutex_unlock( &mnt_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &mnt_mutex );

#elif defined( sun )
     FILE *f;
@@ -948,7 +948,7 @@ static char *get_default_drive_device( const char *root )
     if (res == -1) res = stat( root, &st );
     if (res == -1) return NULL;

-    mutex_lock( &mnt_mutex );
+    WINENTDLL_MUTEX_LOCK( &mnt_mutex );

if ((f = fopen( "/etc/mnttab", "r" )))
     {
@@ -962,7 +962,7 @@ static char *get_default_drive_device( const char *root )
         fclose( f );
     }
     if (device) ret = strdup( device );
-    mutex_unlock( &mnt_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &mnt_mutex );

#elif defined(__APPLE__)
     struct statfs *mntStat;
@@ -980,7 +980,7 @@ static char *get_default_drive_device( const char *root )
     dev = st.st_dev;
     ino = st.st_ino;

-    mutex_lock( &mnt_mutex );
+    WINENTDLL_MUTEX_LOCK( &mnt_mutex );

mntSize = getmntinfo(&mntStat, MNT_NOWAIT);

@@ -1001,7 +1001,7 @@ static char *get_default_drive_device( const char *root )
             }
         }
     }
-    mutex_unlock( &mnt_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &mnt_mutex );
 #else
     static int warned;
     if (!warned++) FIXME( "auto detection of DOS devices not supported on this platform\n" );
@@ -1022,7 +1022,7 @@ static char *get_device_mount_point( dev_t dev )
 #ifdef linux
     FILE *f;

-    mutex_lock( &mnt_mutex );
+    WINENTDLL_MUTEX_LOCK( &mnt_mutex );

#ifdef __ANDROID__
     if ((f = fopen( "/proc/mounts", "r" )))
@@ -1069,13 +1069,13 @@ static char *get_device_mount_point( dev_t dev )
         }
         fclose( f );
     }
-    mutex_unlock( &mnt_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &mnt_mutex );
 #elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
     struct statfs *entry;
     struct stat st;
     int i, size;

-    mutex_lock( &mnt_mutex );
+    WINENTDLL_MUTEX_LOCK( &mnt_mutex );

size = getmntinfo( &entry, MNT_NOWAIT );
     for (i = 0; i < size; i++)
@@ -1087,7 +1087,7 @@ static char *get_device_mount_point( dev_t dev )
             break;
         }
     }
-    mutex_unlock( &mnt_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &mnt_mutex );
 #else
     static int warned;
     if (!warned++) FIXME( "unmounting devices not supported on this platform\n" );
@@ -2169,14 +2169,14 @@ static unsigned int server_open_file_object( HANDLE *handle, ACCESS_MASK access,
 /* retrieve device/inode number for all the drives */
 static unsigned int get_drives_info( struct file_identity info[MAX_DOS_DRIVES] )
 {
-    static pthread_mutex_t cache_mutex = PTHREAD_MUTEX_INITIALIZER;
+    static WINE_MUTEX_TYPE cache_mutex = WINE_MUTEX_INIT;
     static struct file_identity cache[MAX_DOS_DRIVES];
     static time_t last_update;
     static unsigned int nb_drives;
     unsigned int ret;
     time_t now = time(NULL);

-    mutex_lock( &cache_mutex );
+    WINENTDLL_MUTEX_LOCK( &cache_mutex );
     if (now != last_update)
     {
         char *buffer, *p;
@@ -2208,7 +2208,7 @@ static unsigned int get_drives_info( struct file_identity info[MAX_DOS_DRIVES] )
     }
     memcpy( info, cache, sizeof(cache) );
     ret = nb_drives;
-    mutex_unlock( &cache_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &cache_mutex );
     return ret;
 }

@@ -2744,7 +2744,7 @@ NTSTATUS WINAPI NtQueryDirectoryFile( HANDLE handle, HANDLE event, PIO_APC_ROUTI

io->Information = 0;

-    mutex_lock( &dir_mutex );
+    WINENTDLL_MUTEX_LOCK( &dir_mutex );

cwd = open( ".", O_RDONLY );
     if (fchdir( fd ) != -1)
@@ -2771,7 +2771,7 @@ NTSTATUS WINAPI NtQueryDirectoryFile( HANDLE handle, HANDLE event, PIO_APC_ROUTI
     }
     else status = errno_to_status( errno );

-    mutex_unlock( &dir_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &dir_mutex );

if (needs_close) close( fd );
     if (cwd != -1) close( cwd );
@@ -3369,7 +3369,7 @@ static NTSTATUS file_id_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char *
         goto done;
     }

-    mutex_lock( &dir_mutex );
+    WINENTDLL_MUTEX_LOCK( &dir_mutex );
     if ((old_cwd = open( ".", O_RDONLY )) != -1 && fchdir( root_fd ) != -1)
     {
         /* shortcut for ".." */
@@ -3390,7 +3390,7 @@ static NTSTATUS file_id_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char *
         if (fchdir( old_cwd ) == -1) chdir( "/" );
     }
     else status = errno_to_status( errno );
-    mutex_unlock( &dir_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &dir_mutex );
     if (old_cwd != -1) close( old_cwd );

done:
@@ -3691,14 +3691,14 @@ NTSTATUS nt_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char **name_ret, U
         }
         else
         {
-            mutex_lock( &dir_mutex );
+            WINENTDLL_MUTEX_LOCK( &dir_mutex );
             if ((old_cwd = open( ".", O_RDONLY )) != -1 && fchdir( root_fd ) != -1)
             {
                 status = lookup_unix_name( name, name_len, &unix_name, unix_len, 1, disposition, FALSE );
                 if (fchdir( old_cwd ) == -1) chdir( "/" );
             }
             else status = errno_to_status( errno );
-            mutex_unlock( &dir_mutex );
+            WINENTDLL_MUTEX_UNLOCK( &dir_mutex );
             if (old_cwd != -1) close( old_cwd );
             if (needs_close) close( root_fd );
         }
diff --git a/dlls/ntdll/unix/server.c b/dlls/ntdll/unix/server.c
index f3ffd99c3fc..a56ffc7a1ea 100644
--- a/dlls/ntdll/unix/server.c
+++ b/dlls/ntdll/unix/server.c
@@ -103,7 +103,7 @@ sigset_t server_block_set;  /* signals to block during server calls */
 static int fd_socket = -1;  /* socket to exchange file descriptors with the server */
 static int initial_cwd = -1;
 static pid_t server_pid;
-static pthread_mutex_t fd_cache_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE fd_cache_mutex = WINE_MUTEX_INIT;

/* atomically exchange a 64-bit value */
 static inline LONG64 interlocked_xchg64( LONG64 *dest, LONG64 val )
@@ -297,22 +297,40 @@ NTSTATUS unixcall_wine_server_call( void *args )
 /***********************************************************************
  *           server_enter_uninterrupted_section
  */
-void server_enter_uninterrupted_section( pthread_mutex_t *mutex, sigset_t *sigset )
+void server_enter_uninterrupted_section( WINE_MUTEX_TYPE *mutex, sigset_t *sigset )
 {
     pthread_sigmask( SIG_BLOCK, &server_block_set, sigset );
-    mutex_lock( mutex );
+    WINENTDLL_MUTEX_LOCK( mutex );
 }

/***********************************************************************
  *           server_leave_uninterrupted_section
  */
-void server_leave_uninterrupted_section( pthread_mutex_t *mutex, sigset_t *sigset )
+void server_leave_uninterrupted_section( WINE_MUTEX_TYPE *mutex, sigset_t *sigset )
 {
-    mutex_unlock( mutex );
+    WINENTDLL_MUTEX_UNLOCK( mutex );
     pthread_sigmask( SIG_SETMASK, sigset, NULL );
 }

+/***********************************************************************
+ *           server_enter_uninterrupted_section_recursive
+ */
+void server_enter_uninterrupted_section_recursive( WINE_MUTEX_RECURSIVE_TYPE *mutex, sigset_t *sigset )
+{
+    pthread_sigmask( SIG_BLOCK, &server_block_set, sigset );
+    WINENTDLL_MUTEX_RECURSIVE_LOCK( mutex );
+}
+
+
+/***********************************************************************
+ *           server_leave_uninterrupted_section_recursive
+ */
+void server_leave_uninterrupted_section_recursive( WINE_MUTEX_RECURSIVE_TYPE *mutex, sigset_t *sigset )
+{
+    WINENTDLL_MUTEX_RECURSIVE_UNLOCK( mutex );
+    pthread_sigmask( SIG_SETMASK, sigset, NULL );
+}

/***********************************************************************
  *              wait_select_reply
diff --git a/dlls/ntdll/unix/signal_i386.c b/dlls/ntdll/unix/signal_i386.c
index 61d41ec3589..1739d56b4c9 100644
--- a/dlls/ntdll/unix/signal_i386.c
+++ b/dlls/ntdll/unix/signal_i386.c
@@ -2179,7 +2179,7 @@ struct ldt_copy
 } __wine_ldt_copy;

static WORD gdt_fs_sel;
-static pthread_mutex_t ldt_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE ldt_mutex = WINE_MUTEX_INIT;
 static const LDT_ENTRY null_entry;

static inline void *ldt_get_base( LDT_ENTRY ent )
diff --git a/dlls/ntdll/unix/signal_x86_64.c b/dlls/ntdll/unix/signal_x86_64.c
index e84044fa805..b5cfba3a953 100644
--- a/dlls/ntdll/unix/signal_x86_64.c
+++ b/dlls/ntdll/unix/signal_x86_64.c
@@ -2223,7 +2223,7 @@ struct ldt_copy
     unsigned char flags[LDT_SIZE];
 } __wine_ldt_copy;

-static pthread_mutex_t ldt_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE ldt_mutex = WINE_MUTEX_INIT;

static inline void *ldt_get_base( LDT_ENTRY ent )
 {
diff --git a/dlls/ntdll/unix/system.c b/dlls/ntdll/unix/system.c
index 9343d13262c..5dda70683dc 100644
--- a/dlls/ntdll/unix/system.c
+++ b/dlls/ntdll/unix/system.c
@@ -230,7 +230,7 @@ static SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *logical_proc_info_ex;
 static unsigned int logical_proc_info_ex_size, logical_proc_info_ex_alloc_size;
 static ULONG_PTR system_cpu_mask;

-static pthread_mutex_t timezone_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE timezone_mutex = WINE_MUTEX_INIT;

/*******************************************************************************
  * Architecture specific feature detection for CPUs
@@ -2483,7 +2483,7 @@ static void get_timezone_info( RTL_DYNAMIC_TIME_ZONE_INFORMATION *tzi )
     time_t year_start, year_end, tmp, dlt = 0, std = 0;
     int is_dst, bias;

-    mutex_lock( &timezone_mutex );
+    WINENTDLL_MUTEX_LOCK( &timezone_mutex );

year_start = time(NULL);
     tm = gmtime(&year_start);
@@ -2493,7 +2493,7 @@ static void get_timezone_info( RTL_DYNAMIC_TIME_ZONE_INFORMATION *tzi )
     if (current_year == tm->tm_year && current_bias == bias)
     {
         *tzi = cached_tzi;
-        mutex_unlock( &timezone_mutex );
+        WINENTDLL_MUTEX_UNLOCK( &timezone_mutex );
         return;
     }

@@ -2586,7 +2586,7 @@ static void get_timezone_info( RTL_DYNAMIC_TIME_ZONE_INFORMATION *tzi )

find_reg_tz_info(tzi, tz_name, current_year + 1900);
     cached_tzi = *tzi;
-    mutex_unlock( &timezone_mutex );
+    WINENTDLL_MUTEX_UNLOCK( &timezone_mutex );
 }

@@ -2796,7 +2796,7 @@ NTSTATUS WINAPI NtQuerySystemInformation( SYSTEM_INFORMATION_CLASS class,
         sti.BootTime.QuadPart = server_start_time;

utc = time( NULL );
-        pthread_mutex_lock( &timezone_mutex );
+        WINENTDLL_MUTEX_LOCK( &timezone_mutex );
         if (utc != last_utc)
         {
             last_utc = utc;
@@ -2807,7 +2807,7 @@ NTSTATUS WINAPI NtQuerySystemInformation( SYSTEM_INFORMATION_CLASS class,
             last_bias *= TICKSPERSEC;
         }
         sti.TimeZoneBias.QuadPart = last_bias;
-        pthread_mutex_unlock( &timezone_mutex );
+        WINENTDLL_MUTEX_UNLOCK( &timezone_mutex );

NtQuerySystemTime( &sti.SystemTime );

diff --git a/dlls/ntdll/unix/unix_private.h b/dlls/ntdll/unix/unix_private.h
index ee5630e76f1..1d2ce77014d 100644
--- a/dlls/ntdll/unix/unix_private.h
+++ b/dlls/ntdll/unix/unix_private.h
@@ -27,6 +27,7 @@
 #include "wine/unixlib.h"
 #include "wine/server.h"
 #include "wine/list.h"
+#include "wine/mutex.h"
 #include "wine/debug.h"

struct msghdr;
@@ -205,8 +206,10 @@ extern ULONG_PTR redirect_arm64ec_rva( void *module, ULONG_PTR rva, const IMAGE_
 extern void start_server( BOOL debug );

extern unsigned int server_call_unlocked( void *req_ptr );
-extern void server_enter_uninterrupted_section( pthread_mutex_t *mutex, sigset_t *sigset );
-extern void server_leave_uninterrupted_section( pthread_mutex_t *mutex, sigset_t *sigset );
+extern void server_enter_uninterrupted_section( WINE_MUTEX_TYPE *mutex, sigset_t *sigset );
+extern void server_leave_uninterrupted_section( WINE_MUTEX_TYPE *mutex, sigset_t *sigset );
+extern void server_enter_uninterrupted_section_recursive( WINE_MUTEX_RECURSIVE_TYPE *mutex, sigset_t *sigset );
+extern void server_leave_uninterrupted_section_recursive( WINE_MUTEX_RECURSIVE_TYPE *mutex, sigset_t *sigset );
 extern unsigned int server_select( const select_op_t *select_op, data_size_t size, UINT flags,
                                    timeout_t abs_timeout, context_t *context, user_apc_t *user_apc );
 extern unsigned int server_wait( const select_op_t *select_op, data_size_t size, UINT flags,
@@ -422,16 +425,6 @@ static inline BOOL is_ec_code( ULONG_PTR ptr )
     return (map[page / 64] >> (page & 63)) & 1;
 }

-static inline void mutex_lock( pthread_mutex_t *mutex )
-{
-    if (!process_exiting) pthread_mutex_lock( mutex );
-}
-
-static inline void mutex_unlock( pthread_mutex_t *mutex )
-{
-    if (!process_exiting) pthread_mutex_unlock( mutex );
-}
-
 static inline async_data_t server_async( HANDLE handle, struct async_fileio *user, HANDLE event,
                                          PIO_APC_ROUTINE apc, void *apc_context, client_ptr_t iosb )
 {
@@ -570,4 +563,9 @@ static inline NTSTATUS map_section( HANDLE mapping, void **ptr, SIZE_T *size, UL
                                0, NULL, size, ViewShare, 0, protect );
 }

+#define WINENTDLL_MUTEX_LOCK(RESOURCE) { if (!process_exiting) WINE_MUTEX_LOCK(RESOURCE); }
+#define WINENTDLL_MUTEX_UNLOCK(RESOURCE) { if (!process_exiting) WINE_MUTEX_UNLOCK(RESOURCE); }
+#define WINENTDLL_MUTEX_RECURSIVE_LOCK(RESOURCE) { if (!process_exiting) WINE_MUTEX_RECURSIVE_LOCK(RESOURCE); }
+#define WINENTDLL_MUTEX_RECURSIVE_UNLOCK(RESOURCE) { if (!process_exiting) WINE_MUTEX_RECURSIVE_UNLOCK(RESOURCE); }
+
 #endif /* __NTDLL_UNIX_PRIVATE_H */
diff --git a/dlls/ntdll/unix/virtual.c b/dlls/ntdll/unix/virtual.c
index 0fedfe0fb1d..afd74904c10 100644
--- a/dlls/ntdll/unix/virtual.c
+++ b/dlls/ntdll/unix/virtual.c
@@ -150,7 +150,7 @@ static const BYTE VIRTUAL_Win32Flags[16] =
 };

static struct wine_rb_tree views_tree;
-static pthread_mutex_t virtual_mutex;
+static WINE_MUTEX_RECURSIVE_TYPE virtual_mutex;

static const UINT page_shift = 12;
 static const UINT_PTR page_mask = 0xfff;
@@ -619,7 +619,7 @@ void *get_builtin_so_handle( void *module )
     void *ret = NULL;
     struct builtin_module *builtin;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     LIST_FOR_EACH_ENTRY( builtin, &builtin_modules, struct builtin_module, entry )
     {
         if (builtin->module != module) continue;
@@ -627,7 +627,7 @@ void *get_builtin_so_handle( void *module )
         if (ret) builtin->refcount++;
         break;
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return ret;
 }

@@ -642,7 +642,7 @@ static NTSTATUS get_builtin_unix_funcs( void *module, BOOL wow, const void **fun
     NTSTATUS status = STATUS_DLL_NOT_FOUND;
     struct builtin_module *builtin;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     LIST_FOR_EACH_ENTRY( builtin, &builtin_modules, struct builtin_module, entry )
     {
         if (builtin->module != module) continue;
@@ -655,7 +655,7 @@ static NTSTATUS get_builtin_unix_funcs( void *module, BOOL wow, const void **fun
         }
         break;
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -669,7 +669,7 @@ NTSTATUS load_builtin_unixlib( void *module, const char *name )
     NTSTATUS status = STATUS_SUCCESS;
     struct builtin_module *builtin;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     LIST_FOR_EACH_ENTRY( builtin, &builtin_modules, struct builtin_module, entry )
     {
         if (builtin->module != module) continue;
@@ -677,7 +677,7 @@ NTSTATUS load_builtin_unixlib( void *module, const char *name )
         else status = STATUS_IMAGE_ALREADY_LOADED;
         break;
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -1164,12 +1164,12 @@ static void VIRTUAL_Dump(void)
     struct file_view *view;

TRACE( "Dump of all virtual memory views:\n" );
-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     WINE_RB_FOR_EACH_ENTRY( view, &views_tree, struct file_view, entry )
     {
         dump_view( view );
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
 }
 #endif

@@ -3075,7 +3075,7 @@ static NTSTATUS virtual_map_image( HANDLE mapping, void **addr_ptr, SIZE_T *size
         SERVER_END_REQ;
     }

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

status = map_image_view( &view, image_info, size, limit_low, limit_high, alloc_type );
     if (status) goto done;
@@ -3104,7 +3104,7 @@ static NTSTATUS virtual_map_image( HANDLE mapping, void **addr_ptr, SIZE_T *size
     else delete_view( view );

done:
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (needs_close) close( unix_fd );
     if (shared_needs_close) close( shared_fd );
     return status;
@@ -3209,7 +3209,7 @@ static unsigned int virtual_map_section( HANDLE handle, PVOID *addr_ptr, ULONG_P

if ((res = server_get_unix_fd( handle, 0, &unix_handle, &needs_close, NULL, NULL ))) return res;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

res = map_view( &view, base, size, alloc_type, vprot, limit_low, limit_high, 0 );
     if (res) goto done;
@@ -3240,7 +3240,7 @@ static unsigned int virtual_map_section( HANDLE handle, PVOID *addr_ptr, ULONG_P
     else delete_view( view );

done:
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (needs_close) close( unix_handle );
     return res;
 }
@@ -3289,12 +3289,8 @@ void virtual_init(void)
     const char *preload = getenv( "WINEPRELOADRESERVE" );
     size_t size;
     int i;
-    pthread_mutexattr_t attr;

-    pthread_mutexattr_init( &attr );
-    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
-    pthread_mutex_init( &virtual_mutex, &attr );
-    pthread_mutexattr_destroy( &attr );
+    WINE_MUTEX_RECURSIVE_INIT(&virtual_mutex);

#ifdef __aarch64__
     host_addr_space_limit = get_host_addr_space_limit();
@@ -3502,7 +3498,7 @@ NTSTATUS virtual_create_builtin_view( void *module, const UNICODE_STRING *nt_nam
     void *base = wine_server_get_ptr( info->base );
     int i;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     status = create_view( &view, base, size, SEC_IMAGE | SEC_FILE | VPROT_SYSTEM |
                           VPROT_COMMITTED | VPROT_READ | VPROT_WRITECOPY | VPROT_EXEC );
     if (!status)
@@ -3539,7 +3535,7 @@ NTSTATUS virtual_create_builtin_view( void *module, const UNICODE_STRING *nt_nam
         }
         else delete_view( view );
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );

return status;
 }
@@ -3708,7 +3704,7 @@ NTSTATUS virtual_alloc_teb( TEB **ret_teb )
     NTSTATUS status = STATUS_SUCCESS;
     SIZE_T block_size = signal_stack_mask + 1;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (next_free_teb)
     {
         ptr = next_free_teb;
@@ -3724,7 +3720,7 @@ NTSTATUS virtual_alloc_teb( TEB **ret_teb )
             if ((status = NtAllocateVirtualMemory( NtCurrentProcess(), &ptr, user_space_wow_limit,
                                                    &total, MEM_RESERVE, PAGE_READWRITE )))
             {
-                server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+                server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
                 return status;
             }
             teb_block = ptr;
@@ -3735,14 +3731,14 @@ NTSTATUS virtual_alloc_teb( TEB **ret_teb )
                                  MEM_COMMIT, PAGE_READWRITE );
     }
     *ret_teb = teb = init_teb( ptr, is_wow64() );
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if ((status = signal_alloc_thread( teb )))
     {
-        server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+        server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
         *(void **)ptr = next_free_teb;
         next_free_teb = ptr;
-        server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+        server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     }
     return status;
 }
@@ -3783,13 +3779,13 @@ void virtual_free_teb( TEB *teb )
         NtFreeVirtualMemory( GetCurrentProcess(), &ptr, &size, MEM_RELEASE );
     }

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     list_remove( &thread_data->entry );
     ptr = teb;
     if (!is_win64) ptr = (char *)ptr - teb_offset;
     *(void **)ptr = next_free_teb;
     next_free_teb = ptr;
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
 }

@@ -3803,7 +3799,7 @@ NTSTATUS virtual_clear_tls_index( ULONG index )

if (index < TLS_MINIMUM_AVAILABLE)
     {
-        server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+        server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
         LIST_FOR_EACH_ENTRY( thread_data, &teb_list, struct ntdll_thread_data, entry )
         {
             TEB *teb = CONTAINING_RECORD( thread_data, TEB, GdiTebBatch );
@@ -3814,14 +3810,14 @@ NTSTATUS virtual_clear_tls_index( ULONG index )
 #endif
             teb->TlsSlots[index] = 0;
         }
-        server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+        server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     }
     else
     {
         index -= TLS_MINIMUM_AVAILABLE;
         if (index >= 8 * sizeof(peb->TlsExpansionBitmapBits)) return STATUS_INVALID_PARAMETER;

-        server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+        server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
         LIST_FOR_EACH_ENTRY( thread_data, &teb_list, struct ntdll_thread_data, entry )
         {
             TEB *teb = CONTAINING_RECORD( thread_data, TEB, GdiTebBatch );
@@ -3836,7 +3832,7 @@ NTSTATUS virtual_clear_tls_index( ULONG index )
 #endif
             if (teb->TlsExpansionSlots) teb->TlsExpansionSlots[index] = 0;
         }
-        server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+        server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     }
     return STATUS_SUCCESS;
 }
@@ -3860,7 +3856,7 @@ NTSTATUS virtual_alloc_thread_stack( INITIAL_TEB *stack, ULONG_PTR limit_low, UL
     if (size < 1024 * 1024) size = 1024 * 1024;  /* Xlib needs a large stack */
     size = (size + 0xffff) & ~0xffff;  /* round to 64K boundary */

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

status = map_view( &view, NULL, size, 0, VPROT_READ | VPROT_WRITE | VPROT_COMMITTED,
                        limit_low, limit_high, 0 );
@@ -3887,7 +3883,7 @@ NTSTATUS virtual_alloc_thread_stack( INITIAL_TEB *stack, ULONG_PTR limit_low, UL
     stack->StackBase = (char *)view->base + view->size;
     stack->StackLimit = (char *)view->base + (guard_page ? 2 * page_size : 0);
 done:
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -3995,7 +3991,7 @@ NTSTATUS virtual_handle_fault( void *addr, DWORD err, void *stack )
     char *page = ROUND_ADDR( addr, page_mask );
     BYTE vprot;

-    mutex_lock( &virtual_mutex );  /* no need for signal masking inside signal handler */
+    WINENTDLL_MUTEX_RECURSIVE_LOCK( &virtual_mutex );  /* no need for signal masking inside signal handler */
     vprot = get_page_vprot( page );

#ifdef __APPLE__
@@ -4032,7 +4028,7 @@ NTSTATUS virtual_handle_fault( void *addr, DWORD err, void *stack )
                 ret = STATUS_SUCCESS;
         }
     }
-    mutex_unlock( &virtual_mutex );
+    WINENTDLL_MUTEX_RECURSIVE_UNLOCK( &virtual_mutex );
     return ret;
 }

@@ -4070,14 +4066,14 @@ void *virtual_setup_exception( void *stack_ptr, size_t size, EXCEPTION_RECORD *r
     }
     else if (stack < stack_info.limit)
     {
-        mutex_lock( &virtual_mutex );  /* no need for signal masking inside signal handler */
+        WINENTDLL_MUTEX_RECURSIVE_LOCK( &virtual_mutex );  /* no need for signal masking inside signal handler */
         if ((get_page_vprot( stack ) & VPROT_GUARD) &&
             grow_thread_stack( ROUND_ADDR( stack, page_mask ), &stack_info ))
         {
             rec->ExceptionCode = STATUS_STACK_OVERFLOW;
             rec->NumberParameters = 0;
         }
-        mutex_unlock( &virtual_mutex );
+        WINENTDLL_MUTEX_RECURSIVE_UNLOCK( &virtual_mutex );
     }
 #if defined(VALGRIND_MAKE_MEM_UNDEFINED)
     VALGRIND_MAKE_MEM_UNDEFINED( stack, size );
@@ -4126,14 +4122,14 @@ unsigned int virtual_locked_server_call( void *req_ptr )

if (!size) return wine_server_call( req_ptr );

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (!(ret = check_write_access( addr, size, &has_write_watch )))
     {
         ret = server_call_unlocked( req );
         if (has_write_watch) update_write_watches( addr, size, wine_server_reply_size( req ));
     }
     else memset( &req->u.reply, 0, sizeof(req->u.reply) );
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return ret;
 }

@@ -4150,14 +4146,14 @@ ssize_t virtual_locked_read( int fd, void *addr, size_t size )
     ssize_t ret = read( fd, addr, size );
     if (ret != -1 || errno != EFAULT) return ret;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (!check_write_access( addr, size, &has_write_watch ))
     {
         ret = read( fd, addr, size );
         err = errno;
         if (has_write_watch) update_write_watches( addr, size, max( 0, ret ));
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     errno = err;
     return ret;
 }
@@ -4175,14 +4171,14 @@ ssize_t virtual_locked_pread( int fd, void *addr, size_t size, off_t offset )
     ssize_t ret = pread( fd, addr, size, offset );
     if (ret != -1 || errno != EFAULT) return ret;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (!check_write_access( addr, size, &has_write_watch ))
     {
         ret = pread( fd, addr, size, offset );
         err = errno;
         if (has_write_watch) update_write_watches( addr, size, max( 0, ret ));
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     errno = err;
     return ret;
 }
@@ -4201,7 +4197,7 @@ ssize_t virtual_locked_recvmsg( int fd, struct msghdr *hdr, int flags )
     ssize_t ret = recvmsg( fd, hdr, flags );
     if (ret != -1 || errno != EFAULT) return ret;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     for (i = 0; i < hdr->msg_iovlen; i++)
         if (check_write_access( hdr->msg_iov[i].iov_base, hdr->msg_iov[i].iov_len, &has_write_watch ))
             break;
@@ -4213,7 +4209,7 @@ ssize_t virtual_locked_recvmsg( int fd, struct msghdr *hdr, int flags )
     if (has_write_watch)
         while (i--) update_write_watches( hdr->msg_iov[i].iov_base, hdr->msg_iov[i].iov_len, 0 );

-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     errno = err;
     return ret;
 }
@@ -4228,10 +4224,10 @@ BOOL virtual_is_valid_code_address( const void *addr, SIZE_T size )
     BOOL ret = FALSE;
     sigset_t sigset;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if ((view = find_view( addr, size )))
         ret = !(view->protect & VPROT_SYSTEM);  /* system views are not visible to the app */
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return ret;
 }

@@ -4318,7 +4314,7 @@ SIZE_T virtual_uninterrupted_read_memory( const void *addr, void *buffer, SIZE_T

if (!size) return 0;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if ((view = find_view( addr, size )))
     {
         if (!(view->protect & VPROT_SYSTEM))
@@ -4334,7 +4330,7 @@ SIZE_T virtual_uninterrupted_read_memory( const void *addr, void *buffer, SIZE_T
             }
         }
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return bytes_read;
 }

@@ -4354,13 +4350,13 @@ NTSTATUS virtual_uninterrupted_write_memory( void *addr, const void *buffer, SIZ

if (!size) return STATUS_SUCCESS;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (!(ret = check_write_access( addr, size, &has_write_watch )))
     {
         memcpy( addr, buffer, size );
         if (has_write_watch) update_write_watches( addr, size, size );
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return ret;
 }

@@ -4375,7 +4371,7 @@ void virtual_set_force_exec( BOOL enable )
     struct file_view *view;
     sigset_t sigset;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (!force_exec_prot != !enable)  /* change all existing views */
     {
         force_exec_prot = enable;
@@ -4388,7 +4384,7 @@ void virtual_set_force_exec( BOOL enable )
             mprotect_range( view->base, view->size, commit, 0 );
         }
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
 }

/* free reserved areas within a given range */
@@ -4520,7 +4516,7 @@ static NTSTATUS allocate_virtual_memory( void **ret, SIZE_T *size_ptr, ULONG typ

/* Reserve the memory */

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if ((type & MEM_RESERVE) || !base)
     {
@@ -4570,7 +4566,7 @@ static NTSTATUS allocate_virtual_memory( void **ret, SIZE_T *size_ptr, ULONG typ

if (!status) VIRTUAL_DEBUG_DUMP_VIEW( view );

-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if (status == STATUS_SUCCESS)
     {
@@ -4824,7 +4820,7 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *si
     if (size) size = ROUND_SIZE( addr, size );
     base = ROUND_ADDR( addr, page_mask );

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

/* avoid freeing the DOS area when a broken app passes a NULL pointer */
     if (!base)
@@ -4869,7 +4865,7 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *si
         *addr_ptr = base;
         *size_ptr = size;
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -4923,7 +4919,7 @@ NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T
     size = ROUND_SIZE( addr, size );
     base = ROUND_ADDR( addr, page_mask );

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if ((view = find_view( base, size )))
     {
@@ -4939,7 +4935,7 @@ NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T

if (!status) VIRTUAL_DEBUG_DUMP_VIEW( view );

-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if (status == STATUS_SUCCESS)
     {
@@ -4964,7 +4960,7 @@ static unsigned int fill_basic_memory_info( const void *addr, MEMORY_BASIC_INFOR

/* Find the view containing the address */

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     ptr = views_tree.root;
     while (ptr)
     {
@@ -5064,7 +5060,7 @@ static unsigned int fill_basic_memory_info( const void *addr, MEMORY_BASIC_INFOR
         else if (view->protect & (SEC_FILE | SEC_RESERVE | SEC_COMMIT)) info->Type = MEM_MAPPED;
         else info->Type = MEM_PRIVATE;
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );

return STATUS_SUCCESS;
 }
@@ -5328,7 +5324,7 @@ static NTSTATUS get_working_set_ex( HANDLE process, LPCVOID addr,
     start = ref[0].addr;
     end = ref[count - 1].addr + page_size;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     init_fill_working_set_info_data( &data, end );

view = find_view_range( start, end - start );
@@ -5359,7 +5355,7 @@ static NTSTATUS get_working_set_ex( HANDLE process, LPCVOID addr,

free_fill_working_set_info_data( &data );
     if (ref != ref_buffer) free( ref );
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if (res_len)
         *res_len = len;
@@ -5736,7 +5732,7 @@ static NTSTATUS unmap_view_of_section( HANDLE process, PVOID addr, ULONG flags )
         return status;
     }

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (!(view = find_view( addr, 0 )) || is_view_valloc( view )) goto done;

if (flags & MEM_PRESERVE_PLACEHOLDER && !(view->protect & VPROT_PLACEHOLDER))
@@ -5755,7 +5751,7 @@ static NTSTATUS unmap_view_of_section( HANDLE process, PVOID addr, ULONG flags )
             {
                 TRACE( "not freeing in-use builtin %p\n", view->base );
                 builtin->refcount--;
-                server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+                server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
                 return STATUS_SUCCESS;
             }
         }
@@ -5775,7 +5771,7 @@ static NTSTATUS unmap_view_of_section( HANDLE process, PVOID addr, ULONG flags )
     }
     else FIXME( "failed to unmap %p %x\n", view->base, status );
 done:
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -5927,7 +5923,7 @@ NTSTATUS WINAPI NtFlushVirtualMemory( HANDLE process, LPCVOID *addr_ptr,
         return result.virtual_flush.status;
     }

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     if (!(view = find_view( addr, *size_ptr ))) status = STATUS_INVALID_PARAMETER;
     else
     {
@@ -5937,7 +5933,7 @@ NTSTATUS WINAPI NtFlushVirtualMemory( HANDLE process, LPCVOID *addr_ptr,
         if (msync( addr, *size_ptr, MS_ASYNC )) status = STATUS_NOT_MAPPED_DATA;
 #endif
     }
-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -5964,7 +5960,7 @@ NTSTATUS WINAPI NtGetWriteWatch( HANDLE process, ULONG flags, PVOID base, SIZE_T
     TRACE( "%p %x %p-%p %p %lu\n", process, (int)flags, base, (char *)base + size,
            addresses, *count );

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if (is_write_watch_range( base, size ))
     {
@@ -5983,7 +5979,7 @@ NTSTATUS WINAPI NtGetWriteWatch( HANDLE process, ULONG flags, PVOID base, SIZE_T
     }
     else status = STATUS_INVALID_PARAMETER;

-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -6004,14 +6000,14 @@ NTSTATUS WINAPI NtResetWriteWatch( HANDLE process, PVOID base, SIZE_T size )

if (!size) return STATUS_INVALID_PARAMETER;

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

if (is_write_watch_range( base, size ))
         reset_write_watches( base, size );
     else
         status = STATUS_INVALID_PARAMETER;

-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

@@ -6102,7 +6098,7 @@ NTSTATUS WINAPI NtAreMappedFilesTheSame(PVOID addr1, PVOID addr2)

TRACE("%p %p\n", addr1, addr2);

-    server_enter_uninterrupted_section( &virtual_mutex, &sigset );
+    server_enter_uninterrupted_section_recursive( &virtual_mutex, &sigset );

view1 = find_view( addr1, 0 );
     view2 = find_view( addr2, 0 );
@@ -6126,7 +6122,7 @@ NTSTATUS WINAPI NtAreMappedFilesTheSame(PVOID addr1, PVOID addr2)
         SERVER_END_REQ;
     }

-    server_leave_uninterrupted_section( &virtual_mutex, &sigset );
+    server_leave_uninterrupted_section_recursive( &virtual_mutex, &sigset );
     return status;
 }

[PATCH 4/6] winevulkan: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 dlls/winevulkan/vulkan.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c
index 041fb4c4c4b..2da61039c1c 100644
--- a/dlls/winevulkan/vulkan.c
+++ b/dlls/winevulkan/vulkan.c
@@ -25,6 +25,7 @@
 #include <time.h>

#include "vulkan_private.h"
+#include "wine/mutex.h"
 #include "wine/vulkan_driver.h"
 #include "wine/rbtree.h"
 #include "ntgdi.h"
@@ -57,7 +58,7 @@ static int window_surface_compare(const void *key, const struct rb_entry *entry)
     return 0;
 }

-static pthread_mutex_t window_surfaces_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE window_surfaces_lock = WINE_MUTEX_INIT;
 static struct rb_tree window_surfaces = {.compare = window_surface_compare};

static void window_surfaces_insert(struct wine_surface *surface)
@@ -65,7 +66,7 @@ static void window_surfaces_insert(struct wine_surface *surface)
     struct wine_surface *previous;
     struct rb_entry *ptr;

-    pthread_mutex_lock(&window_surfaces_lock);
+    WINE_MUTEX_LOCK(&window_surfaces_lock);

if (!(ptr = rb_get(&window_surfaces, surface->hwnd)))
         rb_put(&window_surfaces, surface->hwnd, &surface->window_entry);
@@ -76,14 +77,14 @@ static void window_surfaces_insert(struct wine_surface *surface)
         previous->hwnd = 0; /* make sure previous surface becomes invalid */
     }

-    pthread_mutex_unlock(&window_surfaces_lock);
+    WINE_MUTEX_UNLOCK(&window_surfaces_lock);
 }

static void window_surfaces_remove(struct wine_surface *surface)
 {
-    pthread_mutex_lock(&window_surfaces_lock);
+    WINE_MUTEX_LOCK(&window_surfaces_lock);
     if (surface->hwnd) rb_remove(&window_surfaces, &surface->window_entry);
-    pthread_mutex_unlock(&window_surfaces_lock);
+    WINE_MUTEX_UNLOCK(&window_surfaces_lock);
 }

static BOOL is_wow64(void)

[PATCH 5/6] wine32u: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 dlls/win32u/class.c           |  7 +--
 dlls/win32u/clipboard.c       | 31 +++++++------
 dlls/win32u/d3dkmt.c          | 49 ++++++++++----------
 dlls/win32u/dc.c              | 11 +++--
 dlls/win32u/dce.c             | 27 +++++++----
 dlls/win32u/dibdrv/graphics.c |  9 ++--
 dlls/win32u/font.c            | 87 ++++++++++++++++++-----------------
 dlls/win32u/gdiobj.c          | 63 ++++++++++++-------------
 dlls/win32u/imm.c             | 35 +++++++-------
 dlls/win32u/rawinput.c        | 31 +++++++------
 dlls/win32u/sysparams.c       | 45 +++++++++---------
 dlls/win32u/winstation.c      |  9 ++--
 include/wine/gdi_driver.h     |  3 +-
 13 files changed, 209 insertions(+), 198 deletions(-)

diff --git a/dlls/win32u/class.c b/dlls/win32u/class.c
index 33baed3dc23..733b8287832 100644
--- a/dlls/win32u/class.c
+++ b/dlls/win32u/class.c
@@ -30,6 +30,7 @@
 #define WIN32_NO_STATUS
 #include "win32u_private.h"
 #include "ntuser_private.h"
+#include "wine/mutex.h"
 #include "wine/server.h"
 #include "wine/debug.h"

@@ -79,7 +80,7 @@ typedef struct tagWINDOWPROC

static WINDOWPROC winproc_array[MAX_WINPROCS];
 static UINT winproc_used = NB_BUILTIN_WINPROCS;
-static pthread_mutex_t winproc_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE winproc_lock = WINE_MUTEX_INIT;

static struct list class_list = LIST_INIT( class_list );

@@ -132,7 +133,7 @@ static inline WINDOWPROC *alloc_winproc_ptr( WNDPROC func, BOOL ansi )
     if (!func) return NULL;
     if ((proc = get_winproc_ptr( func ))) return proc;

-    pthread_mutex_lock( &winproc_lock );
+    WINE_MUTEX_LOCK( &winproc_lock );

/* check if we already have a winproc for that function */
     if (!(proc = find_winproc( func, ansi )))
@@ -150,7 +151,7 @@ static inline WINDOWPROC *alloc_winproc_ptr( WNDPROC func, BOOL ansi )
     }
     else TRACE_(win)( "reusing %p for %p\n", proc_to_handle(proc), func );

-    pthread_mutex_unlock( &winproc_lock );
+    WINE_MUTEX_UNLOCK( &winproc_lock );
     return proc;
 }

diff --git a/dlls/win32u/clipboard.c b/dlls/win32u/clipboard.c
index 6cf484a56ca..7e37b04c54d 100644
--- a/dlls/win32u/clipboard.c
+++ b/dlls/win32u/clipboard.c
@@ -33,12 +33,13 @@
 #include "win32u_private.h"
 #include "ntgdi_private.h"
 #include "ntuser_private.h"
+#include "wine/mutex.h"
 #include "wine/server.h"
 #include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(clipboard);

-static pthread_mutex_t clipboard_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE clipboard_mutex = WINE_MUTEX_INIT;

struct cached_format
 {
@@ -179,7 +180,7 @@ BOOL WINAPI NtUserOpenClipboard( HWND hwnd, ULONG unk )

user_driver->pUpdateClipboard();

-    pthread_mutex_lock( &clipboard_mutex );
+    WINE_MUTEX_LOCK( &clipboard_mutex );

SERVER_START_REQ( open_clipboard )
     {
@@ -191,7 +192,7 @@ BOOL WINAPI NtUserOpenClipboard( HWND hwnd, ULONG unk )

if (ret && !is_current_process_window( owner )) invalidate_memory_formats( &free_list );

-    pthread_mutex_unlock( &clipboard_mutex );
+    WINE_MUTEX_UNLOCK( &clipboard_mutex );
     free_cached_formats( &free_list );
     return ret;
 }
@@ -235,7 +236,7 @@ BOOL WINAPI NtUserEmptyClipboard(void)
     if (owner)
         send_message_timeout( owner, WM_DESTROYCLIPBOARD, 0, 0, SMTO_ABORTIFHUNG, 5000, FALSE );

-    pthread_mutex_lock( &clipboard_mutex );
+    WINE_MUTEX_LOCK( &clipboard_mutex );

SERVER_START_REQ( empty_clipboard )
     {
@@ -249,7 +250,7 @@ BOOL WINAPI NtUserEmptyClipboard(void)
         list_move_tail( &free_list, &cached_formats );
     }

-    pthread_mutex_unlock( &clipboard_mutex );
+    WINE_MUTEX_UNLOCK( &clipboard_mutex );
     free_cached_formats( &free_list );
     return ret;
 }
@@ -579,12 +580,12 @@ NTSTATUS WINAPI NtUserSetClipboardData( UINT format, HANDLE data, struct set_cli

if (params->cache_only)
     {
-        pthread_mutex_lock( &clipboard_mutex );
+        WINE_MUTEX_LOCK( &clipboard_mutex );
         if ((cache = get_cached_format( format )) && cache->seqno == params->seqno)
             cache->handle = data;
         else
             status = STATUS_UNSUCCESSFUL;
-        pthread_mutex_unlock( &clipboard_mutex );
+        WINE_MUTEX_UNLOCK( &clipboard_mutex );
         return status;
     }

@@ -606,7 +607,7 @@ NTSTATUS WINAPI NtUserSetClipboardData( UINT format, HANDLE data, struct set_cli
     }
     NtQueryDefaultLocale( TRUE, &lcid );

-    pthread_mutex_lock( &clipboard_mutex );
+    WINE_MUTEX_LOCK( &clipboard_mutex );

SERVER_START_REQ( set_clipboard_data )
     {
@@ -628,7 +629,7 @@ NTSTATUS WINAPI NtUserSetClipboardData( UINT format, HANDLE data, struct set_cli
     }
     else free( cache );

-    pthread_mutex_unlock( &clipboard_mutex );
+    WINE_MUTEX_UNLOCK( &clipboard_mutex );
     if (prev) free_cached_data( prev );

done:
@@ -649,7 +650,7 @@ HANDLE WINAPI NtUserGetClipboardData( UINT format, struct get_clipboard_params *

for (;;)
     {
-        pthread_mutex_lock( &clipboard_mutex );
+        WINE_MUTEX_LOCK( &clipboard_mutex );

if (!params->data_only) cache = get_cached_format( format );

@@ -680,7 +681,7 @@ HANDLE WINAPI NtUserGetClipboardData( UINT format, struct get_clipboard_params *
                 if (cache->handle && data_seqno == cache->seqno)  /* we can reuse the cached data */
                 {
                     HANDLE ret = cache->handle;
-                    pthread_mutex_unlock( &clipboard_mutex );
+                    WINE_MUTEX_UNLOCK( &clipboard_mutex );
                     TRACE( "%s returning %p\n", debugstr_format( format ), ret );
                     return ret;
                 }
@@ -692,14 +693,14 @@ HANDLE WINAPI NtUserGetClipboardData( UINT format, struct get_clipboard_params *

if (params->data_only)
             {
-                pthread_mutex_unlock( &clipboard_mutex );
+                WINE_MUTEX_UNLOCK( &clipboard_mutex );
                 return params->data;
             }

/* allocate new cache entry */
             if (!(cache = malloc( sizeof(*cache) )))
             {
-                pthread_mutex_unlock( &clipboard_mutex );
+                WINE_MUTEX_UNLOCK( &clipboard_mutex );
                 return 0;
             }

@@ -708,12 +709,12 @@ HANDLE WINAPI NtUserGetClipboardData( UINT format, struct get_clipboard_params *
             cache->handle = NULL;
             params->seqno = cache->seqno;
             list_add_tail( &cached_formats, &cache->entry );
-            pthread_mutex_unlock( &clipboard_mutex );
+            WINE_MUTEX_UNLOCK( &clipboard_mutex );
             TRACE( "%s needs unmarshaling\n", debugstr_format( format ) );
             params->data_size = ~0;
             return 0;
         }
-        pthread_mutex_unlock( &clipboard_mutex );
+        WINE_MUTEX_UNLOCK( &clipboard_mutex );

if (status == STATUS_BUFFER_OVERFLOW)
         {
diff --git a/dlls/win32u/d3dkmt.c b/dlls/win32u/d3dkmt.c
index d6eedc44a9b..b7105f193e9 100644
--- a/dlls/win32u/d3dkmt.c
+++ b/dlls/win32u/d3dkmt.c
@@ -29,6 +29,7 @@
 #include "ntgdi_private.h"
 #include "win32u_private.h"
 #include "ntuser_private.h"
+#include "wine/mutex.h"
 #include "wine/vulkan.h"
 #include "wine/vulkan_driver.h"

@@ -55,7 +56,7 @@ struct d3dkmt_vidpn_source
     struct list entry;                      /* List entry */
 };

-static pthread_mutex_t d3dkmt_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE d3dkmt_lock = WINE_MUTEX_INIT;
 static struct list d3dkmt_adapters = LIST_INIT( d3dkmt_adapters );
 static struct list d3dkmt_devices = LIST_INIT( d3dkmt_devices );
 static struct list d3dkmt_vidpn_sources = LIST_INIT( d3dkmt_vidpn_sources );   /* VidPN source information list */
@@ -158,13 +159,13 @@ NTSTATUS WINAPI NtGdiDdDDICloseAdapter( const D3DKMT_CLOSEADAPTER *desc )

if (!desc || !desc->hAdapter) return STATUS_INVALID_PARAMETER;

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );
     if ((adapter = find_adapter_from_handle( desc->hAdapter )))
     {
         list_remove( &adapter->entry );
         status = STATUS_SUCCESS;
     }
-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );

free( adapter );
     return status;
@@ -256,10 +257,10 @@ NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc
     else if (!(adapter->vk_device = get_vulkan_physical_device( &uuid )))
         WARN( "Failed to find vulkan device with GUID %s\n", debugstr_guid( &uuid ) );

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );
     desc->hAdapter = adapter->handle = ++handle_start;
     list_add_tail( &d3dkmt_adapters, &adapter->entry );
-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );

return STATUS_SUCCESS;
 }
@@ -277,9 +278,9 @@ NTSTATUS WINAPI NtGdiDdDDICreateDevice( D3DKMT_CREATEDEVICE *desc )

if (!desc) return STATUS_INVALID_PARAMETER;

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );
     found = !!find_adapter_from_handle( desc->hAdapter );
-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );

if (!found) return STATUS_INVALID_PARAMETER;

@@ -289,10 +290,10 @@ NTSTATUS WINAPI NtGdiDdDDICreateDevice( D3DKMT_CREATEDEVICE *desc )
     device = calloc( 1, sizeof(*device) );
     if (!device) return STATUS_NO_MEMORY;

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );
     device->handle = ++handle_start;
     list_add_tail( &d3dkmt_devices, &device->entry );
-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );

desc->hDevice = device->handle;
     return STATUS_SUCCESS;
@@ -310,7 +311,7 @@ NTSTATUS WINAPI NtGdiDdDDIDestroyDevice( const D3DKMT_DESTROYDEVICE *desc )

if (!desc || !desc->hDevice) return STATUS_INVALID_PARAMETER;

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );
     LIST_FOR_EACH_ENTRY( device, &d3dkmt_devices, struct d3dkmt_device, entry )
     {
         if (device->handle == desc->hDevice)
@@ -320,7 +321,7 @@ NTSTATUS WINAPI NtGdiDdDDIDestroyDevice( const D3DKMT_DESTROYDEVICE *desc )
             break;
         }
     }
-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );

if (!found) return STATUS_INVALID_PARAMETER;

@@ -382,7 +383,7 @@ NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *des
     desc->CurrentReservation = 0;
     desc->AvailableForReservation = 0;

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );
     if ((adapter = find_adapter_from_handle( desc->hAdapter )) && adapter->vk_device)
     {
         memset( &budget, 0, sizeof(budget) );
@@ -403,7 +404,7 @@ NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *des
         }
         desc->AvailableForReservation = desc->Budget / 2;
     }
-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );

return adapter ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER;
 }
@@ -431,7 +432,7 @@ NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER
     if (!desc || !desc->hDevice || (desc->VidPnSourceCount && (!desc->pType || !desc->pVidPnSourceId)))
         return STATUS_INVALID_PARAMETER;

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );

/* Check parameters */
     for (i = 0; i < desc->VidPnSourceCount; ++i)
@@ -449,7 +450,7 @@ NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER
                         (source->type == D3DKMT_VIDPNSOURCEOWNER_EMULATED &&
                          desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE))
                     {
-                        pthread_mutex_unlock( &d3dkmt_lock );
+                        WINE_MUTEX_UNLOCK( &d3dkmt_lock );
                         return STATUS_INVALID_PARAMETER;
                     }
                 }
@@ -460,7 +461,7 @@ NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER
                         (desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE ||
                          desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EMULATED))
                     {
-                        pthread_mutex_unlock( &d3dkmt_lock );
+                        WINE_MUTEX_UNLOCK( &d3dkmt_lock );
                         return STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE;
                     }
                 }
@@ -471,14 +472,14 @@ NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER
          * D3DKMT_VIDPNSOURCEOWNER_SHARED come back STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE */
         if (desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_SHARED)
         {
-            pthread_mutex_unlock( &d3dkmt_lock );
+            WINE_MUTEX_UNLOCK( &d3dkmt_lock );
             return STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE;
         }

/* FIXME: D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVEGDI unsupported */
         if (desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVEGDI || desc->pType[i] > D3DKMT_VIDPNSOURCEOWNER_EMULATED)
         {
-            pthread_mutex_unlock( &d3dkmt_lock );
+            WINE_MUTEX_UNLOCK( &d3dkmt_lock );
             return STATUS_INVALID_PARAMETER;
         }
     }
@@ -495,7 +496,7 @@ NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER
             }
         }

-        pthread_mutex_unlock( &d3dkmt_lock );
+        WINE_MUTEX_UNLOCK( &d3dkmt_lock );
         return STATUS_SUCCESS;
     }

@@ -518,7 +519,7 @@ NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER
             source = malloc( sizeof(*source) );
             if (!source)
             {
-                pthread_mutex_unlock( &d3dkmt_lock );
+                WINE_MUTEX_UNLOCK( &d3dkmt_lock );
                 return STATUS_NO_MEMORY;
             }

@@ -529,7 +530,7 @@ NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER
         }
     }

-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );
     return STATUS_SUCCESS;
 }

@@ -544,18 +545,18 @@ NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNE

if (!desc || !desc->hAdapter) return STATUS_INVALID_PARAMETER;

-    pthread_mutex_lock( &d3dkmt_lock );
+    WINE_MUTEX_LOCK( &d3dkmt_lock );

LIST_FOR_EACH_ENTRY( source, &d3dkmt_vidpn_sources, struct d3dkmt_vidpn_source, entry )
     {
         if (source->id == desc->VidPnSourceId && source->type == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE)
         {
-            pthread_mutex_unlock( &d3dkmt_lock );
+            WINE_MUTEX_UNLOCK( &d3dkmt_lock );
             return STATUS_GRAPHICS_PRESENT_OCCLUDED;
         }
     }

-    pthread_mutex_unlock( &d3dkmt_lock );
+    WINE_MUTEX_UNLOCK( &d3dkmt_lock );
     return STATUS_SUCCESS;
 }

diff --git a/dlls/win32u/dc.c b/dlls/win32u/dc.c
index 3f6a501041a..ba22395974b 100644
--- a/dlls/win32u/dc.c
+++ b/dlls/win32u/dc.c
@@ -36,6 +36,7 @@
 #include "winternl.h"
 #include "winerror.h"
 #include "ntgdi_private.h"
+#include "wine/mutex.h"
 #include "wine/wgl.h"
 #include "wine/wgl_driver.h"

@@ -43,7 +44,7 @@

WINE_DEFAULT_DEBUG_CHANNEL(dc);

-static pthread_mutex_t dc_attr_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE dc_attr_lock = WINE_MUTEX_INIT;

struct dc_attr_bucket
 {
@@ -90,7 +91,7 @@ static DC_ATTR *alloc_dc_attr(void)
     struct dc_attr_bucket *bucket;
     DC_ATTR *dc_attr = NULL;

-    pthread_mutex_lock( &dc_attr_lock );
+    WINE_MUTEX_LOCK( &dc_attr_lock );

LIST_FOR_EACH_ENTRY( bucket, &dc_attr_buckets, struct dc_attr_bucket, entry )
     {
@@ -125,7 +126,7 @@ static DC_ATTR *alloc_dc_attr(void)

if (dc_attr) memset( dc_attr, 0, sizeof( *dc_attr ));

-    pthread_mutex_unlock( &dc_attr_lock );
+    WINE_MUTEX_UNLOCK( &dc_attr_lock );

return dc_attr;
 }
@@ -135,7 +136,7 @@ static void free_dc_attr( DC_ATTR *dc_attr )
 {
     struct dc_attr_bucket *bucket;

-    pthread_mutex_lock( &dc_attr_lock );
+    WINE_MUTEX_LOCK( &dc_attr_lock );

LIST_FOR_EACH_ENTRY( bucket, &dc_attr_buckets, struct dc_attr_bucket, entry )
     {
@@ -145,7 +146,7 @@ static void free_dc_attr( DC_ATTR *dc_attr )
         break;
     }

-    pthread_mutex_unlock( &dc_attr_lock );
+    WINE_MUTEX_UNLOCK( &dc_attr_lock );
 }

diff --git a/dlls/win32u/dce.c b/dlls/win32u/dce.c
index 5faea17a6a2..a11dde258cc 100644
--- a/dlls/win32u/dce.c
+++ b/dlls/win32u/dce.c
@@ -30,6 +30,7 @@
 #include "ntgdi_private.h"
 #include "ntuser_private.h"
 #include "wine/server.h"
+#include "wine/mutex.h"
 #include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(win);
@@ -50,7 +51,7 @@ static struct list dce_list = LIST_INIT(dce_list);
 #define DCE_CACHE_SIZE 64

static struct list window_surfaces = LIST_INIT( window_surfaces );
-static pthread_mutex_t surfaces_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE surfaces_lock = WINE_MUTEX_INIT;

/*******************************************************************
  * Dummy window surface for windows that shouldn't get painted.
@@ -86,7 +87,7 @@ struct window_surface dummy_surface =
     .funcs = &dummy_surface_funcs,
     .ref = 1,
     .rect = {.right = 1, .bottom = 1},
-    .mutex = PTHREAD_MUTEX_INITIALIZER,
+    .mutex = WINE_MUTEX_INIT,
 };

/*******************************************************************
@@ -354,7 +355,13 @@ W32KAPI BOOL window_surface_init( struct window_surface *surface, const struct w
     surface->color_key = CLR_INVALID;
     surface->alpha_bits = -1;
     surface->alpha_mask = 0;
-    pthread_mutex_init( &surface->mutex, NULL );
+
+#ifdef USE_AFL
+    __atomic_store_n(&surface->mutex, AFL_UNLOCKED, __ATOMIC_RELEASE);
+#else
+    pthread_mutex_init(&surface->mutex, NULL);
+#endif
+
     reset_bounds( &surface->bounds );

if (!bitmap) bitmap = NtGdiCreateDIBSection( 0, NULL, 0, info, DIB_RGB_COLORS, 0, 0, 0, NULL );
@@ -373,7 +380,7 @@ W32KAPI void window_surface_release( struct window_surface *surface )
     ULONG ret = InterlockedDecrement( &surface->ref );
     if (!ret)
     {
-        if (surface != &dummy_surface) pthread_mutex_destroy( &surface->mutex );
+        if (surface != &dummy_surface) WINE_MUTEX_DESTROY( &surface->mutex );
         if (surface->clip_region) NtGdiDeleteObjectApp( surface->clip_region );
         if (surface->color_bitmap) NtGdiDeleteObjectApp( surface->color_bitmap );
         if (surface->shape_bitmap) NtGdiDeleteObjectApp( surface->shape_bitmap );
@@ -384,13 +391,13 @@ W32KAPI void window_surface_release( struct window_surface *surface )
 W32KAPI void window_surface_lock( struct window_surface *surface )
 {
     if (surface == &dummy_surface) return;
-    pthread_mutex_lock( &surface->mutex );
+    WINE_MUTEX_LOCK( &surface->mutex );
 }

W32KAPI void window_surface_unlock( struct window_surface *surface )
 {
     if (surface == &dummy_surface) return;
-    pthread_mutex_unlock( &surface->mutex );
+    WINE_MUTEX_UNLOCK( &surface->mutex );
 }

void *window_surface_get_color( struct window_surface *surface, BITMAPINFO *info )
@@ -545,10 +552,10 @@ void register_window_surface( struct window_surface *old, struct window_surface
     if (old == &dummy_surface) old = NULL;
     if (new == &dummy_surface) new = NULL;
     if (old == new) return;
-    pthread_mutex_lock( &surfaces_lock );
+    WINE_MUTEX_LOCK( &surfaces_lock );
     if (old) list_remove( &old->entry );
     if (new) list_add_tail( &window_surfaces, &new->entry );
-    pthread_mutex_unlock( &surfaces_lock );
+    WINE_MUTEX_UNLOCK( &surfaces_lock );
 }

/*******************************************************************
@@ -562,7 +569,7 @@ void flush_window_surfaces( BOOL idle )
     DWORD now;
     struct window_surface *surface;

-    pthread_mutex_lock( &surfaces_lock );
+    WINE_MUTEX_LOCK( &surfaces_lock );
     now = NtGetTickCount();
     if (idle) last_idle = now;
     /* if not idle, we only flush if there's evidence that the app never goes idle */
@@ -571,7 +578,7 @@ void flush_window_surfaces( BOOL idle )
     LIST_FOR_EACH_ENTRY( surface, &window_surfaces, struct window_surface, entry )
         window_surface_flush( surface );
 done:
-    pthread_mutex_unlock( &surfaces_lock );
+    WINE_MUTEX_UNLOCK( &surfaces_lock );
 }

/***********************************************************************
diff --git a/dlls/win32u/dibdrv/graphics.c b/dlls/win32u/dibdrv/graphics.c
index 009143bc2d2..def42099425 100644
--- a/dlls/win32u/dibdrv/graphics.c
+++ b/dlls/win32u/dibdrv/graphics.c
@@ -27,6 +27,7 @@
 #include "ntgdi_private.h"
 #include "dibdrv.h"

+#include "wine/mutex.h"
 #include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(dib);
@@ -60,7 +61,7 @@ struct cached_font

static struct list font_cache = LIST_INIT( font_cache );

-static pthread_mutex_t font_cache_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE font_cache_lock = WINE_MUTEX_INIT;

static BOOL brush_rect( dibdrv_physdev *pdev, dib_brush *brush, const RECT *rect, HRGN clip )
@@ -569,7 +570,7 @@ static struct cached_font *add_cached_font( DC *dc, HFONT hfont, UINT aa_flags )
     font.aa_flags = aa_flags;
     font.hash = font_cache_hash( &font );

-    pthread_mutex_lock( &font_cache_lock );
+    WINE_MUTEX_LOCK( &font_cache_lock );
     LIST_FOR_EACH_ENTRY( ptr, &font_cache, struct cached_font, entry )
     {
         if (!font_cache_cmp( &font, ptr ))
@@ -602,7 +603,7 @@ static struct cached_font *add_cached_font( DC *dc, HFONT hfont, UINT aa_flags )
     }
     else if (!(ptr = malloc( sizeof(*ptr) )))
     {
-        pthread_mutex_unlock( &font_cache_lock );
+        WINE_MUTEX_UNLOCK( &font_cache_lock );
         return NULL;
     }

@@ -611,7 +612,7 @@ static struct cached_font *add_cached_font( DC *dc, HFONT hfont, UINT aa_flags )
     memset( ptr->glyphs, 0, sizeof(ptr->glyphs) );
 done:
     list_add_head( &font_cache, &ptr->entry );
-    pthread_mutex_unlock( &font_cache_lock );
+    WINE_MUTEX_UNLOCK( &font_cache_lock );
     TRACE( "%d %s -> %p\n", (int)ptr->lf.lfHeight, debugstr_w(ptr->lf.lfFaceName), ptr );
     return ptr;
 }
diff --git a/dlls/win32u/font.c b/dlls/win32u/font.c
index 62a4dc51035..910f92f0298 100644
--- a/dlls/win32u/font.c
+++ b/dlls/win32u/font.c
@@ -43,6 +43,7 @@

#include "wine/unixlib.h"
 #include "wine/rbtree.h"
+#include "wine/mutex.h"
 #include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(font);
@@ -461,7 +462,7 @@ static const struct nls_update_font_list
     }
 };

-static pthread_mutex_t font_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE font_lock = WINE_MUTEX_INIT;

#ifdef WORDS_BIGENDIAN
 #define GET_BE_WORD(x) (x)
@@ -1060,7 +1061,7 @@ static int remove_font( const WCHAR *file, DWORD flags )
     struct gdi_font_face *face, *face_next;
     int count = 0;

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR( family, family_next, &family_name_tree, struct gdi_font_family, name_entry )
     {
         family->refcount++;
@@ -1077,7 +1078,7 @@ static int remove_font( const WCHAR *file, DWORD flags )
    }
         release_family( family );
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return count;
 }

@@ -2981,7 +2982,7 @@ static void release_gdi_font( struct gdi_font *font )
     TRACE( "font %p\n", font );

/* add it to the unused list */
-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     if (!--font->refcount)
     {
         list_add_head( &unused_gdi_font_list, &font->unused_entry );
@@ -2995,7 +2996,7 @@ static void release_gdi_font( struct gdi_font *font )
         }
         else unused_font_count++;
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
 }

static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl, int dpi)
@@ -3527,9 +3528,9 @@ static BOOL enum_face_charsets( const struct gdi_font_family *family, struct gdi
                elf.elfLogFont.lfCharSet, type, debugstr_w(elf.elfScript),
                elf.elfLogFont.lfItalic, (int)elf.elfLogFont.lfWeight, (int)ntm.ntmTm.ntmFlags );
         /* release section before callback (FIXME) */
-        pthread_mutex_unlock( &font_lock );
+        WINE_MUTEX_UNLOCK( &font_lock );
         if (!proc( &elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam )) return FALSE;
-        pthread_mutex_lock( &font_lock );
+        WINE_MUTEX_LOCK( &font_lock );
     }
     return TRUE;
 }
@@ -3548,7 +3549,7 @@ static BOOL font_EnumFonts( PHYSDEV dev, LOGFONTW *lf, font_enum_proc proc, LPAR

count = create_enum_charset_list( charset, enum_charsets );

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );

if (lf && lf->lfFaceName[0])
     {
@@ -3584,7 +3585,7 @@ static BOOL font_EnumFonts( PHYSDEV dev, LOGFONTW *lf, font_enum_proc proc, LPAR
                 return FALSE; /* enum_face_charsets() unlocked font_lock */
    }
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return TRUE;
 }

@@ -3931,13 +3932,13 @@ static BOOL font_GetCharABCWidths( PHYSDEV dev, UINT first, UINT count, WCHAR *c

TRACE( "%p, %u, %u, %p\n", physdev->font, first, count, buffer );

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     for (i = 0; i < count; i++)
     {
         c = chars ? chars[i] : first + i;
         get_glyph_outline( physdev->font, c, GGO_METRICS, NULL, &buffer[i], 0, NULL, NULL );
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return TRUE;
 }

@@ -3958,11 +3959,11 @@ static BOOL font_GetCharABCWidthsI( PHYSDEV dev, UINT first, UINT count, WORD *g

TRACE( "%p, %u, %u, %p\n", physdev->font, first, count, buffer );

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     for (c = 0; c < count; c++, buffer++)
         get_glyph_outline( physdev->font, gi ? gi[c] : first + c, GGO_METRICS | GGO_GLYPH_INDEX,
                            NULL, buffer, 0, NULL, NULL );
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return TRUE;
 }

@@ -3984,7 +3985,7 @@ static BOOL font_GetCharWidth( PHYSDEV dev, UINT first, UINT count, const WCHAR

TRACE( "%p, %d, %d, %p\n", physdev->font, first, count, buffer );

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     for (i = 0; i < count; i++)
     {
         c = chars ? chars[i] : i + first;
@@ -3993,7 +3994,7 @@ static BOOL font_GetCharWidth( PHYSDEV dev, UINT first, UINT count, const WCHAR
         else
             buffer[i] = abc.abcA + abc.abcB + abc.abcC;
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return TRUE;
 }

@@ -4118,7 +4119,7 @@ static DWORD font_GetGlyphIndices( PHYSDEV dev, const WCHAR *str, INT count, WOR
         got_default = TRUE;
     }

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );

for (i = 0; i < count; i++)
     {
@@ -4147,7 +4148,7 @@ static DWORD font_GetGlyphIndices( PHYSDEV dev, const WCHAR *str, INT count, WOR
         else gi[i] = get_GSUB_vert_glyph( physdev->font, glyph );
     }

-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return count;
 }

@@ -4166,9 +4167,9 @@ static DWORD font_GetGlyphOutline( PHYSDEV dev, UINT glyph, UINT format,
         dev = GET_NEXT_PHYSDEV( dev, pGetGlyphOutline );
         return dev->funcs->pGetGlyphOutline( dev, glyph, format, gm, buflen, buf, mat );
     }
-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     ret = get_glyph_outline( physdev->font, glyph, format, gm, NULL, buflen, buf, mat );
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return ret;
 }

@@ -4186,11 +4187,11 @@ static DWORD font_GetKerningPairs( PHYSDEV dev, DWORD count, KERNINGPAIR *pairs
         return dev->funcs->pGetKerningPairs( dev, count, pairs );
     }

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     if (physdev->font->kern_count == -1)
         physdev->font->kern_count = font_funcs->get_kerning_pairs( physdev->font,
                                                                    &physdev->font->kern_pairs );
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );

if (count && pairs)
     {
@@ -4283,7 +4284,7 @@ static UINT font_GetOutlineTextMetrics( PHYSDEV dev, UINT size, OUTLINETEXTMETRI

if (!physdev->font->scalable) return 0;

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     if (font_funcs->set_outline_text_metrics( physdev->font ))
     {
    ret = physdev->font->otm.otmSize;
@@ -4305,7 +4306,7 @@ static UINT font_GetOutlineTextMetrics( PHYSDEV dev, UINT size, OUTLINETEXTMETRI
             scale_outline_font_metrics( physdev->font, metrics );
         }
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return ret;
 }

@@ -4344,14 +4345,14 @@ static BOOL font_GetTextExtentExPoint( PHYSDEV dev, const WCHAR *str, INT count,

TRACE( "%p, %s, %d\n", physdev->font, debugstr_wn(str, count), count );

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     for (i = pos = 0; i < count; i++)
     {
         get_glyph_outline( physdev->font, str[i], GGO_METRICS, NULL, &abc, 0, NULL, NULL );
         pos += abc.abcA + abc.abcB + abc.abcC;
         dxs[i] = pos;
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return TRUE;
 }

@@ -4373,7 +4374,7 @@ static BOOL font_GetTextExtentExPointI( PHYSDEV dev, const WORD *indices, INT co

TRACE( "%p, %p, %d\n", physdev->font, indices, count );

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     for (i = pos = 0; i < count; i++)
     {
         get_glyph_outline( physdev->font, indices[i], GGO_METRICS | GGO_GLYPH_INDEX,
@@ -4381,7 +4382,7 @@ static BOOL font_GetTextExtentExPointI( PHYSDEV dev, const WORD *indices, INT co
         pos += abc.abcA + abc.abcB + abc.abcC;
         dxs[i] = pos;
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return TRUE;
 }

@@ -4470,7 +4471,7 @@ static BOOL font_GetTextMetrics( PHYSDEV dev, TEXTMETRICW *metrics )
         return dev->funcs->pGetTextMetrics( dev, metrics );
     }

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     if (font_funcs->set_outline_text_metrics( physdev->font ) ||
         font_funcs->set_bitmap_text_metrics( physdev->font ))
     {
@@ -4478,7 +4479,7 @@ static BOOL font_GetTextMetrics( PHYSDEV dev, TEXTMETRICW *metrics )
         scale_font_metrics( physdev->font, metrics );
         ret = TRUE;
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return ret;
 }

@@ -4676,7 +4677,7 @@ static HFONT font_SelectFont( PHYSDEV dev, HFONT hfont, UINT *aa_flags )
         }
         TRACE( "DC transform %f %f %f %f\n", dcmat.eM11, dcmat.eM12, dcmat.eM21, dcmat.eM22 );

-        pthread_mutex_lock( &font_lock );
+        WINE_MUTEX_LOCK( &font_lock );

font = select_font( &lf, dcmat, can_use_bitmap );

@@ -4693,7 +4694,7 @@ static HFONT font_SelectFont( PHYSDEV dev, HFONT hfont, UINT *aa_flags )
             *aa_flags = font_funcs->get_aa_flags( font, *aa_flags, antialias_fakes );
         }
         TRACE( "%p %s %d aa %x\n", hfont, debugstr_w(lf.lfFaceName), (int)lf.lfHeight, *aa_flags );
-        pthread_mutex_unlock( &font_lock );
+        WINE_MUTEX_UNLOCK( &font_lock );
     }
     physdev->font = font;
     if (prev) release_gdi_font( prev );
@@ -6452,16 +6453,16 @@ static int add_system_font_resource( const WCHAR *file, DWORD flags )

/* try in %WINDIR%/fonts, needed for Fotobuch Designer */
     get_fonts_win_dir_path( file, path );
-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     ret = font_funcs->add_font( path, flags );
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     /* try in datadir/fonts (or builddir/fonts), needed for Magic the Gathering Online */
     if (!ret)
     {
         get_fonts_data_dir_path( file, path );
-        pthread_mutex_lock( &font_lock );
+        WINE_MUTEX_LOCK( &font_lock );
         ret = font_funcs->add_font( path, flags );
-        pthread_mutex_unlock( &font_lock );
+        WINE_MUTEX_UNLOCK( &font_lock );
     }
     return ret;
 }
@@ -6489,9 +6490,9 @@ static int add_font_resource( LPCWSTR file, DWORD flags )
         DWORD addfont_flags = ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE;

if (!(flags & FR_PRIVATE)) addfont_flags |= ADDFONT_ADD_TO_CACHE;
-        pthread_mutex_lock( &font_lock );
+        WINE_MUTEX_LOCK( &font_lock );
         ret = font_funcs->add_font( file, addfont_flags );
-        pthread_mutex_unlock( &font_lock );
+        WINE_MUTEX_UNLOCK( &font_lock );
     }
     else if (!wcschr( file, '\' ))
         ret = add_system_font_resource( file, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE );
@@ -6878,9 +6879,9 @@ HANDLE WINAPI NtGdiAddFontMemResourceEx( void *ptr, DWORD size, void *dv, ULONG
     if (!(copy = malloc( size ))) return NULL;
     memcpy( copy, ptr, size );

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     num_fonts = font_funcs->add_mem_font( copy, size, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE );
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );

if (!num_fonts)
     {
@@ -7018,7 +7019,7 @@ BOOL WINAPI NtGdiGetFontFileData( DWORD instance_id, DWORD file_index, UINT64 *o
     BOOL ret = FALSE;

if (!font_funcs) return FALSE;
-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );
     if ((font = get_font_from_handle( instance_id )))
     {
         if (font->ttc_item_offset) tag = MS_TTCF_TAG;
@@ -7028,7 +7029,7 @@ BOOL WINAPI NtGdiGetFontFileData( DWORD instance_id, DWORD file_index, UINT64 *o
         else
             RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
     }
-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     return ret;
 }

@@ -7042,7 +7043,7 @@ BOOL WINAPI NtGdiGetFontFileInfo( DWORD instance_id, DWORD file_index, struct fo
     struct gdi_font *font;
     BOOL ret = FALSE;

-    pthread_mutex_lock( &font_lock );
+    WINE_MUTEX_LOCK( &font_lock );

if ((font = get_font_from_handle( instance_id )))
     {
@@ -7057,7 +7058,7 @@ BOOL WINAPI NtGdiGetFontFileInfo( DWORD instance_id, DWORD file_index, struct fo
         else RtlSetLastWin32Error( ERROR_INSUFFICIENT_BUFFER );
     }

-    pthread_mutex_unlock( &font_lock );
+    WINE_MUTEX_UNLOCK( &font_lock );
     if (needed) *needed = required_size;
     return ret;
 }
diff --git a/dlls/win32u/gdiobj.c b/dlls/win32u/gdiobj.c
index fec99243aa2..bd503b24648 100644
--- a/dlls/win32u/gdiobj.c
+++ b/dlls/win32u/gdiobj.c
@@ -38,6 +38,7 @@

#include "ntgdi_private.h"
 #include "wine/debug.h"
+#include "wine/mutex.h"
 #include "wine/unixlib.h"

WINE_DEFAULT_DEBUG_CHANNEL(gdi);
@@ -88,7 +89,7 @@ static const LOGBRUSH DkGrayBrush = { BS_SOLID, RGB(64,64,64), 0 };

static const LOGBRUSH DCBrush = { BS_SOLID, RGB(255,255,255), 0 };

-static pthread_mutex_t gdi_lock;
+static WINE_MUTEX_RECURSIVE_TYPE gdi_lock;

/****************************************************************************
@@ -454,9 +455,9 @@ void make_gdi_object_system( HGDIOBJ handle, BOOL set)
 {
     GDI_HANDLE_ENTRY *entry;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if ((entry = handle_entry( handle ))) entry_obj( entry )->system = !!set;
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
 }

/******************************************************************************
@@ -492,9 +493,9 @@ UINT GDI_get_ref_count( HGDIOBJ handle )
     GDI_HANDLE_ENTRY *entry;
     UINT ret = 0;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if ((entry = handle_entry( handle ))) ret = entry_obj( entry )->selcount;
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
     return ret;
 }

@@ -508,10 +509,10 @@ HGDIOBJ GDI_inc_ref_count( HGDIOBJ handle )
 {
     GDI_HANDLE_ENTRY *entry;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if ((entry = handle_entry( handle ))) entry_obj( entry )->selcount++;
     else handle = 0;
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
     return handle;
 }

@@ -525,7 +526,7 @@ BOOL GDI_dec_ref_count( HGDIOBJ handle )
 {
     GDI_HANDLE_ENTRY *entry;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if ((entry = handle_entry( handle )))
     {
         assert( entry_obj( entry )->selcount );
@@ -533,13 +534,13 @@ BOOL GDI_dec_ref_count( HGDIOBJ handle )
         {
             /* handle delayed DeleteObject*/
             entry_obj( entry )->deleted = 0;
-            pthread_mutex_unlock( &gdi_lock );
+            WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
             TRACE( "executing delayed DeleteObject for %p\n", handle );
             NtGdiDeleteObjectApp( handle );
             return TRUE;
         }
     }
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
     return entry != NULL;
 }

@@ -696,7 +697,7 @@ static void dump_gdi_objects( void )

TRACE( "%u objects:\n", GDI_MAX_HANDLE_COUNT );

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     for (entry = gdi_shared->Handles; entry < next_unused; entry++)
     {
         if (!entry->Type)
@@ -707,7 +708,7 @@ static void dump_gdi_objects( void )
                    gdi_obj_type( entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT ),
                    entry_obj( entry )->selcount, entry_obj( entry )->deleted );
     }
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
 }

/***********************************************************************
@@ -722,7 +723,7 @@ HGDIOBJ alloc_gdi_handle( struct gdi_obj_header *obj, DWORD type, const struct g

assert( type );  /* type 0 is reserved to mark free entries */

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );

entry = next_free;
     if (entry)
@@ -731,7 +732,7 @@ HGDIOBJ alloc_gdi_handle( struct gdi_obj_header *obj, DWORD type, const struct g
         entry = next_unused++;
     else
     {
-        pthread_mutex_unlock( &gdi_lock );
+        WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
         ERR( "out of GDI object handles, expect a crash\n" );
         if (TRACE_ON(gdi)) dump_gdi_objects();
         return 0;
@@ -745,7 +746,7 @@ HGDIOBJ alloc_gdi_handle( struct gdi_obj_header *obj, DWORD type, const struct g
     entry->Type    = entry->ExtType & 0x1f;
     if (++entry->Generation == 0x80) entry->Generation = 1;
     ret = entry_to_handle( entry );
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
     TRACE( "allocated %s %p %u/%u\n", gdi_obj_type(type), ret,
            (int)InterlockedIncrement( &debug_count ), GDI_MAX_HANDLE_COUNT );
     return ret;
@@ -762,7 +763,7 @@ void *free_gdi_handle( HGDIOBJ handle )
     void *object = NULL;
     GDI_HANDLE_ENTRY *entry;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if ((entry = handle_entry( handle )))
     {
         TRACE( "freed %s %p %u/%u\n", gdi_obj_type( entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT ),
@@ -772,7 +773,7 @@ void *free_gdi_handle( HGDIOBJ handle )
         entry->Object = (UINT_PTR)next_free;
         next_free = entry;
     }
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
     return object;
 }

@@ -800,7 +801,7 @@ void *get_any_obj_ptr( HGDIOBJ handle, DWORD *type )
     void *ptr = NULL;
     GDI_HANDLE_ENTRY *entry;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );

if ((entry = handle_entry( handle )))
     {
@@ -808,7 +809,7 @@ void *get_any_obj_ptr( HGDIOBJ handle, DWORD *type )
         *type = entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT;
     }

-    if (!ptr) pthread_mutex_unlock( &gdi_lock );
+    if (!ptr) WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
     return ptr;
 }

@@ -837,7 +838,7 @@ void *GDI_GetObjPtr( HGDIOBJ handle, DWORD type )
  */
 void GDI_ReleaseObj( HGDIOBJ handle )
 {
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
 }

@@ -861,10 +862,10 @@ BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj )
     const struct gdi_obj_funcs *funcs = NULL;
     struct gdi_obj_header *header;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if (!(entry = handle_entry( obj )))
     {
-        pthread_mutex_unlock( &gdi_lock );
+        WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
         return FALSE;
     }

@@ -872,7 +873,7 @@ BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj )
     if (header->system)
     {
    TRACE("Preserving system object %p\n", obj);
-        pthread_mutex_unlock( &gdi_lock );
+        WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );
    return TRUE;
     }

@@ -885,7 +886,7 @@ BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj )
     }
     else funcs = header->funcs;

-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );

TRACE("%p\n", obj );

@@ -932,13 +933,13 @@ INT WINAPI NtGdiExtGetObjectW( HGDIOBJ handle, INT count, void *buffer )

TRACE("%p %d %p\n", handle, count, buffer );

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if ((entry = handle_entry( handle )))
     {
         funcs = entry_obj( entry )->funcs;
         handle = entry_to_handle( entry );  /* make it a full handle */
     }
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );

if (funcs && funcs->pGetObjectW)
     {
@@ -990,13 +991,13 @@ BOOL WINAPI NtGdiUnrealizeObject( HGDIOBJ obj )
     const struct gdi_obj_funcs *funcs = NULL;
     GDI_HANDLE_ENTRY *entry;

-    pthread_mutex_lock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock  );
     if ((entry = handle_entry( obj )))
     {
         funcs = entry_obj( entry )->funcs;
         obj = entry_to_handle( entry );  /* make it a full handle */
     }
-    pthread_mutex_unlock( &gdi_lock );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock  );

if (funcs && funcs->pUnrealizeObject) return funcs->pUnrealizeObject( obj );
     return funcs != NULL;
@@ -1032,13 +1033,9 @@ BOOL WINAPI NtGdiSetColorAdjustment( HDC hdc, const COLORADJUSTMENT *ca )

void gdi_init(void)
 {
-    pthread_mutexattr_t attr;
     unsigned int dpi;

-    pthread_mutexattr_init( &attr );
-    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
-    pthread_mutex_init( &gdi_lock, &attr );
-    pthread_mutexattr_destroy( &attr );
+    WINE_MUTEX_RECURSIVE_INIT(&gdi_lock);

NtQuerySystemInformation( SystemBasicInformation, &system_info, sizeof(system_info), NULL );
     init_gdi_shared();
diff --git a/dlls/win32u/imm.c b/dlls/win32u/imm.c
index 4a9aca22360..a429194d3aa 100644
--- a/dlls/win32u/imm.c
+++ b/dlls/win32u/imm.c
@@ -30,6 +30,7 @@
 #include "win32u_private.h"
 #include "ntuser_private.h"
 #include "immdev.h"
+#include "wine/mutex.h"
 #include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(imm);
@@ -65,7 +66,7 @@ struct imm_thread_data
 };

static struct list thread_data_list = LIST_INIT( thread_data_list );
-static pthread_mutex_t imm_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE imm_mutex = WINE_MUTEX_INIT;
 static struct list ime_updates = LIST_INIT( ime_updates );
 static BOOL disable_ime;

@@ -266,9 +267,9 @@ static struct imm_thread_data *get_imm_thread_data(void)
         if (!(data = calloc( 1, sizeof( *data )))) return NULL;
         data->thread_id = GetCurrentThreadId();

-        pthread_mutex_lock( &imm_mutex );
+        WINE_MUTEX_LOCK( &imm_mutex );
         list_add_tail( &thread_data_list, &data->entry );
-        pthread_mutex_unlock( &imm_mutex );
+        WINE_MUTEX_UNLOCK( &imm_mutex );

thread_info->imm_thread_data = data;
     }
@@ -339,7 +340,7 @@ BOOL WINAPI NtUserDisableThreadIme( DWORD thread_id )
     {
         disable_ime = TRUE;

-        pthread_mutex_lock( &imm_mutex );
+        WINE_MUTEX_LOCK( &imm_mutex );
         LIST_FOR_EACH_ENTRY( thread_data, &thread_data_list, struct imm_thread_data, entry )
         {
             if (thread_data->thread_id == GetCurrentThreadId()) continue;
@@ -347,7 +348,7 @@ BOOL WINAPI NtUserDisableThreadIme( DWORD thread_id )
             NtUserMessageCall( thread_data->default_hwnd, WM_WINE_DESTROYWINDOW, 0, 0,
                                0, NtUserSendNotifyMessage, FALSE );
         }
-        pthread_mutex_unlock( &imm_mutex );
+        WINE_MUTEX_UNLOCK( &imm_mutex );
     }
     else if (!thread_id || thread_id == GetCurrentThreadId())
     {
@@ -375,14 +376,14 @@ HWND get_default_ime_window( HWND hwnd )

if (!(thread_id = get_window_thread( hwnd, NULL ))) return 0;

-        pthread_mutex_lock( &imm_mutex );
+        WINE_MUTEX_LOCK( &imm_mutex );
         LIST_FOR_EACH_ENTRY( thread_data, &thread_data_list, struct imm_thread_data, entry )
         {
             if (thread_data->thread_id != thread_id) continue;
             ret = thread_data->default_hwnd;
             break;
         }
-        pthread_mutex_unlock( &imm_mutex );
+        WINE_MUTEX_UNLOCK( &imm_mutex );
     }
     else if ((thread_data = get_user_thread_info()->imm_thread_data))
     {
@@ -399,9 +400,9 @@ void cleanup_imm_thread(void)

if (thread_info->imm_thread_data)
     {
-        pthread_mutex_lock( &imm_mutex );
+        WINE_MUTEX_LOCK( &imm_mutex );
         list_remove( &thread_info->imm_thread_data->entry );
-        pthread_mutex_unlock( &imm_mutex );
+        WINE_MUTEX_UNLOCK( &imm_mutex );
         free( thread_info->imm_thread_data );
         thread_info->imm_thread_data = NULL;
     }
@@ -456,11 +457,11 @@ static void post_ime_update( HWND hwnd, UINT cursor_pos, WCHAR *comp_str, WCHAR

if (!(update->vkey = data->ime_process_vkey))
     {
-        pthread_mutex_lock( &imm_mutex );
+        WINE_MUTEX_LOCK( &imm_mutex );
         id = update->scan = ++ime_update_count;
         update->vkey = VK_PROCESSKEY;
         list_add_tail( &ime_updates, &update->entry );
-        pthread_mutex_unlock( &imm_mutex );
+        WINE_MUTEX_UNLOCK( &imm_mutex );

NtUserPostMessage( hwnd, WM_IME_NOTIFY, IMN_WINE_SET_COMP_STRING, id );
     }
@@ -490,11 +491,11 @@ UINT ime_to_tascii_ex( UINT vkey, UINT lparam, const BYTE *state, COMPOSITIONSTR

TRACE( "vkey %#x, lparam %#x, state %p, compstr %p, himc %p\n", vkey, lparam, state, compstr, himc );

-    pthread_mutex_lock( &imm_mutex );
+    WINE_MUTEX_LOCK( &imm_mutex );

if (!(update = find_ime_update( vkey, lparam )))
     {
-        pthread_mutex_unlock( &imm_mutex );
+        WINE_MUTEX_UNLOCK( &imm_mutex );
         return STATUS_NOT_FOUND;
     }

@@ -518,12 +519,12 @@ UINT ime_to_tascii_ex( UINT vkey, UINT lparam, const BYTE *state, COMPOSITIONSTR
     if (compstr->dwSize < needed)
     {
         compstr->dwSize = needed;
-        pthread_mutex_unlock( &imm_mutex );
+        WINE_MUTEX_UNLOCK( &imm_mutex );
         return STATUS_BUFFER_TOO_SMALL;
     }

list_remove( &update->entry );
-    pthread_mutex_unlock( &imm_mutex );
+    WINE_MUTEX_UNLOCK( &imm_mutex );

memset( compstr, 0, sizeof(*compstr) );
     compstr->dwSize = sizeof(*compstr);
@@ -590,9 +591,9 @@ LRESULT ime_driver_call( HWND hwnd, enum wine_ime_call call, WPARAM wparam, LPAR

if (data->update)
         {
-            pthread_mutex_lock( &imm_mutex );
+            WINE_MUTEX_LOCK( &imm_mutex );
             list_add_tail( &ime_updates, &data->update->entry );
-            pthread_mutex_unlock( &imm_mutex );
+            WINE_MUTEX_UNLOCK( &imm_mutex );
             data->update = NULL;
             res = TRUE;
         }
diff --git a/dlls/win32u/rawinput.c b/dlls/win32u/rawinput.c
index 62b1707dbfe..f47937a7449 100644
--- a/dlls/win32u/rawinput.c
+++ b/dlls/win32u/rawinput.c
@@ -33,6 +33,7 @@
 #include "ddk/hidclass.h"
 #include "wine/hid.h"
 #include "wine/server.h"
+#include "wine/mutex.h"
 #include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(rawinput);
@@ -65,7 +66,7 @@ struct device
 static RAWINPUTDEVICE *registered_devices;
 static unsigned int registered_device_count;
 static struct list devices = LIST_INIT( devices );
-static pthread_mutex_t rawinput_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE rawinput_mutex = WINE_MUTEX_INIT;

static struct device *add_device( HKEY key, DWORD type )
 {
@@ -344,7 +345,7 @@ UINT WINAPI NtUserGetRawInputDeviceList( RAWINPUTDEVICELIST *device_list, UINT *
         return ~0u;
     }

-    pthread_mutex_lock( &rawinput_mutex );
+    WINE_MUTEX_LOCK( &rawinput_mutex );

rawinput_update_device_list( FALSE );

@@ -356,7 +357,7 @@ UINT WINAPI NtUserGetRawInputDeviceList( RAWINPUTDEVICELIST *device_list, UINT *
         device_list++;
     }

-    pthread_mutex_unlock( &rawinput_mutex );
+    WINE_MUTEX_UNLOCK( &rawinput_mutex );

if (!device_list)
     {
@@ -398,11 +399,11 @@ UINT WINAPI NtUserGetRawInputDeviceInfo( HANDLE handle, UINT command, void *data
         return ~0u;
     }

-    pthread_mutex_lock( &rawinput_mutex );
+    WINE_MUTEX_LOCK( &rawinput_mutex );

if (!(device = find_device_from_handle( handle, TRUE )))
     {
-        pthread_mutex_unlock( &rawinput_mutex );
+        WINE_MUTEX_UNLOCK( &rawinput_mutex );
         RtlSetLastWin32Error( ERROR_INVALID_HANDLE );
         return ~0u;
     }
@@ -435,7 +436,7 @@ UINT WINAPI NtUserGetRawInputDeviceInfo( HANDLE handle, UINT command, void *data
         break;
     }

-    pthread_mutex_unlock( &rawinput_mutex );
+    WINE_MUTEX_UNLOCK( &rawinput_mutex );

if (!data)
         return 0;
@@ -575,7 +576,7 @@ BOOL process_rawinput_message( MSG *msg, UINT hw_id, const struct hardware_msg_d
         BOOL refresh = msg->wParam == GIDC_ARRIVAL;
         struct device *device;

-        pthread_mutex_lock( &rawinput_mutex );
+        WINE_MUTEX_LOCK( &rawinput_mutex );
         if ((device = find_device_from_handle( UlongToHandle( msg_data->rawinput.device ), refresh )))
         {
             if (msg->wParam == GIDC_REMOVAL)
@@ -586,7 +587,7 @@ BOOL process_rawinput_message( MSG *msg, UINT hw_id, const struct hardware_msg_d
                 free( device );
             }
         }
-        pthread_mutex_unlock( &rawinput_mutex );
+        WINE_MUTEX_UNLOCK( &rawinput_mutex );
     }
     else
     {
@@ -696,18 +697,18 @@ BOOL WINAPI NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT d
             FIXME( "Unhandled flags %#x for device %u.\n", (int)devices[i].dwFlags, i );
     }

-    pthread_mutex_lock( &rawinput_mutex );
+    WINE_MUTEX_LOCK( &rawinput_mutex );

if (!registered_device_count && !device_count)
     {
-        pthread_mutex_unlock( &rawinput_mutex );
+        WINE_MUTEX_UNLOCK( &rawinput_mutex );
         return TRUE;
     }

size = (SIZE_T)device_size * (registered_device_count + device_count);
     if (!(new_registered_devices = realloc( registered_devices, size )))
     {
-        pthread_mutex_unlock( &rawinput_mutex );
+        WINE_MUTEX_UNLOCK( &rawinput_mutex );
         RtlSetLastWin32Error( ERROR_OUTOFMEMORY );
         return FALSE;
     }
@@ -720,7 +721,7 @@ BOOL WINAPI NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT d
     if (!(device_count = registered_device_count)) server_devices = NULL;
     else if (!(server_devices = malloc( device_count * sizeof(*server_devices) )))
     {
-        pthread_mutex_unlock( &rawinput_mutex );
+        WINE_MUTEX_UNLOCK( &rawinput_mutex );
         RtlSetLastWin32Error( ERROR_OUTOFMEMORY );
         return FALSE;
     }
@@ -741,7 +742,7 @@ BOOL WINAPI NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT d

free( server_devices );

-    pthread_mutex_unlock( &rawinput_mutex );
+    WINE_MUTEX_UNLOCK( &rawinput_mutex );

return ret;
 }
@@ -761,14 +762,14 @@ UINT WINAPI NtUserGetRegisteredRawInputDevices( RAWINPUTDEVICE *devices, UINT *d
         return ~0u;
     }

-    pthread_mutex_lock( &rawinput_mutex );
+    WINE_MUTEX_LOCK( &rawinput_mutex );

capacity = *device_count * device_size;
     *device_count = registered_device_count;
     size = (SIZE_T)device_size * *device_count;
     if (devices && capacity >= size) memcpy( devices, registered_devices, size );

-    pthread_mutex_unlock( &rawinput_mutex );
+    WINE_MUTEX_UNLOCK( &rawinput_mutex );

if (!devices) return 0;

diff --git a/dlls/win32u/sysparams.c b/dlls/win32u/sysparams.c
index 094a963d305..12641c53c87 100644
--- a/dlls/win32u/sysparams.c
+++ b/dlls/win32u/sysparams.c
@@ -34,6 +34,7 @@
 #include "winreg.h"
 #include "cfgmgr32.h"
 #include "d3dkmdt.h"
+#include "wine/mutex.h"
 #include "wine/wingdi16.h"
 #include "wine/server.h"

@@ -145,7 +146,7 @@ static struct list gpus = LIST_INIT(gpus);
 static struct list sources = LIST_INIT(sources);
 static struct list monitors = LIST_INIT(monitors);
 static INT64 last_query_display_time;
-static pthread_mutex_t display_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE display_lock = WINE_MUTEX_INIT;

BOOL enable_thunk_lock = FALSE;

@@ -279,21 +280,21 @@ static RECT work_area;
 static DWORD process_layout = ~0u;

static HDC display_dc;
-static pthread_mutex_t display_dc_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE display_dc_lock = WINE_MUTEX_INIT;

-static pthread_mutex_t user_mutex;
+static WINE_MUTEX_RECURSIVE_TYPE user_mutex;
 static unsigned int user_lock_thread, user_lock_rec;

void user_lock(void)
 {
-    pthread_mutex_lock( &user_mutex );
+    WINE_MUTEX_RECURSIVE_LOCK( &user_mutex );
     if (!user_lock_rec++) user_lock_thread = GetCurrentThreadId();
 }

void user_unlock(void)
 {
     if (!--user_lock_rec) user_lock_thread = 0;
-    pthread_mutex_unlock( &user_mutex );
+    WINE_MUTEX_RECURSIVE_UNLOCK( &user_mutex );
 }

void user_check_not_lock(void)
@@ -1229,7 +1230,7 @@ static void add_gpu( const char *name, const struct pci_id *pci_id, const GUID *

if (!ctx->mutex)
     {
-        pthread_mutex_lock( &display_lock );
+        WINE_MUTEX_LOCK( &display_lock );
         ctx->mutex = get_display_device_init_mutex();
         prepare_devices();
     }
@@ -1536,7 +1537,7 @@ static void release_display_manager_ctx( struct device_manager_ctx *ctx )
 {
     if (ctx->mutex)
     {
-        pthread_mutex_unlock( &display_lock );
+        WINE_MUTEX_UNLOCK( &display_lock );
         release_display_device_init_mutex( ctx->mutex );
         ctx->mutex = 0;
     }
@@ -1718,7 +1719,7 @@ static BOOL update_display_cache_from_registry(void)

if (key.LastWriteTime.QuadPart <= last_query_display_time) return TRUE;

-    pthread_mutex_lock( &display_lock );
+    WINE_MUTEX_LOCK( &display_lock );
     mutex = get_display_device_init_mutex();

clear_display_devices();
@@ -1773,7 +1774,7 @@ static BOOL update_display_cache_from_registry(void)

if ((ret = !list_empty( &sources ) && !list_empty( &monitors )))
         last_query_display_time = key.LastWriteTime.QuadPart;
-    pthread_mutex_unlock( &display_lock );
+    WINE_MUTEX_UNLOCK( &display_lock );
     release_display_device_init_mutex( mutex );
     return ret;
 }
@@ -2035,10 +2036,10 @@ BOOL update_display_cache( BOOL force )
     if (NtUserGetObjectInformation( winstation, UOI_NAME, name, sizeof(name), NULL )
         && !wcscmp( name, wine_service_station_name ))
     {
-        pthread_mutex_lock( &display_lock );
+        WINE_MUTEX_LOCK( &display_lock );
         clear_display_devices();
         list_add_tail( &monitors, &virtual_monitor.entry );
-        pthread_mutex_unlock( &display_lock );
+        WINE_MUTEX_UNLOCK( &display_lock );
         return TRUE;
     }

@@ -2073,25 +2074,25 @@ BOOL update_display_cache( BOOL force )
 static BOOL lock_display_devices(void)
 {
     if (!update_display_cache( FALSE )) return FALSE;
-    pthread_mutex_lock( &display_lock );
+    WINE_MUTEX_LOCK( &display_lock );
     return TRUE;
 }

static void unlock_display_devices(void)
 {
-    pthread_mutex_unlock( &display_lock );
+    WINE_MUTEX_UNLOCK( &display_lock );
 }

static HDC get_display_dc(void)
 {
-    pthread_mutex_lock( &display_dc_lock );
+    WINE_MUTEX_LOCK( &display_dc_lock );
     if (!display_dc)
     {
         HDC dc;

-        pthread_mutex_unlock( &display_dc_lock );
+        WINE_MUTEX_UNLOCK( &display_dc_lock );
         dc = NtGdiOpenDCW( NULL, NULL, NULL, 0, TRUE, NULL, NULL, NULL );
-        pthread_mutex_lock( &display_dc_lock );
+        WINE_MUTEX_LOCK( &display_dc_lock );
         if (display_dc)
             NtGdiDeleteObjectApp( dc );
         else
@@ -2108,7 +2109,7 @@ HBITMAP get_display_bitmap(void)
     HBITMAP ret;

virtual_rect = get_virtual_screen_rect( 0 );
-    pthread_mutex_lock( &display_dc_lock );
+    WINE_MUTEX_LOCK( &display_dc_lock );
     if (!EqualRect( &old_virtual_rect, &virtual_rect ))
     {
         if (hbitmap) NtGdiDeleteObjectApp( hbitmap );
@@ -2117,13 +2118,13 @@ HBITMAP get_display_bitmap(void)
         old_virtual_rect = virtual_rect;
     }
     ret = hbitmap;
-    pthread_mutex_unlock( &display_dc_lock );
+    WINE_MUTEX_UNLOCK( &display_dc_lock );
     return ret;
 }

static void release_display_dc( HDC hdc )
 {
-    pthread_mutex_unlock( &display_dc_lock );
+    WINE_MUTEX_UNLOCK( &display_dc_lock );
 }

/**********************************************************************
@@ -4838,17 +4839,13 @@ void sysparams_init(void)
     WCHAR buffer[MAX_PATH+16], *p, *appname;
     DWORD i, dispos, dpi_scaling;
     WCHAR layout[KL_NAMELENGTH];
-    pthread_mutexattr_t attr;
     HKEY hkey, appkey = 0;
     DWORD len;

static const WCHAR oneW[] = {'1',0};
     static const WCHAR x11driverW[] = {'\','X','1','1',' ','D','r','i','v','e','r',0};

-    pthread_mutexattr_init( &attr );
-    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
-    pthread_mutex_init( &user_mutex, &attr );
-    pthread_mutexattr_destroy( &attr );
+    WINE_MUTEX_RECURSIVE_INIT( &user_mutex );

if ((hkey = reg_create_ascii_key( hkcu_key, "Keyboard Layout\Preload", 0, NULL )))
     {
diff --git a/dlls/win32u/winstation.c b/dlls/win32u/winstation.c
index d2386fd5af5..bcf00072b7f 100644
--- a/dlls/win32u/winstation.c
+++ b/dlls/win32u/winstation.c
@@ -37,6 +37,7 @@
 #include "ntgdi_private.h"
 #include "ntuser_private.h"
 #include "wine/server.h"
+#include "wine/mutex.h"
 #include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(winstation);
@@ -69,7 +70,7 @@ struct session_block
     SIZE_T      size;       /* size of the mmaped data */
 };

-static pthread_mutex_t session_lock = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE session_lock = WINE_MUTEX_INIT;
 static struct list session_blocks = LIST_INIT(session_blocks);

static struct session_thread_data *get_session_thread_data(void)
@@ -156,14 +157,14 @@ static NTSTATUS find_shared_session_block( SIZE_T offset, SIZE_T size, struct se

assert( offset + size > offset );

-    pthread_mutex_lock( &session_lock );
+    WINE_MUTEX_LOCK( &session_lock );

LIST_FOR_EACH_ENTRY( block, &session_blocks, struct session_block, entry )
     {
         if (block->offset < offset && offset + size <= block->offset + block->size)
         {
             *ret = block;
-            pthread_mutex_unlock( &session_lock );
+            WINE_MUTEX_UNLOCK( &session_lock );
             return STATUS_SUCCESS;
         }
     }
@@ -174,7 +175,7 @@ static NTSTATUS find_shared_session_block( SIZE_T offset, SIZE_T size, struct se
             wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), status );
     }

-    pthread_mutex_unlock( &session_lock );
+    WINE_MUTEX_UNLOCK( &session_lock );

return status;
 }
diff --git a/include/wine/gdi_driver.h b/include/wine/gdi_driver.h
index 69bd096a1a5..0a0a445a3c2 100644
--- a/include/wine/gdi_driver.h
+++ b/include/wine/gdi_driver.h
@@ -38,6 +38,7 @@
 #include "shellapi.h"
 #include "ddk/d3dkmthk.h"
 #include "kbd.h"
+#include "wine/mutex.h"
 #include "wine/list.h"
 #include "wine/debug.h"

@@ -240,7 +241,7 @@ struct window_surface
     HWND                               hwnd;  /* window the surface was created for */
     RECT                               rect;  /* constant, no locking needed */

-    pthread_mutex_t                    mutex;        /* mutex needed for any field below */
+    WINE_MUTEX_TYPE                    mutex;        /* mutex needed for any field below */
     RECT                               bounds;       /* dirty area rectangle */
     HRGN                               clip_region;  /* visible region of the surface, fully visible if 0 */
     DWORD                              draw_start_ticks; /* start ticks of fresh draw */

[PATCH 6/6] ws2_32: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 dlls/ws2_32/unixlib.c | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/dlls/ws2_32/unixlib.c b/dlls/ws2_32/unixlib.c
index e0e1263e025..c71787857eb 100644
--- a/dlls/ws2_32/unixlib.c
+++ b/dlls/ws2_32/unixlib.c
@@ -98,6 +98,7 @@
 #include "ws2tcpip.h"
 #include "wsipx.h"
 #include "af_irda.h"
+#include "wine/mutex.h"
 #include "wine/debug.h"

#include "ws2_32_private.h"
@@ -106,7 +107,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(winsock);
 WINE_DECLARE_DEBUG_CHANNEL(winediag);

#ifndef HAVE_LINUX_GETHOSTBYNAME_R_6
-static pthread_mutex_t host_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE host_mutex = WINE_MUTEX_INIT;
 #endif

#define MAP(x) {WS_ ## x, x}
@@ -923,18 +924,18 @@ static NTSTATUS unix_gethostbyaddr( void *args )
         return ret;
     }
 #else
-    pthread_mutex_lock( &host_mutex );
+    WINE_MUTEX_LOCK( &host_mutex );

if (!(unix_host = gethostbyaddr( addr, params->len, unix_family )))
     {
         ret = (h_errno < 0 ? errno_from_unix( errno ) : host_errno_from_unix( h_errno ));
-        pthread_mutex_unlock( &host_mutex );
+        WINE_MUTEX_UNLOCK( &host_mutex );
         return ret;
     }

ret = hostent_from_unix( unix_host, params->host, params->size );

-    pthread_mutex_unlock( &host_mutex );
+    WINE_MUTEX_UNLOCK( &host_mutex );
     return ret;
 #endif
 }
@@ -1022,19 +1023,19 @@ static NTSTATUS unix_gethostbyname( void *args )
     struct hostent *unix_host;
     int ret;

-    pthread_mutex_lock( &host_mutex );
+    WINE_MUTEX_LOCK( &host_mutex );

if (!(unix_host = gethostbyname( params->name )))
     {
         ret = (h_errno < 0 ? errno_from_unix( errno ) : host_errno_from_unix( h_errno ));
-        pthread_mutex_unlock( &host_mutex );
+        WINE_MUTEX_UNLOCK( &host_mutex );
         return ret;
     }

sort_addrs_hashed( unix_host );
     ret = hostent_from_unix( unix_host, params->host, params->size );

-    pthread_mutex_unlock( &host_mutex );
+    WINE_MUTEX_UNLOCK( &host_mutex );
     return ret;
 }
 #endif

[PATCH 6/6] ws2_32: Add atomic lock support.

[Marvin]

Hi,

It looks like your patch introduced the new failures shown below.
Please investigate and fix them before resubmitting your patch.
If they are not new, fixing them anyway would help a lot. Otherwise
please ask for the known failures list to be updated.

The full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=147825

Your paranoid android.

=== debian11 (build log) ===

../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
Task: The win32 Wine build failed

=== debian11b (build log) ===

../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
../wine/include/wine/mutex.h:33:2: error: #error USE_AFL is not defined!
Task: The wow64 Wine build failed

[Elizabeth Figura (＠zfigura)]

> I'm not sure about the need for this solution, so it's a **DRAFT**.

Why submit it, then?

[Grigory Vasilyev (＠h0tc0d3)]

On Tue Aug 20 08:44:15 2024 +0000, Elizabeth Figura wrote:
> > I'm not sure about the need for this solution, so it's a **DRAFT**.
>
> Why submit it, then?

@zfigura Get feedback or help. There are many types of mutexes, classic, robust-list, priority inherit, all have their pros and cons. Also POSIX imposes some restrictions on the implementation of mutexes, and for example in glibc there is a bug report and MR for PI condvar. Probably a more subtle implementation of the synchronization primitives required by Wine will help its work. Of course ntsync, fsync, esync already solve problems, but I offer an alternative, and not a replacement for them, i.e. it may not work as effectively or work together. I am not sure of the effectiveness of this solution, but it seems to me that some of the problems can be solved by atomic structures and the number of system calls can be reduced.