- Wine-Devel - list.winehq.org

[PATCH] ws2_32: Do not print an ERR message when returning WSAEWOULDBLOCK from WSAIoctl()
by Jeff Latimer Jan. 20, 2021

Jan. 20, 2021

Signed-off-by: Jeff Latimer <lats(a)yless4u.com.au> --- dlls/ws2_32/socket.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

2 1

[PATCH v2] user32/tests: Add tests for window creation.
by Alistair Leslie-Hughes Jan. 19, 2021

Jan. 19, 2021

Based on a patch by Paul Gofman. v2 - Changed title - Removed CoCreateInstance calls. Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/user32/tests/Makefile.in | 2 +- dlls/user32/tests/win.c | 156 ++++++++++++++++++++++++++++++++++ 2 files changed, 157 insertions(+), 1 deletion(-) diff --git a/dlls/user32/tests/Makefile.in b/dlls/user32/tests/Makefile.in index dd101d69f3c..73f692b9d4b 100644 --- a/dlls/user32/tests/Makefile.in +++ b/dlls/user32/tests/Makefile.in @@ -1,5 +1,5 @@ TESTDLL = user32.dll -IMPORTS = user32 gdi32 advapi32 hid +IMPORTS = user32 gdi32 advapi32 hid ole32 imm32 C_SRCS = \ broadcast.c \ diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index 47864340e39..08f413c88e6 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -31,6 +31,8 @@ #include "wingdi.h" #include "winuser.h" #include "winreg.h" +#include "objbase.h" +#include "imm.h" #include "wine/test.h" @@ -11894,6 +11896,158 @@ static void test_cancel_mode(void) DestroyWindow(hwnd2); } +static LRESULT CALLBACK TestWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + return DefWindowProcA(hwnd, uMsg, wParam, lParam); +} + +static DWORD WINAPI window_create_noime_thread(LPVOID data) +{ + APTTYPEQUALIFIER apttypequal; + APTTYPE apttype; + HWND hwnd; + HRESULT hr; + + /* Show that Disabling IME stops the implicit MTA creation. */ + ImmDisableIME(GetCurrentThreadId()); + + hwnd = CreateWindowExA(0, "Test class", "Test window", WS_VISIBLE, 0, 0, 100, 100, + GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL); + + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); + + DestroyWindow(hwnd); + + return 0; +} + +static DWORD WINAPI window_create_setwindowpos_thread(LPVOID data) +{ + APTTYPEQUALIFIER apttypequal; + APTTYPE apttype; + HWND hwnd; + HRESULT hr; + + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); + + hwnd = CreateWindowExA(0, "Test class", "Test window", WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_SYSMENU | WS_MINIMIZEBOX, 0, 0, 100, 100, + GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL); + + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); + + /* Showing the window actually causes the implicit MTA */ + SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW); + + hr = CoGetApartmentType(&apttype, &apttypequal); + todo_wine ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + todo_wine ok(apttype == APTTYPE_MAINSTA && apttypequal == APTTYPEQUALIFIER_NONE, "Unexpected %u/%u\n", apttype, apttypequal); + + hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(apttype == APTTYPE_MTA && apttypequal == APTTYPEQUALIFIER_NONE, "Unexpected %u/%u\n", apttype, apttypequal); + CoUninitialize(); + + DestroyWindow(hwnd); + + return 0; +} + +static DWORD WINAPI window_create_show_window_thread(LPVOID data) +{ + APTTYPEQUALIFIER apttypequal; + APTTYPE apttype; + HWND hwnd; + HRESULT hr; + + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); + + hwnd = CreateWindowExA(0, "Test class", "Test window", WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_SYSMENU | WS_MINIMIZEBOX, 0, 0, 100, 100, + GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL); + + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); + + /* Showing the window actually causes the implicit MTA */ + ShowWindow(hwnd, SW_SHOW); + + hr = CoGetApartmentType(&apttype, &apttypequal); + todo_wine ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + todo_wine ok(apttype == APTTYPE_MAINSTA && apttypequal == APTTYPEQUALIFIER_NONE, "Unexpected %u/%u\n", apttype, apttypequal); + + DestroyWindow(hwnd); + + return 0; +} + +static DWORD WINAPI window_create_visible_thread(LPVOID data) +{ + APTTYPEQUALIFIER apttypequal; + APTTYPE apttype; + HWND hwnd; + HRESULT hr; + + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); + + hwnd = CreateWindowExA(0, "Test class", "Test window", WS_VISIBLE, 0, 0, 100, 100, + GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL); + + hr = CoGetApartmentType(&apttype, &apttypequal); + todo_wine ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + todo_wine ok(apttype == APTTYPE_MAINSTA && apttypequal == APTTYPEQUALIFIER_NONE, "Unexpected %u/%u\n", apttype, apttypequal); + + DestroyWindow(hwnd); + + return 0; +} + +static void test_implicit_mta(void) +{ + APTTYPEQUALIFIER apttypequal; + APTTYPE apttype; + WNDCLASSA clsA; + HRESULT hr; + HANDLE thread; + + clsA.style = 0; + clsA.lpfnWndProc = TestWindowProc; + clsA.cbClsExtra = 0; + clsA.cbWndExtra = 0; + clsA.hInstance = GetModuleHandleA(NULL); + clsA.hIcon = 0; + clsA.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW); + clsA.hbrBackground = GetStockObject(WHITE_BRUSH); + clsA.lpszMenuName = NULL; + clsA.lpszClassName = "Test class"; + + RegisterClassA(&clsA); + + hr = CoGetApartmentType(&apttype, &apttypequal); + ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); + + thread = CreateThread(NULL, 0, window_create_noime_thread, NULL, 0, NULL); + WaitForSingleObject(thread, INFINITE); + CloseHandle(thread); + + thread = CreateThread(NULL, 0, window_create_setwindowpos_thread, NULL, 0, NULL); + WaitForSingleObject(thread, INFINITE); + CloseHandle(thread); + + thread = CreateThread(NULL, 0, window_create_show_window_thread, NULL, 0, NULL); + WaitForSingleObject(thread, INFINITE); + CloseHandle(thread); + + thread = CreateThread(NULL, 0, window_create_visible_thread, NULL, 0, NULL); + WaitForSingleObject(thread, INFINITE); + CloseHandle(thread); +} + START_TEST(win) { char **argv; @@ -11941,6 +12095,8 @@ START_TEST(win) return; } + test_implicit_mta(); + if (!RegisterWindowClasses()) assert(0); hwndMain = CreateWindowExA(/*WS_EX_TOOLWINDOW*/ 0, "MainWindowClass", "Main window", -- 2.29.2

4 4

[PATCH 1/6] d3d11: Add semi-stub implementation of D3DDeviceContextState.
by Rémi Bernon Jan. 19, 2021

Jan. 19, 2021

