June 2019 - Wine-Devel - list.winehq.org

[PATCH vkd3d 1/6] vkd3d: Clarify DSV attachment mask handling.
by Józef Kucia June 12, 2019

June 12, 2019

From: Józef Kucia <jkucia(a)codeweavers.com> It isn't immediately obvious what "1u << graphics->rt_count" means. Use dsv_attachment_mask() helper instead. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 15 ++------------- libs/vkd3d/state.c | 8 ++++---- libs/vkd3d/vkd3d_private.h | 17 +++++++++++++++++ 3 files changed, 23 insertions(+), 17 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index fcb7a4899091..55a15d9546c5 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -2278,17 +2278,6 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_list_ClearState(ID3D12GraphicsCom return E_NOTIMPL; } -static bool d3d12_command_list_has_unknown_dsv_format(struct d3d12_command_list *list) -{ - struct d3d12_graphics_pipeline_state *graphics; - - if (!d3d12_pipeline_state_is_graphics(list->state)) - return false; - - graphics = &list->state->u.graphics; - return graphics->null_attachment_mask & (1u << graphics->rt_count); -} - static bool d3d12_command_list_has_depth_stencil_view(struct d3d12_command_list *list) { struct d3d12_graphics_pipeline_state *graphics; @@ -2296,7 +2285,7 @@ static bool d3d12_command_list_has_depth_stencil_view(struct d3d12_command_list assert(d3d12_pipeline_state_is_graphics(list->state)); graphics = &list->state->u.graphics; - return graphics->dsv_format || (d3d12_command_list_has_unknown_dsv_format(list) && list->dsv_format); + return graphics->dsv_format || (d3d12_pipeline_state_has_unknown_dsv_format(list->state) && list->dsv_format); } static void d3d12_command_list_get_fb_extent(struct d3d12_command_list *list, @@ -4386,7 +4375,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12Graphi } } - if (prev_dsv_format != list->dsv_format && d3d12_command_list_has_unknown_dsv_format(list)) + if (prev_dsv_format != list->dsv_format && d3d12_pipeline_state_has_unknown_dsv_format(list->state)) d3d12_command_list_invalidate_current_pipeline(list); d3d12_command_list_invalidate_current_framebuffer(list); diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index 514fdc3a74f2..be2aa4f4bca4 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -2038,7 +2038,7 @@ static HRESULT d3d12_graphics_pipeline_state_create_render_pass( memcpy(key.vk_formats, graphics->rtv_formats, sizeof(graphics->rtv_formats)); key.attachment_count = graphics->rt_count; - if (!(dsv_format = graphics->dsv_format) && (graphics->null_attachment_mask & (1u << graphics->rt_count))) + if (!(dsv_format = graphics->dsv_format) && (graphics->null_attachment_mask & dsv_attachment_mask(graphics))) dsv_format = dynamic_dsv_format; if (dsv_format) @@ -2220,7 +2220,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s { WARN("DSV format is DXGI_FORMAT_UNKNOWN.\n"); graphics->dsv_format = VK_FORMAT_UNDEFINED; - graphics->null_attachment_mask |= 1u << graphics->rt_count; + graphics->null_attachment_mask |= dsv_attachment_mask(graphics); } else if ((format = vkd3d_get_format(device, desc->DSVFormat, true))) { @@ -2503,7 +2503,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s goto fail; } - is_dsv_format_unknown = graphics->null_attachment_mask & (1u << graphics->rt_count); + is_dsv_format_unknown = graphics->null_attachment_mask & dsv_attachment_mask(graphics); rs_desc_from_d3d12(&graphics->rs_desc, &desc->RasterizerState); have_attachment = graphics->rt_count || graphics->dsv_format || is_dsv_format_unknown; @@ -2855,7 +2855,7 @@ VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_sta /* Create a render pass for pipelines with DXGI_FORMAT_UNKNOWN. */ if (!(pipeline_desc.renderPass = graphics->render_pass)) { - if (graphics->null_attachment_mask & (1u << graphics->rt_count)) + if (graphics->null_attachment_mask & dsv_attachment_mask(graphics)) TRACE("Compiling %p with DSV format %#x.\n", state, dsv_format); if (FAILED(hr = d3d12_graphics_pipeline_state_create_render_pass(graphics, device, dsv_format, diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 4118d5d170e0..9f00d327b73b 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -706,6 +706,11 @@ struct d3d12_graphics_pipeline_state bool xfb_enabled; }; +static inline unsigned int dsv_attachment_mask(const struct d3d12_graphics_pipeline_state *graphics) +{ + return 1u << graphics->rt_count; +} + struct d3d12_compute_pipeline_state { VkPipeline vk_pipeline; @@ -746,6 +751,18 @@ static inline bool d3d12_pipeline_state_is_graphics(const struct d3d12_pipeline_ return state && state->vk_bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS; } +static inline bool d3d12_pipeline_state_has_unknown_dsv_format(struct d3d12_pipeline_state *state) +{ + if (d3d12_pipeline_state_is_graphics(state)) + { + struct d3d12_graphics_pipeline_state *graphics = &state->u.graphics; + + return graphics->null_attachment_mask & dsv_attachment_mask(graphics); + } + + return false; +} + HRESULT d3d12_pipeline_state_create_compute(struct d3d12_device *device, const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) DECLSPEC_HIDDEN; HRESULT d3d12_pipeline_state_create_graphics(struct d3d12_device *device, -- 2.21.0

2 1

[PATCH v2 1/2] wined3d: Use 3 component norm for 'nrm' opcode in GLSL backend.
by Paul Gofman June 12, 2019

