[PATCH v7 0/8] MR6031: Draft: wine: Use atomic locks insted pthread_mutex.

[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. First impressions are that games have become smoother, but need to think about tests that can actually be measured.

Before build need define `WINE_USE_ATOMIC_LOCKS`.

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

--
  v7: ws2_32: Add atomic lock support.
      wine32u: Add atomic lock support.
      winevulkan: Add atomic lock support.
      ntdll: Add atomic lock support.
      winewayland: Add atomic lock support.
      include: Define custom mutex macroses.
      msxml3: Fix compilation errors with Clang 18.
      configure: Change C standard to C17.

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

[PATCH v7 1/8] configure: Change C standard to C17.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 configure.ac | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/configure.ac b/configure.ac
index 23d3f8fbc49..eaefd4d1f6b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -897,26 +897,26 @@ This is an error since --enable-archs=$wine_arch was requested.])])
         continue
     fi

-    AS_VAR_PUSHDEF([wine_cv_crosscc_c99],[ac_cv_${wine_arch}_crosscc_c99])
-    AC_MSG_CHECKING([for $CC option to enable C99 features])
-    AC_CACHE_VAL([wine_cv_crosscc_c99],
-        [AS_VAR_SET([wine_cv_crosscc_c99],[no])
-         for arg in '' '-std=gnu99' '-D__STDC__'
+    AS_VAR_PUSHDEF([wine_cv_crosscc_c17],[ac_cv_${wine_arch}_crosscc_c17])
+    AC_MSG_CHECKING([for $CC option to enable c17 features])
+    AC_CACHE_VAL([wine_cv_crosscc_c17],
+        [AS_VAR_SET([wine_cv_crosscc_c17],[no])
+         for arg in '' '-std=gnu17' '-D__STDC__'
          do
              test -z "$arg" || CC="$CC $arg"
-             AC_COMPILE_IFELSE([AC_LANG_SOURCE([$ac_c_conftest_c99_program])],
-                               [AS_VAR_SET([wine_cv_crosscc_c99],[$arg])],
-                               [AS_VAR_SET([wine_cv_crosscc_c99],[no])])
+             AC_COMPILE_IFELSE([AC_LANG_SOURCE([$ac_c_conftest_c17_program])],
+                               [AS_VAR_SET([wine_cv_crosscc_c17],[$arg])],
+                               [AS_VAR_SET([wine_cv_crosscc_c17],[no])])
              AS_VAR_COPY([CC],[${wine_arch}_CC])
-             AS_VAR_IF([wine_cv_crosscc_c99],[no],[],[break])
+             AS_VAR_IF([wine_cv_crosscc_c17],[no],[],[break])
          done])
-    AS_VAR_COPY([res],[wine_cv_crosscc_c99])
-    AS_VAR_POPDEF([wine_cv_crosscc_c99])
+    AS_VAR_COPY([res],[wine_cv_crosscc_c17])
+    AS_VAR_POPDEF([wine_cv_crosscc_c17])
     case "x$res" in
       x) AC_MSG_RESULT([none needed]) ;;
       xno) AC_MSG_RESULT([unsupported])
            AS_VAR_SET_IF([enable_archs],
-                [AC_MSG_ERROR([$wine_arch PE cross-compiler supporting C99 not found.
+                [AC_MSG_ERROR([$wine_arch PE cross-compiler supporting C17 not found.
 This is an error since --enable-archs=$wine_arch was requested.])])
            continue
            ;;

[PATCH v7 2/8] msxml3: Fix compilation errors with Clang 18.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 dlls/msxml3/domdoc.c        | 4 ++--
 dlls/msxml3/main.c          | 3 ++-
 dlls/msxml3/msxml_private.h | 2 +-
 dlls/msxml3/schema.c        | 4 ++--
 dlls/msxml3/selection.c     | 2 +-
 5 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/dlls/msxml3/domdoc.c b/dlls/msxml3/domdoc.c
index 2acbffc0a88..e95b5313c16 100644
--- a/dlls/msxml3/domdoc.c
+++ b/dlls/msxml3/domdoc.c
@@ -26,7 +26,7 @@
 #include <libxml/parser.h>
 #include <libxml/xmlerror.h>
 #include <libxml/xpathInternals.h>
-# include <libxml/xmlsave.h>
+#include <libxml/xmlsave.h>
 #include <libxml/SAX2.h>
 #include <libxml/parserInternals.h>

@@ -502,7 +502,7 @@ static void LIBXML2_LOG_CALLBACK sax_warning(void* ctx, char const* msg, ...)
     va_end(ap);
 }

-static void sax_serror(void* ctx, xmlErrorPtr err)
+static void sax_serror(void* ctx, xmlError* err)
 {
     LIBXML2_CALLBACK_SERROR(doparse, err);
 }
diff --git a/dlls/msxml3/main.c b/dlls/msxml3/main.c
index 5e8de1676cf..8f9565d7000 100644
--- a/dlls/msxml3/main.c
+++ b/dlls/msxml3/main.c
@@ -22,6 +22,7 @@
 #define COBJMACROS

#include <stdarg.h>
+#include <libxml/globals.h>
 #include <libxml/parser.h>
 #include <libxml/xmlerror.h>
 #include <libxslt/pattern.h>
@@ -77,7 +78,7 @@ void wineXmlCallbackLog(char const* caller, xmlErrorLevel lvl, char const* msg,
     wine_dbg_log(dbcl, &__wine_dbch_msxml, caller, "%s", buff);
 }

-void wineXmlCallbackError(char const* caller, xmlErrorPtr err)
+void wineXmlCallbackError(char const* caller, xmlError* err)
 {
     enum __wine_debug_class dbcl;

diff --git a/dlls/msxml3/msxml_private.h b/dlls/msxml3/msxml_private.h
index 54f54995c76..05f162c3303 100644
--- a/dlls/msxml3/msxml_private.h
+++ b/dlls/msxml3/msxml_private.h
@@ -165,7 +165,7 @@ extern MSXML_VERSION xmldoc_version( xmlDocPtr doc );
 extern HRESULT XMLElement_create( xmlNodePtr node, LPVOID *ppObj, BOOL own );

extern void wineXmlCallbackLog(char const* caller, xmlErrorLevel lvl, char const* msg, va_list ap);
-extern void wineXmlCallbackError(char const* caller, xmlErrorPtr err);
+extern void wineXmlCallbackError(char const* caller, xmlError* err);

#define LIBXML2_LOG_CALLBACK WINAPIV __WINE_PRINTF_ATTR(2,3)

diff --git a/dlls/msxml3/schema.c b/dlls/msxml3/schema.c
index b6b790d9894..8be448ebf4b 100644
--- a/dlls/msxml3/schema.c
+++ b/dlls/msxml3/schema.c
@@ -243,7 +243,7 @@ static void LIBXML2_LOG_CALLBACK parser_warning(void* ctx, char const* msg, ...)
     va_end(ap);
 }

-static void parser_serror(void* ctx, xmlErrorPtr err)
+static void parser_serror(void* ctx, xmlError* err)
 {
     LIBXML2_CALLBACK_SERROR(Schema_parse, err);
 }
@@ -273,7 +273,7 @@ static void LIBXML2_LOG_CALLBACK validate_warning(void* ctx, char const* msg, ..
     va_end(ap);
 }

-static void validate_serror(void* ctx, xmlErrorPtr err)
+static void validate_serror(void* ctx, xmlError* err)
 {
     LIBXML2_CALLBACK_SERROR(Schema_validate_tree, err);
 }
diff --git a/dlls/msxml3/selection.c b/dlls/msxml3/selection.c
index f94b17379d9..aa7d2864907 100644
--- a/dlls/msxml3/selection.c
+++ b/dlls/msxml3/selection.c
@@ -756,7 +756,7 @@ static void XSLPattern_OP_IGEq(xmlXPathParserContextPtr pctx, int nargs)
     xmlFree(arg2);
 }

-static void query_serror(void* ctx, xmlErrorPtr err)
+static void query_serror(void* ctx, xmlError* err)
 {
     LIBXML2_CALLBACK_SERROR(domselection_create, err);
 }

[PATCH v7 3/8] include: Define custom mutex macroses.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 include/Makefile.in  |   1 +
 include/wine/mutex.h | 155 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 156 insertions(+)
 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/mutex.h b/include/wine/mutex.h
new file mode 100644
index 00000000000..9998a43e492
--- /dev/null
+++ b/include/wine/mutex.h
@@ -0,0 +1,155 @@
+#ifndef __WINE_WINE_MUTEX_H
+#define __WINE_WINE_MUTEX_H
+
+#if defined(WINE_USE_ATOMIC_LOCKS) && defined(__STDC_VERSION__) \
+  && __STDC_VERSION__ >= 201112L
+#ifndef __STDC_NO_ATOMICS__
+
+#include <errno.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <stdatomic.h>
+#include <sys/types.h>
+#include <sys/syscall.h>
+#include <linux/futex.h>
+
+#define __wine_mutex_unlikely(cond) __builtin_expect((cond), 0)
+#define __wine_mutex_likely(cond) __builtin_expect((cond), 1)
+
+typedef _Atomic uint32_t WINE_MUTEX_TYPE; // futex only can use 32-bit int
+
+#if __STDC_VERSION__ >= 201710L
+#define WINE_MUTEX_INIT 0
+#else
+#define WINE_MUTEX_INIT ATOMIC_VAR_INIT(0)
+#endif
+
+#define WINE_MUTEX_UNLOCKED 0      // Mutex Unlocked
+#define WINE_MUTEX_LOCKED_NOWAIT 1 // Mutex Locked and Not Have Waiters
+#define WINE_MUTEX_LOCKED_WAIT 2   // Mutex Locked and Have Waiters
+
+static inline int wine_mutex_lock(WINE_MUTEX_TYPE *mutex)
+{
+    uint32_t expected = WINE_MUTEX_UNLOCKED;
+
+    if (!atomic_compare_exchange_strong(mutex, &expected,
+                                        WINE_MUTEX_LOCKED_NOWAIT)) {
+        if (expected == WINE_MUTEX_LOCKED_NOWAIT) {
+            expected = atomic_exchange(mutex, WINE_MUTEX_LOCKED_WAIT);
+        }
+        while (expected != WINE_MUTEX_UNLOCKED) {
+            syscall(SYS_futex, mutex, FUTEX_WAIT, WINE_MUTEX_LOCKED_WAIT, NULL,
+                    NULL, 0);
+            expected = atomic_exchange(mutex, WINE_MUTEX_LOCKED_WAIT);
+        }
+    }
+
+    return 0;
+}
+
+static inline int wine_mutex_unlock(WINE_MUTEX_TYPE *mutex)
+{
+    if (atomic_load(mutex)
+        && atomic_fetch_sub(mutex, 1) == WINE_MUTEX_LOCKED_WAIT) {
+        atomic_store(mutex, WINE_MUTEX_UNLOCKED);
+        syscall(SYS_futex, mutex, FUTEX_WAKE, 1, NULL, NULL, 0);
+    }
+
+    return 0;
+}
+
+#define WINE_MUTEX_LOCK(__MUTEX__) wine_mutex_lock(__MUTEX__)
+#define WINE_MUTEX_UNLOCK(__MUTEX__) wine_mutex_unlock(__MUTEX__)
+#define WINE_MUTEX_DESTROY(__MUTEX__) wine_mutex_unlock(__MUTEX__)
+
+typedef struct
+{
+    _Atomic uint32_t lock;
+    _Atomic pthread_t owner;
+    _Atomic size_t count;
+} WINE_MUTEX_RECURSIVE_TYPE __attribute__((aligned(16)));
+
+static inline int wine_mutex_recursive_init(WINE_MUTEX_RECURSIVE_TYPE *mutex)
+{
+    atomic_store(&mutex->lock, 0);
+    atomic_store(&mutex->owner, 0);
+    atomic_store(&mutex->count, 0);
+
+    return 0;
+}
+
+static inline int wine_mutex_recursive_lock(WINE_MUTEX_RECURSIVE_TYPE *mutex)
+{
+    uint32_t expected = WINE_MUTEX_LOCKED_NOWAIT;
+    pthread_t tid = pthread_self();
+
+    if (atomic_load(&mutex->owner) == tid) {
+        // Check counter for overflow
+        if (__wine_mutex_unlikely(atomic_load(&mutex->count) + 1 == 0))
+            return EAGAIN;
+        atomic_fetch_add(&mutex->count, 1);
+        return 0;
+    }
+
+    while (expected != WINE_MUTEX_UNLOCKED) {
+        syscall(SYS_futex, &mutex->lock, FUTEX_WAIT, WINE_MUTEX_LOCKED_NOWAIT,
+                NULL, NULL, 0);
+        expected = atomic_exchange(&mutex->lock, WINE_MUTEX_LOCKED_NOWAIT);
+    }
+
+    atomic_store(&mutex->count, 1);
+    atomic_store(&mutex->owner, tid);
+
+    return 0;
+}
+
+static inline int wine_mutex_recursive_unlock(WINE_MUTEX_RECURSIVE_TYPE *mutex)
+{
+    pthread_t tid = pthread_self();
+
+    if (atomic_load(&mutex->owner) != tid)
+        return EPERM;
+
+    if (atomic_fetch_sub(&mutex->count, 1) <= 1) {
+        atomic_store(&mutex->owner, 0);
+        atomic_store(&mutex->lock, WINE_MUTEX_UNLOCKED);
+        syscall(SYS_futex, &mutex->lock, FUTEX_WAKE, 1, NULL, NULL, 0);
+    }
+
+    return 0;
+}
+
+#define WINE_MUTEX_RECURSIVE_INIT(__MUTEX__) \
+    wine_mutex_recursive_init(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_LOCK(__MUTEX__) \
+    wine_mutex_recursive_lock(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_UNLOCK(__MUTEX__) \
+    wine_mutex_recursive_unlock(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_DESTROY(__MUTEX__) \
+    wine_mutex_recursive_init(__MUTEX__)
+
+#else
+#error C11 Atomic operations not supported. Compiler defined __STDC_NO_ATOMICS__.
+#endif
+#else
+#error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
+#define WINE_MUTEX_TYPE pthread_mutex_t
+#define WINE_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
+#define WINE_MUTEX_LOCK(__MUTEX__) pthread_mutex_lock(__MUTEX__)
+#define WINE_MUTEX_UNLOCK(__MUTEX__) pthread_mutex_unlock(__MUTEX__)
+#define WINE_MUTEX_DESTROY(__MUTEX__) pthread_mutex_destroy(__MUTEX__)
+#define WINE_MUTEX_RECURSIVE_TYPE pthread_mutex_t
+#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__)
+#endif
+
+#endif /* __WINE_WINE_MUTEX_H */

[PATCH v7 4/8] winewayland: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev

---
 dlls/winewayland.drv/display.c          |  4 +--
 dlls/winewayland.drv/opengl.c           | 38 ++++++++++-----------
 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, 121 insertions(+), 116 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..3d6414fc6ed 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;
 }
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 bdef56e8f0c..16dc8812000 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;
@@ -670,9 +670,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;
 }
@@ -710,7 +710,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)
     {
@@ -737,14 +737,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);
     }