To support ID3D10Device interface activation on D3D11 devices. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- The idea here is only to have a minimal implementation of SwapDeviceContextState, to fix the D2D1 over D3D11 regression. What's missing is the actual state change, as well as the enabling / disabling or the D3D10 / D3D11 interface methods when state is changed to another version, as described in [1]. I didn't really investigate what the full device context state implementation would require, but I suspect it to be much bigger scope. This could possibly serve as an initial work for it as well. [1] https://docs.microsoft.com/en-us/windows/win32/api/d3d11_1/nf-d3d11_1-id3d1… dlls/d3d11/d3d11_main.c | 1 + dlls/d3d11/d3d11_private.h | 13 +++ dlls/d3d11/device.c | 187 ++++++++++++++++++++++++++++++++++++- dlls/d3d11/tests/d3d11.c | 38 +++++--- 4 files changed, 223 insertions(+), 16 deletions(-) diff --git a/dlls/d3d11/d3d11_main.c b/dlls/d3d11/d3d11_main.c index dac59d09999..6666876049d 100644 --- a/dlls/d3d11/d3d11_main.c +++ b/dlls/d3d11/d3d11_main.c @@ -137,6 +137,7 @@ HRESULT WINAPI D3D11CoreCreateDevice(IDXGIFactory *factory, IDXGIAdapter *adapte return E_FAIL; } d3d_device->d3d11_only = TRUE; + d3d_device->emulated_interface = IID_ID3D11Device2; return S_OK; } diff --git a/dlls/d3d11/d3d11_private.h b/dlls/d3d11/d3d11_private.h index 3248285fcda..2effe3a8242 100644 --- a/dlls/d3d11/d3d11_private.h +++ b/dlls/d3d11/d3d11_private.h @@ -516,6 +516,18 @@ struct d3d_query *unsafe_impl_from_ID3D11Query(ID3D11Query *iface) DECLSPEC_HIDD struct d3d_query *unsafe_impl_from_ID3D10Query(ID3D10Query *iface) DECLSPEC_HIDDEN; struct d3d_query *unsafe_impl_from_ID3D11Asynchronous(ID3D11Asynchronous *iface) DECLSPEC_HIDDEN; +/* ID3DDeviceContextState */ +struct d3d_device_context_state +{ + ID3DDeviceContextState ID3DDeviceContextState_iface; + LONG refcount; + + struct wined3d_private_store private_store; + + ID3D11Device2 *device; + GUID emulated_interface; +}; + /* ID3D11DeviceContext - immediate context */ struct d3d11_immediate_context { @@ -539,6 +551,7 @@ struct d3d_device D3D_FEATURE_LEVEL feature_level; BOOL d3d11_only; + GUID emulated_interface; struct d3d11_immediate_context immediate_context; diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index 50e8cd58fe2..dac31913340 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -29,6 +29,140 @@ static const struct wined3d_parent_ops d3d_null_wined3d_parent_ops = d3d_null_wined3d_object_destroyed, }; +/* ID3DDeviceContextState methods */ + +static inline struct d3d_device_context_state *impl_from_ID3DDeviceContextState(ID3DDeviceContextState *iface) +{ + return CONTAINING_RECORD(iface, struct d3d_device_context_state, ID3DDeviceContextState_iface); +} + +static inline struct d3d_device *device_from_ID3DDeviceContextState(ID3DDeviceContextState *iface) +{ + struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface); + return impl_from_ID3D11Device2(state->device); +} + +static HRESULT STDMETHODCALLTYPE d3d_device_context_state_QueryInterface(ID3DDeviceContextState *iface, + REFIID iid, void **out) +{ + struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface); + + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID3DDeviceContextState) + || IsEqualGUID(iid, &IID_ID3D11DeviceChild) + || IsEqualGUID(iid, &IID_IUnknown)) + { + *out = &state->ID3DDeviceContextState_iface; + } + else + { + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + *out = NULL; + return E_NOINTERFACE; + } + + ID3DDeviceContextState_AddRef(iface); + return S_OK; +} + +static ULONG STDMETHODCALLTYPE d3d_device_context_state_AddRef(ID3DDeviceContextState *iface) +{ + struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface); + struct d3d_device *device = device_from_ID3DDeviceContextState(iface); + ULONG refcount = InterlockedIncrement(&state->refcount); + + TRACE("%p increasing refcount to %u.\n", state, refcount); + + if (refcount == 1) + { + ID3D11Device2_AddRef(&device->ID3D11Device2_iface); + } + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d3d_device_context_state_Release(ID3DDeviceContextState *iface) +{ + struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface); + struct d3d_device *device = device_from_ID3DDeviceContextState(iface); + ULONG refcount = InterlockedDecrement(&state->refcount); + + TRACE("%p decreasing refcount to %u.\n", state, refcount); + + if (!refcount) + { + wined3d_private_store_cleanup(&state->private_store); + ID3D11Device2_Release(&device->ID3D11Device2_iface); + } + + return refcount; +} + +static void STDMETHODCALLTYPE d3d_device_context_state_GetDevice(ID3DDeviceContextState *iface, ID3D11Device **device) +{ + struct d3d_device *device_object = device_from_ID3DDeviceContextState(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (ID3D11Device *)&device_object->ID3D11Device2_iface; + ID3D11Device_AddRef(*device); +} + +static HRESULT STDMETHODCALLTYPE d3d_device_context_state_GetPrivateData(ID3DDeviceContextState *iface, REFGUID guid, + UINT *data_size, void *data) +{ + struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface); + + TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data); + + return d3d_get_private_data(&state->private_store, guid, data_size, data); +} + +static HRESULT STDMETHODCALLTYPE d3d_device_context_state_SetPrivateData(ID3DDeviceContextState *iface, REFGUID guid, + UINT data_size, const void *data) +{ + struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface); + + TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data); + + return d3d_set_private_data(&state->private_store, guid, data_size, data); +} + +static HRESULT STDMETHODCALLTYPE d3d_device_context_state_SetPrivateDataInterface(ID3DDeviceContextState *iface, + REFGUID guid, const IUnknown *data) +{ + struct d3d_device_context_state *state = impl_from_ID3DDeviceContextState(iface); + + TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data); + + return d3d_set_private_data_interface(&state->private_store, guid, data); +} + +static const struct ID3DDeviceContextStateVtbl d3d_device_context_state_vtbl = +{ + /* IUnknown methods */ + d3d_device_context_state_QueryInterface, + d3d_device_context_state_AddRef, + d3d_device_context_state_Release, + /* ID3D11DeviceChild methods */ + d3d_device_context_state_GetDevice, + d3d_device_context_state_GetPrivateData, + d3d_device_context_state_SetPrivateData, + d3d_device_context_state_SetPrivateDataInterface, +}; + +static void d3d_device_context_state_init(struct d3d_device_context_state *context, struct d3d_device *device, + REFIID emulated_interface) +{ + context->ID3DDeviceContextState_iface.lpVtbl = &d3d_device_context_state_vtbl; + context->refcount = 1; + context->emulated_interface = *emulated_interface; + ID3D11Device2_AddRef(context->device = &device->ID3D11Device2_iface); + + wined3d_private_store_init(&context->private_store); +} + /* ID3D11DeviceContext - immediate context methods */ static inline struct d3d11_immediate_context *impl_from_ID3D11DeviceContext1(ID3D11DeviceContext1 *iface) @@ -2551,7 +2685,33 @@ static void STDMETHODCALLTYPE d3d11_immediate_context_CSGetConstantBuffers1(ID3D static void STDMETHODCALLTYPE d3d11_immediate_context_SwapDeviceContextState(ID3D11DeviceContext1 *iface, ID3DDeviceContextState *state, ID3DDeviceContextState **prev_state) { - FIXME("iface %p, state %p, prev_state %p stub!\n", iface, state, prev_state); + static int once; + struct d3d_device_context_state *d3d_dc_state; + struct d3d_device *device = device_from_immediate_ID3D11DeviceContext1(iface); + + if (!once++) FIXME("iface %p, state %p, prev_state %p semi-stub!\n", iface, state, prev_state); + + if (prev_state) + { + *prev_state = NULL; + if ((d3d_dc_state = heap_alloc(sizeof(*d3d_dc_state)))) + { + d3d_device_context_state_init(d3d_dc_state, device, &device->emulated_interface); + *prev_state = &d3d_dc_state->ID3DDeviceContextState_iface; + } + } + + if (!(d3d_dc_state = impl_from_ID3DDeviceContextState(state))) + return; + + if (device->d3d11_only && + (IsEqualGUID(&d3d_dc_state->emulated_interface, &IID_ID3D10Device1) + || IsEqualGUID(&d3d_dc_state->emulated_interface, &IID_ID3D10Device))) + device->d3d11_only = FALSE; + + device->emulated_interface = d3d_dc_state->emulated_interface; + + /* FIXME: Apply device context state */ } static void STDMETHODCALLTYPE d3d11_immediate_context_ClearView(ID3D11DeviceContext1 *iface, ID3D11View *view, @@ -3738,11 +3898,31 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CreateDeviceContextState(ID3D11Dev const D3D_FEATURE_LEVEL *feature_levels, UINT feature_levels_count, UINT sdk_version, REFIID emulated_interface, D3D_FEATURE_LEVEL *chosen_feature_level, ID3DDeviceContextState **state) { + struct d3d_device *device = impl_from_ID3D11Device2(iface); + struct d3d_device_context_state *d3d_device_context_state; + FIXME("iface %p, flags %#x, feature_levels %p, feature_level_count %u, sdk_version %u, " - "emulated_interface %s, chosen_feature_level %p, state %p stub!\n", iface, flags, feature_levels, + "emulated_interface %s, chosen_feature_level %p, state %p semi-stub!\n", iface, flags, feature_levels, feature_levels_count, sdk_version, debugstr_guid(emulated_interface), chosen_feature_level, state); - return E_NOTIMPL; + if (chosen_feature_level) + *chosen_feature_level = 0; + + if (state) + { + *state = NULL; + if (!(d3d_device_context_state = heap_alloc(sizeof(*d3d_device_context_state)))) + return E_OUTOFMEMORY; + d3d_device_context_state_init(d3d_device_context_state, device, emulated_interface); + *state = &d3d_device_context_state->ID3DDeviceContextState_iface; + } + + /* FIXME: Return actual chosen feature level for the device context state */ + + if (chosen_feature_level) + *chosen_feature_level = ID3D11Device2_GetFeatureLevel(iface); + + return state ? S_OK : S_FALSE; } static HRESULT STDMETHODCALLTYPE d3d11_device_OpenSharedResource1(ID3D11Device2 *iface, HANDLE handle, @@ -6235,6 +6415,7 @@ void d3d_device_init(struct d3d_device *device, void *outer_unknown) /* COM aggregation always takes place */ device->outer_unk = outer_unknown; device->d3d11_only = FALSE; + device->emulated_interface = GUID_NULL; d3d11_immediate_context_init(&device->immediate_context, device); ID3D11DeviceContext1_Release(&device->immediate_context.ID3D11DeviceContext1_iface); diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 9fc09a5ec83..134902e000a 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -6686,7 +6686,6 @@ static void test_device_context_state(void) feature_level = min(feature_level, D3D_FEATURE_LEVEL_10_1); hr = ID3D11Device1_CreateDeviceContextState(device, 0, &feature_level, 1, D3D11_SDK_VERSION, &IID_ID3D10Device, NULL, &context_state); -todo_wine ok(SUCCEEDED(hr), "Failed to create device context state, hr %#x.\n", hr); if (FAILED(hr)) { @@ -6747,61 +6746,74 @@ todo_wine ID3D11DeviceContext1_PSSetSamplers(context, 0, 1, &sampler); tmp_sampler = (ID3D11SamplerState *)0xdeadbeef; ID3D11DeviceContext1_PSGetSamplers(context, 0, 1, &tmp_sampler); - ok(tmp_sampler == (ID3D11SamplerState *)0xdeadbeef, "Got unexpected sampler %p.\n", tmp_sampler); + todo_wine ok(tmp_sampler == (ID3D11SamplerState *)0xdeadbeef, "Got unexpected sampler %p.\n", tmp_sampler); + if (tmp_sampler && tmp_sampler != (ID3D11SamplerState *)0xdeadbeef) + ID3D11SamplerState_Release(tmp_sampler); if (!enable_debug_layer) ID3D11DeviceContext1_PSSetSamplers(context, 0, 1, &tmp_sampler); ID3D11DeviceContext1_CSSetSamplers(context, 0, 1, &sampler); tmp_sampler = (ID3D11SamplerState *)0xdeadbeef; ID3D11DeviceContext1_CSGetSamplers(context, 0, 1, &tmp_sampler); - ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + todo_wine ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + if (tmp_sampler) ID3D11SamplerState_Release(tmp_sampler); ID3D11DeviceContext1_DSSetSamplers(context, 0, 1, &sampler); tmp_sampler = (ID3D11SamplerState *)0xdeadbeef; ID3D11DeviceContext1_DSGetSamplers(context, 0, 1, &tmp_sampler); - ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + todo_wine ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + if (tmp_sampler) ID3D11SamplerState_Release(tmp_sampler); ID3D11DeviceContext1_GSSetSamplers(context, 0, 1, &sampler); tmp_sampler = (ID3D11SamplerState *)0xdeadbeef; ID3D11DeviceContext1_GSGetSamplers(context, 0, 1, &tmp_sampler); - ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + todo_wine ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + if (tmp_sampler) ID3D11SamplerState_Release(tmp_sampler); ID3D11DeviceContext1_HSSetSamplers(context, 0, 1, &sampler); tmp_sampler = (ID3D11SamplerState *)0xdeadbeef; ID3D11DeviceContext1_HSGetSamplers(context, 0, 1, &tmp_sampler); - ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + todo_wine ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + if (tmp_sampler) ID3D11SamplerState_Release(tmp_sampler); ID3D11DeviceContext1_VSSetSamplers(context, 0, 1, &sampler); tmp_sampler = (ID3D11SamplerState *)0xdeadbeef; ID3D11DeviceContext1_VSGetSamplers(context, 0, 1, &tmp_sampler); - ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + todo_wine ok(!tmp_sampler, "Got unexpected sampler %p.\n", tmp_sampler); + if (tmp_sampler) ID3D11SamplerState_Release(tmp_sampler); context_type = ID3D11DeviceContext1_GetType(context); ok(context_type == D3D11_DEVICE_CONTEXT_IMMEDIATE, "Unexpected context type %u.\n", context_type); tmp_cb = (ID3D11Buffer *)0xdeadbeef; ID3D11DeviceContext1_CSGetConstantBuffers(context, 0, 1, &tmp_cb); - ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + todo_wine ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + if (tmp_cb) ID3D11Buffer_Release(tmp_cb); tmp_cb = (ID3D11Buffer *)0xdeadbeef; ID3D11DeviceContext1_PSGetConstantBuffers(context, 0, 1, &tmp_cb); - ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + todo_wine ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + if (tmp_cb) ID3D11Buffer_Release(tmp_cb); tmp_cb = (ID3D11Buffer *)0xdeadbeef; ID3D11DeviceContext1_VSGetConstantBuffers(context, 0, 1, &tmp_cb); - ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + todo_wine ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + if (tmp_cb) ID3D11Buffer_Release(tmp_cb); tmp_cb = (ID3D11Buffer *)0xdeadbeef; ID3D11DeviceContext1_DSGetConstantBuffers(context, 0, 1, &tmp_cb); - ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + todo_wine ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + if (tmp_cb) ID3D11Buffer_Release(tmp_cb); tmp_cb = (ID3D11Buffer *)0xdeadbeef; ID3D11DeviceContext1_GSGetConstantBuffers(context, 0, 1, &tmp_cb); - ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + todo_wine ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + if (tmp_cb) ID3D11Buffer_Release(tmp_cb); tmp_cb = (ID3D11Buffer *)0xdeadbeef; ID3D11DeviceContext1_HSGetConstantBuffers(context, 0, 1, &tmp_cb); - ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + todo_wine ok(!tmp_cb, "Got unexpected buffer %p.\n", tmp_cb); + if (tmp_cb) ID3D11Buffer_Release(tmp_cb); check_interface(device, &IID_ID3D10Device, TRUE, FALSE); check_interface(device, &IID_ID3D10Device1, TRUE, FALSE); -- 2.30.0

