[PATCH v5 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"
```

--
  v5: 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 v5 1/8] configure: Change C standard to C17.

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 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
            ;;
-- 
GitLab


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

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

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 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);
 }
-- 
GitLab


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

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

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 include/Makefile.in  |   1 +
 include/wine/mutex.h | 132 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 133 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..f9d54cce956
--- /dev/null
+++ b/include/wine/mutex.h
@@ -0,0 +1,132 @@
+#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 <stdint.h>
+#include <unistd.h>
+#include <stdatomic.h>
+#include <sys/types.h>
+#include <sys/syscall.h>
+#include <linux/futex.h>
+
+#define WINE_MUTEX_TYPE _Atomic unsigned 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 no waiters
+#define WINE_MUTEX_LOCKED_WAIT 2   // Mutex Locked and have waiters
+
+#define WINE_MUTEX_LOCK(RESOURCE)                                                                          \
+    do {                                                                                                   \
+        unsigned int __wine_mutex_expected = WINE_MUTEX_UNLOCKED;                                          \
+        if (!atomic_compare_exchange_strong(RESOURCE, &__wine_mutex_expected, WINE_MUTEX_LOCKED_NOWAIT)) { \
+            if (__wine_mutex_expected == WINE_MUTEX_LOCKED_NOWAIT) {                                       \
+                __wine_mutex_expected = atomic_exchange(RESOURCE, WINE_MUTEX_LOCKED_WAIT);                 \
+            }                                                                                              \
+            while (__wine_mutex_expected != WINE_MUTEX_UNLOCKED) {                                         \
+                syscall(SYS_futex, RESOURCE, FUTEX_WAIT, WINE_MUTEX_LOCKED_WAIT, NULL, NULL, 0);           \
+                __wine_mutex_expected = atomic_exchange(RESOURCE, WINE_MUTEX_LOCKED_WAIT);                 \
+            }                                                                                              \
+        }                                                                                                  \
+    } while (0)
+
+#define WINE_MUTEX_UNLOCK(RESOURCE)                                      \
+    do {                                                                 \
+        if (atomic_fetch_sub(RESOURCE, 1) != WINE_MUTEX_LOCKED_NOWAIT) { \
+            atomic_store(RESOURCE, 0);                                   \
+            syscall(SYS_futex, RESOURCE, FUTEX_WAKE, 1, NULL, NULL, 0);  \
+        }                                                                \
+    } while (0)
+
+#define WINE_MUTEX_DESTROY(RESOURCE) WINE_MUTEX_UNLOCK(RESOURCE)
+
+struct __wine_mutex_recursive
+{
+    _Atomic pid_t owner;
+    WINE_MUTEX_TYPE mutex;
+};
+
+#define WINE_MUTEX_RECURSIVE_TYPE struct __wine_mutex_recursive
+
+#define WINE_MUTEX_RECURSIVE_INIT(RESOURCE)                      \
+    do {                                                         \
+        WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = RESOURCE;      \
+        atomic_store(&__wine_mutex->owner, 0);                   \
+        atomic_store(&__wine_mutex->mutex, WINE_MUTEX_UNLOCKED); \
+    } while (0)
+
+#define WINE_MUTEX_RECURSIVE_LOCK(RESOURCE)                                                                      \
+    do {                                                                                                         \
+        pid_t tid = 0;                                                                                           \
+        unsigned int __wine_mutex_expected = WINE_MUTEX_UNLOCKED;                                                \
+        WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = RESOURCE;                                                      \
+        tid = syscall(SYS_gettid);                                                                               \
+        if (atomic_load(&__wine_mutex->owner) != tid) {                                                          \
+            if (!atomic_load(&__wine_mutex->owner)) {                                                            \
+                atomic_store(&__wine_mutex->owner, tid);                                                         \
+                atomic_store(&__wine_mutex->mutex, WINE_MUTEX_LOCKED_NOWAIT);                                    \
+            } else {                                                                                             \
+                if (atomic_load(&__wine_mutex->mutex) == WINE_MUTEX_LOCKED_NOWAIT) {                             \
+                    __wine_mutex_expected = atomic_exchange(&__wine_mutex->mutex, WINE_MUTEX_LOCKED_WAIT);       \
+                }                                                                                                \
+                while (__wine_mutex_expected != WINE_MUTEX_UNLOCKED) {                                           \
+                    syscall(SYS_futex, &__wine_mutex->mutex, FUTEX_WAIT, WINE_MUTEX_LOCKED_WAIT, NULL, NULL, 0); \
+                    __wine_mutex_expected = atomic_exchange(&__wine_mutex->mutex, WINE_MUTEX_LOCKED_WAIT);       \
+                }                                                                                                \
+                atomic_store(&__wine_mutex->owner, tid);                                                         \
+            }                                                                                                    \
+        }                                                                                                        \
+    } while (0)
+
+#define WINE_MUTEX_RECURSIVE_UNLOCK(RESOURCE)                                            \
+    do {                                                                                 \
+        pid_t tid = 0;                                                                   \
+        WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = RESOURCE;                              \
+        tid = syscall(SYS_gettid);                                                       \
+        if (atomic_load(&__wine_mutex->owner) == tid) {                                  \
+            if (atomic_fetch_sub(&__wine_mutex->mutex, 1) != WINE_MUTEX_LOCKED_NOWAIT) { \
+                atomic_store(&__wine_mutex->owner, 0);                                   \
+                atomic_store(&__wine_mutex->mutex, 0);                                   \
+                syscall(SYS_futex, &__wine_mutex->mutex, FUTEX_WAKE, 1, NULL, NULL, 0);  \
+            }                                                                            \
+        }                                                                                \
+    } while (0)
+
+#define WINE_MUTEX_RECURSIVE_DESTROY(RESOURCE)              \
+    do {                                                    \
+        WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = RESOURCE; \
+        atomic_store(&__wine_mutex->owner, 0);              \
+        atomic_store(&__wine_mutex->mutex, 0);              \
+    } while (0)
+
+#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(RESOURCE) pthread_mutex_lock(RESOURCE)
+#define WINE_MUTEX_UNLOCK(RESOURCE) pthread_mutex_unlock(RESOURCE)
+#define WINE_MUTEX_DESTROY(RESOURCE) pthread_mutex_destroy(RESOURCE)
+#define WINE_MUTEX_RECURSIVE_TYPE pthread_mutex_t
+#define WINE_MUTEX_RECURSIVE_INIT(RESOURCE)                        \
+    do {                                                           \
+        pthread_mutexattr_t attr;                                  \
+        pthread_mutexattr_init(&attr);                             \
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); \
+        pthread_mutex_init(RESOURCE, &attr);                       \
+        pthread_mutexattr_destroy(&attr);                          \
+    } while (0)
+#define WINE_MUTEX_RECURSIVE_LOCK(RESOURCE) pthread_mutex_lock(RESOURCE)
+#define WINE_MUTEX_RECURSIVE_UNLOCK(RESOURCE) pthread_mutex_unlock(RESOURCE)
+#define WINE_MUTEX_RECURSIVE_DESTROY(RESOURCE) pthread_mutex_destroy(RESOURCE)
+#endif
+
+#endif /* __WINE_WINE_MUTEX_H */
-- 
GitLab


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

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

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 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);
-- 
GitLab


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

[PATCH v5 5/8] ntdll: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 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;
 }
 
-- 
GitLab


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

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

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 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)
-- 
GitLab


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

[PATCH v5 7/8] wine32u: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 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 aa6836e3440..4824b6a157b 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 )
@@ -548,10 +555,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 );
 }
 
 /*******************************************************************
@@ -565,7 +572,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 */
@@ -574,7 +581,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 */
-- 
GitLab


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

[PATCH v5 8/8] ws2_32: Add atomic lock support.

[Grigory Vasilyev]

From: Grigory Vasilyev <h0tc0d3(a)gmail.com>

---
 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
-- 
GitLab

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

[PATCH v5 8/8] ws2_32: Add atomic lock support.

[Marvin]

Hi,

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

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

Your paranoid android.


=== debian11 (build log) ===

../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
Task: The win32 Wine build failed

=== debian11b (build log) ===

../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
../wine/include/wine/mutex.h:112:2: error: #error C11 Atomic operations not supported. C version is lower than C11 or WINE_USE_ATOMIC_LOCKS not defined.
Task: The wow64 Wine build failed

[Grigory Vasilyev (＠h0tc0d3)]

v5. Implemented atomic recursive mutex.

**TODO:**
- Adapt tests and benchmarks from glibc to check speed and correct behavior.
- Wine benchmarks.
- Implement atomic alternative pthread_once.

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

[Tatsuyuki Ishi (＠ishitatsuyuki)]

Like Alcaro said, you need to focus on some kind of benchmark (even just one) that directly represents a user journey, not microbenchmarks. For example, if you are experiencing slowness or jitter in some game, then you can measure frame time and/or standard deviation and see if you can make a statistically significant difference. FWIW, I don't think we have evidence that suggest noticeable slowness or jitters are coming from pthread_mutexes.

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

[Grigory Vasilyev (＠h0tc0d3)]

On Thu Jul 11 12:29:53 2024 +0000, Tatsuyuki Ishi wrote:
> Like Alcaro said, you need to focus on some kind of benchmark (even just
> one) that directly represents a user journey, not microbenchmarks. For
> example, if you are experiencing slowness or jitter in some game, then
> you can measure frame time and/or standard deviation and see if you can
> make a statistically significant difference. FWIW, I don't think we have
> evidence that suggest noticeable slowness or jitters are coming from pthread_mutexes.
> Once again I ask you to refuse empty comments containing **obvious things**.

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

[Tatsuyuki Ishi (＠ishitatsuyuki)]

On Thu Jul 11 12:30:53 2024 +0000, Grigory Vasilyev wrote:
> Once again I ask you to refuse empty comments containing **obvious
> things**. I will be glad if you help with tests and improving the code,
> but not with tediousness.
> If it is so obvious then why have you not done the relevant testing?

Also, I don't really understand why you are doing this. What is the use case for faster mutex? What is the practical goal that it achieves?

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

[Grigory Vasilyev (＠h0tc0d3)]

On Thu Jul 11 12:37:30 2024 +0000, Tatsuyuki Ishi wrote:
> If it is so obvious then why have you not done the relevant testing?
> Also, I don't really understand why you are doing this. What is the use
> case for faster mutex? What is the practical goal that it achieves?
> @ishitatsuyuki

```text
I'm not sure about the need for this solution, so it's a DRAFT. For me it is an academic interest
```

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

[Tatsuyuki Ishi (＠ishitatsuyuki)]

On Thu Jul 11 12:43:30 2024 +0000, Grigory Vasilyev wrote:
> @ishitatsuyuki 
> ```text
> I'm not sure about the need for this solution, so it's a DRAFT. For me
> it is an academic interest
> ```
> Whether it makes a practical difference is the biggest question that needs to be answered about this change. Microbenchmarks and others are only useful to explain the practical metric, they are not justifications on their own. Hence I'm suggesting to prioritize having a way to measure practical impact, then focus on everything else.

If you want help with measurements, how about providing the game name (and optionally information about setup, so people can replicate as much as possible) that you tested with?

Also, I'm not sure dismissing everything reasonable as obvious is a constructive way to discuss. Academism also doesn't go without measurements and practical discussions.

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

[Alfred Agrell (＠Alcaro)]

On Thu Jul 11 13:20:38 2024 +0000, Tatsuyuki Ishi wrote:
> Whether it makes a practical difference is the biggest question that
> needs to be answered about this change. Microbenchmarks and others are
> only useful to explain the practical metric, they are not justifications
> on their own. Hence I'm suggesting to prioritize having a way to measure
> practical impact, then focus on everything else.
> If you want help with measurements, how about providing the game name
> (and optionally information about setup, so people can replicate as much
> as possible) that you tested with?
> Also, I'm not sure dismissing everything reasonable as obvious is a
> constructive way to discuss. Academism also doesn't go without
> measurements and practical discussions.
> Before a MR can be approved and merged, the maintainers need to agree that (1) this is a problem worth solving (2) this is a good approach to said problem (3) the code looks good (4) tests pass (whether CI, manual, or both).

If the answer to 1 or 2 turns out to be no, then most effort spent on 3 and 4 will become a waste of time. That's why we're focusing on the former two first.

It's clear that your expectations are different.

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

[Grigory Vasilyev (＠h0tc0d3)]

On Thu Jul 11 14:01:57 2024 +0000, Alfred Agrell wrote:
> Before a MR can be approved and merged, the maintainers need to agree
> that (1) this is a problem worth solving (2) this is a good approach to
> said problem (3) the code looks good (4) tests pass (whether CI, manual,
> or both).
> If the answer to 1 or 2 turns out to be no, then most effort spent on 3
> and 4 will become a waste of time. That's why we're focusing on the
> former two first.
> It's clear that your expectations are different.
> @Alcaro you have problems? Do you don't have anyone to talk? I repeat once again, **I do not believe that this should be MERGED!** This is just a test of the hypothesis that reducing the number of context switches in the scheduler can have a positive effect on performance. First need to implement it, and then test it. Therefore, refuse any comments not related to help with tests or how to improve the code.

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

[Tatsuyuki Ishi (＠ishitatsuyuki)]

> you have problems? Do you don't have anyone to talk?

Please chill. Talking like this will only get *you yourself* into trouble.
> I repeat once again, **I do not believe that this should be MERGED!**

People are just here to give you suggestions, people are not here trying to NACK your idea.

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

[Jordan Johnston (＠nine7nine)]

Non-Wine Dev here, but always interested in achieving top-notch performance in Wine for my own use cases.

I decided to pull in some of this patchset (v5) into a test build of my own custom Wine, strictly incorporating only the ntdll changes (along with adjusting a lock in my wineserver to match, which doesn't exist in upstream Wine). Below are some quick tests I conducted using a Windows executable that performs rapid mutex tests, comparing different versions of Wine.

```
1. Wine-9.12:

[0] obtained the mutex 93975 times (23493 times per second)
[1] obtained the mutex 93979 times (23494 times per second)
[2] obtained the mutex 93988 times (23497 times per second)
[3] obtained the mutex 93999 times (23499 times per second)
[4] obtained the mutex 93977 times (23494 times per second)

2. Wine-Staging-9.12:

[0] obtained the mutex 96179 times (24044 times per second)
[1] obtained the mutex 96705 times (24176 times per second)
[2] obtained the mutex 96861 times (24215 times per second)
[3] obtained the mutex 97627 times (24406 times per second)
[4] obtained the mutex 95905 times (23976 times per second)

3. Wine-NSPA: Atomic Locks / FSYNC / RT

[0] obtained the mutex 663948 times (165987 times per second)
[1] obtained the mutex 646190 times (161547 times per second)
[2] obtained the mutex 615943 times (153985 times per second)
[3] obtained the mutex 657453 times (164363 times per second)
[4] obtained the mutex 697292 times (174323 times per second)

4. Wine-NSPA: Pi Mutexes / FSYNC / RT

[0] obtained the mutex 696384 times (174096 times per second)
[1] obtained the mutex 650608 times (162652 times per second)
[2] obtained the mutex 657671 times (164417 times per second)
[3] obtained the mutex 665090 times (166272 times per second)
[4] obtained the mutex 661732 times (165433 times per second)
```

Obviously, 1/2 don't do very well on these tests (for reasons mentioned below), but I thought I would include them anyway as a baseline of upstream.

3/4 are my own custom builds, which are the easiest for me to test against. These builds are based on Wine-8.19 with plenty of backports, performance enhancements, and RT-related features. In both cases:

-> FSYNC is enabled (futex_waitv, futex ops for Windows synchronization stuff).
-> Wineserver is multi-threaded (shmem per thread for server requests/replies).
-> RT Scheduling is enabled (Time Critical threads are SCHED_FIFO, the others are SCHED_RR. Wineserver is SCHED_FIFO).

In 3: I am using your atomic locks (v5) within ntdll and wineserver. The rest of Wine is using pi_mutexes (replacing pthread_mutexes), except where FSYNC is used.

In 4: I am using purely pi_mutexes in Wine (e.g., FUTEX_LOCK_PI, FUTEX_CMP_REQUEUE_PI, etc.), except where FSYNC is used... It tented to have less variance between tests.

As you may be aware, Futex PI has more overhead and is slower compared to regular futex ops. So based on that alone, one would think that your code should be able to obtain more mutexes per second, but clearly that isn't the case here (they are very similar, despite pi_mutex likely being 3x slower than your mutexes/locks).

I have my doubts that a faster mutex implementation will have any real benefits in terms of real applications running in Wine (atm). I don't think it's *the* bottleneck or limiting factor here. I mean, isn't there some kind of global locking in the heap code? As #1/2 vs. #3/4 show; Wineserver (single-thread) is a bigger problem, along with the lack of RT scheduling, lack of a better implementation for Windows synchronization primitives (be it Esync, Fsync, MSync, or Winesync/NTSync), and so on.

Anyway, all that aside:

-> You may want to look at where Wine uses pthread condvars, as I am not sure how well that plays with your atomic locks. If I recall correctly, there is also a place or two where pthread rwlocks are used as well.

On a final positive note: I didn't notice any real regressions using your code, and I did test it with some pretty CPU-heavy applications with lots of threads. So that's good, but I also didn't see any indication of improvements over using pi_mutexes either.

fun experiment either way ;-)

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