- Wine-Devel - list.winehq.org

[PATCH 6/7] wineoss: Implement Wow64 midi entry points in the Unix library.
by Huw Davies May 4, 2022

May 4, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/oss.c | 6 +- dlls/wineoss.drv/ossmidi.c | 354 +++++++++++++++++++++++++++++++++++++ dlls/wineoss.drv/unixlib.h | 6 + 3 files changed, 363 insertions(+), 3 deletions(-) diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 9f2cba68f86..0c9fef90d58 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -1987,9 +1987,9 @@ unixlib_entry_t __wine_unix_call_wow64_funcs[] = wow64_set_event_handle, is_started, midi_release, - midi_out_message, - midi_in_message, - midi_notify_wait, + wow64_midi_out_message, + wow64_midi_in_message, + wow64_midi_notify_wait, aux_message, }; diff --git a/dlls/wineoss.drv/ossmidi.c b/dlls/wineoss.drv/ossmidi.c index 6677609a5a6..09eed8085c4 100644 --- a/dlls/wineoss.drv/ossmidi.c +++ b/dlls/wineoss.drv/ossmidi.c @@ -1771,3 +1771,357 @@ NTSTATUS midi_notify_wait(void *args) return STATUS_SUCCESS; } + +#ifdef _WIN64 + +typedef UINT PTR32; + +struct notify_context32 +{ + BOOL send_notify; + WORD dev_id; + WORD msg; + UINT param_1; + UINT param_2; + UINT callback; + UINT flags; + PTR32 device; + UINT instance; +}; + +static void notify_to_notify32(struct notify_context32 *notify32, + const struct notify_context *notify) +{ + notify32->send_notify = notify->send_notify; + notify32->dev_id = notify->dev_id; + notify32->msg = notify->msg; + notify32->param_1 = notify->param_1; + notify32->param_2 = notify->param_2; + notify32->callback = notify->callback; + notify32->flags = notify->flags; + notify32->device = PtrToUlong(notify->device); + notify32->instance = notify->instance; +} + +struct midi_open_desc32 +{ + PTR32 hMidi; + UINT dwCallback; + UINT dwInstance; + UINT dnDevNode; + UINT cIds; + MIDIOPENSTRMID rgIds; +}; + +struct midi_hdr32 +{ + PTR32 lpData; + UINT dwBufferLength; + UINT dwBytesRecorded; + UINT dwUser; + UINT dwFlags; + PTR32 lpNext; + UINT reserved; + UINT dwOffset; + UINT dwReserved[8]; +}; + +static UINT wow64_midi_out_prepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (hdr->dwFlags & MHDR_PREPARED) + return MMSYSERR_NOERROR; + + hdr->lpNext = 0; + hdr->dwFlags |= MHDR_PREPARED; + hdr->dwFlags &= ~(MHDR_DONE | MHDR_INQUEUE); + return MMSYSERR_NOERROR; +} + +static UINT wow64_midi_out_unprepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (!(hdr->dwFlags & MHDR_PREPARED)) + return MMSYSERR_NOERROR; + if (hdr->dwFlags & MHDR_INQUEUE) + return MIDIERR_STILLPLAYING; + + hdr->dwFlags &= ~MHDR_PREPARED; + return MMSYSERR_NOERROR; +} + +NTSTATUS wow64_midi_out_message(void *args) +{ + struct + { + UINT dev_id; + UINT msg; + UINT user; + UINT param_1; + UINT param_2; + PTR32 err; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_open_desc32 *desc32; + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIOPENDESC open_desc; + MIDIHDR hdr; + struct midi_out_message_params params = + { + .dev_id = params32->dev_id, + .msg = params32->msg, + .user = params32->user, + .param_1 = params32->param_1, + .param_2 = params32->param_2, + .err = ULongToPtr(params32->err), + .notify = &notify + }; + notify32->send_notify = FALSE; + + switch (params32->msg) + { + case MODM_OPEN: + desc32 = ULongToPtr(params32->param_1); + + open_desc.hMidi = ULongToPtr(desc32->hMidi); + open_desc.dwCallback = desc32->dwCallback; + open_desc.dwInstance = desc32->dwInstance; + open_desc.dnDevNode = desc32->dnDevNode; + open_desc.cIds = desc32->cIds; + open_desc.rgIds.dwStreamID = desc32->rgIds.dwStreamID; + open_desc.rgIds.wDeviceID = desc32->rgIds.wDeviceID; + + params.param_1 = (UINT_PTR)&open_desc; + break; + + case MODM_LONGDATA: + hdr32 = ULongToPtr(params32->param_1); + + memset(&hdr, 0, sizeof(hdr)); + hdr.lpData = ULongToPtr(hdr32->lpData); + hdr.dwBufferLength = hdr32->dwBufferLength; + hdr.dwFlags = hdr32->dwFlags; + + params.param_1 = (UINT_PTR)&hdr; + params.param_2 = sizeof(hdr); + break; + + case MODM_PREPARE: /* prepare and unprepare are easier to handle explicitly */ + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_out_prepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + + case MODM_UNPREPARE: + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_out_unprepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + } + + midi_out_message(&params); + + switch (params32->msg) + { + case MODM_LONGDATA: + hdr32 = ULongToPtr(params32->param_1); + + hdr32->dwFlags = hdr.dwFlags; + break; + } + + if (notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MOM_DONE) + notify32->param_1 = params32->param_1; /* restore the 32-bit hdr */ + } + return STATUS_SUCCESS; +} + +static UINT wow64_midi_in_prepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (hdr->dwFlags & MHDR_PREPARED) + return MMSYSERR_NOERROR; + + hdr->lpNext = 0; + hdr->dwFlags |= MHDR_PREPARED; + hdr->dwFlags &= ~(MHDR_DONE | MHDR_INQUEUE); + + return MMSYSERR_NOERROR; +} + +static UINT wow64_midi_in_unprepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (!(hdr->dwFlags & MHDR_PREPARED)) + return MMSYSERR_NOERROR; + if (hdr->dwFlags & MHDR_INQUEUE) + return MIDIERR_STILLPLAYING; + + hdr->dwFlags &= ~MHDR_PREPARED; + + return MMSYSERR_NOERROR; +} + +NTSTATUS wow64_midi_in_message(void *args) +{ + struct + { + UINT dev_id; + UINT msg; + UINT user; + UINT param_1; + UINT param_2; + PTR32 err; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_open_desc32 *desc32; + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIOPENDESC open_desc; + MIDIHDR *hdr = NULL; + struct midi_in_message_params params = + { + .dev_id = params32->dev_id, + .msg = params32->msg, + .user = params32->user, + .param_1 = params32->param_1, + .param_2 = params32->param_2, + .err = ULongToPtr(params32->err), + .notify = &notify + }; + notify32->send_notify = FALSE; + + switch (params32->msg) + { + case MIDM_OPEN: + desc32 = ULongToPtr(params32->param_1); + + open_desc.hMidi = ULongToPtr(desc32->hMidi); + open_desc.dwCallback = desc32->dwCallback; + open_desc.dwInstance = desc32->dwInstance; + open_desc.dnDevNode = desc32->dnDevNode; + open_desc.cIds = desc32->cIds; + open_desc.rgIds.dwStreamID = desc32->rgIds.dwStreamID; + open_desc.rgIds.wDeviceID = desc32->rgIds.wDeviceID; + + params.param_1 = (UINT_PTR)&open_desc; + break; + + case MIDM_ADDBUFFER: + hdr32 = ULongToPtr(params32->param_1); + + hdr = calloc(1, sizeof(*hdr)); + hdr->lpData = ULongToPtr(hdr32->lpData); + hdr->dwBufferLength = hdr32->dwBufferLength; + hdr->dwFlags = hdr32->dwFlags; + hdr->dwReserved[7] = params32->param_1; /* keep hdr32 for MIM_LONGDATA notification */ + + params.param_1 = (UINT_PTR)hdr; + params.param_2 = sizeof(*hdr); + break; + + case MIDM_PREPARE: /* prepare and unprepare are easier to handle explicitly */ + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_in_prepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + + case MIDM_UNPREPARE: + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_in_unprepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + } + + midi_in_message(&params); + + switch (params32->msg) + { + case MIDM_ADDBUFFER: + hdr32 = ULongToPtr(params32->param_1); + + if (!*params.err) + { + hdr32->dwFlags = hdr->dwFlags; + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->lpNext = 0; + } + else + free(hdr); + break; + } + + if (notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MIM_LONGDATA) + { + hdr = (MIDIHDR *)notify.param_1; + notify32->param_1 = hdr->dwReserved[7]; + hdr32 = ULongToPtr(notify32->param_1); + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->dwFlags = hdr->dwFlags; + free(hdr); + } + } + return STATUS_SUCCESS; +} + +NTSTATUS wow64_midi_notify_wait(void *args) +{ + struct + { + PTR32 quit; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIHDR *hdr; + struct midi_notify_wait_params params = + { + .quit = ULongToPtr(params32->quit), + .notify = &notify + }; + notify32->send_notify = FALSE; + + midi_notify_wait(&params); + + if (!*params.quit && notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MIM_LONGDATA) + { + hdr = (MIDIHDR *)notify.param_1; + notify32->param_1 = hdr->dwReserved[7]; + hdr32 = ULongToPtr(notify32->param_1); + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->dwFlags = hdr->dwFlags; + free(hdr); + } + } + return STATUS_SUCCESS; +} + +#endif /* _WIN64 */ diff --git a/dlls/wineoss.drv/unixlib.h b/dlls/wineoss.drv/unixlib.h index 208dec7f69d..e36c82ff35b 100644 --- a/dlls/wineoss.drv/unixlib.h +++ b/dlls/wineoss.drv/unixlib.h @@ -297,6 +297,12 @@ NTSTATUS midi_out_message(void *args) DECLSPEC_HIDDEN; NTSTATUS midi_in_message(void *args) DECLSPEC_HIDDEN; NTSTATUS midi_notify_wait(void *args) DECLSPEC_HIDDEN; +#ifdef _WIN64 +NTSTATUS wow64_midi_out_message(void *args) DECLSPEC_HIDDEN; +NTSTATUS wow64_midi_in_message(void *args) DECLSPEC_HIDDEN; +NTSTATUS wow64_midi_notify_wait(void *args) DECLSPEC_HIDDEN; +#endif + extern unixlib_handle_t oss_handle; #define OSS_CALL(func, params) __wine_unix_call(oss_handle, oss_ ## func, params) -- 2.25.1