3 10

[tools 1/5] testbot/LogUtils: Move the .errors format documentation to LoadLogErrors().
by Francois Gouget Jan. 19, 2021

Jan. 19, 2021

Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/LogUtils.pm | 60 ++++++++++++++--------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/testbot/lib/WineTestBot/LogUtils.pm b/testbot/lib/WineTestBot/LogUtils.pm index 77837fbf..1e7dcda8 100644 --- a/testbot/lib/WineTestBot/LogUtils.pm +++ b/testbot/lib/WineTestBot/LogUtils.pm @@ -822,6 +822,7 @@ sub GetLogLabel($) return defined $Label ? sprintf($Label, $Extra) : $LogFileName; } + # # Log errors caching [Part 1] # @@ -833,10 +834,36 @@ sub GetLogLabel($) Loads the specified log errors file. -See _WriteLogErrors() for the format of the errors file. - Returns the errors in the same format as TagNewErrors(). +All lines are of the following form: + <type> <value1> <value2> + +The values depend on the <type> of the line. <type> and <value1> must not +contain spaces while <value2> runs to the end of the line. +More specifically the line formats are: +=over + +=item p <name> <value> +Property lines contain (name, value) pairs. +Note that properties which can be calculated while reading the errors file +are not saved (e.g. ErrCount and NewCount). + +=item g <lineno> <groupname> +Group lines contain the group name and the line number of the first line of +the group in the log. Note that the first line would typically not be an +error line. +A group line should be followed by the old and new error lines in this group. + +=item o <lineno> <line> +Old error lines contain the line number of the error in the log and a verbatim +copy of that line (with CR/LF converted to a simple LF). + +=item n <lineno> <line> +The format for new error lines is identical to that for old errors but with a +different type. + +=back =back =cut @@ -919,35 +946,8 @@ sub LoadLogErrors($) =item C<_WriteLogErrors()> Writes the LogInfo structure in text form to the specified file descriptor. +See _LoadLogErrors() for the format of the errors file. -All lines follow are of the following form: - <type> <value1> <value2> - -The values depend on the <type> of the line. <type> and <value1> must not -contain spaces while <value2> runs to the end of the line. More specifically -the line formats are: -=over - -=item p <name> <value> -Property lines contain (name, value) pairs. -Note that properties which can be calculated while reading the errors file -are not saved (e.g. ErrCount and NewCount). - -=item g <lineno> <groupname> -Group lines contain the group name and the line number of the first line of -the group in the log. Note that the first line would typically not be an -error line. -A group line should be followed by the old and new error lines in this group. - -=item o <lineno> <line> -Old error lines contain the line number of the error in the log and a verbatim -copy of that line (with CR/LF converted to a simple LF). - -=item n <lineno> <line> -The format for new error lines is identical to that for old errors but with a -different type. - -=back =back =cut -- 2.20.1