@@ -767,9 +767,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);
@@ -782,7 +782,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);
     }
 }

@@ -799,10 +799,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. */
@@ -857,10 +857,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);

@@ -917,10 +917,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);
 }

@@ -931,7 +931,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);
@@ -947,7 +947,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)
     {
@@ -965,14 +965,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 39c3976cdfd..7496bb29593 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. */
@@ -117,7 +117,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)
@@ -149,7 +149,11 @@ struct wayland_surface *wayland_surface_create(HWND hwnd)

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

+#ifdef WINE_USE_ATOMIC_LOCKS
+    atomic_store(&surface->mutex, 0);
+#else
     pthread_mutex_init(&surface->mutex, NULL);
+#endif

surface->hwnd = hwnd;
     surface->wl_surface = wl_compositor_create_surface(process_wayland.wl_compositor);
@@ -183,7 +187,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;
@@ -191,14 +195,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)
     {
@@ -224,14 +228,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 efb13821696..6b79101de1f 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 dc6a6b7e03a..ba1a26142c3 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);
 }

@@ -503,14 +503,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;
     }

@@ -572,7 +572,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);

@@ -658,7 +658,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);
     }
 }

@@ -676,18 +676,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)
             {
@@ -701,8 +701,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;
         }
     }
@@ -738,7 +738,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 e9eb74b17ca..b5cb903d4dc 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 v7 5/8] 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 15fdf2cb021..afe3c4ce482 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 efb6e7f4579..7343823e68d 100644
--- a/dlls/ntdll/unix/system.c
+++ b/dlls/ntdll/unix/system.c
@@ -229,7 +229,7 @@ static unsigned int logical_proc_info_len, logical_proc_info_alloc_len;
 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 pthread_mutex_t timezone_mutex = PTHREAD_MUTEX_INITIALIZER;