2 1

[PATCH 5/7] wineoss: Implement Wow64 mmdevapi entry points in the Unix libraray.
by Huw Davies May 4, 2022

May 4, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/oss.c | 353 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 353 insertions(+) diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 40b8879ef47..9f2cba68f86 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -1641,3 +1641,356 @@ unixlib_entry_t __wine_unix_call_funcs[] = midi_notify_wait, aux_message, }; + +#ifdef _WIN64 + +typedef UINT PTR32; + +static NTSTATUS wow64_get_endpoint_ids(void *args) +{ + struct + { + EDataFlow flow; + PTR32 endpoints; + unsigned int size; + HRESULT result; + unsigned int num; + unsigned int default_idx; + } *params32 = args; + struct get_endpoint_ids_params params = + { + .flow = params32->flow, + .endpoints = ULongToPtr(params32->endpoints), + .size = params32->size + }; + get_endpoint_ids(&params); + params32->size = params.size; + params32->result = params.result; + params32->num = params.num; + params32->default_idx = params.default_idx; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_create_stream(void *args) +{ + struct + { + PTR32 device; + EDataFlow flow; + AUDCLNT_SHAREMODE share; + UINT flags; + REFERENCE_TIME duration; + REFERENCE_TIME period; + PTR32 fmt; + HRESULT result; + PTR32 stream; + } *params32 = args; + struct create_stream_params params = + { + .device = ULongToPtr(params32->device), + .flow = params32->flow, + .share = params32->share, + .flags = params32->flags, + .duration = params32->duration, + .period = params32->period, + .fmt = ULongToPtr(params32->fmt), + .stream = ULongToPtr(params32->stream) + }; + create_stream(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_release_stream(void *args) +{ + struct + { + stream_handle stream; + PTR32 timer_thread; + HRESULT result; + } *params32 = args; + struct release_stream_params params = + { + .stream = params32->stream, + .timer_thread = ULongToHandle(params32->timer_thread) + }; + release_stream(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_render_buffer(void *args) +{ + struct + { + stream_handle stream; + UINT32 frames; + HRESULT result; + PTR32 data; + } *params32 = args; + BYTE *data = NULL; + struct get_render_buffer_params params = + { + .stream = params32->stream, + .frames = params32->frames, + .data = &data + }; + get_render_buffer(&params); + params32->result = params.result; + *(unsigned int *)ULongToPtr(params32->data) = PtrToUlong(data); + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_capture_buffer(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 data; + PTR32 frames; + PTR32 flags; + PTR32 devpos; + PTR32 qpcpos; + } *params32 = args; + BYTE *data = NULL; + struct get_capture_buffer_params params = + { + .stream = params32->stream, + .data = &data, + .frames = ULongToPtr(params32->frames), + .flags = ULongToPtr(params32->flags), + .devpos = ULongToPtr(params32->devpos), + .qpcpos = ULongToPtr(params32->qpcpos) + }; + get_capture_buffer(&params); + params32->result = params.result; + *(unsigned int *)ULongToPtr(params32->data) = PtrToUlong(data); + return STATUS_SUCCESS; +}; + +static NTSTATUS wow64_is_format_supported(void *args) +{ + struct + { + PTR32 device; + EDataFlow flow; + AUDCLNT_SHAREMODE share; + PTR32 fmt_in; + PTR32 fmt_out; + HRESULT result; + } *params32 = args; + struct is_format_supported_params params = + { + .device = ULongToPtr(params32->device), + .flow = params32->flow, + .share = params32->share, + .fmt_in = ULongToPtr(params32->fmt_in), + .fmt_out = ULongToPtr(params32->fmt_out) + }; + is_format_supported(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_mix_format(void *args) +{ + struct + { + PTR32 device; + EDataFlow flow; + PTR32 fmt; + HRESULT result; + } *params32 = args; + struct get_mix_format_params params = + { + .device = ULongToPtr(params32->device), + .flow = params32->flow, + .fmt = ULongToPtr(params32->fmt) + }; + get_mix_format(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_buffer_size(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 size; + } *params32 = args; + struct get_buffer_size_params params = + { + .stream = params32->stream, + .size = ULongToPtr(params32->size) + }; + get_buffer_size(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_latency(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 latency; + } *params32 = args; + struct get_latency_params params = + { + .stream = params32->stream, + .latency = ULongToPtr(params32->latency) + }; + get_latency(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_current_padding(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 padding; + } *params32 = args; + struct get_current_padding_params params = + { + .stream = params32->stream, + .padding = ULongToPtr(params32->padding) + }; + get_current_padding(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_next_packet_size(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 frames; + } *params32 = args; + struct get_next_packet_size_params params = + { + .stream = params32->stream, + .frames = ULongToPtr(params32->frames) + }; + get_next_packet_size(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_frequency(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 frequency; + } *params32 = args; + struct get_frequency_params params = + { + .stream = params32->stream, + .frequency = ULongToPtr(params32->frequency) + }; + get_frequency(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_position(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 position; + PTR32 qpctime; + } *params32 = args; + struct get_position_params params = + { + .stream = params32->stream, + .position = ULongToPtr(params32->position), + .qpctime = ULongToPtr(params32->qpctime) + }; + get_position(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_set_volumes(void *args) +{ + struct + { + stream_handle stream; + float master_volume; + PTR32 volumes; + PTR32 session_volumes; + } *params32 = args; + struct set_volumes_params params = + { + .stream = params32->stream, + .master_volume = params32->master_volume, + .volumes = ULongToPtr(params32->volumes), + .session_volumes = ULongToPtr(params32->session_volumes) + }; + return set_volumes(&params); +} + +static NTSTATUS wow64_set_event_handle(void *args) +{ + struct + { + stream_handle stream; + PTR32 event; + HRESULT result; + } *params32 = args; + struct set_event_handle_params params = + { + .stream = params32->stream, + .event = ULongToHandle(params32->event) + }; + + set_event_handle(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +unixlib_entry_t __wine_unix_call_wow64_funcs[] = +{ + test_connect, + wow64_get_endpoint_ids, + wow64_create_stream, + wow64_release_stream, + start, + stop, + reset, + timer_loop, + wow64_get_render_buffer, + release_render_buffer, + wow64_get_capture_buffer, + release_capture_buffer, + wow64_is_format_supported, + wow64_get_mix_format, + wow64_get_buffer_size, + wow64_get_latency, + wow64_get_current_padding, + wow64_get_next_packet_size, + wow64_get_frequency, + wow64_get_position, + wow64_set_volumes, + wow64_set_event_handle, + is_started, + midi_release, + midi_out_message, + midi_in_message, + midi_notify_wait, + aux_message, +}; + +#endif /* _WIN64 */ -- 2.25.1