June 12, 2019

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=8848 Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- v2: no changes. dlls/wined3d/glsl_shader.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 9d4f6057c3..6239467741 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -4265,11 +4265,24 @@ static void shader_glsl_nrm(const struct wined3d_shader_instruction *ins) mask_size = shader_glsl_get_write_mask_size(write_mask); shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param); - shader_addline(buffer, "tmp0.x = dot(%s, %s);\n", - src_param.param_str, src_param.param_str); + if (mask_size > 3) + shader_addline(buffer, "tmp0.x = dot(vec3(%s), vec3(%s));\n", + src_param.param_str, src_param.param_str); + else + shader_addline(buffer, "tmp0.x = dot(%s, %s);\n", + src_param.param_str, src_param.param_str); shader_glsl_append_dst(buffer, ins); - if (mask_size > 1) + if (mask_size == 4) + { + static const float max_float = FLT_MAX; + + shader_addline(buffer, "tmp0.x == 0.0 ? vec4(vec3(0.0), sign(%s[3]) * ", + src_param.param_str); + shader_glsl_append_imm_vec(buffer, &max_float, 1, ins->ctx->gl_info); + shader_addline(buffer, ") : (%s * inversesqrt(tmp0.x)));\n", src_param.param_str); + } + else if (mask_size > 1) { shader_addline(buffer, "tmp0.x == 0.0 ? vec%u(0.0) : (%s * inversesqrt(tmp0.x)));\n", mask_size, src_param.param_str); -- 2.21.0

3 3

[PATCH v4 1/5] server: Added support for tracking registered device notifications
by Micah N Gorrell June 12, 2019

June 12, 2019

Signed-off-by: Micah N Gorrell <mgorrell(a)codeweavers.com> --- server/protocol.def | 23 +++++++++ server/user.h | 3 +- server/window.c | 112 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 137 insertions(+), 1 deletion(-) diff --git a/server/protocol.def b/server/protocol.def index e450388c17..1645d09d5f 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3692,6 +3692,29 @@ struct handle_info @END +/* Register a handle for device notifications */ +(a)REQ(register_device_notification) + user_handle_t recipient; /* handle to a window or service that will receive device events */ +(a)REPLY + user_handle_t handle; /* handle associated with the registration */ +(a)END + + +/* Unregister device notifications for a handle */ +(a)REQ(unregister_device_notification) + user_handle_t notification; /* handle that was previously returned by register_device_notification */ +(a)END + + +/* Return a list of handles that have registered for device notifications */ +(a)REQ(get_device_notifications) +(a)REPLY + int count; /* total count of registered handles */ + VARARG(handles,user_handles); /* registered handles */ +(a)END + + + /* Make the current process a system process */ @REQ(make_process_system) @REPLY diff --git a/server/user.h b/server/user.h index eb1b7ce1e4..282cb63339 100644 --- a/server/user.h +++ b/server/user.h @@ -36,7 +36,8 @@ enum user_object { USER_WINDOW = 1, USER_HOOK, - USER_CLIENT /* arbitrary client handle */ + USER_CLIENT, /* arbitrary client handle */ + USER_DEVNOTIFY }; #define DESKTOP_ATOM ((atom_t)32769) diff --git a/server/window.c b/server/window.c index c9b131cba5..80ac897ea6 100644 --- a/server/window.c +++ b/server/window.c @@ -129,6 +129,19 @@ static struct window *taskman_window; #define WINPTR_TOPMOST ((struct window *)3L) #define WINPTR_NOTOPMOST ((struct window *)4L) +struct device_notification +{ + user_handle_t recipient; /* the window handle to send notifications to */ + user_handle_t handle; /* full handle for this window */ + struct process *process; /* process that owns this notification handle */ + struct list entry; /* entry in global notifications list */ + + /* FIXME: Add support for notification filters */ +}; + +/* global list of handles that have registered for device notifications */ +static struct list device_notifications = LIST_INIT(device_notifications); + /* retrieve a pointer to a window from its handle */ static inline struct window *get_window( user_handle_t handle ) { @@ -2880,3 +2893,102 @@ DECL_HANDLER(set_window_layered_info) } else set_win32_error( ERROR_INVALID_WINDOW_HANDLE ); } + +/* retrieve a pointer to a device_notification from its handle */ +static inline struct device_notification *get_device_notification( user_handle_t handle ) +{ + struct device_notification *ret = get_user_object( handle, USER_DEVNOTIFY ); + if (!ret) set_win32_error( ERROR_INVALID_HANDLE ); + return ret; +} + +/* create a new device notification structure and link it into the global list */ +static struct device_notification *register_device_notification( struct window *recipient ) +{ + struct device_notification *notification; + + if (!recipient) + { + return NULL; + } + + if (!(notification = mem_alloc( sizeof(*notification) ))) goto failed; + if (!(notification->handle = alloc_user_handle( notification, USER_DEVNOTIFY ))) goto failed; + + notification->recipient = recipient->handle; + notification->process = current->process; + /* FIXME: Add support for notification filters */ + + list_add_tail( &device_notifications, &notification->entry ); + + return notification; +failed: + if (notification) + { + if (notification->handle) free_user_handle( notification->handle ); + free( notification ); + } + + return NULL; +} + +static void unregister_device_notification( struct device_notification *notification) +{ + list_remove( &notification->entry ); + free_user_handle( notification->handle ); + memset( notification, 0x55, sizeof(*notification) ); + free( notification ); +} + +static int get_device_notifications( struct user_handle_array *array ) +{ + struct device_notification *notification; + + LIST_FOR_EACH_ENTRY( notification, &device_notifications, struct device_notification, entry ) + { + /* FIXME: Implement notification filtering */ + if (!add_handle_to_array( array, notification->recipient )) return 0; + } + + return 1; +} + +/* register for device notifications */ +DECL_HANDLER(register_device_notification) +{ + struct device_notification *notification = NULL; + struct window *recipient = get_window( req->recipient ); + + reply->handle = 0; + if (!recipient) return; + + if (!(notification = register_device_notification( recipient ))) return; + + reply->handle = notification->handle; +} + +DECL_HANDLER(unregister_device_notification) +{ + struct device_notification *notification = get_device_notification( req->notification ); + if (notification) { + if (notification->process == current->process) unregister_device_notification(notification); + else set_error( STATUS_ACCESS_DENIED ); + } +} + +DECL_HANDLER(get_device_notifications) +{ + struct user_handle_array array; + data_size_t len; + + array.handles = NULL; + array.count = 0; + array.total = 0; + + if (!get_device_notifications( &array )) return; + + reply->count = array.count; + len = min( get_reply_max_size(), array.count * sizeof(user_handle_t) ); + if (len) set_reply_data_ptr( array.handles, len ); + else free( array.handles ); +} -- 2.21.0

3 7

[PATCH] mf/tests: Add sample processing tests for Video Processor.
by Nikolay Sivov June 12, 2019

June 12, 2019

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mf/tests/mf.c | 122 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 121 insertions(+), 1 deletion(-) diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index f55104c039..15aa58620a 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -2063,8 +2063,14 @@ static void test_video_processor(void) DWORD input_min, input_max, output_min, output_max, i, count; IMFAttributes *attributes, *attributes2; IMFMediaType *media_type, *media_type2; + MFT_OUTPUT_DATA_BUFFER output_buffer; + MFT_OUTPUT_STREAM_INFO output_info; MFT_INPUT_STREAM_INFO input_info; + IMFSample *sample, *sample2; IMFTransform *transform; + IMFMediaBuffer *buffer; + IMFMediaEvent *event; + IUnknown *unk; HRESULT hr; GUID guid; @@ -2079,6 +2085,12 @@ todo_wine if (FAILED(hr)) goto failed; + hr = IMFTransform_QueryInterface(transform, &IID_IMFMediaEventGenerator, (void **)&unk); + ok(hr == E_NOINTERFACE, "Unexpected hr %#x.\n", hr); + + hr = IMFTransform_QueryInterface(transform, &IID_IMFShutdown, (void **)&unk); + ok(hr == E_NOINTERFACE, "Unexpected hr %#x.\n", hr); + /* Transform global attributes. */ hr = IMFTransform_GetAttributes(transform, &attributes); ok(hr == S_OK, "Failed to get attributes, hr %#x.\n", hr); @@ -2149,6 +2161,14 @@ todo_wine ok(input_info.cbMaxLookahead == 0, "Unexpected lookahead length %u.\n", input_info.cbMaxLookahead); ok(input_info.cbAlignment == 0, "Unexpected alignment %u.\n", input_info.cbAlignment); + hr = MFCreateMediaEvent(MEUnknown, &GUID_NULL, S_OK, NULL, &event); + ok(hr == S_OK, "Failed to create event object, hr %#x.\n", hr); + hr = IMFTransform_ProcessEvent(transform, 0, event); + ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr); + hr = IMFTransform_ProcessEvent(transform, 1, event); + ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr); + IMFMediaEvent_Release(event); + /* Configure stream types. */ for (i = 0;;++i) { @@ -2213,13 +2233,113 @@ todo_wine hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info); ok(hr == S_OK, "Failed to get stream info, hr %#x.\n", hr); - ok(input_info.dwFlags == 0, "Unexpected flag %#x.\n", input_info.dwFlags); + ok(input_info.dwFlags == 0, "Unexpected flags %#x.\n", input_info.dwFlags); ok(input_info.cbMaxLookahead == 0, "Unexpected lookahead length %u.\n", input_info.cbMaxLookahead); ok(input_info.cbAlignment == 0, "Unexpected alignment %u.\n", input_info.cbAlignment); IMFMediaType_Release(media_type); } + /* IYUV -> RGB32 */ + hr = MFCreateMediaType(&media_type); + ok(hr == S_OK, "Failed to create media type, hr %#x.\n", hr); + + hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFVideoFormat_IYUV); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFMediaType_SetUINT64(media_type, &MF_MT_FRAME_SIZE, ((UINT64)16 << 32) | 16); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFTransform_SetInputType(transform, 0, media_type, 0); + ok(hr == S_OK, "Failed to set input type, hr %#x.\n", hr); + + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFVideoFormat_RGB32); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFTransform_SetOutputType(transform, 0, media_type, 0); + ok(hr == S_OK, "Failed to set output type, hr %#x.\n", hr); + + hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info); + ok(hr == S_OK, "Failed to get stream info, hr %#x.\n", hr); + ok(output_info.dwFlags == 0, "Unexpected flags %#x.\n", output_info.dwFlags); + ok(output_info.cbSize > 0, "Unexpected size %u.\n", output_info.cbSize); + ok(output_info.cbAlignment == 0, "Unexpected alignment %u.\n", output_info.cbAlignment); + + hr = MFCreateSample(&sample); + ok(hr == S_OK, "Failed to create a sample, hr %#x.\n", hr); + + hr = MFCreateSample(&sample2); + ok(hr == S_OK, "Failed to create a sample, hr %#x.\n", hr); + + memset(&output_buffer, 0, sizeof(output_buffer)); + output_buffer.pSample = sample; + flags = 0; + hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); + ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Unexpected hr %#x.\n", hr); + ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); + ok(flags == 0, "Unexpected status %#x.\n", flags); + + hr = IMFTransform_ProcessInput(transform, 0, sample2, 0); + ok(hr == S_OK, "Failed to push a sample, hr %#x.\n", hr); + + hr = IMFTransform_ProcessInput(transform, 0, sample2, 0); + ok(hr == MF_E_NOTACCEPTING, "Unexpected hr %#x.\n", hr); + + memset(&output_buffer, 0, sizeof(output_buffer)); + output_buffer.pSample = sample; + flags = 0; + hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); + ok(hr == MF_E_NO_SAMPLE_TIMESTAMP, "Unexpected hr %#x.\n", hr); + ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); + ok(flags == 0, "Unexpected status %#x.\n", flags); + + hr = IMFSample_SetSampleTime(sample2, 0); + ok(hr == S_OK, "Failed to set sample time, hr %#x.\n", hr); + memset(&output_buffer, 0, sizeof(output_buffer)); + output_buffer.pSample = sample; + flags = 0; + hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); + ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr); + ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); + ok(flags == 0, "Unexpected status %#x.\n", flags); + + hr = MFCreateMemoryBuffer(1024 * 1024, &buffer); + ok(hr == S_OK, "Failed to create a buffer, hr %#x.\n", hr); + + hr = IMFSample_AddBuffer(sample2, buffer); + ok(hr == S_OK, "Failed to add a buffer, hr %#x.\n", hr); + + hr = IMFSample_AddBuffer(sample, buffer); + ok(hr == S_OK, "Failed to add a buffer, hr %#x.\n", hr); + + memset(&output_buffer, 0, sizeof(output_buffer)); + output_buffer.pSample = sample; + flags = 0; + hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); + ok(hr == S_OK || broken(FAILED(hr)) /* Win8 */, "Failed to get output buffer, hr %#x.\n", hr); + ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); + ok(flags == 0, "Unexpected status %#x.\n", flags); + + if (SUCCEEDED(hr)) + { + memset(&output_buffer, 0, sizeof(output_buffer)); + output_buffer.pSample = sample; + flags = 0; + hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); + ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Unexpected hr %#x.\n", hr); + ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); + ok(flags == 0, "Unexpected status %#x.\n", flags); + } + + IMFSample_Release(sample2); + IMFSample_Release(sample); + IMFMediaBuffer_Release(buffer); + + IMFMediaType_Release(media_type); + IMFTransform_Release(transform); failed: -- 2.20.1