+static WINE_MUTEX_TYPE timezone_mutex = WINE_MUTEX_INIT;

/*******************************************************************************
  * Architecture specific feature detection for CPUs
@@ -2403,7 +2403,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);
@@ -2413,7 +2413,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;
     }

@@ -2506,7 +2506,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 );
 }

@@ -2716,7 +2716,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;
@@ -2727,7 +2727,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 6cd88a5acc0..ae599fc0c95 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,
@@ -415,16 +418,6 @@ static inline BOOL is_inside_signal_stack( void *ptr )
             (char *)ptr < (char *)get_signal_stack() + signal_stack_size);
 }

-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 )
 {
@@ -563,4 +556,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 0d88315164a..37de09b76af 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;
 }

@@ -6088,7 +6084,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 );
@@ -6112,7 +6108,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 v7 6/8] 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 f6e06bcc085..fe606feba1c 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 v7 7/8] 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       | 41 ++++++++---------
 dlls/win32u/winstation.c      |  9 ++--
 include/wine/gdi_driver.h     |  3 +-
 13 files changed, 207 insertions(+), 196 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 24a3bca5544..fccdbac61f7 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 4a672d6c519..a7d8cd2e2a8 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,
 };

/*******************************************************************
@@ -355,7 +356,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 WINE_USE_ATOMIC_LOCKS
+    atomic_store(&surface->mutex, 0);
+#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 );
@@ -374,7 +381,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 );
@@ -385,13 +392,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 )
@@ -546,10 +553,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 );
 }

/*******************************************************************
@@ -563,7 +570,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 */
@@ -572,7 +579,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 8fb3128f5e0..c3c4008c037 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);
@@ -460,7 +461,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)
@@ -1059,7 +1060,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++;
@@ -1076,7 +1077,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;
 }