1 4

[PATCH 1/4] winmm: Set error when mmioOpen(MMIO_EXIST) is called with non-existant path.
by Gijs Vermeulen Jan. 19, 2021

Jan. 19, 2021

Signed-off-by: Gijs Vermeulen <gijsvrm(a)gmail.com> --- dlls/winmm/mmio.c | 3 +++ dlls/winmm/tests/mmio.c | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/dlls/winmm/mmio.c b/dlls/winmm/mmio.c index 1255cf69da2..1d755ea82b8 100644 --- a/dlls/winmm/mmio.c +++ b/dlls/winmm/mmio.c @@ -650,7 +650,10 @@ static HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer)) return (HMMIO)FALSE; if ((dwOpenFlags & MMIO_EXIST) && (GetFileAttributesA(buffer) == INVALID_FILE_ATTRIBUTES)) + { + refmminfo->wErrorRet = MMIOERR_FILENOTFOUND; return (HMMIO)FALSE; + } strcpy(szFileName, buffer); return (HMMIO)TRUE; } diff --git a/dlls/winmm/tests/mmio.c b/dlls/winmm/tests/mmio.c index a232070064c..cfe917e8b38 100644 --- a/dlls/winmm/tests/mmio.c +++ b/dlls/winmm/tests/mmio.c @@ -565,7 +565,7 @@ static void test_mmioOpen_create(void) info.wErrorRet = 0xdead; hmmio = mmioOpenW(buffer, &info, MMIO_EXIST); ok(hmmio == (HMMIO)FALSE, "file should exist\n"); - todo_wine ok(info.wErrorRet == MMIOERR_FILENOTFOUND, "got error %#x\n", info.wErrorRet); + ok(info.wErrorRet == MMIOERR_FILENOTFOUND, "got error %#x\n", info.wErrorRet); ret = DeleteFileA("test_mmio_path"); ok(!ret, "expected failure\n"); -- 2.30.0

2 4

[PATCH 1/2] d2d1: Fix text position in DrawText().
by Nikolay Sivov Jan. 19, 2021

Jan. 19, 2021

From: Haoyang Chen <chenhaoyang(a)uniontech.com> Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/device.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index 5f04c3aa833..bd3af3d16ff 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -1189,7 +1189,7 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawText(ID2D1DeviceContext *if return; } - d2d_point_set(&origin, layout_rect->left, layout_rect->top); + d2d_point_set(&origin, min(layout_rect->left, layout_rect->right), min(layout_rect->top, layout_rect->bottom)); ID2D1DeviceContext_DrawTextLayout(iface, origin, text_layout, brush, options); IDWriteTextLayout_Release(text_layout); } -- 2.29.2

2 3

[PATCH] winegstreamer: Wait on error conditions when initializing GStreamer.
by Giovanni Mascellani Jan. 19, 2021

Jan. 19, 2021

GStreamer doesn't necessarily signals all error when setting the PLAYING or PAUSED state. If Wine just waits on no-more-pads, it risks a deadlock if an error is signalled after gst_element_get_state was called. This patch also waits on the error condition. Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- dlls/winegstreamer/gstdemux.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/dlls/winegstreamer/gstdemux.c b/dlls/winegstreamer/gstdemux.c index d6b47e871d5..dfab94220fa 100644 --- a/dlls/winegstreamer/gstdemux.c +++ b/dlls/winegstreamer/gstdemux.c @@ -1648,6 +1648,7 @@ static BOOL decodebin_parser_init_gst(struct parser *filter) { GstElement *element = gst_element_factory_make("decodebin", NULL); unsigned int i; + HANDLE events[2]; int ret; if (!element) @@ -1681,15 +1682,19 @@ static BOOL decodebin_parser_init_gst(struct parser *filter) return FALSE; } - WaitForSingleObject(filter->no_more_pads_event, INFINITE); + events[0] = filter->no_more_pads_event; + events[1] = filter->error_event; + if (WaitForMultipleObjects(2, events, FALSE, INFINITE)) + return FALSE; for (i = 0; i < filter->source_count; ++i) { struct parser_source *pin = filter->sources[i]; - const HANDLE events[2] = {pin->caps_event, filter->error_event}; pin->seek.llDuration = pin->seek.llStop = query_duration(pin->their_src); pin->seek.llCurrent = 0; + events[0] = pin->caps_event; + events[1] = filter->error_event; if (WaitForMultipleObjects(2, events, FALSE, INFINITE)) return FALSE; } @@ -2470,6 +2475,7 @@ static BOOL avi_splitter_init_gst(struct parser *filter) { GstElement *element = gst_element_factory_make("avidemux", NULL); unsigned int i; + HANDLE events[2]; int ret; if (!element) @@ -2502,15 +2508,19 @@ static BOOL avi_splitter_init_gst(struct parser *filter) return FALSE; } - WaitForSingleObject(filter->no_more_pads_event, INFINITE); + events[0] = filter->no_more_pads_event; + events[1] = filter->error_event; + if (WaitForMultipleObjects(2, events, FALSE, INFINITE)) + return FALSE; for (i = 0; i < filter->source_count; ++i) { struct parser_source *pin = filter->sources[i]; - const HANDLE events[2] = {pin->caps_event, filter->error_event}; pin->seek.llDuration = pin->seek.llStop = query_duration(pin->their_src); pin->seek.llCurrent = 0; + events[0] = pin->caps_event; + events[1] = filter->error_event; if (WaitForMultipleObjects(2, events, FALSE, INFINITE)) return FALSE; } -- 2.30.0