1 0

[PATCH v4 1/2] ntdll/directory: Add support for EXT4 case folding per directory
by Gabriel Ivăncescu June 12, 2019

June 12, 2019

This adds support for checking the case-insensitive attribute on ext4 with newer kernels so that Wine can rely on it for performance. It has some conditional processing for perf reasons. Checking for the EXT4_CASEFOLD_FL attribute involves an ioctl, which operates on file descriptors, while all the former checks operated directly on the dir pathname (e.g. statfs). Obviously, it's best to avoid looking up the directory multiple times (also for correctness, so it refers to the same dir). So in the case that we *do* have a file descriptor, then use it everywhere, with e.g. fstatfs. However, to avoid a perf regression or downgrade on systems that don't support the EXT2_IOC_GETFLAGS ioctl (e.g. MacOS, FreeBSD), we continue using statfs and the like directly, this shaves off two syscalls (open/close). But in the case the EXT4_CASEFOLD_FL is not supported on Linux (i.e. on current kernels) or the directory doesn't have it, this will unfortunately involve a bit more syscalls now, because it has to open() and close() the fd, but it shouldn't be too much of a problem. (the fstatfs and fstatat make it less impactful somewhat, so they won't have to lookup the directory again, hopefully mitigating some of it) Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=47099 Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v4: Simplify the #if checks and get rid of the GET_DIR_CASE_SENSITIVITY_USE_FD constant. Huw, I know you wanted to #include the header that defines EXT4_CASEFOLD_FL and others. I resent it without that so that Alexandre can see how the patch looks like, if he doesn't want to add another dependency. I know he's away today so his reply will have to wait probably after 4.10, I'll make sure to remind him if he doesn't, though ;-) That, plus the fact I'm really bad at autotools so I'll end up copy-pasting some similar check. Also, in case we do add a configure check for it, should we display a warning if it's not found? Like "ext2_fs.h not available, case-folding per directory will be unsupported." dlls/ntdll/directory.c | 69 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 61 insertions(+), 8 deletions(-) diff --git a/dlls/ntdll/directory.c b/dlls/ntdll/directory.c index bbdbbe9..2d6563e 100644 --- a/dlls/ntdll/directory.c +++ b/dlls/ntdll/directory.c @@ -115,6 +115,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(file); /* just in case... */ #undef VFAT_IOCTL_READDIR_BOTH +#undef EXT2_IOC_GETFLAGS +#undef EXT4_CASEFOLD_FL #ifdef linux @@ -130,6 +132,12 @@ typedef struct /* Define the VFAT ioctl to get both short and long file names */ #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, KERNEL_DIRENT [2] ) +/* Define the ext2 ioctl for handling extra attributes */ +#define EXT2_IOC_GETFLAGS _IOR('f', 1, long) + +/* Case-insensitivity attribute */ +#define EXT4_CASEFOLD_FL 0x40000000 + #ifndef O_DIRECTORY # define O_DIRECTORY 0200000 /* must be directory */ #endif @@ -1109,18 +1117,36 @@ static int get_dir_case_sensitivity_attr( const char *dir ) } #endif +#ifdef EXT4_CASEFOLD_FL + +/*********************************************************************** + * get_dir_case_sensitivity_ioctl + * + * Checks if the specified directory is case sensitive or not. Uses ioctl(2). + */ +static int get_dir_case_sensitivity_ioctl(int fd) +{ + int flags; + if (ioctl(fd, EXT2_IOC_GETFLAGS, &flags) != -1 && (flags & EXT4_CASEFOLD_FL)) + return FALSE; + return -1; +} +#endif + /*********************************************************************** * get_dir_case_sensitivity_stat * * Checks if the volume containing the specified directory is case - * sensitive or not. Uses statfs(2) or statvfs(2). + * sensitive or not. Uses (f)statfs(2), (f)statvfs(2), or fstatat(2). */ -static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) +static BOOLEAN get_dir_case_sensitivity_stat( const char *dir, int fd ) { #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) struct statfs stfs; - if (statfs( dir, &stfs ) == -1) return FALSE; + if (fd != -1 && fstatfs( fd, &stfs ) == -1) return FALSE; + if (fd == -1 && statfs( dir, &stfs ) == -1) return FALSE; + /* Assume these file systems are always case insensitive on Mac OS. * For FreeBSD, only assume CIOPFS is case insensitive (AFAIK, Mac OS * is the only UNIX that supports case-insensitive lookup). @@ -1157,7 +1183,9 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) #elif defined(__NetBSD__) struct statvfs stfs; - if (statvfs( dir, &stfs ) == -1) return FALSE; + if (fd != -1 && fstatvfs( fd, &stfs ) == -1) return FALSE; + if (fd == -1 && statvfs( dir, &stfs ) == -1) return FALSE; + /* Only assume CIOPFS is case insensitive. */ if (strcmp( stfs.f_fstypename, "fusefs" ) || strncmp( stfs.f_mntfromname, "ciopfs", 5 )) @@ -1170,7 +1198,9 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) char *cifile; /* Only assume CIOPFS is case insensitive. */ - if (statfs( dir, &stfs ) == -1) return FALSE; + if (fd != -1 && fstatfs( fd, &stfs ) == -1) return FALSE; + if (fd == -1 && statfs( dir, &stfs ) == -1) return FALSE; + if (stfs.f_type != 0x65735546 /* FUSE_SUPER_MAGIC */) return TRUE; /* Normally, we'd have to parse the mtab to find out exactly what @@ -1180,6 +1210,13 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) * This will break if somebody puts a file named ".ciopfs" in a non- * CIOPFS directory. */ + if (fd != -1) + { + if (fstatat( fd, ".ciopfs", &st, AT_NO_AUTOMOUNT ) == 0) + return FALSE; + return TRUE; + } + cifile = RtlAllocateHeap( GetProcessHeap(), 0, strlen( dir )+sizeof("/.ciopfs") ); if (!cifile) return TRUE; strcpy( cifile, dir ); @@ -1201,16 +1238,32 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) * get_dir_case_sensitivity * * Checks if the volume containing the specified directory is case - * sensitive or not. Uses statfs(2) or statvfs(2). + * sensitive or not. Uses multiple methods, depending on platform. */ static BOOLEAN get_dir_case_sensitivity( const char *dir ) { + int case_sensitive, fd = -1; + #if defined(HAVE_GETATTRLIST) && defined(ATTR_VOL_CAPABILITIES) && \ defined(VOL_CAPABILITIES_FORMAT) && defined(VOL_CAP_FMT_CASE_SENSITIVE) - int case_sensitive = get_dir_case_sensitivity_attr( dir ); + case_sensitive = get_dir_case_sensitivity_attr( dir ); if (case_sensitive != -1) return case_sensitive; #endif - return get_dir_case_sensitivity_stat( dir ); + +#ifdef EXT4_CASEFOLD_FL + if ((fd = open(dir, O_RDONLY | O_NONBLOCK | O_LARGEFILE)) == -1) + return TRUE; + if ((case_sensitive = get_dir_case_sensitivity_ioctl(fd)) != -1) + { + close(fd); + return case_sensitive; + } +#endif + + case_sensitive = get_dir_case_sensitivity_stat(dir, fd); + + if (fd != -1) close(fd); + return case_sensitive; } -- 2.21.0

3 5

[PATCH v3 3/3] dxgi: Return DXGI_STATUS_OCCLUDED for minimized window in d3d11_swapchain_Present.
by Zhiyi Zhang June 12, 2019

June 12, 2019

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/dxgi/swapchain.c | 3 +++ dlls/dxgi/tests/dxgi.c | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/dlls/dxgi/swapchain.c b/dlls/dxgi/swapchain.c index e09df4862d..179e61b233 100644 --- a/dlls/dxgi/swapchain.c +++ b/dlls/dxgi/swapchain.c @@ -306,6 +306,9 @@ static HRESULT d3d11_swapchain_present(struct d3d11_swapchain *swapchain, return DXGI_ERROR_INVALID_CALL; } + if (IsIconic(d3d11_swapchain_get_hwnd(swapchain))) + return DXGI_STATUS_OCCLUDED; + if (flags & ~DXGI_PRESENT_TEST) FIXME("Unimplemented flags %#x.\n", flags); if (flags & DXGI_PRESENT_TEST) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 3d6e7f99b2..207d7782d5 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -4072,7 +4072,7 @@ static void test_swapchain_present(IUnknown *device, BOOL is_d3d12) /* Minimized window */ ShowWindow(swapchain_desc.OutputWindow, SW_MINIMIZE); hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); - todo_wine_if(!is_d3d12) ok(hr == (is_d3d12 ? S_OK : DXGI_STATUS_OCCLUDED), "Got unexpected hr %#x.\n", hr); + ok(hr == (is_d3d12 ? S_OK : DXGI_STATUS_OCCLUDED), "Got unexpected hr %#x.\n", hr); ShowWindow(swapchain_desc.OutputWindow, SW_NORMAL); /* Hidden window */ -- 2.20.1