@@ -2962,7 +2963,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 );
@@ -2976,7 +2977,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)
@@ -3508,9 +3509,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;
 }
@@ -3529,7 +3530,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])
     {
@@ -3565,7 +3566,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;
 }

@@ -3912,13 +3913,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;
 }

@@ -3939,11 +3940,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;
 }

@@ -3965,7 +3966,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;
@@ -3974,7 +3975,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;
 }

@@ -4099,7 +4100,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++)
     {
@@ -4128,7 +4129,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;
 }

@@ -4147,9 +4148,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;
 }

@@ -4167,11 +4168,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)
     {
@@ -4264,7 +4265,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;
@@ -4286,7 +4287,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;
 }

@@ -4325,14 +4326,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;
 }

@@ -4354,7 +4355,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,
@@ -4362,7 +4363,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;
 }

@@ -4451,7 +4452,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 ))
     {
@@ -4459,7 +4460,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;
 }

@@ -4657,7 +4658,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 );

@@ -4674,7 +4675,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 );
@@ -6433,16 +6434,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;
 }
@@ -6470,9 +6471,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 );
@@ -6859,9 +6860,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)
     {
@@ -6999,7 +7000,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;
@@ -7009,7 +7010,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;
 }

@@ -7023,7 +7024,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 )))
     {
@@ -7038,7 +7039,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 5cf99e39ff0..a2745382663 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)
     {
@@ -987,13 +988,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;
@@ -1029,13 +1030,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 9a06db2c7f6..b92c2de3f9f 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)
@@ -1228,7 +1229,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();
     }