2 1

Kernel interface for Wine synchronization primitives
by Zebediah Figura Jan. 19, 2021

Jan. 19, 2021

Hello all, [I've added to CC those people listed as maintainers in the areas of locking and futexes, in the hopes that they will be able to offer their expertise on a problem related to synchronization primitives.] As a basic summary to what follows, we at the Wine project are looking to introduce a kernel API that will allow us to implement Windows NT synchronization object API with at most one syscall per operation, and without managing object state in user-managed shared memory, for the sake of performance. I'm hoping to get opinions with this mail as to what such an API should look like, or whether it would be accepted. Apologies if what follows is overly verbose; I try to err on that side in order to provide all of the necessary context. Section 4 of this mail contains a relatively concrete UAPI proposal. 0. TABLE OF CONTENTS 1. BACKGROUND 2. REQUIREMENTS 3. WHY IT CAN'T BE DONE WITH EXISTING TOOLS 4. PROPOSAL APPENDIX: PERFORMANCE IMPROVEMENTS DUE TO "ESYNC" 1. BACKGROUND I am a contributor to the Wine project (which, in case anyone is unfamiliar, is a translation layer allowing Windows programs to run on POSIX systems). Windows NT has a set of synchronization primitives, essentially all of which are stateful and can be shared between processes. I've written a detailed description of these primitives below. Because these objects can be shared between processes, Wine implements them using a dedicated 'wineserver' process, which receives requests from "client" processes somewhat analogous to system calls. For example, server requests exist corresponding to "release [up] a semaphore" and "wait for an object to be signaled". Each server request is a remote procedure call to the wineserver process, wherein data is sent over a socket from the client to the server, the server performs some operation, and then sends a reply back to the client. (This "wineserver" process also manages many other features managed by the Windows kernel, such as window management, asynchronous I/O, process and thread state, named pipes, etc.) In recent years applications, especially high-performance games, have made heavy use of multiple threads, and consequently heavy use of these synchronization primitives. The RPC to the wineserver has become not just a bottleneck, but a heavy bottleneck. It's particularly a problem because the server is single-threaded and can only service one request at a time. A few years ago I wrote a set of out-of-tree patches for Wine, colloquially called "esync", that reimplements the performance-critical parts of many of these operations on top of the eventfd interface, with NT kernel objects essentially mapping directly to eventfd objects, plus some extra state which lives in shared memory. To a large degree this results in theoretically equal performance with Windows; most operations which are understood to comprise one system call on Windows now also comprise one system call (to the Linux kernel) on Wine. The actual performance improvement is, depending on the application, quite substantial; I've attached some data as a postscript to this mail. However, "esync" has its problems. There are some areas where eventfd just doesn't provide the necessary interfaces for NT kernel APIs, and we have to badly emulate them. As a result there are some applications that simply don't work with it. It also relies on shared memory being mapped read/write into every application; as a result object state can easily be corrupted by a misbehaving process. These problems have led to its remaining out of tree. There are also some operations that need more than one system call and hence could theoretically be improved performance-wise. I later developed a second out-of-tree patch set, the awfully named "fsync", which uses futexes instead of eventfds. It was developed by request, on the grounds that futexes can be faster than eventfds (since an uncontended object needs no syscalls). In practice, there is sometimes a positive performance difference, sometimes a negative one, and often no measurable difference at all; it also sometimes makes performance much less consistent. It shares all of the same problems as "esync", including (to a degree) some inefficiencies when executing contended waits. Having not yet found an interface that provides what we need, my goal is to introduce to the Linux kernel an interface—either based on an existing one, or designed from the ground up—that exposes the missing pieces, allows for ideally at least equal performance with Windows, and which can be used in mainstream Wine. I'm not immediately sure what form this API should take, however. Extending existing APIs such as eventfd does not seem particularly attractive [especially given that the semantics of APIs like NtWaitForMultipleObjects() and NtPulseEvent() are very fundamentally different from the way that POSIX file descriptors work]. There are many very badly designed parts—including APIs that Microsoft has publicly deprecated—that we nevertheless have to perfectly emulate, and so designing a new explicitly general-purpose API that covers this does also not seem particularly attractive. I don't think we want to encourage actual use (outside of API translation) of the ugly parts, and most of the non-ugly parts are pretty much already covered by existing tools like eventfd. On the other hand, API translation is itself an important use case. 2. REQUIREMENTS In order to give an idea of what we actually need, from the Wine side, I've described below the behaviour of the Windows NT primitives we're trying to emulate. This isn't necessarily the API that I'm proposing needs to exist in the kernel; I'm rather trying to describe the problem so that a solution of some sort can be found, including maybe something I've missed that doesn't require kernel changes. Windows kernel objects are exposed to user space via "handles", which are 32- or 64-bit values (depending on architecture) roughly analogous to file descriptors. Like file descriptors, multiple handles can refer to the same object, and have different access flags. In the case of synchronization primitives, there are three different access flags, roughly corresponding to "wait", "modify", and "read" operations, but the actual semantics are rather strange. There are four primary types of synchronization primitive we care about: * Semaphore - a classic semaphore object. It holds one 32-bit value of dynamic state, which can be decreased by one [i.e. acquire] or increased by an arbitrary amount [i.e. release]; the object is "signaled" when this value is nonzero. It also holds a second, static 32-bit value denoting the maximum count; an attempt to post past this maximum results in an error. * Mutex (or "mutant") - a classic recursive mutex. This holds one 32-bit value denoting the current recursion count, as well as some reference to the thread which owns it. A thread which exits (normally or violently) while holding a mutex "abandons" it, and the user-space API makes a distinction as to whether a mutex is signaled normally or abandoned (much like pthread mutexes and EOWNERDEAD.) * Manual-reset event - holds a single boolean value denoting whether the object is signaled or nonsignaled. "Wait" operations do not change the state of this object. * Auto-reset event - as above; however, "wait" operations do reset the state to nonsignaled (more details below). [As a bit of an aside, there are more types of synchronizable objects than this, including e.g. processes and threads, which much like pidfd are considered signaled when the process exits. However, these objects are not thus far a performance concern, and can thus be implemented on top of one of the objects above.] There are a rather large number of system calls that we need to implement: * NtWaitForSingleObject - This is a rather complex operation. It takes an object of any type and a timeout (which may be "infinite"), sleeps until the object is signaled or the timeout expires, and atomically "consumes" the object if appropriate. In detail: - A semaphore is considered signaled if its count is nonzero, and consumed by decreasing the count by one. This is the only way to acquire a semaphore; there is no distinct semaphore-specific "down" operation. - A mutex is considered signaled if it is already owned by the current thread or if it is unowned. It is consumed by granting ownership to the current thread (if it is not already owned) and increasing its recursion count by one. This is the only way to acquire a mutex. The return value to this function also includes a flag denoting whether the mutex was abandoned. - An event is considered signaled if it is in the signaled state. A manual-reset event is not affected by this function; an auto-reset event is atomically reset to the nonsignaled state. [An auto-reset event is somewhat similar to a non-recursive mutex, though it is not usually used that way]. The caller must have "wait" access to the object, or this function fails. Note that even though the call may modify state, "modify" access is not required. * NtWaitForMultipleObjects - Essentially a superset of the above [in particular, NtWaitForSingleObject can be trivially implemented on top of NtWaitForMultipleObjects], but for the sake of clarity I've separated it here. This function receives up to a fixed limit of 64 handles. It has two modes of operation: - wait for any of the objects to become signaled, atomically consuming [at most] one object; - wait for *all* of the objects to become signaled, atomically consuming all of them at once. Times out if all of the objects are never simultaneously signaled. This operation is rarely used in practice. Furthermore, the function can optionally be made "alertable", in which case certain kernel APIs will cause it to return with a special code. Note that in the case of wait-all, the function can therefore return in one of three ways: timeout, alert, or when all objects are signaled and consumed. As above, the caller must have "wait" access to all objects, but no other access is required. * NtReleaseSemaphore - atomically increments the semaphore count by a given 32-bit value, and returns the previous value. If threads are waiting on the semaphore, they will be signaled, and the semaphore's count decremented as appropriate. The caller must have "modify" access. * NtQuerySemaphore - read the current and maximum semaphore count without modifying the semaphore. The caller must have "read" access. * NtReleaseMutant - atomically decrements the mutex recursion count by one, and returns the previous count. If the count reaches zero, relinquishes ownership of the mutex, and causes it to become signaled. No access is required. * NtQueryMutant - returns the current mutex recursion count, whether the caller owns it, and whether it is "abandoned". The caller must have "read" access. * NtSetEvent - atomically sets an auto-reset or manual-reset event to the signaled state, and returns its previous state. The caller must have "modify" access. * NtResetEvent - atomically sets an auto-reset or manual-reset event to the nonsignaled state, and returns its previous state. The caller must have "modify" access. * NtPulseEvent - if the event is already signaled, set its state to nonsignaled and return. Otherwise, if the event is an auto-reset event, wakes up one thread (if any) waiting on the event; if the event is a manual-reset event, wakes up all threads (if any) waiting on the event. In both cases the event state is *not* changed to signaled. Note that a thread inside of "wait-all" is only woken if all other objects are also signaled. The caller must have "modify" access.[1] * NtQueryEvent - returns whether the event is currently signaled, and whether it is manual-reset or auto-reset. The caller must have "read" access. * NtSignalAndWaitForSingleObject - Set an object of any type to a signaled state; depending on the object type, this is equivalent to NtSetEvent, NtReleaseSemaphore (with a count of 1), or NtReleaseMutant. Then, wait on another object, as with NtWaitForSingleObject. The objects may be the same or different. If either handle is invalid (or has insufficient access) the call fails and neither object is affected. The two operations are not atomic, *but* if the call fails neither object can be affected—i.e. we must protect against a race where one object is closed mid-call. * NtDuplicateObject - This is not a synchronization-specific API, but deserves some comment nonetheless. It's a much more generic version of dup(), in which the caller in process A can specify to duplicate a handle from process B into process C, and all three processes can be different. The new handle can be given different access rights than the original. There is also an optional flag allowing to close the source handle at the same time. This is insane, of course—to allow a process to close another process's handles without its knowledge—but we need to implement it. This API alone is the cause of most of the difficulty we've had optimizing synchronization primitives in user space. Without it, it'd be easy to guess which objects need to be available cross-process, and use some futex- or eventfd-based scheduling mechanism within one process while using the slow server path for any cross-process objects. * A set of APIs that create or open objects, and one API (NtClose) destroying them. These calls specify the ACL associated with the object, and the rights requested when opening it. We're not concerned with the speed of these APIs, however (and actually optimizing that would be a lot more difficult anyway, as it interacts with a lot of other details currently managed by the wine server). If all handles to an object are closed while a thread is sleeping on it, the thread is not interrupted, but rather behaves as if the object remains unsignaled, i.e. the wait will either time out, be signaled by a different object, or continue forever until interrupted in some other way. Finally, a word deserves to be said regarding "abandoned" mutices. A thread which terminates (gracefully or violently) while holding one or more mutices releases those mutices, but sets an internal flag marking them as "abandoned". This flag can be retrieved by NtQueryMutant, and is also returned by NtWaitForSingleObject and NtWaitForMultipleObjects. Broadly speaking, what we actually need to be fast is mostly limited to the following operations: * NtWaitForSingleObject * NtWaitForMultipleObjects * NtSetEvent * NtResetEvent * NtReleaseSemaphore * NtReleaseMutant i.e. the "signal" and "wait" operations for all three object types. Other operations (create, open, close, query state, NtDuplicateObject, and NtPulseEvent) are rare in critical paths, or rare in programs where synchronization primitives are a bottleneck. Furthermore, the "wait-all" case of NtWaitForMultipleObjects is also relatively rare as a bottleneck [though I'm not confident to say that it never is a bottleneck]. 3. WHY IT CAN'T BE DONE WITH EXISTING TOOLS An out-of-tree patch set has been already mentioned ("esync"), which reimplements Win32 synchronization objects on top of eventfds, plus a few bytes of shared memory per object for that dynamic state which eventfd can't store. Semaphores use EFD_SEMAPHORE. Waiting is implemented using a loop of poll(), all file descriptors having been marked nonblocking, and a second call to read() to actually acquire the object. There are a few general problems with this: * NtPulseEvent can't work right. We badly emulate it by setting and then immediately resetting the event, but due to the above gap between poll() and read(), most threads end up missing the wakeup anyway. * Wait-for-all-objects is kind of broken. We implement it by grabbing each object in sequence and then undoing that operation if we fail to grab any object. * Storing object state in shared memory means that it can be corrupted. It's not usually a problem in practice, of course, but it's not safe enough for upstream. The "fsync" patch set stores all of its state in shared memory, and uses simple futex operations. It ends up working quite similarly, and shares the exact same problems. According to my reasoning, in order to really have PulseEvent work right, we need explicit scheduler support. That does bring up the option of having a "scheduler", i.e. managing wait-queues, in user space. Unfortunately this still doesn't help with the shared memory problem—in fact, now it's worse, because processes can die while holding locks that the scheduler needs. This means that wineserver itself—the "kernel" of Wine applications—can be broken by a misbehaving process, which is absolutely unacceptable for Wine. I've also thought about trying to implement a scheme whereby objects live in-process until they're accessed by another process, at which point they can be "migrated" down to the server. Since most usage (esp. most performance-critical usage) is within a single process, this might be feasible. However, it turns out to be hard if not impossible to avoid races while migrating. I've also been warned that synchronization between multiple processes is becoming more common (along the lines of e.g. separate processes executing GPU work, IIUC). I'd really love to be told that there's some user-space solution I'm missing, but after considering the problem for multiple years I've yet to find one. 4. PROPOSAL The following describes my best attempt at proposing a concrete interface, and if I don't get any concrete feedback to this mail other than "show me an implementation first", it's what I'll try to write up. Introduce a module, let's call it "ntsync". [I'd propose "winesync", but in theory I guess this could be useful to some other translation layer, not that I know of any.] This will create a char device /dev/ntsync which supports a set of ioctls. [My reasoning here is that we should modularize this feature, since it's meant for a specific and not ubiquitous program, and I'm presuming that this is the best way to expose something from a module.] Each ioctl matches up relatively closely to an NT syscall. Each ioctl on an object is atomic and totally ordered with respect to other ioctls on the same object. The list of ioctls is as follows: - NTSYNC_IOCTL_CREATE_MANUAL_EVENT - Takes a single int denoting initial state — nonzero signaled, zero nonsignaled. Internally creates a manual-reset event object, and returns a unique 32-bit integer representing this object. (This need not match the Win32 handle; we can map that trivially in user space.) - NTSYNC_IOCTL_CREATE_AUTO_EVENT - As above (but creates an auto-reset event). - NTSYNC_IOCTL_CREATE_SEMAPHORE - Takes a struct of two ints denoting initial count and maximum count; returns -EINVAL if initial > max. Internally allocates a semaphore object and returns a unique 32-bit integer representing it. - NTSYNC_IOCTL_CREATE_MUTEX - Takes a single int denoting initial state — nonzero owned by the current thread (with recursion count 1), zero unowned. Internally creates a mutex, and returns a unique 32-bit integer representing it. - NTSYNC_IOCTL_CLOSE - Takes an object identifier returned by one of the CREATE ioctls. Invalidates that object so that further ioctls on it return -EBADF [not a great error code, but I'm not sure what's better. It'd be nice to have a distinct error code, though.] Does not actually destroy the object until all outstanding syscalls on the object have executed it. [I.e. the objects are refcounted internally.] Does not interrupt existing syscalls using the object. - NTSYNC_IOCTL_WAIT_ANY - Takes an array of up to 65 identifiers [or some number greater than 65, as 65 is a bit ugly], a count, and an optional struct timespec pointer. Return -EINVAL if count < 1 or count > 65. Sleeps until at least one of the objects identified is in the signaled state (if it is not already) or the timeout expires. If the timeout expires, return -EAGAIN. Otherwise, consume exactly one object. Returns the index into the array passed in. Separately, also returns a flag denoting whether the signaling object was an abandoned mutex. A semaphore is considered signaled if its count is nonzero; a mutex is considered signaled if it is unowned or owned by the current thread. Consumption means as follows: * a manual-reset event is unaffected; * an auto-reset event is reset to the nonsignaled state; * a semaphore has its count decreased by 1; * a mutex is marked as owned by the current thread [if it is not already] and its recursion count is increased by 1. - NTSYNC_IOCTL_WAIT_ALL - Much like the above. However, instead of waiting for *any* of the objects to become signaled, wait for them all to become simultaneously signaled [or for the timeout to expire], and atomically consume them all at once if so. Hence, on success, it simply returns 0 instead of an index. - NTSYNC_IOCTL_SET_EVENT - Takes an object identifier returned by one of the CREATE ioctls. If the event is a manual-reset event, set its state to signaled, and wake up all eligible threads. If the event is an auto-reset event, and there is at least one eligible thread waiting on it, wake up that thread and leave the event unsignaled; if there are no eligible threads waiting on it, set the event to signaled. Returns -ENOSYS if not called on an event. (An "eligible" thread is defined as one whose wait condition is satisfied—i.e. a thread executing an ANY wait is eligible if any of its items are signaled; a thread executing an ALL wait is eligible if all of its items are signaled.) - NTSYNC_IOCTL_RESET_EVENT - Takes an object identifier returned by one of the CREATE ioctls. Set the state of an auto- or manual-reset event to nonsignaled. Returns -ENOSYS if not called on an event. - NTSYNC_IOCTL_PULSE_EVENT - Takes an object identifier returned by one of the CREATE ioctls. If the event is already signaled, this ioctl is equivalent to NTSYNC_IOCTL_RESET_EVENT. Otherwise, if the event is an auto-reset event and there is an eligible thread waiting on it, wake it up. If the event is a manual-reset event, wake up all eligible threads waiting on it. Do not change the state of the event to signaled. Returns -ENOSYS if not called on an event. - NTSYNC_IOCTL_READ_EVENT - Takes an object identifier returned by one of the CREATE ioctls. Returns the event's state (signaled or nonsignaled). Returns -ENOSYS if not called on an event. - NTSYNC_IOCTL_RELEASE_SEMAPHORE - Takes an object identifier returned by one of the CREATE ioctls, and a 32-bit integer "count". Return -EOVERFLOW if "count" is greater than the internal maximum. Otherwise, increase the internal count by "count", then, wake up the first at most {internal count} eligible threads waiting on this semaphore, decreasing {internal count} by 1 for each thread. This whole operation is of course atomic. Returns -ENOSYS if not called on a semaphore. - NTSYNC_IOCTL_READ_SEMAPHORE - Takes an object identifier returned by one of the CREATE ioctls. Returns the semaphore's count. Returns -ENOSYS if not called on a semaphore. - NTSYNC_IOCTL_RELEASE_MUTEX - Takes an object identifier returned by one of the CREATE ioctls. Return -EPERM if the calling thread does not own the mutex. Otherwise, decrease the mutex's recursion count by 1. If it reaches zero, and there is an eligible thread waiting on this semaphore, wake it up and mark it as owner, setting the recursion count back to 1. If there is no eligible thread, leave the mutex in an "unowned" state. Returns -ENOSYS if not called on a mutex. - NTSYNC_IOCTL_READ_MUTEX - Takes an object identifier returned by one of the CREATE ioctls. Returns an int describing whether the mutex is owned by the caller (1 if owned by the caller, 0 otherwise) and similarly an int describing whether the mutex is abandoned. Returns -ENOSYS if not called on a mutex. - NTSYNC_IOCTL_ABANDON_MUTEX - Takes an object identifier and marks the given mutex as abandoned and unowned. Returns -ENOSYS if not called on a mutex. - NTSYNC_IOCTL_SIGNAL_AND_WAIT - Takes two object identifiers and an optional struct timespec pointer. Depending on the type of the first object identifier, equivalent to NTSYNC_IOCTL_SET_EVENT, NTSYNC_IOCTL_RELEASE_MUTEX, or NTSYNC_IOCTL_RELEASE_SEMAPHORE (with a count of 1), followed by NTSYNC_IOCTL_WAIT_ANY on the second object. If either object is invalid (has been closed), returns -EBADF and does not affect the state of either object. (We can almost implement this in user space without help from the kernel, except that we need to protect against races where one object is closed mid-call.) Note that we don't use fds for object handles, even though they're analogous concepts. There are a couple reasons for this: * Windows doesn't have a concept of NOFILE. Buggy programs exist which leak hundreds of thousands of synch primitives. Google Earth VR is an example. esync ships with a notice telling the user to raise the hard limit for NOFILE; later systemd itself raised the default limit (not solely because of esync, but it was the trigger). * These objects are remarkably idiosyncratic in their behaviour. read() and write() make less sense on them than they do on eventfd. poll() barely makes sense, and in any case it's not useful for Wine—we need combined atomic poll-and-acquire semantics. All of the above object identifiers are per-fd. Access control flags and handle duplication would be handled in user space. We would have a one-to-one correspondence between objects and UAPI identifiers; the kernel would therefore have a one-to-one correspondence between UAPI identifiers and actual objects. Alertable waits would also be handled in user space, via signals. Thus we would need it to be guaranteed that a WAIT call return -EINTR on a signal, so that we can check whether the thread is alerted. For the sake of comparison, if an existing API like eventfd were instead extended, here is a list of the things we would need. * A blocking operation, like poll() that optionally consumes things, or like read() on a vectored set of file descriptors. This doesn't necessarily mean we have to replicate the manual/auto distinction in the kernel; we can handle that in user space. This by itself doesn't actually seem all that unreasonable, but... * A blocking operation like the above, but corresponding to "wait-all"; i.e. which atomically reads from all descriptors. Just from skimming the code surrounding things like read() and poll(), this seems very ugly to implement. * A way to atomically write() to an eventfd and retrieve its current count [for semaphore and event operations]. * A way to signal an eventfd, such that waiters are woken, but without changing its current count [i.e. an operation corresponding to NtPulseEvent]. * A way to read the current count of an eventfd without changing it [for NtQuerySemaphore and NtQueryMutant; for NtQueryEvent we can use poll.] That concludes my description and proposal; I'd love to hear your thoughts. ἔρρωσθε, Zebediah Figura (she/her) [1] NtPulseEvent has been publicly deprecated by Microsoft for some time, and is rarely used in modern programs. It's inherently racy (it relies you to know whether a thread is actually waiting for your event, which is in theory impossible, if in practice less so), and not only that, but Microsoft warns that kernel threads sleeping on an event can be arbitrarily un-scheduled in order to run an asynchronous kernel procedure (I don't know why the kernel unqueues the thread in this case, but I'm also not yet a kernel developer). In practice it was usually used to implement a loose equivalent of alarm(2), before a better API was invented for this, and so the rare race or missed wakeup was not a problem. APPENDIX: PERFORMANCE IMPROVEMENTS DUE TO "ESYNC" These are to some extent cherry-picked. The point isn't so much to show that "esync" helps everything—it doesn't by any means—but to show that it does result in significant improvement for a non-negligible number of applications. Most of the following benchmarks measure FPS. A secondary benefit though, that I have observed in practice (but unfortunately have no numbers for, and at the moment don't particularly have the hardware to reproduce) is that CPU utilization is greatly decreased, especially in the wineserver process. * <https://github.com/ValveSoftware/Proton/issues/2966#issuecomment-520187737> - Thief (2014). Average FPS increase due to "esync" is 93 -> 123 FPS. * <https://github.com/ValveSoftware/Proton/issues/2966#issuecomment-521792609> - Grand Theft Auto V (2015). 100 -> 131 FPS. * <https://www.youtube.com/watch?v=GRTPb-ar0sI> - Recorded benchmark of Grand Theft Auto V (2015) with a side-by-side comparison. There is not always a visible difference between "esync" and server-side synchronization; it depends largely on whether the game is CPU- or GPU-limited at any given time. Unfortunately there are no average numbers. The following benchmarks were all uploaded by the same user, apparently with the same hardware (details are listed on each page) and also include "fsync". They also include graphs taken over a larger time period, giving more information than simply average FPS. * <https://flightlessmango.com/games/1700/logs/778> - Assassin's Creed Odyssey (2018). 50 -> 54 FPS. * <https://flightlessmango.com/games/15605/logs/785> - Ori and the Will of the Wisps (2020). 99 -> 115 FPS. * <https://flightlessmango.com/games/2596/logs/786> - Bioshock (2007). 526 -> 622 FPS. * <https://flightlessmango.com/games/2597/logs/789> - Bioshock 2 (2010). 313 -> 338 FPS. * <https://flightlessmango.com/games/23256/logs/788> - The Witcher 3: Wild Hunt (2016). 82 -> 90 FPS.

4 3

[PATCH v4] include: Move InterlockedCompareExchange128 next to the other InterlockedCompareExchange* functions.
by Zebediah Figura Jan. 19, 2021

Jan. 19, 2021

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- v4: Keep the inline asm code path. include/winnt.h | 65 +++++++++++++++++++++++++------------------------ 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/include/winnt.h b/include/winnt.h index 7bbe0185139..60d15ac0d10 100644 --- a/include/winnt.h +++ b/include/winnt.h @@ -6898,6 +6898,9 @@ static inline BOOLEAN BitScanReverse(DWORD *index, DWORD mask) #pragma intrinsic(_InterlockedCompareExchange) #pragma intrinsic(_InterlockedCompareExchange64) +#ifdef _WIN64 +#pragma intrinsic(_InterlockedCompareExchange128) +#endif #pragma intrinsic(_InterlockedExchange) #pragma intrinsic(_InterlockedExchangeAdd) #pragma intrinsic(_InterlockedIncrement) @@ -6905,6 +6908,9 @@ static inline BOOLEAN BitScanReverse(DWORD *index, DWORD mask) long _InterlockedCompareExchange(long volatile*,long,long); long long _InterlockedCompareExchange64(long long volatile*,long long,long long); +#ifdef _WIN64 +unsigned char _InterlockedCompareExchange128(volatile __int64 *, __int64, __int64, __int64 *); +#endif long _InterlockedDecrement(long volatile*); long _InterlockedExchange(long volatile*,long); long _InterlockedExchangeAdd(long volatile*,long); @@ -6920,6 +6926,13 @@ static FORCEINLINE LONGLONG WINAPI InterlockedCompareExchange64( LONGLONG volati return _InterlockedCompareExchange64( (long long volatile *)dest, compare, xchg ); } +#ifdef _WIN64 +static FORCEINLINE unsigned char WINAPI InterlockedCompareExchange128( volatile __int64 *dest, __int64 xchg_high, __int64 xchg_low, __int64 *compare ) +{ + return _InterlockedCompareExchange128( dest, xchg_high, xchg_low, compare ); +} +#endif + static FORCEINLINE LONG WINAPI InterlockedExchange( LONG volatile *dest, LONG val ) { return _InterlockedExchange( (long volatile *)dest, val ); @@ -6982,6 +6995,26 @@ static FORCEINLINE LONGLONG WINAPI InterlockedCompareExchange64( LONGLONG volati return __sync_val_compare_and_swap( dest, compare, xchg ); } +#ifdef _WIN64 +#ifdef __x86_64__ +static FORCEINLINE unsigned char InterlockedCompareExchange128( __int64 *dest, __int64 xchg_high, __int64 xchg_low, __int64 *compare ) +{ + unsigned char ret; + __asm__ __volatile__( "lock cmpxchg16b %0; setz %b2" + : "=m" (dest[0]), "=m" (dest[1]), "=r" (ret), + "=a" (compare[0]), "=d" (compare[1]) + : "m" (dest[0]), "m" (dest[1]), "3" (compare[0]), "4" (compare[1]), + "c" (xchg_high), "b" (xchg_low) ); + return ret; +} +#else +static FORCEINLINE unsigned char WINAPI InterlockedCompareExchange128( volatile __int64 *dest, __int64 xchg_high, __int64 xchg_low, __int64 *compare ) +{ + return __sync_bool_compare_and_swap( (__int128 *)dest, *(__int128 *)compare, ((__int128)xchg_high << 64) | xchg_low ); +} +#endif +#endif + static FORCEINLINE LONG WINAPI InterlockedExchange( LONG volatile *dest, LONG val ) { LONG ret; @@ -7024,38 +7057,6 @@ static FORCEINLINE void * WINAPI InterlockedExchangePointer( void *volatile *des #endif /* __GNUC__ */ -#ifdef _WIN64 - -#if defined(_MSC_VER) - -#define InterlockedCompareExchange128 _InterlockedCompareExchange128 -unsigned char _InterlockedCompareExchange128(volatile __int64 *dest, __int64 xchg_high, __int64 xchg_low, __int64 *compare); -#pragma intrinsic(_InterlockedCompareExchange128) - -#elif defined(__x86_64__) - -static inline unsigned char InterlockedCompareExchange128(__int64 *dest, __int64 xchg_high, __int64 xchg_low, __int64 *compare) -{ - unsigned char ret; - __asm__ __volatile__( "lock cmpxchg16b %0; setz %b2" - : "=m" (dest[0]), "=m" (dest[1]), "=r" (ret), - "=a" (compare[0]), "=d" (compare[1]) - : "m" (dest[0]), "m" (dest[1]), "3" (compare[0]), "4" (compare[1]), - "c" (xchg_high), "b" (xchg_low) ); - return ret; -} - -#elif defined(__GNUC__) - -static inline unsigned char InterlockedCompareExchange128(__int64 *dest, __int64 xchg_high, __int64 xchg_low, __int64 *compare) -{ - return __sync_bool_compare_and_swap( (__int128 *)dest, *(__int128 *)compare, ((__int128)xchg_high << 64) | xchg_low ); -} - -#endif - -#endif /* _WIN64 */ - #ifdef __cplusplus } #endif -- 2.29.2

1 0

[PATCH vkd3d 1/5] vkd3d-shader: Treat undefined identifiers as equal to 0.
by Zebediah Figura Jan. 19, 2021

Jan. 19, 2021

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/preproc.y | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/libs/vkd3d-shader/preproc.y b/libs/vkd3d-shader/preproc.y index f9047c9f..008d01e7 100644 --- a/libs/vkd3d-shader/preproc.y +++ b/libs/vkd3d-shader/preproc.y @@ -588,6 +588,11 @@ expr $$ = preproc_parse_integer($1); vkd3d_free($1); } + | T_IDENTIFIER + { + $$ = 0; + vkd3d_free($1); + } | T_DEFINED T_IDENTIFIER { $$ = !!preproc_find_macro(ctx, $2); -- 2.30.0

3 8