2 2

[PATCH 4/7] wineoss: Limit Wow64 buffer allocations to 32-bit addresses.
by Huw Davies May 4, 2022

May 4, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/oss.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 986ed274445..40b8879ef47 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -535,6 +535,15 @@ static HRESULT setup_oss_device(AUDCLNT_SHAREMODE share, int fd, return ret; } +static ULONG_PTR zero_bits(void) +{ +#ifdef _WIN64 + return !NtCurrentTeb()->WowTebOffset ? 0 : 0x7fffffff; +#else + return 0; +#endif +} + static NTSTATUS create_stream(void *args) { struct create_stream_params *params = args; @@ -597,8 +606,8 @@ static NTSTATUS create_stream(void *args) if(params->share == AUDCLNT_SHAREMODE_EXCLUSIVE) stream->bufsize_frames -= stream->bufsize_frames % stream->period_frames; size = stream->bufsize_frames * params->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->local_buffer, 0, &size, - MEM_COMMIT, PAGE_READWRITE)){ + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->local_buffer, zero_bits(), + &size, MEM_COMMIT, PAGE_READWRITE)){ params->result = E_OUTOFMEMORY; goto exit; } @@ -931,8 +940,8 @@ static NTSTATUS get_render_buffer(void *args) stream->tmp_buffer = NULL; } size = frames * stream->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, 0, &size, - MEM_COMMIT, PAGE_READWRITE)){ + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, zero_bits(), + &size, MEM_COMMIT, PAGE_READWRITE)){ stream->tmp_buffer_frames = 0; return oss_unlock_result(stream, &params->result, E_OUTOFMEMORY); } @@ -1041,8 +1050,8 @@ static NTSTATUS get_capture_buffer(void *args) stream->tmp_buffer = NULL; } size = *frames * stream->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, 0, &size, - MEM_COMMIT, PAGE_READWRITE)){ + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, zero_bits(), + &size, MEM_COMMIT, PAGE_READWRITE)){ stream->tmp_buffer_frames = 0; return oss_unlock_result(stream, &params->result, E_OUTOFMEMORY); } -- 2.25.1

2 1

[PATCH 3/7] wineoss: Return offsets rather than ptrs to the strings.
by Huw Davies May 4, 2022

May 4, 2022

This will make the Wow64 syscall rather simpler. Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/mmdevdrv.c | 12 +++++++----- dlls/wineoss.drv/oss.c | 18 ++++++++---------- dlls/wineoss.drv/unixlib.h | 4 ++-- 3 files changed, 17 insertions(+), 17 deletions(-) diff --git a/dlls/wineoss.drv/mmdevdrv.c b/dlls/wineoss.drv/mmdevdrv.c index c9aae98ec2e..9c1261ce05c 100644 --- a/dlls/wineoss.drv/mmdevdrv.c +++ b/dlls/wineoss.drv/mmdevdrv.c @@ -390,8 +390,10 @@ HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, GUID **gu } for(i = 0; i < params.num; i++){ - unsigned int name_size = (wcslen(params.endpoints[i].name) + 1) * sizeof(WCHAR); - unsigned int dev_size = strlen(params.endpoints[i].device) + 1; + WCHAR *name = (WCHAR *)((char *)params.endpoints + params.endpoints[i].name); + char *device = (char *)params.endpoints + params.endpoints[i].device; + unsigned int name_size = (wcslen(name) + 1) * sizeof(WCHAR); + unsigned int dev_size = strlen(device) + 1; OSSDevice *oss_dev; ids[i] = HeapAlloc(GetProcessHeap(), 0, name_size); @@ -401,12 +403,12 @@ HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, GUID **gu params.result = E_OUTOFMEMORY; goto end; } - memcpy(ids[i], params.endpoints[i].name, name_size); - get_device_guid(flow, params.endpoints[i].device, guids + i); + memcpy(ids[i], name, name_size); + get_device_guid(flow, device, guids + i); oss_dev->flow = flow; oss_dev->guid = guids[i]; - memcpy(oss_dev->devnode, params.endpoints[i].device, dev_size); + memcpy(oss_dev->devnode, device, dev_size); device_add(oss_dev); } *def_index = params.default_idx; diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index a628548ddcd..986ed274445 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -226,11 +226,10 @@ static NTSTATUS get_endpoint_ids(void *args) WCHAR name[ARRAY_SIZE(ai.name) + ARRAY_SIZE(outW)]; char device[OSS_DEVNODE_SIZE]; } *info; - unsigned int i, j, num, needed, name_len, device_len, default_idx = 0; + unsigned int i, j, num, needed, name_len, device_len, offset, default_idx = 0; char default_device[OSS_DEVNODE_SIZE]; struct endpoint *endpoint; int mixer_fd; - char *ptr; mixer_fd = open("/dev/mixer", O_RDONLY, 0); if(mixer_fd < 0){ @@ -333,9 +332,8 @@ static NTSTATUS get_endpoint_ids(void *args) } close(mixer_fd); - needed = num * sizeof(*params->endpoints); + offset = needed = num * sizeof(*params->endpoints); endpoint = params->endpoints; - ptr = (char *)(endpoint + num); for(i = 0; i < num; i++){ name_len = wcslen(info[i].name) + 1; @@ -343,12 +341,12 @@ static NTSTATUS get_endpoint_ids(void *args) needed += name_len * sizeof(WCHAR) + ((device_len + 1) & ~1); if(needed <= params->size){ - endpoint->name = (WCHAR *)ptr; - memcpy(endpoint->name, info[i].name, name_len * sizeof(WCHAR)); - ptr += name_len * sizeof(WCHAR); - endpoint->device = ptr; - memcpy(endpoint->device, info[i].device, device_len); - ptr += (device_len + 1) & ~1; + endpoint->name = offset; + memcpy((char *)params->endpoints + offset, info[i].name, name_len * sizeof(WCHAR)); + offset += name_len * sizeof(WCHAR); + endpoint->device = offset; + memcpy((char *)params->endpoints + offset, info[i].device, device_len); + offset += (device_len + 1) & ~1; endpoint++; } } diff --git a/dlls/wineoss.drv/unixlib.h b/dlls/wineoss.drv/unixlib.h index 278dfdbe612..208dec7f69d 100644 --- a/dlls/wineoss.drv/unixlib.h +++ b/dlls/wineoss.drv/unixlib.h @@ -36,8 +36,8 @@ struct test_connect_params struct endpoint { - WCHAR *name; - char *device; + unsigned int name; + unsigned int device; }; struct get_endpoint_ids_params -- 2.25.1