2 1

[PATCH v3 2/3] dxgi/tests: Add more IDXGISwapChain_Present tests.
by Zhiyi Zhang June 12, 2019

June 12, 2019

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/dxgi/tests/dxgi.c | 201 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 201 insertions(+) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index f8d987eacc..3d6e7f99b2 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -476,6 +476,25 @@ static void compute_expected_swapchain_fullscreen_state_after_fullscreen_change_ } } +#define wait_fullscreen_state(a, b, c) wait_fullscreen_state_(__LINE__, a, b, c) +static void wait_fullscreen_state_(INT line, IDXGISwapChain *swapchain, BOOL expected, BOOL todo) +{ + static const DWORD wait_timeout = 2000; + static const DWORD wait_step = 100; + DWORD total_time = 0; + BOOL got; + do + { + got = !expected; + IDXGISwapChain_GetFullscreenState(swapchain, &got, NULL); + if (got == expected) + break; + Sleep(wait_step); + total_time += wait_step; + } while (total_time < wait_timeout); + todo_wine_if(todo) ok_(__FILE__, line)(got == expected, "Expect %#x, got %#x.\n", expected, got); +} + static IDXGIAdapter *create_adapter(void) { IDXGIFactory4 *factory4; @@ -4002,9 +4021,12 @@ static void test_swapchain_parameters(void) static void test_swapchain_present(IUnknown *device, BOOL is_d3d12) { + static const DWORD flags[] = {0, DXGI_PRESENT_TEST}; DXGI_SWAP_CHAIN_DESC swapchain_desc; IDXGISwapChain *swapchain; IDXGIFactory *factory; + IDXGIOutput *output; + BOOL fullscreen; unsigned int i; ULONG refcount; HRESULT hr; @@ -4039,6 +4061,185 @@ static void test_swapchain_present(IUnknown *device, BOOL is_d3d12) hr = IDXGISwapChain_Present(swapchain, 0, 0); ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + for (i = 0; i < ARRAY_SIZE(flags); ++i) + { + HWND occluding_hwnd = CreateWindowA("static", "occluding_window", WS_POPUP | WS_VISIBLE, 0, 0, 400, 200, 0, 0, 0, 0); + + /* Another window covers the swapchain window, doesn't report as occluded */ + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + /* Minimized window */ + ShowWindow(swapchain_desc.OutputWindow, SW_MINIMIZE); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + todo_wine_if(!is_d3d12) ok(hr == (is_d3d12 ? S_OK : DXGI_STATUS_OCCLUDED), "Got unexpected hr %#x.\n", hr); + ShowWindow(swapchain_desc.OutputWindow, SW_NORMAL); + + /* Hidden window */ + ShowWindow(swapchain_desc.OutputWindow, SW_HIDE); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ShowWindow(swapchain_desc.OutputWindow, SW_SHOW); + DestroyWindow(occluding_hwnd); + + /* Test IDXGIOutput_ReleaseOwnership makes the swapchain exit fullscreen */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + /* DXGI_ERROR_NOT_CURRENTLY_AVAILABLE on some machines. DXGI_ERROR_UNSUPPORTED on Win 7 testbot. */ + if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE || broken(hr == DXGI_ERROR_UNSUPPORTED)) + { + skip("Could not change fullscreen state.\n"); + continue; + } + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + output = NULL; + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, &output); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + todo_wine_if(is_d3d12) ok(output != NULL, "Expect output not null.\n"); + + if (output) IDXGIOutput_ReleaseOwnership(output); + /* Still in fullscreen */ + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + /* Now calling IDXGISwapChain_Present will exit the fullscreen */ + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + /* Now fullscreen mode is exited */ + if (flags[i] == 0 && !is_d3d12) + { + /* Still on fullscreen on vista and 2008 */ + todo_wine ok(!fullscreen || broken(fullscreen), "Unexpected fullscreen status.\n"); + } + else + { + ok(fullscreen, "Unexpected fullscreen status.\n"); + } + if (output) + { + IDXGIOutput_Release(output); + } + + /* Test creating a window when swapchain is in fullscreen. + * The window should break the swapchain out of fullscreen mode on d3d10/11. + * d3d12 is different, new occluding window doesn't break swapchain out of fullscreen because d3d12 swapchain + * fullscreen mode doesn't take exclusive ownership over output, nor does it disable compositing. + * d3d12 fullscreen mode acts just like borderless fullscreen window mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + occluding_hwnd = CreateWindowA("static", "occluding_window", WS_POPUP, 0, 0, 400, 200, 0, 0, 0, 0); + /* Invisible window doesn't cause fullscreen mode to exit */ + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + /* Visible but with bottom z-order window still cause fullscreen mode to exit for d3d11 */ + SetWindowPos(occluding_hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); + ShowWindow(occluding_hwnd, SW_SHOW); + /* Fullscreen mode takes a while to exit */ + if (!is_d3d12) + { + wait_fullscreen_state(swapchain, FALSE, TRUE); + } + + /* No longer fullscreen before calling IDXGISwapChain_Present except for d3d12 */ + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(!is_d3d12) ok(is_d3d12 ? fullscreen : !fullscreen, "Unexpected fullscreen status.\n"); + + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + todo_wine_if(is_d3d12) ok(hr == (is_d3d12 ? DXGI_STATUS_OCCLUDED : S_OK), "Got unexpected hr %#x.\n", hr); + + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + if (flags[i] == DXGI_PRESENT_TEST) + { + todo_wine_if(!is_d3d12) ok(is_d3d12 ? fullscreen : !fullscreen, "Unexpected fullscreen status.\n"); + } + else + { + todo_wine ok(!fullscreen, "Unexpected fullscreen status.\n"); + } + + /* Even though d3d12 doesn't exit fullscreen, a IDXGISwapChain_ResizeBuffers is still needed for subsequent + * IDXGISwapChain_Present calls to work, otherwise they will return DXGI_ERROR_INVALID_CALL */ + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + if (flags[i] == DXGI_PRESENT_TEST) + { + todo_wine_if(is_d3d12) ok(hr == (is_d3d12 ? DXGI_STATUS_OCCLUDED : S_OK), "Got unexpected hr %#x.\n", hr); + } + else + { + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + } + + /* Trying break out of fullscreen mode again. This time, don't call IDXGISwapChain_GetFullscreenState before + * IDXGISwapChain_Present */ + ShowWindow(occluding_hwnd, SW_HIDE); + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ShowWindow(occluding_hwnd, SW_SHOW); + + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + /* hr == S_OK on vista and 2008 */ + todo_wine ok(hr == DXGI_STATUS_OCCLUDED || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr); + + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + if (flags[i] == DXGI_PRESENT_TEST) + { + todo_wine ok(hr == DXGI_STATUS_OCCLUDED || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr); + /* IDXGISwapChain_Present without flags refresh the occlusion state */ + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, 0); + todo_wine ok(hr == DXGI_STATUS_OCCLUDED || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, DXGI_PRESENT_TEST); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + } + else + { + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + } + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine ok(!fullscreen, "Unexpected fullscreen status.\n"); + + DestroyWindow(occluding_hwnd); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + } + wait_device_idle(device); IDXGISwapChain_Release(swapchain); -- 2.20.1