@@ -1530,7 +1531,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;
     }
@@ -1712,7 +1713,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();
@@ -1767,7 +1768,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;
 }
@@ -2023,10 +2024,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;
     }

@@ -2061,25 +2062,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
@@ -2090,7 +2091,7 @@ static HDC get_display_dc(void)

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

/**********************************************************************
@@ -4805,17 +4806,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 297a3b788ad..9a94f2136aa 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 774211fea15..22f221e76c3 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"

struct gdi_dc_funcs;
@@ -226,7 +227,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 v7 8/8] 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

[Grigory Vasilyev (＠h0tc0d3)]

v7. Bugs fixed. Now all mutexes are 1 to 4 times faster depending on the load and number of threads, the operating time of mutexes is more deterministic with a lower standard deviation.

Interesting Facts:
1) `syscall(SYS_gettid)` kills performance, and makes the code 10-15 times slower compared to pthread_mutex.
2) `static inline` is a little faster than `#define`, apparently due to the large amount of inlining, branching and the processor cache stops working efficiently.
3) Optimizing fast blocking paths can be several times slower. This is a paradox. The fastest recursive mutex turned out to be the least optimal based on common sense. For the same reason, pthread_mutex recursive does not optimize fast paths.

```
pthread_mutex
duration=67245843.000000
iterations=100.000000
mean=672458.430000
stdev=242104.122553
min=625500.000000
max=2840101.000000

atomic_mutex
duration=29866077.000000
iterations=100.000000
mean=298660.770000
stdev=199965.048512
min=229918.000000
max=2840101.000000

pthread_mutex_recursive
duration=384579581.000000
iterations=100.000000
mean=3845795.810000
stdev=631946.613951
min=3796231.000000
max=8124933.000000

atomic_mutex_recursive
duration=206283709.000000
iterations=100.000000
mean=2062837.090000
stdev=241309.789530
min=2028265.000000
max=8124933.000000
```

[PATCH v7 0/8] MR6031: Draft: wine: Use atomic locks insted pthread_mutex. - closed

[Grigory Vasilyev (＠h0tc0d3)]

This merge request was closed by Grigory Vasilyev.