2 1

[PATCH 2/7] wineoss: Use UINT64 handles to represent the stream.
by Huw Davies May 4, 2022

May 4, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/mmdevdrv.c | 6 +++--- dlls/wineoss.drv/oss.c | 43 +++++++++++++++++++++---------------- dlls/wineoss.drv/unixlib.h | 40 +++++++++++++++++----------------- 3 files changed, 47 insertions(+), 42 deletions(-) diff --git a/dlls/wineoss.drv/mmdevdrv.c b/dlls/wineoss.drv/mmdevdrv.c index 93bf775ebc8..c9aae98ec2e 100644 --- a/dlls/wineoss.drv/mmdevdrv.c +++ b/dlls/wineoss.drv/mmdevdrv.c @@ -96,7 +96,7 @@ struct ACImpl { EDataFlow dataflow; float *vols; UINT32 channel_count; - struct oss_stream *stream; + stream_handle stream; HANDLE timer_thread; @@ -239,7 +239,7 @@ int WINAPI AUDDRV_GetPriority(void) return params.priority; } -static HRESULT stream_release(struct oss_stream *stream, HANDLE timer_thread) +static HRESULT stream_release(stream_handle stream, HANDLE timer_thread) { struct release_stream_params params; @@ -651,7 +651,7 @@ static HRESULT WINAPI AudioClient_Initialize(IAudioClient3 *iface, { ACImpl *This = impl_from_IAudioClient3(iface); struct create_stream_params params; - struct oss_stream *stream; + stream_handle stream; unsigned int i; TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This, mode, flags, diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 6490081e069..a628548ddcd 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -111,6 +111,11 @@ static NTSTATUS oss_unlock_result(struct oss_stream *stream, return STATUS_SUCCESS; } +static struct oss_stream *handle_get_stream(stream_handle h) +{ + return (struct oss_stream *)(UINT_PTR)h; +} + static NTSTATUS test_connect(void *args) { struct test_connect_params *params = args; @@ -615,7 +620,7 @@ exit: free(stream->fmt); free(stream); }else{ - *params->stream = stream; + *params->stream = (stream_handle)(UINT_PTR)stream; } return STATUS_SUCCESS; @@ -624,7 +629,7 @@ exit: static NTSTATUS release_stream(void *args) { struct release_stream_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); SIZE_T size; if(params->timer_thread){ @@ -653,7 +658,7 @@ static NTSTATUS release_stream(void *args) static NTSTATUS start(void *args) { struct start_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -671,7 +676,7 @@ static NTSTATUS start(void *args) static NTSTATUS stop(void *args) { struct stop_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -687,7 +692,7 @@ static NTSTATUS stop(void *args) static NTSTATUS reset(void *args) { struct reset_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -860,7 +865,7 @@ static void oss_read_data(struct oss_stream *stream) static NTSTATUS timer_loop(void *args) { struct timer_loop_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); LARGE_INTEGER delay, now, next; int adjust; @@ -902,7 +907,7 @@ static NTSTATUS timer_loop(void *args) static NTSTATUS get_render_buffer(void *args) { struct get_render_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 write_pos, frames = params->frames; BYTE **data = params->data; SIZE_T size; @@ -968,7 +973,7 @@ static void oss_wrap_buffer(struct oss_stream *stream, BYTE *buffer, UINT32 writ static NTSTATUS release_render_buffer(void *args) { struct release_render_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 written_frames = params->written_frames; UINT flags = params->flags; BYTE *buffer; @@ -1008,7 +1013,7 @@ static NTSTATUS release_render_buffer(void *args) static NTSTATUS get_capture_buffer(void *args) { struct get_capture_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT64 *devpos = params->devpos, *qpcpos = params->qpcpos; UINT32 *frames = params->frames; UINT *flags = params->flags; @@ -1074,7 +1079,7 @@ static NTSTATUS get_capture_buffer(void *args) static NTSTATUS release_capture_buffer(void *args) { struct release_capture_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 done = params->done; oss_lock(stream); @@ -1231,7 +1236,7 @@ static NTSTATUS get_mix_format(void *args) static NTSTATUS get_buffer_size(void *args) { struct get_buffer_size_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1243,7 +1248,7 @@ static NTSTATUS get_buffer_size(void *args) static NTSTATUS get_latency(void *args) { struct get_latency_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1257,7 +1262,7 @@ static NTSTATUS get_latency(void *args) static NTSTATUS get_current_padding(void *args) { struct get_current_padding_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1269,7 +1274,7 @@ static NTSTATUS get_current_padding(void *args) static NTSTATUS get_next_packet_size(void *args) { struct get_next_packet_size_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 *frames = params->frames; oss_lock(stream); @@ -1282,7 +1287,7 @@ static NTSTATUS get_next_packet_size(void *args) static NTSTATUS get_frequency(void *args) { struct get_frequency_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT64 *freq = params->frequency; oss_lock(stream); @@ -1298,7 +1303,7 @@ static NTSTATUS get_frequency(void *args) static NTSTATUS get_position(void *args) { struct get_position_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT64 *pos = params->position, *qpctime = params->qpctime; oss_lock(stream); @@ -1342,7 +1347,7 @@ static NTSTATUS get_position(void *args) static NTSTATUS set_volumes(void *args) { struct set_volumes_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); stream->mute = !params->master_volume; @@ -1354,7 +1359,7 @@ static NTSTATUS set_volumes(void *args) static NTSTATUS set_event_handle(void *args) { struct set_event_handle_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1374,7 +1379,7 @@ static NTSTATUS set_event_handle(void *args) static NTSTATUS is_started(void *args) { struct is_started_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); diff --git a/dlls/wineoss.drv/unixlib.h b/dlls/wineoss.drv/unixlib.h index 25e9a7007b3..278dfdbe612 100644 --- a/dlls/wineoss.drv/unixlib.h +++ b/dlls/wineoss.drv/unixlib.h @@ -18,7 +18,7 @@ #include "mmdeviceapi.h" -struct stream_oss; +typedef UINT64 stream_handle; /* From <dlls/mmdevapi/mmdevapi.h> */ enum DriverPriority @@ -60,42 +60,42 @@ struct create_stream_params REFERENCE_TIME period; const WAVEFORMATEX *fmt; HRESULT result; - struct oss_stream **stream; + stream_handle *stream; }; struct release_stream_params { - struct oss_stream *stream; + stream_handle stream; HANDLE timer_thread; HRESULT result; }; struct start_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; struct stop_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; struct reset_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; struct timer_loop_params { - struct oss_stream *stream; + stream_handle stream; }; struct get_render_buffer_params { - struct oss_stream *stream; + stream_handle stream; UINT32 frames; HRESULT result; BYTE **data; @@ -103,7 +103,7 @@ struct get_render_buffer_params struct release_render_buffer_params { - struct oss_stream *stream; + stream_handle stream; UINT32 written_frames; UINT flags; HRESULT result; @@ -111,7 +111,7 @@ struct release_render_buffer_params struct get_capture_buffer_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; BYTE **data; UINT32 *frames; @@ -122,7 +122,7 @@ struct get_capture_buffer_params struct release_capture_buffer_params { - struct oss_stream *stream; + stream_handle stream; UINT32 done; HRESULT result; }; @@ -147,42 +147,42 @@ struct get_mix_format_params struct get_buffer_size_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT32 *size; }; struct get_latency_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; REFERENCE_TIME *latency; }; struct get_current_padding_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT32 *padding; }; struct get_next_packet_size_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT32 *frames; }; struct get_frequency_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT64 *frequency; }; struct get_position_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT64 *position; UINT64 *qpctime; @@ -190,7 +190,7 @@ struct get_position_params struct set_volumes_params { - struct oss_stream *stream; + stream_handle stream; float master_volume; const float *volumes; const float *session_volumes; @@ -198,14 +198,14 @@ struct set_volumes_params struct set_event_handle_params { - struct oss_stream *stream; + stream_handle stream; HANDLE event; HRESULT result; }; struct is_started_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; -- 2.25.1

2 1

[PATCH 1/7] wineoss: Pass a client ptr to the callback instead of a stream.
by Huw Davies May 4, 2022

May 4, 2022

This is to allow stream handles to be larger than sizeof(void *). Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/mmdevdrv.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/wineoss.drv/mmdevdrv.c b/dlls/wineoss.drv/mmdevdrv.c index c282ff14f01..93bf775ebc8 100644 --- a/dlls/wineoss.drv/mmdevdrv.c +++ b/dlls/wineoss.drv/mmdevdrv.c @@ -252,10 +252,10 @@ static HRESULT stream_release(struct oss_stream *stream, HANDLE timer_thread) static DWORD WINAPI timer_thread(void *user) { - struct oss_stream *stream = user; struct timer_loop_params params; + struct ACImpl *This = user; - params.stream = stream; + params.stream = This->stream; OSS_CALL(timer_loop, &params); return 0; @@ -913,7 +913,7 @@ static HRESULT WINAPI AudioClient_Start(IAudioClient3 *iface) OSS_CALL(start, &params); if(SUCCEEDED(params.result) && !This->timer_thread){ - This->timer_thread = CreateThread(NULL, 0, timer_thread, This->stream, 0, NULL); + This->timer_thread = CreateThread(NULL, 0, timer_thread, This, 0, NULL); SetThreadPriority(This->timer_thread, THREAD_PRIORITY_TIME_CRITICAL); } -- 2.25.1

2 1

[PATCH 0/1] MR29: mfplat: Avoid a race condition when releasing a tracked sample.
by Giovanni Mascellani (＠giomasce) May 4, 2022

May 4, 2022

Right now, if the same tracked sample is released at the same time from two different threads it might happen that neither of them calls the callback, because they might go through the critical section at the same time (while neither has decremented the reference count yet). Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> -- https://gitlab.winehq.org/wine/wine/-/merge_requests/29

3 4

[PATCH 0/11] MR36: winex11: PE conversion preparation
by Jacek Caban (＠jacek) May 4, 2022

May 4, 2022

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

2 11

[PATCH 1/2] ntdll: Add a partial implementation of NtMapViewOfSectionEx().
by Nikolay Sivov May 4, 2022

May 4, 2022

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/ntdll/ntdll.spec | 2 + dlls/ntdll/tests/virtual.c | 149 +++++++++++++++++++++++++++++++++++++ dlls/ntdll/unix/loader.c | 1 + dlls/ntdll/unix/virtual.c | 12 +++ dlls/wow64/syscall.h | 1 + dlls/wow64/virtual.c | 34 +++++++++ include/winternl.h | 1 + 7 files changed, 200 insertions(+) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index ba29b21d61d..a7a39a0bce2 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -253,6 +253,7 @@ # @ stub NtMapUserPhysicalPages # @ stub NtMapUserPhysicalPagesScatter @ stdcall -syscall NtMapViewOfSection(long long ptr long long ptr ptr long long long) +@ stdcall -syscall NtMapViewOfSectionEx(long long ptr ptr ptr long long ptr long) # @ stub NtModifyBootEntry @ stdcall -syscall NtNotifyChangeDirectoryFile(long long ptr ptr ptr ptr long long long) @ stdcall -syscall NtNotifyChangeKey(long long ptr ptr ptr long long ptr long long) @@ -1279,6 +1280,7 @@ # @ stub ZwMapUserPhysicalPages # @ stub ZwMapUserPhysicalPagesScatter @ stdcall -private -syscall ZwMapViewOfSection(long long ptr long long ptr ptr long long long) NtMapViewOfSection +@ stdcall -private -syscall ZwMapViewOfSectionEx(long long ptr ptr ptr long long ptr long) NtMapViewOfSectionEx # @ stub ZwModifyBootEntry @ stdcall -private -syscall ZwNotifyChangeDirectoryFile(long long ptr ptr ptr ptr long long long) NtNotifyChangeDirectoryFile @ stdcall -private -syscall ZwNotifyChangeKey(long long ptr ptr ptr long long ptr long long) NtNotifyChangeKey diff --git a/dlls/ntdll/tests/virtual.c b/dlls/ntdll/tests/virtual.c index 30a97ba9d94..aeef2ed8fb9 100644 --- a/dlls/ntdll/tests/virtual.c +++ b/dlls/ntdll/tests/virtual.c @@ -39,6 +39,9 @@ static void * (WINAPI *pRtlFindExportedRoutineByName)(HMODULE,const char*); static BOOL (WINAPI *pIsWow64Process)(HANDLE, PBOOL); static NTSTATUS (WINAPI *pNtAllocateVirtualMemoryEx)(HANDLE, PVOID *, SIZE_T *, ULONG, ULONG, MEM_EXTENDED_PARAMETER *, ULONG); +static NTSTATUS (WINAPI *pNtMapViewOfSectionEx)(HANDLE, HANDLE, PVOID *, const LARGE_INTEGER *, SIZE_T *, + ULONG, ULONG, MEM_EXTENDED_PARAMETER *, ULONG); + static const BOOL is_win64 = sizeof(void*) != sizeof(int); static BOOL is_wow64; @@ -908,6 +911,150 @@ static void test_NtMapViewOfSection(void) CloseHandle(process); } +static void test_NtMapViewOfSectionEx(void) +{ + static const char testfile[] = "testfile.xxx"; + static const char data[] = "test data for NtMapViewOfSectionEx"; + char buffer[sizeof(data)]; + HANDLE file, mapping, process; + DWORD status, written; + SIZE_T size, result; + LARGE_INTEGER offset; + void *ptr, *ptr2; + BOOL ret; + + if (!pNtMapViewOfSectionEx) + { + win_skip("NtMapViewOfSectionEx() is not supported.\n"); + return; + } + + if (!pIsWow64Process || !pIsWow64Process(NtCurrentProcess(), &is_wow64)) is_wow64 = FALSE; + + file = CreateFileA(testfile, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0); + ok(file != INVALID_HANDLE_VALUE, "Failed to create test file\n"); + WriteFile(file, data, sizeof(data), &written, NULL); + SetFilePointer(file, 4096, NULL, FILE_BEGIN); + SetEndOfFile(file); + + /* read/write mapping */ + + mapping = CreateFileMappingA(file, NULL, PAGE_READWRITE, 0, 4096, NULL); + ok(mapping != 0, "CreateFileMapping failed\n"); + + process = create_target_process("sleep"); + ok(process != NULL, "Can't start process\n"); + + ptr = NULL; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr, &offset, &size, 0, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_SUCCESS, "Unexpected status %08lx\n", status); + ok(!((ULONG_PTR)ptr & 0xffff), "returned memory %p is not aligned to 64k\n", ptr); + + ret = ReadProcessMemory(process, ptr, buffer, sizeof(buffer), &result); + ok(ret, "ReadProcessMemory failed\n"); + ok(result == sizeof(buffer), "ReadProcessMemory didn't read all data (%Ix)\n", result); + ok(!memcmp(buffer, data, sizeof(buffer)), "Wrong data read\n"); + + /* mapping at the same page conflicts */ + ptr2 = ptr; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, 0, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_CONFLICTING_ADDRESSES, "Unexpected status %08lx\n", status); + + /* offset has to be aligned */ + ptr2 = ptr; + size = 0; + offset.QuadPart = 1; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, 0, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_MAPPED_ALIGNMENT, "Unexpected status %08lx\n", status); + + /* ptr has to be aligned */ + ptr2 = (char *)ptr + 42; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, 0, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_MAPPED_ALIGNMENT, "Unexpected status %08lx\n", status); + + /* still not 64k aligned */ + ptr2 = (char *)ptr + 0x1000; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, 0, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_MAPPED_ALIGNMENT, "Unexpected status %08lx\n", status); + + if (!is_win64 && !is_wow64) + { + /* new memory region conflicts with previous mapping */ + ptr2 = ptr; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, AT_ROUND_TO_PAGE, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_CONFLICTING_ADDRESSES, "Unexpected status %08lx\n", status); + + ptr2 = (char *)ptr + 42; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, AT_ROUND_TO_PAGE, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_CONFLICTING_ADDRESSES, "Unexpected status %08lx\n", status); + + /* in contrary to regular NtMapViewOfSection, only 4kb align is enforced */ + ptr2 = (char *)ptr + 0x1000; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, AT_ROUND_TO_PAGE, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_SUCCESS, "Unexpected status %08lx\n", status); + ok((char *)ptr2 == (char *)ptr + 0x1000, + "expected address %p, got %p\n", (char *)ptr + 0x1000, ptr2); + status = NtUnmapViewOfSection(process, ptr2); + ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection returned %08lx\n", status); + + /* the address is rounded down if not on a page boundary */ + ptr2 = (char *)ptr + 0x1001; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, AT_ROUND_TO_PAGE, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_SUCCESS, "Unexpected status %08lx\n", status); + ok((char *)ptr2 == (char *)ptr + 0x1000, + "expected address %p, got %p\n", (char *)ptr + 0x1000, ptr2); + status = NtUnmapViewOfSection(process, ptr2); + ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection returned %08lx\n", status); + + ptr2 = (char *)ptr + 0x2000; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, AT_ROUND_TO_PAGE, PAGE_READWRITE, NULL, 0); + ok(status == STATUS_SUCCESS, "Unexpected status %08lx\n", status); + ok((char *)ptr2 == (char *)ptr + 0x2000, + "expected address %p, got %p\n", (char *)ptr + 0x2000, ptr2); + status = NtUnmapViewOfSection(process, ptr2); + ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection returned %08lx\n", status); + } + else + { + ptr2 = (char *)ptr + 0x1000; + size = 0; + offset.QuadPart = 0; + status = pNtMapViewOfSectionEx(mapping, process, &ptr2, &offset, &size, AT_ROUND_TO_PAGE, PAGE_READWRITE, NULL, 0); + todo_wine + ok(status == STATUS_INVALID_PARAMETER_9 || status == STATUS_INVALID_PARAMETER, + "NtMapViewOfSection returned %08lx\n", status); + } + + status = NtUnmapViewOfSection(process, ptr); + ok(status == STATUS_SUCCESS, "NtUnmapViewOfSection returned %08lx\n", status); + + NtClose(mapping); + + CloseHandle(file); + DeleteFileA(testfile); + + TerminateProcess(process, 0); + CloseHandle(process); +} + #define SUPPORTED_XSTATE_FEATURES ((1 << XSTATE_LEGACY_FLOATING_POINT) | (1 << XSTATE_LEGACY_SSE) | (1 << XSTATE_AVX)) static void test_user_shared_data(void) @@ -1160,6 +1307,7 @@ START_TEST(virtual) pRtlFindExportedRoutineByName = (void *)GetProcAddress(mod, "RtlFindExportedRoutineByName"); pRtlGetEnabledExtendedFeatures = (void *)GetProcAddress(mod, "RtlGetEnabledExtendedFeatures"); pNtAllocateVirtualMemoryEx = (void *)GetProcAddress(mod, "NtAllocateVirtualMemoryEx"); + pNtMapViewOfSectionEx = (void *)GetProcAddress(mod, "NtMapViewOfSectionEx"); NtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), NULL); trace("system page size %#lx\n", sbi.PageSize); @@ -1169,6 +1317,7 @@ START_TEST(virtual) test_NtAllocateVirtualMemory(); test_RtlCreateUserStack(); test_NtMapViewOfSection(); + test_NtMapViewOfSectionEx(); test_user_shared_data(); test_syscalls(); } diff --git a/dlls/ntdll/unix/loader.c b/dlls/ntdll/unix/loader.c index d1c42ddc0f3..cad760a1445 100644 --- a/dlls/ntdll/unix/loader.c +++ b/dlls/ntdll/unix/loader.c @@ -207,6 +207,7 @@ static void * const syscalls[] = NtLockVirtualMemory, NtMakeTemporaryObject, NtMapViewOfSection, + NtMapViewOfSectionEx, NtNotifyChangeDirectoryFile, NtNotifyChangeKey, NtNotifyChangeMultipleKeys, diff --git a/dlls/ntdll/unix/virtual.c b/dlls/ntdll/unix/virtual.c index 94b300c5057..02478cceb06 100644 --- a/dlls/ntdll/unix/virtual.c +++ b/dlls/ntdll/unix/virtual.c @@ -4536,6 +4536,18 @@ NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_p offset_ptr, size_ptr, alloc_type, protect ); } +/*********************************************************************** + * NtMapViewOfSectionEx (NTDLL.@) + * ZwMapViewOfSectionEx (NTDLL.@) + */ +NTSTATUS WINAPI NtMapViewOfSectionEx( HANDLE handle, HANDLE process, PVOID *addr_ptr, const LARGE_INTEGER *offset_ptr, + SIZE_T *size_ptr, ULONG alloc_type, ULONG protect, MEM_EXTENDED_PARAMETER *params, ULONG params_count ) +{ + if (params) + FIXME("Ignoring extended parameters.\n"); + + return NtMapViewOfSection( handle, process, addr_ptr, 0, 0, offset_ptr, size_ptr, ViewShare, alloc_type, protect ); +} /*********************************************************************** * NtUnmapViewOfSection (NTDLL.@) diff --git a/dlls/wow64/syscall.h b/dlls/wow64/syscall.h index a3af9174c49..3b364d909d7 100644 --- a/dlls/wow64/syscall.h +++ b/dlls/wow64/syscall.h @@ -108,6 +108,7 @@ SYSCALL_ENTRY( NtLockVirtualMemory ) \ SYSCALL_ENTRY( NtMakeTemporaryObject ) \ SYSCALL_ENTRY( NtMapViewOfSection ) \ + SYSCALL_ENTRY( NtMapViewOfSectionEx ) \ SYSCALL_ENTRY( NtNotifyChangeDirectoryFile ) \ SYSCALL_ENTRY( NtNotifyChangeKey ) \ SYSCALL_ENTRY( NtNotifyChangeMultipleKeys ) \ diff --git a/dlls/wow64/virtual.c b/dlls/wow64/virtual.c index e89373f4239..61c84e5d7be 100644 --- a/dlls/wow64/virtual.c +++ b/dlls/wow64/virtual.c @@ -287,6 +287,40 @@ NTSTATUS WINAPI wow64_NtMapViewOfSection( UINT *args ) return status; } +/********************************************************************** + * wow64_NtMapViewOfSectionEx + */ +NTSTATUS WINAPI wow64_NtMapViewOfSectionEx( UINT *args ) +{ + HANDLE handle = get_handle( &args ); + HANDLE process = get_handle( &args ); + ULONG *addr32 = get_ptr( &args ); + const LARGE_INTEGER *offset = get_ptr( &args ); + ULONG *size32 = get_ptr( &args ); + ULONG alloc = get_ulong( &args ); + ULONG protect = get_ulong( &args ); + MEM_EXTENDED_PARAMETER *params = get_ptr( &args ); + ULONG params_count = get_ulong( &args ); + + void *addr; + SIZE_T size; + NTSTATUS status; + + status = NtMapViewOfSectionEx( handle, process, addr_32to64( &addr, addr32 ), offset, size_32to64( &size, size32 ), alloc, + protect, params, params_count ); + if (NT_SUCCESS(status)) + { + SECTION_IMAGE_INFORMATION info; + + if (!NtQuerySection( handle, SectionImageInformation, &info, sizeof(info), NULL )) + { + if (info.Machine == current_machine) init_image_mapping( addr ); + } + put_addr( addr32, addr ); + put_size( size32, size ); + } + return status; +} /********************************************************************** * wow64_NtProtectVirtualMemory diff --git a/include/winternl.h b/include/winternl.h index b4942d86b4c..1d358fc0b2d 100644 --- a/include/winternl.h +++ b/include/winternl.h @@ -4007,6 +4007,7 @@ NTSYSAPI NTSTATUS WINAPI NtLockFile(HANDLE,HANDLE,PIO_APC_ROUTINE,void*,PIO_STA NTSYSAPI NTSTATUS WINAPI NtLockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG); NTSYSAPI NTSTATUS WINAPI NtMakeTemporaryObject(HANDLE); NTSYSAPI NTSTATUS WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG_PTR,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG); +NTSYSAPI NTSTATUS WINAPI NtMapViewOfSectionEx(HANDLE,HANDLE,PVOID*,const LARGE_INTEGER*,SIZE_T*,ULONG,ULONG,MEM_EXTENDED_PARAMETER*,ULONG); NTSYSAPI NTSTATUS WINAPI NtNotifyChangeDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,ULONG,BOOLEAN); NTSYSAPI NTSTATUS WINAPI NtNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN); NTSYSAPI NTSTATUS WINAPI NtNotifyChangeMultipleKeys(HANDLE,ULONG,OBJECT_ATTRIBUTES*,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN); -- 2.35.1

1 1

[PATCH 0/5] MR33: windows.gaming.input: Split async info to a separate struct.
by Rémi Bernon May 4, 2022

May 4, 2022

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

1 5