2 1

[PATCH v3 1/3] dxgi/tests: Add IDXGIOutput ownership tests.
by Zhiyi Zhang June 12, 2019

June 12, 2019

Mostly to show that IDXGIOutput_TakeOwnership and IDXGIOutput_ReleaseOwnership are based on VidPN ownership. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- v3: Mostly style changes. Supersede 166262~166264 dlls/dxgi/tests/dxgi.c | 222 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 221 insertions(+), 1 deletion(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 79e4bc0c15..f8d987eacc 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -17,11 +17,15 @@ */ #include <assert.h> +#include "ntstatus.h" +#define WIN32_NO_STATUS #define COBJMACROS #include "initguid.h" #include "dxgi1_6.h" #include "d3d11.h" #include "d3d12.h" +#include "winternl.h" +#include "ddk/d3dkmthk.h" #include "wine/heap.h" #include "wine/test.h" @@ -36,6 +40,10 @@ static DEVMODEW registry_mode; static HRESULT (WINAPI *pCreateDXGIFactory1)(REFIID iid, void **factory); static HRESULT (WINAPI *pCreateDXGIFactory2)(UINT flags, REFIID iid, void **factory); +static NTSTATUS (WINAPI *pD3DKMTCheckVidPnExclusiveOwnership)(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *); +static NTSTATUS (WINAPI *pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *); +static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromGdiDisplayName)(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *); + static PFN_D3D12_CREATE_DEVICE pD3D12CreateDevice; static PFN_D3D12_GET_DEBUG_INTERFACE pD3D12GetDebugInterface; @@ -658,6 +666,37 @@ static void get_factory_(unsigned int line, IUnknown *device, BOOL is_d3d12, IDX } } +#define get_adapter(a, b) get_adapter_(__LINE__, a, b) +static IDXGIAdapter* get_adapter_(unsigned int line, IUnknown *device, BOOL is_d3d12) +{ + IDXGIAdapter *adapter = NULL; + ID3D12Device *d3d12_device; + IDXGIFactory4 *factory4; + IDXGIFactory *factory; + LUID luid; + HRESULT hr; + + if (is_d3d12) + { + get_factory(device, is_d3d12, &factory); + hr = ID3D12CommandQueue_GetDevice((ID3D12CommandQueue *)device, &IID_ID3D12Device, (void **)&d3d12_device); + ok_(__FILE__, line)(hr == S_OK, "Got unexpected hr %#x.\n", hr); + luid = ID3D12Device_GetAdapterLuid(d3d12_device); + ID3D12Device_Release(d3d12_device); + hr = IDXGIFactory_QueryInterface(factory, &IID_IDXGIFactory4, (void **)&factory4); + ok_(__FILE__, line)(hr == S_OK, "Got unexpected hr %#x.\n", hr); + IDXGIFactory4_EnumAdapterByLuid(factory4, luid, &IID_IDXGIAdapter, (void **)&adapter); + IDXGIFactory4_Release(factory4); + IDXGIFactory_Release(factory); + } + else + { + IDXGIDevice_GetAdapter((IDXGIDevice *)device, &adapter); + } + + return adapter; +} + static void test_adapter_desc(void) { DXGI_ADAPTER_DESC1 desc1; @@ -4985,6 +5024,180 @@ done: ok(!refcount, "Factory has %u references left.\n", refcount); } +/* D3DKMTCheckVidPnExclusiveOwnership returns different result if called too early */ +#define wait_vidpn_exclusive_ownership(a, b, c) wait_vidpn_exclusive_ownership_(__LINE__, a, b, c) +static void wait_vidpn_exclusive_ownership_(INT line, const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *arg, NTSTATUS expected, + BOOL todo) +{ + static const DWORD wait_timeout = 2000; + static const DWORD wait_step = 100; + DWORD total_time = 0; + NTSTATUS got; + do + { + got = pD3DKMTCheckVidPnExclusiveOwnership(arg); + if (got == expected) + break; + Sleep(wait_step); + total_time += wait_step; + } while (total_time < wait_timeout); + todo_wine_if(todo) ok_(__FILE__, line)(got == expected, "Expect %#x, got %#x.\n", expected, got); +} + +static void test_output_ownership(IUnknown *device, BOOL is_d3d12) +{ + D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME open_adapter_gdi_desc; + D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP check_ownership_desc; + D3DKMT_CLOSEADAPTER close_adapter_desc; + DXGI_SWAP_CHAIN_DESC swapchain_desc; + DXGI_OUTPUT_DESC output_desc; + IDXGISwapChain *swapchain; + IDXGIFactory *factory; + IDXGIAdapter *adapter; + IDXGIOutput *output; + BOOL fullscreen; + NTSTATUS status; + ULONG refcount; + HRESULT hr; + + if (!pD3DKMTCheckVidPnExclusiveOwnership || pD3DKMTCheckVidPnExclusiveOwnership(NULL) == STATUS_PROCEDURE_NOT_FOUND) + { + skip("D3DKMTCheckVidPnExclusiveOwnership() is unavailable.\n"); + return; + } + + get_factory(device, is_d3d12, &factory); + adapter = get_adapter(device, is_d3d12); + if (!adapter) + { + skip("Failed to get adapter.\n"); + return; + } + + hr = IDXGIAdapter_EnumOutputs(adapter, 0, &output); + IDXGIAdapter_Release(adapter); + if (hr == DXGI_ERROR_NOT_FOUND) + { + skip("Adapter doesn't have any outputs.\n"); + IDXGIFactory_Release(factory); + return; + } + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDXGIOutput_GetDesc(output, &output_desc); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + lstrcpyW(open_adapter_gdi_desc.DeviceName, output_desc.DeviceName); + status = pD3DKMTOpenAdapterFromGdiDisplayName(&open_adapter_gdi_desc); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); + + check_ownership_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + check_ownership_desc.VidPnSourceId = open_adapter_gdi_desc.VidPnSourceId; + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_SUCCESS, FALSE); + + swapchain_desc.BufferDesc.Width = 800; + swapchain_desc.BufferDesc.Height = 600; + swapchain_desc.BufferDesc.RefreshRate.Numerator = 60; + swapchain_desc.BufferDesc.RefreshRate.Denominator = 60; + swapchain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapchain_desc.SampleDesc.Count = 1; + swapchain_desc.SampleDesc.Quality = 0; + swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapchain_desc.BufferCount = is_d3d12 ? 2 : 1; + swapchain_desc.OutputWindow = CreateWindowA("static", "dxgi_test", 0, 0, 0, 400, 200, 0, 0, 0, 0); + swapchain_desc.Windowed = TRUE; + swapchain_desc.SwapEffect = is_d3d12 ? DXGI_SWAP_EFFECT_FLIP_DISCARD : DXGI_SWAP_EFFECT_DISCARD; + swapchain_desc.Flags = 0; + + hr = IDXGIFactory_CreateSwapChain(factory, device, &swapchain_desc, &swapchain); + ok(hr == S_OK, "Failed to create swapchain, hr %#x.\n", hr); + + /* Swapchain in fullscreen mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, output); + /* DXGI_ERROR_NOT_CURRENTLY_AVAILABLE on some machines. DXGI_ERROR_UNSUPPORTED on Win 7 testbot. */ + if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE || broken(hr == DXGI_ERROR_UNSUPPORTED)) + { + skip("Failed to change fullscreen state.\n"); + goto done; + } + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen state.\n"); + if (is_d3d12) + { + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_SUCCESS, FALSE); + } + else + { + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_GRAPHICS_PRESENT_OCCLUDED, TRUE); + } + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : E_INVALIDARG), "Got unexpected hr %#x.\n", hr); + hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : S_OK), "Got unexpected hr %#x.\n", hr); + /* Calling IDXGIOutput_ReleaseOwnership makes it unoccluded. So we can be confident about IDXGIOutput_TakeOwnership + * was called in IDXGISwapChain_SetFullscreenState */ + IDXGIOutput_ReleaseOwnership(output); + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_SUCCESS, FALSE); + + /* IDXGIOutput_TakeOwnership always return E_NOINTERFACE for d3d12. Tests finished */ + if (is_d3d12) + { + goto done; + } + + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE, "Got unexpected hr %#x.\n", hr); + IDXGIOutput_ReleaseOwnership(output); + + hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + /* The following results shows that IDXGIOutput_TakeOwnership(output, device, TRUE) is used in + * SetFullscreenState(swapchain, TRUE, NULL). This make me believe the MSDN documentation is saying the opposite + * about the last parameter 'exclusive'. It should be D3DKMTSetVidPnSourceOwner(D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE) + * when it's TRUE and D3DKMTSetVidPnSourceOwner(D3DKMT_VIDPNSOURCEOWNER_SHARED) when it's FALSE according to tests */ + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_GRAPHICS_PRESENT_OCCLUDED, TRUE); + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + IDXGIOutput_ReleaseOwnership(output); + + /* Swapchain in windowed mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ok(!fullscreen, "Unexpected fullscreen state.\n"); + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_SUCCESS, FALSE); + + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE, "Got unexpected hr %#x.\n", hr); + + hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_GRAPHICS_PRESENT_OCCLUDED, TRUE); + IDXGIOutput_ReleaseOwnership(output); + wait_vidpn_exclusive_ownership(&check_ownership_desc, STATUS_SUCCESS, FALSE); + +done: + IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + wait_device_idle(device); + + IDXGIOutput_Release(output); + IDXGISwapChain_Release(swapchain); + DestroyWindow(swapchain_desc.OutputWindow); + refcount = IDXGIFactory_Release(factory); + ok(refcount == !is_d3d12, "Got unexpected refcount %u.\n", refcount); + + close_adapter_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); +} + static void run_on_d3d10(void (*test_func)(IUnknown *device, BOOL is_d3d12)) { IDXGIDevice *device; @@ -5028,7 +5241,7 @@ static void run_on_d3d12(void (*test_func)(IUnknown *device, BOOL is_d3d12)) START_TEST(dxgi) { - HMODULE dxgi_module, d3d12_module; + HMODULE dxgi_module, d3d12_module, gdi32_module; BOOL enable_debug_layer = FALSE; unsigned int argc, i; ID3D12Debug *debug; @@ -5038,6 +5251,11 @@ START_TEST(dxgi) pCreateDXGIFactory1 = (void *)GetProcAddress(dxgi_module, "CreateDXGIFactory1"); pCreateDXGIFactory2 = (void *)GetProcAddress(dxgi_module, "CreateDXGIFactory2"); + gdi32_module = GetModuleHandleA("gdi32.dll"); + pD3DKMTCheckVidPnExclusiveOwnership = (void *)GetProcAddress(gdi32_module, "D3DKMTCheckVidPnExclusiveOwnership"); + pD3DKMTCloseAdapter = (void *)GetProcAddress(gdi32_module, "D3DKMTCloseAdapter"); + pD3DKMTOpenAdapterFromGdiDisplayName = (void *)GetProcAddress(gdi32_module, "D3DKMTOpenAdapterFromGdiDisplayName"); + registry_mode.dmSize = sizeof(registry_mode); ok(EnumDisplaySettingsW(NULL, ENUM_REGISTRY_SETTINGS, &registry_mode), "Failed to get display mode.\n"); @@ -5088,6 +5306,7 @@ START_TEST(dxgi) run_on_d3d10(test_swapchain_present); run_on_d3d10(test_swapchain_backbuffer_index); run_on_d3d10(test_swapchain_formats); + run_on_d3d10(test_output_ownership); if (!(d3d12_module = LoadLibraryA("d3d12.dll"))) { @@ -5108,6 +5327,7 @@ START_TEST(dxgi) run_on_d3d12(test_swapchain_present); run_on_d3d12(test_swapchain_backbuffer_index); run_on_d3d12(test_swapchain_formats); + run_on_d3d12(test_output_ownership); FreeLibrary(d3d12_module); } -- 2.20.1

2 1

Experimenting with wine-pba
by Gabriel Ivăncescu June 12, 2019

June 12, 2019

Hi all, Anyone have any experience with the wine-pba patchset? (Persistent Buffer Allocator) The one I know of hasn't been rebased for a long time and so won't apply on current wine, although I see Lutris does make use of it, but not sure if only on older wine versions. Is there some way to get it compiled into current wine so I can test it out? (or perhaps into wine-staging, if it requires that). If not, what's the last wine / wine-staging version that supported it? I'm interested in comparing the performance between it and DXVK on some games I'm testing, especially those where DXVK seems to provide almost no benefit (or sometimes even worse performance!) over wined3d, which is a bit odd. I've seen numerous claims that wine-pba provides even greater performance than DXVK on certain titles, so I'm curious. At this point, it might also be something on my end regarding Vulkan and why DXVK doesn't really shine. If PBA gives a large performance gain, then it would be interesting to see why DXVK is so slow (otherwise it could just be the game itself that's the problem). Overall I think it would be nice to experiment with it. Thanks, Gabriel

7 10

[PATCH v11 1/2] ntdll: Clarify NtAllocateVirtualMemory zero_bits parameter semantics
by Rémi Bernon June 12, 2019

June 12, 2019

This parameter was misinterpreted as an alignment parameter for the lower bits of the allocated memory region, although it is a constraint on the higher bits. Add a new internal ntdll virtual_alloc_aligned function that has a separate alignment parameter which is now used instead of the zero_bits parameter. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/ntdll/directory.c | 4 ++-- dlls/ntdll/heap.c | 5 ++--- dlls/ntdll/ntdll_misc.h | 2 ++ dlls/ntdll/signal_arm.c | 12 ++++++------ dlls/ntdll/signal_arm64.c | 16 ++++++++-------- dlls/ntdll/signal_i386.c | 16 ++++++++-------- dlls/ntdll/signal_powerpc.c | 12 ++++++------ dlls/ntdll/signal_x86_64.c | 16 ++++++++-------- dlls/ntdll/tests/virtual.c | 4 +--- dlls/ntdll/thread.c | 3 +-- dlls/ntdll/virtual.c | 37 ++++++++++++++++++++++++++++++------- 11 files changed, 74 insertions(+), 53 deletions(-) diff --git a/dlls/ntdll/directory.c b/dlls/ntdll/directory.c index bbdbbe9781f..6605999b824 100644 --- a/dlls/ntdll/directory.c +++ b/dlls/ntdll/directory.c @@ -1603,14 +1603,14 @@ static KERNEL_DIRENT *start_vfat_ioctl( int fd ) SIZE_T size = 2 * sizeof(*de) + page_size; void *addr = NULL; - if (NtAllocateVirtualMemory( GetCurrentProcess(), &addr, 1, &size, MEM_RESERVE, PAGE_READWRITE )) + if (virtual_alloc_aligned( &addr, 0, &size, MEM_RESERVE, PAGE_READWRITE, 1 )) return NULL; /* commit only the size needed for the dir entries */ /* this leaves an extra unaccessible page, which should make the kernel */ /* fail with -EFAULT before it stomps all over our memory */ de = addr; size = 2 * sizeof(*de); - NtAllocateVirtualMemory( GetCurrentProcess(), &addr, 1, &size, MEM_COMMIT, PAGE_READWRITE ); + virtual_alloc_aligned( &addr, 0, &size, MEM_COMMIT, PAGE_READWRITE, 1 ); } /* set d_reclen to 65535 to work around an AFS kernel bug */ diff --git a/dlls/ntdll/heap.c b/dlls/ntdll/heap.c index cccaaee1d45..2d2caf551e3 100644 --- a/dlls/ntdll/heap.c +++ b/dlls/ntdll/heap.c @@ -726,8 +726,7 @@ static void *allocate_large_block( HEAP *heap, DWORD flags, SIZE_T size ) LPVOID address = NULL; if (block_size < size) return NULL; /* overflow */ - if (NtAllocateVirtualMemory( NtCurrentProcess(), &address, 5, - &block_size, MEM_COMMIT, get_protection_type( flags ) )) + if (virtual_alloc_aligned( &address, 0, &block_size, MEM_COMMIT, get_protection_type( flags ), 5 )) { WARN("Could not allocate block for %08lx bytes\n", size ); return NULL; @@ -1521,7 +1520,7 @@ void heap_set_debug_flags( HANDLE handle ) void *ptr = NULL; SIZE_T size = MAX_FREE_PENDING * sizeof(*heap->pending_free); - if (!NtAllocateVirtualMemory( NtCurrentProcess(), &ptr, 4, &size, MEM_COMMIT, PAGE_READWRITE )) + if (!virtual_alloc_aligned( &ptr, 0, &size, MEM_COMMIT, PAGE_READWRITE, 4 )) { heap->pending_free = ptr; heap->pending_pos = 0; diff --git a/dlls/ntdll/ntdll_misc.h b/dlls/ntdll/ntdll_misc.h index 3463ebd38ad..f371a0ab42d 100644 --- a/dlls/ntdll/ntdll_misc.h +++ b/dlls/ntdll/ntdll_misc.h @@ -168,6 +168,8 @@ extern NTSTATUS nt_to_unix_file_name_attr( const OBJECT_ATTRIBUTES *attr, ANSI_S UINT disposition ) DECLSPEC_HIDDEN; /* virtual memory */ +extern NTSTATUS virtual_alloc_aligned( PVOID *ret, ULONG zero_bits, SIZE_T *size_ptr, + ULONG type, ULONG protect, ULONG alignment ); extern NTSTATUS virtual_map_section( HANDLE handle, PVOID *addr_ptr, ULONG zero_bits, SIZE_T commit_size, const LARGE_INTEGER *offset_ptr, SIZE_T *size_ptr, ULONG protect, pe_image_info_t *image_info ) DECLSPEC_HIDDEN; diff --git a/dlls/ntdll/signal_arm.c b/dlls/ntdll/signal_arm.c index e01c8ce2193..cf7f2d13160 100644 --- a/dlls/ntdll/signal_arm.c +++ b/dlls/ntdll/signal_arm.c @@ -967,22 +967,22 @@ int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh) */ NTSTATUS signal_alloc_thread( TEB **teb ) { - static size_t sigstack_zero_bits; + static size_t sigstack_alignment; SIZE_T size; NTSTATUS status; - if (!sigstack_zero_bits) + if (!sigstack_alignment) { size_t min_size = page_size; /* find the first power of two not smaller than min_size */ - while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++; + while ((1u << sigstack_alignment) < min_size) sigstack_alignment++; assert( sizeof(TEB) <= min_size ); } - size = 1 << sigstack_zero_bits; + size = 1 << sigstack_alignment; *teb = NULL; - if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits, - &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE ))) + if (!(status = virtual_alloc_aligned( (void **)teb, 0, &size, MEM_COMMIT | MEM_TOP_DOWN, + PAGE_READWRITE, sigstack_alignment ))) { (*teb)->Tib.Self = &(*teb)->Tib; (*teb)->Tib.ExceptionList = (void *)~0UL; diff --git a/dlls/ntdll/signal_arm64.c b/dlls/ntdll/signal_arm64.c index 94520c95ced..d2d43b34bc1 100644 --- a/dlls/ntdll/signal_arm64.c +++ b/dlls/ntdll/signal_arm64.c @@ -871,24 +871,24 @@ int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh) */ NTSTATUS signal_alloc_thread( TEB **teb ) { - static size_t sigstack_zero_bits; + static size_t sigstack_alignment; SIZE_T size; NTSTATUS status; - if (!sigstack_zero_bits) + if (!sigstack_alignment) { size_t min_size = teb_size + max( MINSIGSTKSZ, 8192 ); /* find the first power of two not smaller than min_size */ - sigstack_zero_bits = 12; - while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++; - signal_stack_size = (1 << sigstack_zero_bits) - teb_size; + sigstack_alignment = 12; + while ((1u << sigstack_alignment) < min_size) sigstack_alignment++; + signal_stack_size = (1 << sigstack_alignment) - teb_size; assert( sizeof(TEB) <= teb_size ); } - size = 1 << sigstack_zero_bits; + size = 1 << sigstack_alignment; *teb = NULL; - if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits, - &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE ))) + if (!(status = virtual_alloc_aligned( (void **)teb, 0, &size, MEM_COMMIT | MEM_TOP_DOWN, + PAGE_READWRITE, sigstack_alignment ))) { (*teb)->Tib.Self = &(*teb)->Tib; (*teb)->Tib.ExceptionList = (void *)~0UL; diff --git a/dlls/ntdll/signal_i386.c b/dlls/ntdll/signal_i386.c index b4e88d125f1..b2925062bf7 100644 --- a/dlls/ntdll/signal_i386.c +++ b/dlls/ntdll/signal_i386.c @@ -2312,25 +2312,25 @@ static void ldt_unlock(void) */ NTSTATUS signal_alloc_thread( TEB **teb ) { - static size_t sigstack_zero_bits; + static size_t sigstack_alignment; struct x86_thread_data *thread_data; SIZE_T size; void *addr = NULL; NTSTATUS status; - if (!sigstack_zero_bits) + if (!sigstack_alignment) { size_t min_size = teb_size + max( MINSIGSTKSZ, 8192 ); /* find the first power of two not smaller than min_size */ - sigstack_zero_bits = 12; - while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++; - signal_stack_mask = (1 << sigstack_zero_bits) - 1; - signal_stack_size = (1 << sigstack_zero_bits) - teb_size; + sigstack_alignment = 12; + while ((1u << sigstack_alignment) < min_size) sigstack_alignment++; + signal_stack_mask = (1 << sigstack_alignment) - 1; + signal_stack_size = (1 << sigstack_alignment) - teb_size; } size = signal_stack_mask + 1; - if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), &addr, sigstack_zero_bits, - &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE ))) + if (!(status = virtual_alloc_aligned( &addr, 0, &size, MEM_COMMIT | MEM_TOP_DOWN, + PAGE_READWRITE, sigstack_alignment ))) { *teb = addr; (*teb)->Tib.Self = &(*teb)->Tib; diff --git a/dlls/ntdll/signal_powerpc.c b/dlls/ntdll/signal_powerpc.c index 86398d8f54f..f23265445df 100644 --- a/dlls/ntdll/signal_powerpc.c +++ b/dlls/ntdll/signal_powerpc.c @@ -1018,22 +1018,22 @@ int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh) */ NTSTATUS signal_alloc_thread( TEB **teb ) { - static size_t sigstack_zero_bits; + static size_t sigstack_alignment; SIZE_T size; NTSTATUS status; - if (!sigstack_zero_bits) + if (!sigstack_alignment) { size_t min_size = page_size; /* this is just for the TEB, we don't use a signal stack yet */ /* find the first power of two not smaller than min_size */ - while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++; + while ((1u << sigstack_alignment) < min_size) sigstack_alignment++; assert( sizeof(TEB) <= min_size ); } - size = 1 << sigstack_zero_bits; + size = 1 << sigstack_alignment; *teb = NULL; - if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits, - &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE ))) + if (!(status = virtual_alloc_aligned( (void **)teb, 0, &size, MEM_COMMIT | MEM_TOP_DOWN, + PAGE_READWRITE, sigstack_alignment ))) { (*teb)->Tib.Self = &(*teb)->Tib; (*teb)->Tib.ExceptionList = (void *)~0UL; diff --git a/dlls/ntdll/signal_x86_64.c b/dlls/ntdll/signal_x86_64.c index 2633b988b62..b024de76421 100644 --- a/dlls/ntdll/signal_x86_64.c +++ b/dlls/ntdll/signal_x86_64.c @@ -3263,24 +3263,24 @@ int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh) */ NTSTATUS signal_alloc_thread( TEB **teb ) { - static size_t sigstack_zero_bits; + static size_t sigstack_alignment; SIZE_T size; NTSTATUS status; - if (!sigstack_zero_bits) + if (!sigstack_alignment) { size_t min_size = teb_size + max( MINSIGSTKSZ, 8192 ); /* find the first power of two not smaller than min_size */ - sigstack_zero_bits = 12; - while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++; - signal_stack_size = (1 << sigstack_zero_bits) - teb_size; + sigstack_alignment = 12; + while ((1u << sigstack_alignment) < min_size) sigstack_alignment++; + signal_stack_size = (1 << sigstack_alignment) - teb_size; assert( sizeof(TEB) <= teb_size ); } - size = 1 << sigstack_zero_bits; + size = 1 << sigstack_alignment; *teb = NULL; - if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits, - &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE ))) + if (!(status = virtual_alloc_aligned( (void **)teb, 0, &size, MEM_COMMIT | MEM_TOP_DOWN, + PAGE_READWRITE, sigstack_alignment ))) { (*teb)->Tib.Self = &(*teb)->Tib; (*teb)->Tib.ExceptionList = (void *)~0UL; diff --git a/dlls/ntdll/tests/virtual.c b/dlls/ntdll/tests/virtual.c index 195a54704fb..ff10508a604 100644 --- a/dlls/ntdll/tests/virtual.c +++ b/dlls/ntdll/tests/virtual.c @@ -55,7 +55,6 @@ static void test_AllocateVirtualMemory(void) addr2 = (char *)addr1 + 0x1000; status = NtAllocateVirtualMemory(NtCurrentProcess(), &addr2, 12, &size, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE); - todo_wine ok(status == STATUS_CONFLICTING_ADDRESSES, "NtAllocateVirtualMemory returned %08x\n", status); if (status == STATUS_SUCCESS) { @@ -141,12 +140,11 @@ static void test_AllocateVirtualMemory(void) } else { - todo_wine ok(status == STATUS_SUCCESS || status == STATUS_NO_MEMORY, "NtAllocateVirtualMemory returned %08x\n", status); if (status == STATUS_SUCCESS) { - todo_wine + todo_wine_if((UINT_PTR)addr2 & ~zero_bits) ok(((UINT_PTR)addr2 & ~zero_bits) == 0, "NtAllocateVirtualMemory returned address %p\n", addr2); diff --git a/dlls/ntdll/thread.c b/dlls/ntdll/thread.c index 46de839400d..96aa6be7f2c 100644 --- a/dlls/ntdll/thread.c +++ b/dlls/ntdll/thread.c @@ -184,8 +184,7 @@ void thread_init(void) addr = NULL; size = sizeof(*peb); - NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 1, &size, - MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE ); + virtual_alloc_aligned( &addr, 0, &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE, 1 ); peb = addr; peb->FastPebLock = &peb_lock; diff --git a/dlls/ntdll/virtual.c b/dlls/ntdll/virtual.c index 78973a8cda4..20512d41835 100644 --- a/dlls/ntdll/virtual.c +++ b/dlls/ntdll/virtual.c @@ -2461,19 +2461,16 @@ void virtual_set_large_address_space(void) NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, ULONG zero_bits, SIZE_T *size_ptr, ULONG type, ULONG protect ) { - void *base; - unsigned int vprot; SIZE_T size = *size_ptr; - SIZE_T mask = get_mask( zero_bits ); NTSTATUS status = STATUS_SUCCESS; - BOOL is_dos_memory = FALSE; - struct file_view *view; - sigset_t sigset; TRACE("%p %p %08lx %x %08x\n", process, *ret, size, type, protect ); if (!size) return STATUS_INVALID_PARAMETER; - if (!mask) return STATUS_INVALID_PARAMETER_3; + if (zero_bits > 21 && zero_bits < 32) return STATUS_INVALID_PARAMETER_3; +#ifndef _WIN64 + if (!is_wow64 && zero_bits >= 32) return STATUS_INVALID_PARAMETER_3; +#endif if (process != NtCurrentProcess()) { @@ -2499,6 +2496,32 @@ NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, ULONG zero_ return result.virtual_alloc.status; } + return virtual_alloc_aligned( ret, zero_bits, size_ptr, type, protect, 0 ); +} + + +/*********************************************************************** + * virtual_alloc_aligned (NTDLL.@) + * + * Same as NtAllocateVirtualMemory but with an alignment parameter + */ +NTSTATUS virtual_alloc_aligned( PVOID *ret, ULONG zero_bits, SIZE_T *size_ptr, + ULONG type, ULONG protect, ULONG alignment ) +{ + void *base; + unsigned int vprot; + SIZE_T size = *size_ptr; + SIZE_T mask = get_mask( alignment ); + NTSTATUS status = STATUS_SUCCESS; + BOOL is_dos_memory = FALSE; + struct file_view *view; + sigset_t sigset; + + if (zero_bits) + { + FIXME("Unimplemented zero_bits parameter value\n"); + } + /* Round parameters to a page boundary */ if (is_beyond_limit( 0, size, working_set_limit )) return STATUS_WORKING_SET_LIMIT_RANGE; -- 2.20.1

2 4