[PATCH v6 0/8] MR6031: Draft: wine: Use atomic locks insted pthread_mutex.
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" ``` -- v6: 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
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
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
From: Grigory Vasilyev <h0tc0d3(a)gmail.com> --- include/Makefile.in | 1 + include/wine/mutex.h | 130 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 131 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..ab407269b15 --- /dev/null +++ b/include/wine/mutex.h @@ -0,0 +1,130 @@ +#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 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(__WINE_MUTEX__) \ + do { \ + int __wine_mutex_expected = WINE_MUTEX_UNLOCKED; \ + if (!atomic_compare_exchange_strong(__WINE_MUTEX__, &__wine_mutex_expected, WINE_MUTEX_LOCKED_NOWAIT)) { \ + if (__wine_mutex_expected == WINE_MUTEX_LOCKED_NOWAIT) { \ + __wine_mutex_expected = atomic_exchange(__WINE_MUTEX__, WINE_MUTEX_LOCKED_WAIT); \ + } \ + while (__wine_mutex_expected != WINE_MUTEX_UNLOCKED) { \ + syscall(SYS_futex, __WINE_MUTEX__, FUTEX_WAIT, WINE_MUTEX_LOCKED_WAIT, NULL, NULL, 0); \ + __wine_mutex_expected = atomic_exchange(__WINE_MUTEX__, WINE_MUTEX_LOCKED_WAIT); \ + } \ + } \ + } while (0) + +#define WINE_MUTEX_UNLOCK(__WINE_MUTEX__) \ + do { \ + if (atomic_load(__WINE_MUTEX__) && atomic_fetch_sub(__WINE_MUTEX__, 1) == WINE_MUTEX_LOCKED_WAIT) { \ + atomic_store(__WINE_MUTEX__, WINE_MUTEX_UNLOCKED); \ + syscall(SYS_futex, __WINE_MUTEX__, FUTEX_WAKE, 1, NULL, NULL, 0); \ + } \ + } while (0) + +#define WINE_MUTEX_DESTROY(__WINE_MUTEX__) WINE_MUTEX_UNLOCK(__WINE_MUTEX__) + +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(__WINE_MUTEX__) \ + do { \ + WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = __WINE_MUTEX__; \ + atomic_store(&__wine_mutex->owner, 0); \ + atomic_store(&__wine_mutex->mutex, WINE_MUTEX_UNLOCKED); \ + } while (0) + +#define WINE_MUTEX_RECURSIVE_LOCK(__WINE_MUTEX__) \ + do { \ + pid_t tid = 0; \ + int __wine_mutex_expected = WINE_MUTEX_UNLOCKED; \ + WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = __WINE_MUTEX__; \ + tid = syscall(SYS_gettid); \ + if (atomic_load(&__wine_mutex->owner) != tid) { \ + if (atomic_compare_exchange_strong(&__wine_mutex->owner, &__wine_mutex_expected, 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(__WINE_MUTEX__) \ + do { \ + pid_t tid = 0; \ + WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = __WINE_MUTEX__; \ + tid = syscall(SYS_gettid); \ + if (atomic_load(&__wine_mutex->owner) == tid && atomic_load(&__wine_mutex->mutex) \ + && atomic_fetch_sub(&__wine_mutex->mutex, 1) == WINE_MUTEX_LOCKED_WAIT) { \ + atomic_store(&__wine_mutex->mutex, WINE_MUTEX_UNLOCKED); \ + atomic_store(&__wine_mutex->owner, 0); \ + syscall(SYS_futex, &__wine_mutex->mutex, FUTEX_WAKE, 1, NULL, NULL, 0); \ + } \ + } while (0) + +#define WINE_MUTEX_RECURSIVE_DESTROY(__WINE_MUTEX__) \ + do { \ + WINE_MUTEX_RECURSIVE_TYPE *__wine_mutex = __WINE_MUTEX__; \ + 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(__WINE_MUTEX__) pthread_mutex_lock(__WINE_MUTEX__) +#define WINE_MUTEX_UNLOCK(__WINE_MUTEX__) pthread_mutex_unlock(__WINE_MUTEX__) +#define WINE_MUTEX_DESTROY(__WINE_MUTEX__) pthread_mutex_destroy(__WINE_MUTEX__) +#define WINE_MUTEX_RECURSIVE_TYPE pthread_mutex_t +#define WINE_MUTEX_RECURSIVE_INIT(__WINE_MUTEX__) \ + do { \ + pthread_mutexattr_t attr; \ + pthread_mutexattr_init(&attr); \ + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); \ + pthread_mutex_init(__WINE_MUTEX__, &attr); \ + pthread_mutexattr_destroy(&attr); \ + } while (0) +#define WINE_MUTEX_RECURSIVE_LOCK(__WINE_MUTEX__) pthread_mutex_lock(__WINE_MUTEX__) +#define WINE_MUTEX_RECURSIVE_UNLOCK(__WINE_MUTEX__) pthread_mutex_unlock(__WINE_MUTEX__) +#define WINE_MUTEX_RECURSIVE_DESTROY(__WINE_MUTEX__) pthread_mutex_destroy(__WINE_MUTEX__) +#endif + +#endif /* __WINE_WINE_MUTEX_H */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6031
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
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
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
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 4a672d6c519..a7d8cd2e2a8 100644 --- a/dlls/win32u/dce.c +++ b/dlls/win32u/dce.c @@ -30,6 +30,7 @@ #include "ntgdi_private.h" #include "ntuser_private.h" #include "wine/server.h" +#include "wine/mutex.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(win); @@ -50,7 +51,7 @@ static struct list dce_list = LIST_INIT(dce_list); #define DCE_CACHE_SIZE 64 static struct list window_surfaces = LIST_INIT( window_surfaces ); -static pthread_mutex_t surfaces_lock = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE surfaces_lock = WINE_MUTEX_INIT; /******************************************************************* * Dummy window surface for windows that shouldn't get painted. @@ -86,7 +87,7 @@ struct window_surface dummy_surface = .funcs = &dummy_surface_funcs, .ref = 1, .rect = {.right = 1, .bottom = 1}, - .mutex = PTHREAD_MUTEX_INITIALIZER, + .mutex = WINE_MUTEX_INIT, }; /******************************************************************* @@ -355,7 +356,13 @@ W32KAPI BOOL window_surface_init( struct window_surface *surface, const struct w surface->color_key = CLR_INVALID; surface->alpha_bits = -1; surface->alpha_mask = 0; - pthread_mutex_init( &surface->mutex, NULL ); + +#ifdef WINE_USE_ATOMIC_LOCKS + atomic_store(&surface->mutex, 0); +#else + pthread_mutex_init(&surface->mutex, NULL); +#endif + reset_bounds( &surface->bounds ); if (!bitmap) bitmap = NtGdiCreateDIBSection( 0, NULL, 0, info, DIB_RGB_COLORS, 0, 0, 0, NULL ); @@ -374,7 +381,7 @@ W32KAPI void window_surface_release( struct window_surface *surface ) ULONG ret = InterlockedDecrement( &surface->ref ); if (!ret) { - if (surface != &dummy_surface) pthread_mutex_destroy( &surface->mutex ); + if (surface != &dummy_surface) WINE_MUTEX_DESTROY( &surface->mutex ); if (surface->clip_region) NtGdiDeleteObjectApp( surface->clip_region ); if (surface->color_bitmap) NtGdiDeleteObjectApp( surface->color_bitmap ); if (surface->shape_bitmap) NtGdiDeleteObjectApp( surface->shape_bitmap ); @@ -385,13 +392,13 @@ W32KAPI void window_surface_release( struct window_surface *surface ) W32KAPI void window_surface_lock( struct window_surface *surface ) { if (surface == &dummy_surface) return; - pthread_mutex_lock( &surface->mutex ); + WINE_MUTEX_LOCK( &surface->mutex ); } W32KAPI void window_surface_unlock( struct window_surface *surface ) { if (surface == &dummy_surface) return; - pthread_mutex_unlock( &surface->mutex ); + WINE_MUTEX_UNLOCK( &surface->mutex ); } void *window_surface_get_color( struct window_surface *surface, BITMAPINFO *info ) @@ -546,10 +553,10 @@ void register_window_surface( struct window_surface *old, struct window_surface if (old == &dummy_surface) old = NULL; if (new == &dummy_surface) new = NULL; if (old == new) return; - pthread_mutex_lock( &surfaces_lock ); + WINE_MUTEX_LOCK( &surfaces_lock ); if (old) list_remove( &old->entry ); if (new) list_add_tail( &window_surfaces, &new->entry ); - pthread_mutex_unlock( &surfaces_lock ); + WINE_MUTEX_UNLOCK( &surfaces_lock ); } /******************************************************************* @@ -563,7 +570,7 @@ void flush_window_surfaces( BOOL idle ) DWORD now; struct window_surface *surface; - pthread_mutex_lock( &surfaces_lock ); + WINE_MUTEX_LOCK( &surfaces_lock ); now = NtGetTickCount(); if (idle) last_idle = now; /* if not idle, we only flush if there's evidence that the app never goes idle */ @@ -572,7 +579,7 @@ void flush_window_surfaces( BOOL idle ) LIST_FOR_EACH_ENTRY( surface, &window_surfaces, struct window_surface, entry ) window_surface_flush( surface ); done: - pthread_mutex_unlock( &surfaces_lock ); + WINE_MUTEX_UNLOCK( &surfaces_lock ); } /*********************************************************************** diff --git a/dlls/win32u/dibdrv/graphics.c b/dlls/win32u/dibdrv/graphics.c index 009143bc2d2..def42099425 100644 --- a/dlls/win32u/dibdrv/graphics.c +++ b/dlls/win32u/dibdrv/graphics.c @@ -27,6 +27,7 @@ #include "ntgdi_private.h" #include "dibdrv.h" +#include "wine/mutex.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(dib); @@ -60,7 +61,7 @@ struct cached_font static struct list font_cache = LIST_INIT( font_cache ); -static pthread_mutex_t font_cache_lock = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE font_cache_lock = WINE_MUTEX_INIT; static BOOL brush_rect( dibdrv_physdev *pdev, dib_brush *brush, const RECT *rect, HRGN clip ) @@ -569,7 +570,7 @@ static struct cached_font *add_cached_font( DC *dc, HFONT hfont, UINT aa_flags ) font.aa_flags = aa_flags; font.hash = font_cache_hash( &font ); - pthread_mutex_lock( &font_cache_lock ); + WINE_MUTEX_LOCK( &font_cache_lock ); LIST_FOR_EACH_ENTRY( ptr, &font_cache, struct cached_font, entry ) { if (!font_cache_cmp( &font, ptr )) @@ -602,7 +603,7 @@ static struct cached_font *add_cached_font( DC *dc, HFONT hfont, UINT aa_flags ) } else if (!(ptr = malloc( sizeof(*ptr) ))) { - pthread_mutex_unlock( &font_cache_lock ); + WINE_MUTEX_UNLOCK( &font_cache_lock ); return NULL; } @@ -611,7 +612,7 @@ static struct cached_font *add_cached_font( DC *dc, HFONT hfont, UINT aa_flags ) memset( ptr->glyphs, 0, sizeof(ptr->glyphs) ); done: list_add_head( &font_cache, &ptr->entry ); - pthread_mutex_unlock( &font_cache_lock ); + WINE_MUTEX_UNLOCK( &font_cache_lock ); TRACE( "%d %s -> %p\n", (int)ptr->lf.lfHeight, debugstr_w(ptr->lf.lfFaceName), ptr ); return ptr; } diff --git a/dlls/win32u/font.c b/dlls/win32u/font.c index 8fb3128f5e0..c3c4008c037 100644 --- a/dlls/win32u/font.c +++ b/dlls/win32u/font.c @@ -43,6 +43,7 @@ #include "wine/unixlib.h" #include "wine/rbtree.h" +#include "wine/mutex.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(font); @@ -460,7 +461,7 @@ static const struct nls_update_font_list } }; -static pthread_mutex_t font_lock = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE font_lock = WINE_MUTEX_INIT; #ifdef WORDS_BIGENDIAN #define GET_BE_WORD(x) (x) @@ -1059,7 +1060,7 @@ static int remove_font( const WCHAR *file, DWORD flags ) struct gdi_font_face *face, *face_next; int count = 0; - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR( family, family_next, &family_name_tree, struct gdi_font_family, name_entry ) { family->refcount++; @@ -1076,7 +1077,7 @@ static int remove_font( const WCHAR *file, DWORD flags ) } release_family( family ); } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return count; } @@ -2962,7 +2963,7 @@ static void release_gdi_font( struct gdi_font *font ) TRACE( "font %p\n", font ); /* add it to the unused list */ - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); if (!--font->refcount) { list_add_head( &unused_gdi_font_list, &font->unused_entry ); @@ -2976,7 +2977,7 @@ static void release_gdi_font( struct gdi_font *font ) } else unused_font_count++; } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); } static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl, int dpi) @@ -3508,9 +3509,9 @@ static BOOL enum_face_charsets( const struct gdi_font_family *family, struct gdi elf.elfLogFont.lfCharSet, type, debugstr_w(elf.elfScript), elf.elfLogFont.lfItalic, (int)elf.elfLogFont.lfWeight, (int)ntm.ntmTm.ntmFlags ); /* release section before callback (FIXME) */ - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); if (!proc( &elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam )) return FALSE; - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); } return TRUE; } @@ -3529,7 +3530,7 @@ static BOOL font_EnumFonts( PHYSDEV dev, LOGFONTW *lf, font_enum_proc proc, LPAR count = create_enum_charset_list( charset, enum_charsets ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); if (lf && lf->lfFaceName[0]) { @@ -3565,7 +3566,7 @@ static BOOL font_EnumFonts( PHYSDEV dev, LOGFONTW *lf, font_enum_proc proc, LPAR return FALSE; /* enum_face_charsets() unlocked font_lock */ } } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return TRUE; } @@ -3912,13 +3913,13 @@ static BOOL font_GetCharABCWidths( PHYSDEV dev, UINT first, UINT count, WCHAR *c TRACE( "%p, %u, %u, %p\n", physdev->font, first, count, buffer ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); for (i = 0; i < count; i++) { c = chars ? chars[i] : first + i; get_glyph_outline( physdev->font, c, GGO_METRICS, NULL, &buffer[i], 0, NULL, NULL ); } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return TRUE; } @@ -3939,11 +3940,11 @@ static BOOL font_GetCharABCWidthsI( PHYSDEV dev, UINT first, UINT count, WORD *g TRACE( "%p, %u, %u, %p\n", physdev->font, first, count, buffer ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); for (c = 0; c < count; c++, buffer++) get_glyph_outline( physdev->font, gi ? gi[c] : first + c, GGO_METRICS | GGO_GLYPH_INDEX, NULL, buffer, 0, NULL, NULL ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return TRUE; } @@ -3965,7 +3966,7 @@ static BOOL font_GetCharWidth( PHYSDEV dev, UINT first, UINT count, const WCHAR TRACE( "%p, %d, %d, %p\n", physdev->font, first, count, buffer ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); for (i = 0; i < count; i++) { c = chars ? chars[i] : i + first; @@ -3974,7 +3975,7 @@ static BOOL font_GetCharWidth( PHYSDEV dev, UINT first, UINT count, const WCHAR else buffer[i] = abc.abcA + abc.abcB + abc.abcC; } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return TRUE; } @@ -4099,7 +4100,7 @@ static DWORD font_GetGlyphIndices( PHYSDEV dev, const WCHAR *str, INT count, WOR got_default = TRUE; } - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); for (i = 0; i < count; i++) { @@ -4128,7 +4129,7 @@ static DWORD font_GetGlyphIndices( PHYSDEV dev, const WCHAR *str, INT count, WOR else gi[i] = get_GSUB_vert_glyph( physdev->font, glyph ); } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return count; } @@ -4147,9 +4148,9 @@ static DWORD font_GetGlyphOutline( PHYSDEV dev, UINT glyph, UINT format, dev = GET_NEXT_PHYSDEV( dev, pGetGlyphOutline ); return dev->funcs->pGetGlyphOutline( dev, glyph, format, gm, buflen, buf, mat ); } - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); ret = get_glyph_outline( physdev->font, glyph, format, gm, NULL, buflen, buf, mat ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return ret; } @@ -4167,11 +4168,11 @@ static DWORD font_GetKerningPairs( PHYSDEV dev, DWORD count, KERNINGPAIR *pairs return dev->funcs->pGetKerningPairs( dev, count, pairs ); } - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); if (physdev->font->kern_count == -1) physdev->font->kern_count = font_funcs->get_kerning_pairs( physdev->font, &physdev->font->kern_pairs ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); if (count && pairs) { @@ -4264,7 +4265,7 @@ static UINT font_GetOutlineTextMetrics( PHYSDEV dev, UINT size, OUTLINETEXTMETRI if (!physdev->font->scalable) return 0; - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); if (font_funcs->set_outline_text_metrics( physdev->font )) { ret = physdev->font->otm.otmSize; @@ -4286,7 +4287,7 @@ static UINT font_GetOutlineTextMetrics( PHYSDEV dev, UINT size, OUTLINETEXTMETRI scale_outline_font_metrics( physdev->font, metrics ); } } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return ret; } @@ -4325,14 +4326,14 @@ static BOOL font_GetTextExtentExPoint( PHYSDEV dev, const WCHAR *str, INT count, TRACE( "%p, %s, %d\n", physdev->font, debugstr_wn(str, count), count ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); for (i = pos = 0; i < count; i++) { get_glyph_outline( physdev->font, str[i], GGO_METRICS, NULL, &abc, 0, NULL, NULL ); pos += abc.abcA + abc.abcB + abc.abcC; dxs[i] = pos; } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return TRUE; } @@ -4354,7 +4355,7 @@ static BOOL font_GetTextExtentExPointI( PHYSDEV dev, const WORD *indices, INT co TRACE( "%p, %p, %d\n", physdev->font, indices, count ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); for (i = pos = 0; i < count; i++) { get_glyph_outline( physdev->font, indices[i], GGO_METRICS | GGO_GLYPH_INDEX, @@ -4362,7 +4363,7 @@ static BOOL font_GetTextExtentExPointI( PHYSDEV dev, const WORD *indices, INT co pos += abc.abcA + abc.abcB + abc.abcC; dxs[i] = pos; } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return TRUE; } @@ -4451,7 +4452,7 @@ static BOOL font_GetTextMetrics( PHYSDEV dev, TEXTMETRICW *metrics ) return dev->funcs->pGetTextMetrics( dev, metrics ); } - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); if (font_funcs->set_outline_text_metrics( physdev->font ) || font_funcs->set_bitmap_text_metrics( physdev->font )) { @@ -4459,7 +4460,7 @@ static BOOL font_GetTextMetrics( PHYSDEV dev, TEXTMETRICW *metrics ) scale_font_metrics( physdev->font, metrics ); ret = TRUE; } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return ret; } @@ -4657,7 +4658,7 @@ static HFONT font_SelectFont( PHYSDEV dev, HFONT hfont, UINT *aa_flags ) } TRACE( "DC transform %f %f %f %f\n", dcmat.eM11, dcmat.eM12, dcmat.eM21, dcmat.eM22 ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); font = select_font( &lf, dcmat, can_use_bitmap ); @@ -4674,7 +4675,7 @@ static HFONT font_SelectFont( PHYSDEV dev, HFONT hfont, UINT *aa_flags ) *aa_flags = font_funcs->get_aa_flags( font, *aa_flags, antialias_fakes ); } TRACE( "%p %s %d aa %x\n", hfont, debugstr_w(lf.lfFaceName), (int)lf.lfHeight, *aa_flags ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); } physdev->font = font; if (prev) release_gdi_font( prev ); @@ -6433,16 +6434,16 @@ static int add_system_font_resource( const WCHAR *file, DWORD flags ) /* try in %WINDIR%/fonts, needed for Fotobuch Designer */ get_fonts_win_dir_path( file, path ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); ret = font_funcs->add_font( path, flags ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); /* try in datadir/fonts (or builddir/fonts), needed for Magic the Gathering Online */ if (!ret) { get_fonts_data_dir_path( file, path ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); ret = font_funcs->add_font( path, flags ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); } return ret; } @@ -6470,9 +6471,9 @@ static int add_font_resource( LPCWSTR file, DWORD flags ) DWORD addfont_flags = ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE; if (!(flags & FR_PRIVATE)) addfont_flags |= ADDFONT_ADD_TO_CACHE; - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); ret = font_funcs->add_font( file, addfont_flags ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); } else if (!wcschr( file, '\\' )) ret = add_system_font_resource( file, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE ); @@ -6859,9 +6860,9 @@ HANDLE WINAPI NtGdiAddFontMemResourceEx( void *ptr, DWORD size, void *dv, ULONG if (!(copy = malloc( size ))) return NULL; memcpy( copy, ptr, size ); - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); num_fonts = font_funcs->add_mem_font( copy, size, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE ); - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); if (!num_fonts) { @@ -6999,7 +7000,7 @@ BOOL WINAPI NtGdiGetFontFileData( DWORD instance_id, DWORD file_index, UINT64 *o BOOL ret = FALSE; if (!font_funcs) return FALSE; - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); if ((font = get_font_from_handle( instance_id ))) { if (font->ttc_item_offset) tag = MS_TTCF_TAG; @@ -7009,7 +7010,7 @@ BOOL WINAPI NtGdiGetFontFileData( DWORD instance_id, DWORD file_index, UINT64 *o else RtlSetLastWin32Error( ERROR_INVALID_PARAMETER ); } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); return ret; } @@ -7023,7 +7024,7 @@ BOOL WINAPI NtGdiGetFontFileInfo( DWORD instance_id, DWORD file_index, struct fo struct gdi_font *font; BOOL ret = FALSE; - pthread_mutex_lock( &font_lock ); + WINE_MUTEX_LOCK( &font_lock ); if ((font = get_font_from_handle( instance_id ))) { @@ -7038,7 +7039,7 @@ BOOL WINAPI NtGdiGetFontFileInfo( DWORD instance_id, DWORD file_index, struct fo else RtlSetLastWin32Error( ERROR_INSUFFICIENT_BUFFER ); } - pthread_mutex_unlock( &font_lock ); + WINE_MUTEX_UNLOCK( &font_lock ); if (needed) *needed = required_size; return ret; } diff --git a/dlls/win32u/gdiobj.c b/dlls/win32u/gdiobj.c index 5cf99e39ff0..a2745382663 100644 --- a/dlls/win32u/gdiobj.c +++ b/dlls/win32u/gdiobj.c @@ -38,6 +38,7 @@ #include "ntgdi_private.h" #include "wine/debug.h" +#include "wine/mutex.h" #include "wine/unixlib.h" WINE_DEFAULT_DEBUG_CHANNEL(gdi); @@ -88,7 +89,7 @@ static const LOGBRUSH DkGrayBrush = { BS_SOLID, RGB(64,64,64), 0 }; static const LOGBRUSH DCBrush = { BS_SOLID, RGB(255,255,255), 0 }; -static pthread_mutex_t gdi_lock; +static WINE_MUTEX_RECURSIVE_TYPE gdi_lock; /**************************************************************************** @@ -454,9 +455,9 @@ void make_gdi_object_system( HGDIOBJ handle, BOOL set) { GDI_HANDLE_ENTRY *entry; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( handle ))) entry_obj( entry )->system = !!set; - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); } /****************************************************************************** @@ -492,9 +493,9 @@ UINT GDI_get_ref_count( HGDIOBJ handle ) GDI_HANDLE_ENTRY *entry; UINT ret = 0; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( handle ))) ret = entry_obj( entry )->selcount; - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); return ret; } @@ -508,10 +509,10 @@ HGDIOBJ GDI_inc_ref_count( HGDIOBJ handle ) { GDI_HANDLE_ENTRY *entry; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( handle ))) entry_obj( entry )->selcount++; else handle = 0; - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); return handle; } @@ -525,7 +526,7 @@ BOOL GDI_dec_ref_count( HGDIOBJ handle ) { GDI_HANDLE_ENTRY *entry; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( handle ))) { assert( entry_obj( entry )->selcount ); @@ -533,13 +534,13 @@ BOOL GDI_dec_ref_count( HGDIOBJ handle ) { /* handle delayed DeleteObject*/ entry_obj( entry )->deleted = 0; - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); TRACE( "executing delayed DeleteObject for %p\n", handle ); NtGdiDeleteObjectApp( handle ); return TRUE; } } - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); return entry != NULL; } @@ -696,7 +697,7 @@ static void dump_gdi_objects( void ) TRACE( "%u objects:\n", GDI_MAX_HANDLE_COUNT ); - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); for (entry = gdi_shared->Handles; entry < next_unused; entry++) { if (!entry->Type) @@ -707,7 +708,7 @@ static void dump_gdi_objects( void ) gdi_obj_type( entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT ), entry_obj( entry )->selcount, entry_obj( entry )->deleted ); } - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); } /*********************************************************************** @@ -722,7 +723,7 @@ HGDIOBJ alloc_gdi_handle( struct gdi_obj_header *obj, DWORD type, const struct g assert( type ); /* type 0 is reserved to mark free entries */ - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); entry = next_free; if (entry) @@ -731,7 +732,7 @@ HGDIOBJ alloc_gdi_handle( struct gdi_obj_header *obj, DWORD type, const struct g entry = next_unused++; else { - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); ERR( "out of GDI object handles, expect a crash\n" ); if (TRACE_ON(gdi)) dump_gdi_objects(); return 0; @@ -745,7 +746,7 @@ HGDIOBJ alloc_gdi_handle( struct gdi_obj_header *obj, DWORD type, const struct g entry->Type = entry->ExtType & 0x1f; if (++entry->Generation == 0x80) entry->Generation = 1; ret = entry_to_handle( entry ); - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); TRACE( "allocated %s %p %u/%u\n", gdi_obj_type(type), ret, (int)InterlockedIncrement( &debug_count ), GDI_MAX_HANDLE_COUNT ); return ret; @@ -762,7 +763,7 @@ void *free_gdi_handle( HGDIOBJ handle ) void *object = NULL; GDI_HANDLE_ENTRY *entry; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( handle ))) { TRACE( "freed %s %p %u/%u\n", gdi_obj_type( entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT ), @@ -772,7 +773,7 @@ void *free_gdi_handle( HGDIOBJ handle ) entry->Object = (UINT_PTR)next_free; next_free = entry; } - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); return object; } @@ -800,7 +801,7 @@ void *get_any_obj_ptr( HGDIOBJ handle, DWORD *type ) void *ptr = NULL; GDI_HANDLE_ENTRY *entry; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( handle ))) { @@ -808,7 +809,7 @@ void *get_any_obj_ptr( HGDIOBJ handle, DWORD *type ) *type = entry->ExtType << NTGDI_HANDLE_TYPE_SHIFT; } - if (!ptr) pthread_mutex_unlock( &gdi_lock ); + if (!ptr) WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); return ptr; } @@ -837,7 +838,7 @@ void *GDI_GetObjPtr( HGDIOBJ handle, DWORD type ) */ void GDI_ReleaseObj( HGDIOBJ handle ) { - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); } @@ -861,10 +862,10 @@ BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj ) const struct gdi_obj_funcs *funcs = NULL; struct gdi_obj_header *header; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if (!(entry = handle_entry( obj ))) { - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); return FALSE; } @@ -872,7 +873,7 @@ BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj ) if (header->system) { TRACE("Preserving system object %p\n", obj); - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); return TRUE; } @@ -885,7 +886,7 @@ BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj ) } else funcs = header->funcs; - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); TRACE("%p\n", obj ); @@ -932,13 +933,13 @@ INT WINAPI NtGdiExtGetObjectW( HGDIOBJ handle, INT count, void *buffer ) TRACE("%p %d %p\n", handle, count, buffer ); - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( handle ))) { funcs = entry_obj( entry )->funcs; handle = entry_to_handle( entry ); /* make it a full handle */ } - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); if (funcs && funcs->pGetObjectW) { @@ -987,13 +988,13 @@ BOOL WINAPI NtGdiUnrealizeObject( HGDIOBJ obj ) const struct gdi_obj_funcs *funcs = NULL; GDI_HANDLE_ENTRY *entry; - pthread_mutex_lock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_LOCK( &gdi_lock ); if ((entry = handle_entry( obj ))) { funcs = entry_obj( entry )->funcs; obj = entry_to_handle( entry ); /* make it a full handle */ } - pthread_mutex_unlock( &gdi_lock ); + WINE_MUTEX_RECURSIVE_UNLOCK( &gdi_lock ); if (funcs && funcs->pUnrealizeObject) return funcs->pUnrealizeObject( obj ); return funcs != NULL; @@ -1029,13 +1030,9 @@ BOOL WINAPI NtGdiSetColorAdjustment( HDC hdc, const COLORADJUSTMENT *ca ) void gdi_init(void) { - pthread_mutexattr_t attr; unsigned int dpi; - pthread_mutexattr_init( &attr ); - pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE ); - pthread_mutex_init( &gdi_lock, &attr ); - pthread_mutexattr_destroy( &attr ); + WINE_MUTEX_RECURSIVE_INIT(&gdi_lock); NtQuerySystemInformation( SystemBasicInformation, &system_info, sizeof(system_info), NULL ); init_gdi_shared(); diff --git a/dlls/win32u/imm.c b/dlls/win32u/imm.c index 4a9aca22360..a429194d3aa 100644 --- a/dlls/win32u/imm.c +++ b/dlls/win32u/imm.c @@ -30,6 +30,7 @@ #include "win32u_private.h" #include "ntuser_private.h" #include "immdev.h" +#include "wine/mutex.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(imm); @@ -65,7 +66,7 @@ struct imm_thread_data }; static struct list thread_data_list = LIST_INIT( thread_data_list ); -static pthread_mutex_t imm_mutex = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE imm_mutex = WINE_MUTEX_INIT; static struct list ime_updates = LIST_INIT( ime_updates ); static BOOL disable_ime; @@ -266,9 +267,9 @@ static struct imm_thread_data *get_imm_thread_data(void) if (!(data = calloc( 1, sizeof( *data )))) return NULL; data->thread_id = GetCurrentThreadId(); - pthread_mutex_lock( &imm_mutex ); + WINE_MUTEX_LOCK( &imm_mutex ); list_add_tail( &thread_data_list, &data->entry ); - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); thread_info->imm_thread_data = data; } @@ -339,7 +340,7 @@ BOOL WINAPI NtUserDisableThreadIme( DWORD thread_id ) { disable_ime = TRUE; - pthread_mutex_lock( &imm_mutex ); + WINE_MUTEX_LOCK( &imm_mutex ); LIST_FOR_EACH_ENTRY( thread_data, &thread_data_list, struct imm_thread_data, entry ) { if (thread_data->thread_id == GetCurrentThreadId()) continue; @@ -347,7 +348,7 @@ BOOL WINAPI NtUserDisableThreadIme( DWORD thread_id ) NtUserMessageCall( thread_data->default_hwnd, WM_WINE_DESTROYWINDOW, 0, 0, 0, NtUserSendNotifyMessage, FALSE ); } - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); } else if (!thread_id || thread_id == GetCurrentThreadId()) { @@ -375,14 +376,14 @@ HWND get_default_ime_window( HWND hwnd ) if (!(thread_id = get_window_thread( hwnd, NULL ))) return 0; - pthread_mutex_lock( &imm_mutex ); + WINE_MUTEX_LOCK( &imm_mutex ); LIST_FOR_EACH_ENTRY( thread_data, &thread_data_list, struct imm_thread_data, entry ) { if (thread_data->thread_id != thread_id) continue; ret = thread_data->default_hwnd; break; } - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); } else if ((thread_data = get_user_thread_info()->imm_thread_data)) { @@ -399,9 +400,9 @@ void cleanup_imm_thread(void) if (thread_info->imm_thread_data) { - pthread_mutex_lock( &imm_mutex ); + WINE_MUTEX_LOCK( &imm_mutex ); list_remove( &thread_info->imm_thread_data->entry ); - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); free( thread_info->imm_thread_data ); thread_info->imm_thread_data = NULL; } @@ -456,11 +457,11 @@ static void post_ime_update( HWND hwnd, UINT cursor_pos, WCHAR *comp_str, WCHAR if (!(update->vkey = data->ime_process_vkey)) { - pthread_mutex_lock( &imm_mutex ); + WINE_MUTEX_LOCK( &imm_mutex ); id = update->scan = ++ime_update_count; update->vkey = VK_PROCESSKEY; list_add_tail( &ime_updates, &update->entry ); - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); NtUserPostMessage( hwnd, WM_IME_NOTIFY, IMN_WINE_SET_COMP_STRING, id ); } @@ -490,11 +491,11 @@ UINT ime_to_tascii_ex( UINT vkey, UINT lparam, const BYTE *state, COMPOSITIONSTR TRACE( "vkey %#x, lparam %#x, state %p, compstr %p, himc %p\n", vkey, lparam, state, compstr, himc ); - pthread_mutex_lock( &imm_mutex ); + WINE_MUTEX_LOCK( &imm_mutex ); if (!(update = find_ime_update( vkey, lparam ))) { - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); return STATUS_NOT_FOUND; } @@ -518,12 +519,12 @@ UINT ime_to_tascii_ex( UINT vkey, UINT lparam, const BYTE *state, COMPOSITIONSTR if (compstr->dwSize < needed) { compstr->dwSize = needed; - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); return STATUS_BUFFER_TOO_SMALL; } list_remove( &update->entry ); - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); memset( compstr, 0, sizeof(*compstr) ); compstr->dwSize = sizeof(*compstr); @@ -590,9 +591,9 @@ LRESULT ime_driver_call( HWND hwnd, enum wine_ime_call call, WPARAM wparam, LPAR if (data->update) { - pthread_mutex_lock( &imm_mutex ); + WINE_MUTEX_LOCK( &imm_mutex ); list_add_tail( &ime_updates, &data->update->entry ); - pthread_mutex_unlock( &imm_mutex ); + WINE_MUTEX_UNLOCK( &imm_mutex ); data->update = NULL; res = TRUE; } diff --git a/dlls/win32u/rawinput.c b/dlls/win32u/rawinput.c index 62b1707dbfe..f47937a7449 100644 --- a/dlls/win32u/rawinput.c +++ b/dlls/win32u/rawinput.c @@ -33,6 +33,7 @@ #include "ddk/hidclass.h" #include "wine/hid.h" #include "wine/server.h" +#include "wine/mutex.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(rawinput); @@ -65,7 +66,7 @@ struct device static RAWINPUTDEVICE *registered_devices; static unsigned int registered_device_count; static struct list devices = LIST_INIT( devices ); -static pthread_mutex_t rawinput_mutex = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE rawinput_mutex = WINE_MUTEX_INIT; static struct device *add_device( HKEY key, DWORD type ) { @@ -344,7 +345,7 @@ UINT WINAPI NtUserGetRawInputDeviceList( RAWINPUTDEVICELIST *device_list, UINT * return ~0u; } - pthread_mutex_lock( &rawinput_mutex ); + WINE_MUTEX_LOCK( &rawinput_mutex ); rawinput_update_device_list( FALSE ); @@ -356,7 +357,7 @@ UINT WINAPI NtUserGetRawInputDeviceList( RAWINPUTDEVICELIST *device_list, UINT * device_list++; } - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); if (!device_list) { @@ -398,11 +399,11 @@ UINT WINAPI NtUserGetRawInputDeviceInfo( HANDLE handle, UINT command, void *data return ~0u; } - pthread_mutex_lock( &rawinput_mutex ); + WINE_MUTEX_LOCK( &rawinput_mutex ); if (!(device = find_device_from_handle( handle, TRUE ))) { - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); RtlSetLastWin32Error( ERROR_INVALID_HANDLE ); return ~0u; } @@ -435,7 +436,7 @@ UINT WINAPI NtUserGetRawInputDeviceInfo( HANDLE handle, UINT command, void *data break; } - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); if (!data) return 0; @@ -575,7 +576,7 @@ BOOL process_rawinput_message( MSG *msg, UINT hw_id, const struct hardware_msg_d BOOL refresh = msg->wParam == GIDC_ARRIVAL; struct device *device; - pthread_mutex_lock( &rawinput_mutex ); + WINE_MUTEX_LOCK( &rawinput_mutex ); if ((device = find_device_from_handle( UlongToHandle( msg_data->rawinput.device ), refresh ))) { if (msg->wParam == GIDC_REMOVAL) @@ -586,7 +587,7 @@ BOOL process_rawinput_message( MSG *msg, UINT hw_id, const struct hardware_msg_d free( device ); } } - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); } else { @@ -696,18 +697,18 @@ BOOL WINAPI NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT d FIXME( "Unhandled flags %#x for device %u.\n", (int)devices[i].dwFlags, i ); } - pthread_mutex_lock( &rawinput_mutex ); + WINE_MUTEX_LOCK( &rawinput_mutex ); if (!registered_device_count && !device_count) { - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); return TRUE; } size = (SIZE_T)device_size * (registered_device_count + device_count); if (!(new_registered_devices = realloc( registered_devices, size ))) { - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); RtlSetLastWin32Error( ERROR_OUTOFMEMORY ); return FALSE; } @@ -720,7 +721,7 @@ BOOL WINAPI NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT d if (!(device_count = registered_device_count)) server_devices = NULL; else if (!(server_devices = malloc( device_count * sizeof(*server_devices) ))) { - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); RtlSetLastWin32Error( ERROR_OUTOFMEMORY ); return FALSE; } @@ -741,7 +742,7 @@ BOOL WINAPI NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT d free( server_devices ); - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); return ret; } @@ -761,14 +762,14 @@ UINT WINAPI NtUserGetRegisteredRawInputDevices( RAWINPUTDEVICE *devices, UINT *d return ~0u; } - pthread_mutex_lock( &rawinput_mutex ); + WINE_MUTEX_LOCK( &rawinput_mutex ); capacity = *device_count * device_size; *device_count = registered_device_count; size = (SIZE_T)device_size * *device_count; if (devices && capacity >= size) memcpy( devices, registered_devices, size ); - pthread_mutex_unlock( &rawinput_mutex ); + WINE_MUTEX_UNLOCK( &rawinput_mutex ); if (!devices) return 0; diff --git a/dlls/win32u/sysparams.c b/dlls/win32u/sysparams.c index 9a06db2c7f6..b92c2de3f9f 100644 --- a/dlls/win32u/sysparams.c +++ b/dlls/win32u/sysparams.c @@ -34,6 +34,7 @@ #include "winreg.h" #include "cfgmgr32.h" #include "d3dkmdt.h" +#include "wine/mutex.h" #include "wine/wingdi16.h" #include "wine/server.h" @@ -145,7 +146,7 @@ static struct list gpus = LIST_INIT(gpus); static struct list sources = LIST_INIT(sources); static struct list monitors = LIST_INIT(monitors); static INT64 last_query_display_time; -static pthread_mutex_t display_lock = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE display_lock = WINE_MUTEX_INIT; BOOL enable_thunk_lock = FALSE; @@ -279,21 +280,21 @@ static RECT work_area; static DWORD process_layout = ~0u; static HDC display_dc; -static pthread_mutex_t display_dc_lock = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE display_dc_lock = WINE_MUTEX_INIT; -static pthread_mutex_t user_mutex; +static WINE_MUTEX_RECURSIVE_TYPE user_mutex; static unsigned int user_lock_thread, user_lock_rec; void user_lock(void) { - pthread_mutex_lock( &user_mutex ); + WINE_MUTEX_RECURSIVE_LOCK( &user_mutex ); if (!user_lock_rec++) user_lock_thread = GetCurrentThreadId(); } void user_unlock(void) { if (!--user_lock_rec) user_lock_thread = 0; - pthread_mutex_unlock( &user_mutex ); + WINE_MUTEX_RECURSIVE_UNLOCK( &user_mutex ); } void user_check_not_lock(void) @@ -1228,7 +1229,7 @@ static void add_gpu( const char *name, const struct pci_id *pci_id, const GUID * if (!ctx->mutex) { - pthread_mutex_lock( &display_lock ); + WINE_MUTEX_LOCK( &display_lock ); ctx->mutex = get_display_device_init_mutex(); prepare_devices(); } @@ -1530,7 +1531,7 @@ static void release_display_manager_ctx( struct device_manager_ctx *ctx ) { if (ctx->mutex) { - pthread_mutex_unlock( &display_lock ); + WINE_MUTEX_UNLOCK( &display_lock ); release_display_device_init_mutex( ctx->mutex ); ctx->mutex = 0; } @@ -1712,7 +1713,7 @@ static BOOL update_display_cache_from_registry(void) if (key.LastWriteTime.QuadPart <= last_query_display_time) return TRUE; - pthread_mutex_lock( &display_lock ); + WINE_MUTEX_LOCK( &display_lock ); mutex = get_display_device_init_mutex(); clear_display_devices(); @@ -1767,7 +1768,7 @@ static BOOL update_display_cache_from_registry(void) if ((ret = !list_empty( &sources ) && !list_empty( &monitors ))) last_query_display_time = key.LastWriteTime.QuadPart; - pthread_mutex_unlock( &display_lock ); + WINE_MUTEX_UNLOCK( &display_lock ); release_display_device_init_mutex( mutex ); return ret; } @@ -2023,10 +2024,10 @@ BOOL update_display_cache( BOOL force ) if (NtUserGetObjectInformation( winstation, UOI_NAME, name, sizeof(name), NULL ) && !wcscmp( name, wine_service_station_name )) { - pthread_mutex_lock( &display_lock ); + WINE_MUTEX_LOCK( &display_lock ); clear_display_devices(); list_add_tail( &monitors, &virtual_monitor.entry ); - pthread_mutex_unlock( &display_lock ); + WINE_MUTEX_UNLOCK( &display_lock ); return TRUE; } @@ -2061,25 +2062,25 @@ BOOL update_display_cache( BOOL force ) static BOOL lock_display_devices(void) { if (!update_display_cache( FALSE )) return FALSE; - pthread_mutex_lock( &display_lock ); + WINE_MUTEX_LOCK( &display_lock ); return TRUE; } static void unlock_display_devices(void) { - pthread_mutex_unlock( &display_lock ); + WINE_MUTEX_UNLOCK( &display_lock ); } static HDC get_display_dc(void) { - pthread_mutex_lock( &display_dc_lock ); + WINE_MUTEX_LOCK( &display_dc_lock ); if (!display_dc) { HDC dc; - pthread_mutex_unlock( &display_dc_lock ); + WINE_MUTEX_UNLOCK( &display_dc_lock ); dc = NtGdiOpenDCW( NULL, NULL, NULL, 0, TRUE, NULL, NULL, NULL ); - pthread_mutex_lock( &display_dc_lock ); + WINE_MUTEX_LOCK( &display_dc_lock ); if (display_dc) NtGdiDeleteObjectApp( dc ); else @@ -2090,7 +2091,7 @@ static HDC get_display_dc(void) static void release_display_dc( HDC hdc ) { - pthread_mutex_unlock( &display_dc_lock ); + WINE_MUTEX_UNLOCK( &display_dc_lock ); } /********************************************************************** @@ -4805,17 +4806,13 @@ void sysparams_init(void) WCHAR buffer[MAX_PATH+16], *p, *appname; DWORD i, dispos, dpi_scaling; WCHAR layout[KL_NAMELENGTH]; - pthread_mutexattr_t attr; HKEY hkey, appkey = 0; DWORD len; static const WCHAR oneW[] = {'1',0}; static const WCHAR x11driverW[] = {'\\','X','1','1',' ','D','r','i','v','e','r',0}; - pthread_mutexattr_init( &attr ); - pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE ); - pthread_mutex_init( &user_mutex, &attr ); - pthread_mutexattr_destroy( &attr ); + WINE_MUTEX_RECURSIVE_INIT( &user_mutex ); if ((hkey = reg_create_ascii_key( hkcu_key, "Keyboard Layout\\Preload", 0, NULL ))) { diff --git a/dlls/win32u/winstation.c b/dlls/win32u/winstation.c index 297a3b788ad..9a94f2136aa 100644 --- a/dlls/win32u/winstation.c +++ b/dlls/win32u/winstation.c @@ -37,6 +37,7 @@ #include "ntgdi_private.h" #include "ntuser_private.h" #include "wine/server.h" +#include "wine/mutex.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(winstation); @@ -69,7 +70,7 @@ struct session_block SIZE_T size; /* size of the mmaped data */ }; -static pthread_mutex_t session_lock = PTHREAD_MUTEX_INITIALIZER; +static WINE_MUTEX_TYPE session_lock = WINE_MUTEX_INIT; static struct list session_blocks = LIST_INIT(session_blocks); static struct session_thread_data *get_session_thread_data(void) @@ -156,14 +157,14 @@ static NTSTATUS find_shared_session_block( SIZE_T offset, SIZE_T size, struct se assert( offset + size > offset ); - pthread_mutex_lock( &session_lock ); + WINE_MUTEX_LOCK( &session_lock ); LIST_FOR_EACH_ENTRY( block, &session_blocks, struct session_block, entry ) { if (block->offset < offset && offset + size <= block->offset + block->size) { *ret = block; - pthread_mutex_unlock( &session_lock ); + WINE_MUTEX_UNLOCK( &session_lock ); return STATUS_SUCCESS; } } @@ -174,7 +175,7 @@ static NTSTATUS find_shared_session_block( SIZE_T offset, SIZE_T size, struct se wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), status ); } - pthread_mutex_unlock( &session_lock ); + WINE_MUTEX_UNLOCK( &session_lock ); return status; } diff --git a/include/wine/gdi_driver.h b/include/wine/gdi_driver.h index 774211fea15..22f221e76c3 100644 --- a/include/wine/gdi_driver.h +++ b/include/wine/gdi_driver.h @@ -38,6 +38,7 @@ #include "shellapi.h" #include "ddk/d3dkmthk.h" #include "kbd.h" +#include "wine/mutex.h" #include "wine/list.h" struct gdi_dc_funcs; @@ -226,7 +227,7 @@ struct window_surface HWND hwnd; /* window the surface was created for */ RECT rect; /* constant, no locking needed */ - pthread_mutex_t mutex; /* mutex needed for any field below */ + WINE_MUTEX_TYPE mutex; /* mutex needed for any field below */ RECT bounds; /* dirty area rectangle */ HRGN clip_region; /* visible region of the surface, fully visible if 0 */ DWORD draw_start_ticks; /* start ticks of fresh draw */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6031
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
v6. Fixed errors with blocking and optimized the code. I also ran some mutex benchmarks from glibc. ``` pthread_mutex-empty duration=5810878.000000 iterations=1000000.000000 wall-sec=0.005813 mean=5.816004 stdev=0.003214 min-outlier=5.809830 min=5.810878 max=5.819398 max-outlier=5.830294 pthread_mutex-filler duration=11626435.000000 iterations=1000000.000000 wall-sec=0.011628 mean=11.628719 stdev=0.003357 min-outlier=11.622175 min=11.622733 max=11.633000 max-outlier=11.633489 atomic_mutex-empty duration=3601304.000000 iterations=1000000.000000 wall-sec=0.003603 mean=3.503338 stdev=0.067618 min-outlier=3.401698 min=3.418320 max=3.598511 max-outlier=3.601304 atomic_mutex-filler duration=6488340.000000 iterations=1000000.000000 wall-sec=0.006490 mean=6.486992 stdev=0.002660 min-outlier=6.484080 min=6.484080 max=6.491693 max-outlier=6.492111 ``` -- https://gitlab.winehq.org/wine/wine/-/merge_requests/6031#note_75986
On a final positive note: I didn't notice any real regressions using your code
LMAO. In fact, there were errors in the code, and in some cases the locks did not work correctly, and sometimes my games crashed as a result. It seems like in v6 I was able to fix errors and improve the code a little. Despite the simplicity of locks, their debugging may not be so simple, and errors may be hidden. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/6031#note_75987
On Thu Jul 11 23:17:48 2024 +0000, Grigory Vasilyev wrote:
On a final positive note: I didn't notice any real regressions using your code LMAO. In fact, there were errors in the code, and in some cases the locks did not work correctly, and sometimes my games crashed as a result. It seems like in v6 I was able to fix errors and improve the code a little. Despite the simplicity of locks, their debugging may not be so simple, and errors may be hidden. Upd. It seems v6 is also broken or some of today's commits or tested mr broke some games. well, to be fair: my scope is limited to ntdll/wineserver code, so it's very likely I simply didn't hit any crashes your games trigger, and other errors may be masked or hidden...
but yeah, v6 seems to be broken; it causes very short stutters/stalls... if i don't use the recursive mutexes, then it doesn't happen (ie: in ntdll/unix/virtual.c CS stuff in my case). -- https://gitlab.winehq.org/wine/wine/-/merge_requests/6031#note_75990
participants (3)
-
Grigory Vasilyev -
Grigory Vasilyev (＠h0tc0d3)
-
Jordan Johnston (＠nine7nine)