26 Jul
2022
26 Jul
'22
5:23 a.m.
Signed-off-by: Daniel Lehman <dlehman25(a)gmail.com>
--
v3: kernelbase: Call NtCancelSynchronousIoFile in CancelSynchronousIo.
ntdll: Partially implement NtCancelSynchronousIoFile.
ntdll: Add NtCancelSynchronousIoFile stub.
kernel32/tests: Add tests for CancelSynchronousIo.
https://gitlab.winehq.org/wine/wine/-/merge_requests/47
26 Jul
26 Jul
5:23 a.m.
New subject: [PATCH v3 1/4] kernel32/tests: Add tests for CancelSynchronousIo.
From: Daniel Lehman <dlehman25(a)gmail.com>
Signed-off-by: Daniel Lehman <dlehman25(a)gmail.com>
---
dlls/kernel32/tests/pipe.c | 105 +++++++++++++++++++++++++++++++++++++
1 file changed, 105 insertions(+)
diff --git a/dlls/kernel32/tests/pipe.c b/dlls/kernel32/tests/pipe.c
index 7fa3c313d47..55890cc9172 100644
--- a/dlls/kernel32/tests/pipe.c
+++ b/dlls/kernel32/tests/pipe.c
@@ -37,6 +37,7 @@ static HANDLE alarm_event;
static BOOL (WINAPI *pDuplicateTokenEx)(HANDLE,DWORD,LPSECURITY_ATTRIBUTES,
SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
static BOOL (WINAPI *pCancelIoEx)(HANDLE handle, LPOVERLAPPED lpOverlapped);
+static BOOL (WINAPI *pCancelSynchronousIo)(HANDLE handle);
static BOOL (WINAPI *pGetNamedPipeClientProcessId)(HANDLE,ULONG*);
static BOOL (WINAPI *pGetNamedPipeServerProcessId)(HANDLE,ULONG*);
static BOOL (WINAPI *pGetNamedPipeClientSessionId)(HANDLE,ULONG*);
@@ -4202,6 +4203,108 @@ static void test_exit_process_async(void)
CloseHandle(server);
}
+static DWORD CALLBACK synchronousIoThreadMain(void *arg)
+{
+ HANDLE pipe;
+ BOOL ret;
+
+ pipe = arg;
+ SetLastError(0xdeadbeef);
+ ret = ConnectNamedPipe(pipe, NULL);
+ ok(!ret, "expected failure\n");
+ ok(GetLastError() == ERROR_OPERATION_ABORTED, "got error %lu\n",
GetLastError());
+ return 0;
+}
+
+static DWORD CALLBACK synchronousIoThreadMain2(void *arg)
+{
+ OVERLAPPED ov;
+ HANDLE pipe;
+ BOOL ret;
+
+ pipe = arg;
+ memset(&ov, 0, sizeof(ov));
+ ov.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
+ SetLastError(0xdeadbeef);
+ ret = ConnectNamedPipe(pipe, &ov);
+ ok(!ret, "expected failure\n");
+ ok(GetLastError() == ERROR_IO_PENDING, "got error %lu\n", GetLastError());
+ ret = WaitForSingleObject(ov.hEvent, 1000);
+ ok(ret == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", ret);
+ CloseHandle(ov.hEvent);
+ return 0;
+}
+
+static void test_CancelSynchronousIo(void)
+{
+ BOOL res;
+ DWORD wait;
+ HANDLE file;
+ HANDLE pipe;
+ HANDLE thread;
+
+ /* bogus values */
+ SetLastError(0xdeadbeef);
+ res = pCancelSynchronousIo((HANDLE)0xdeadbeef);
+ ok(!res, "CancelSynchronousIo succeeded unexpectedly\n");
+ todo_wine
+ ok(GetLastError() == ERROR_INVALID_HANDLE,
+ "In CancelSynchronousIo failure, expected ERROR_INVALID_HANDLE, got
%ld\n", GetLastError());
+
+ SetLastError(0xdeadbeef);
+ res = pCancelSynchronousIo(GetCurrentThread());
+ ok(!res, "CancelSynchronousIo succeeded unexpectedly\n");
+ todo_wine
+ ok(GetLastError() == ERROR_NOT_FOUND,
+ "In CancelSynchronousIo failure, expected ERROR_NOT_FOUND, got %ld\n",
GetLastError());
+
+ /* synchronous i/o */
+ pipe = CreateNamedPipeA(PIPENAME, PIPE_ACCESS_DUPLEX,
+ PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
+ 1, 1024, 1024, NMPWAIT_USE_DEFAULT_WAIT, NULL);
+ ok(pipe != INVALID_HANDLE_VALUE, "CreateNamedPipe failed with %lu\n",
GetLastError());
+ thread = CreateThread(NULL, 0, synchronousIoThreadMain, pipe, 0, NULL);
+ /* wait for I/O to start, which transitions the pipe handle from signaled to
nonsignaled state. */
+ while ((wait = WaitForSingleObject(pipe, 0)) == WAIT_OBJECT_0) Sleep(1);
+ ok(wait == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
wait, GetLastError());
+ SetLastError(0xdeadbeef);
+ res = pCancelSynchronousIo(thread);
+ todo_wine
+ {
+ ok(res, "CancelSynchronousIo failed with error %ld\n", GetLastError());
+ ok(GetLastError() == 0xdeadbeef,
+ "In CancelSynchronousIo failure, expected 0xdeadbeef got %ld\n",
GetLastError());
+ }
+ if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
+ CancelIoEx(pipe, NULL);
+ wait = WaitForSingleObject(thread, 1000);
+ ok(wait == WAIT_OBJECT_0, "WaitForSingleObject returned %lx\n", wait);
+ CloseHandle(thread);
+ CloseHandle(pipe);
+
+ /* asynchronous i/o */
+ pipe = CreateNamedPipeA(PIPENAME, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+ PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
+ 1, 1024, 1024, NMPWAIT_USE_DEFAULT_WAIT, NULL);
+ ok(pipe != INVALID_HANDLE_VALUE, "CreateNamedPipe failed with %lu\n",
GetLastError());
+ thread = CreateThread(NULL, 0, synchronousIoThreadMain2, pipe, 0, NULL);
+ /* wait for I/O to start, which transitions the pipe handle from signaled to
nonsignaled state. */
+ while ((wait = WaitForSingleObject(pipe, 0)) == WAIT_OBJECT_0) Sleep(1);
+ ok(wait == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
wait, GetLastError());
+ SetLastError(0xdeadbeef);
+ res = pCancelSynchronousIo(thread);
+ ok(!res, "CancelSynchronousIo succeeded unexpectedly\n");
+ todo_wine
+ ok(GetLastError() == ERROR_NOT_FOUND,
+ "In CancelSynchronousIo failure, expected ERROR_NOT_FOUND, got %ld\n",
GetLastError());
+ file = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0,
0);
+ ok(file != INVALID_HANDLE_VALUE, "CreateFile failed (%ld)\n",
GetLastError());
+ WaitForSingleObject(thread, INFINITE);
+ CloseHandle(thread);
+ CloseHandle(file);
+ CloseHandle(pipe);
+}
+
START_TEST(pipe)
{
char **argv;
@@ -4212,6 +4315,7 @@ START_TEST(pipe)
pDuplicateTokenEx = (void *) GetProcAddress(hmod, "DuplicateTokenEx");
hmod = GetModuleHandleA("kernel32.dll");
pCancelIoEx = (void *) GetProcAddress(hmod, "CancelIoEx");
+ pCancelSynchronousIo = (void *) GetProcAddress(hmod,
"CancelSynchronousIo");
pGetNamedPipeClientProcessId = (void *) GetProcAddress(hmod,
"GetNamedPipeClientProcessId");
pGetNamedPipeServerProcessId = (void *) GetProcAddress(hmod,
"GetNamedPipeServerProcessId");
pGetNamedPipeClientSessionId = (void *) GetProcAddress(hmod,
"GetNamedPipeClientSessionId");
@@ -4282,4 +4386,5 @@ START_TEST(pipe)
test_nowait(PIPE_TYPE_MESSAGE);
test_GetOverlappedResultEx();
test_exit_process_async();
+ test_CancelSynchronousIo();
}
--
GitLab
https://gitlab.winehq.org/wine/wine/-/merge_requests/47
5:23 a.m.
New subject: [PATCH v3 2/4] ntdll: Add NtCancelSynchronousIoFile stub.
From: Daniel Lehman <dlehman25(a)gmail.com>
Signed-off-by: Daniel Lehman <dlehman25(a)gmail.com>
---
dlls/ntdll/ntdll.spec | 2 +
dlls/ntdll/tests/pipe.c | 145 +++++++++++++++++++++++++++++++++++++++
dlls/ntdll/unix/file.c | 9 +++
dlls/ntdll/unix/loader.c | 1 +
include/winternl.h | 1 +
5 files changed, 158 insertions(+)
diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec
index 299d2195800..c2a1d67d9dc 100644
--- a/dlls/ntdll/ntdll.spec
+++ b/dlls/ntdll/ntdll.spec
@@ -153,6 +153,7 @@
# @ stub NtCancelDeviceWakeupRequest
@ stdcall -syscall NtCancelIoFile(long ptr)
@ stdcall -syscall NtCancelIoFileEx(long ptr ptr)
+@ stdcall -syscall NtCancelSynchronousIoFile(long ptr ptr)
@ stdcall -syscall NtCancelTimer(long ptr)
@ stdcall -syscall NtClearEvent(long)
@ stdcall -syscall NtClose(long)
@@ -1184,6 +1185,7 @@
# @ stub ZwCancelDeviceWakeupRequest
@ stdcall -private -syscall ZwCancelIoFile(long ptr) NtCancelIoFile
@ stdcall -private -syscall ZwCancelIoFileEx(long ptr ptr) NtCancelIoFileEx
+@ stdcall -private -syscall ZwCancelSynchronousIoFile(long ptr ptr)
NtCancelSynchronousIoFile
@ stdcall -private -syscall ZwCancelTimer(long ptr) NtCancelTimer
@ stdcall -private -syscall ZwClearEvent(long) NtClearEvent
@ stdcall -private -syscall ZwClose(long) NtClose
diff --git a/dlls/ntdll/tests/pipe.c b/dlls/ntdll/tests/pipe.c
index 0ad09daaa82..8e22acb8bb8 100644
--- a/dlls/ntdll/tests/pipe.c
+++ b/dlls/ntdll/tests/pipe.c
@@ -90,6 +90,7 @@ static NTSTATUS (WINAPI *pNtQueryVolumeInformationFile)(HANDLE handle,
PIO_STATU
static NTSTATUS (WINAPI *pNtSetInformationFile) (HANDLE handle, PIO_STATUS_BLOCK io,
PVOID ptr, ULONG len, FILE_INFORMATION_CLASS class);
static NTSTATUS (WINAPI *pNtCancelIoFile) (HANDLE hFile, PIO_STATUS_BLOCK io_status);
static NTSTATUS (WINAPI *pNtCancelIoFileEx) (HANDLE hFile, IO_STATUS_BLOCK *iosb,
IO_STATUS_BLOCK *io_status);
+static NTSTATUS (WINAPI *pNtCancelSynchronousIoFile) (HANDLE hFile, IO_STATUS_BLOCK
*iosb, IO_STATUS_BLOCK *io_status);
static NTSTATUS (WINAPI *pNtRemoveIoCompletion)(HANDLE, PULONG_PTR, PULONG_PTR,
PIO_STATUS_BLOCK, PLARGE_INTEGER);
static void (WINAPI *pRtlInitUnicodeString) (PUNICODE_STRING target, PCWSTR source);
@@ -114,6 +115,7 @@ static BOOL init_func_ptrs(void)
loadfunc(NtQueryVolumeInformationFile)
loadfunc(NtSetInformationFile)
loadfunc(NtCancelIoFile)
+ loadfunc(NtCancelSynchronousIoFile)
loadfunc(RtlInitUnicodeString)
loadfunc(NtRemoveIoCompletion)
@@ -615,6 +617,146 @@ static void test_cancelio(void)
CloseHandle(hEvent);
}
+struct synchronousio_thread_args
+{
+ HANDLE pipe;
+ IO_STATUS_BLOCK iosb;
+};
+
+static DWORD WINAPI synchronousio_thread(void *arg)
+{
+ struct synchronousio_thread_args *ctx = arg;
+ NTSTATUS res;
+
+ res = listen_pipe(ctx->pipe, NULL, &ctx->iosb, FALSE);
+ ok(res == STATUS_CANCELLED, "NtFsControlFile returned %lx\n", res);
+ return 0;
+}
+
+static void test_cancelsynchronousio(void)
+{
+ DWORD ret;
+ NTSTATUS res;
+ HANDLE event;
+ HANDLE thread;
+ HANDLE client;
+ IO_STATUS_BLOCK iosb;
+ struct synchronousio_thread_args ctx;
+
+ /* bogus values */
+ res = pNtCancelSynchronousIoFile((HANDLE)0xdeadbeef, NULL, &iosb);
+ todo_wine
+ ok(res == STATUS_INVALID_HANDLE, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL, NULL);
+ todo_wine
+ ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL,
(IO_STATUS_BLOCK*)0xdeadbeef);
+ todo_wine
+ ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), (HANDLE)0xdeadbeef, &iosb);
+ todo_wine
+ ok(res == STATUS_ACCESS_VIOLATION || broken(res == STATUS_NOT_FOUND), /* Win<10
*/
+ "NtCancelSynchronousIoFile returned %lx\n", res);
+
+ /* synchronous i/o */
+ res = create_pipe(&ctx.pipe, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_SYNCHRONOUS_IO_NONALERT);
+ ok(!res, "NtCreateNamedPipeFile returned %lx\n", res);
+
+ /* NULL io */
+ U(ctx.iosb).Status = 0xdeadbabe;
+ ctx.iosb.Information = 0xdeadbeef;
+ thread = CreateThread(NULL, 0, synchronousio_thread, &ctx, 0, 0);
+ /* wait for I/O to start, which transitions the pipe handle from signaled to
nonsignaled state. */
+ while ((ret = WaitForSingleObject(ctx.pipe, 0)) == WAIT_OBJECT_0) Sleep(1);
+ ok(ret == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
ret, GetLastError());
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = pNtCancelSynchronousIoFile(thread, NULL, &iosb);
+ todo_wine {
+ ok(res == STATUS_SUCCESS, "Failed to cancel I/O\n");
+ ok(U(iosb).Status == STATUS_SUCCESS, "iosb.Status got changed to %lx\n",
U(iosb).Status);
+ ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
+ }
+ if (res == STATUS_NOT_IMPLEMENTED)
+ pNtCancelIoFileEx(ctx.pipe, NULL, &iosb);
+ ret = WaitForSingleObject(thread, 1000);
+ ok(ret == WAIT_OBJECT_0, "wait returned %lx\n", ret);
+ CloseHandle(thread);
+ CloseHandle(ctx.pipe);
+ ok(U(ctx.iosb).Status == 0xdeadbabe, "wrong status %lx\n",
U(ctx.iosb).Status);
+ ok(ctx.iosb.Information == 0xdeadbeef, "wrong info %Iu\n",
ctx.iosb.Information);
+
+ /* specified io */
+ res = create_pipe(&ctx.pipe, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_SYNCHRONOUS_IO_NONALERT);
+ ok(!res, "NtCreateNamedPipeFile returned %lx\n", res);
+
+ U(ctx.iosb).Status = 0xdeadbabe;
+ ctx.iosb.Information = 0xdeadbeef;
+ thread = CreateThread(NULL, 0, synchronousio_thread, &ctx, 0, 0);
+ /* wait for I/O to start, which transitions the pipe handle from signaled to
nonsignaled state. */
+ while ((ret = WaitForSingleObject(ctx.pipe, 0)) == WAIT_OBJECT_0) Sleep(1);
+ ok(ret == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
ret, GetLastError());
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = pNtCancelSynchronousIoFile(thread, &iosb, &iosb);
+ todo_wine {
+ ok(res == STATUS_NOT_FOUND, "NtCancelSynchronousIoFile returned %lx\n",
res);
+ res = pNtCancelSynchronousIoFile(NULL, &ctx.iosb, &iosb);
+ ok(res == STATUS_INVALID_HANDLE, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ res = pNtCancelSynchronousIoFile(thread, &ctx.iosb, &iosb);
+ ok(res == STATUS_SUCCESS || broken(res == STATUS_NOT_FOUND) /* 32-bit */,
+ "Failed to cancel I/O\n");
+ ok(U(iosb).Status == STATUS_SUCCESS || broken(U(iosb).Status == STATUS_NOT_FOUND) /*
32-bit */,
+ "iosb.Status got changed to %lx\n", U(iosb).Status);
+ ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
+ }
+ if (res == STATUS_NOT_FOUND)
+ {
+ res = pNtCancelSynchronousIoFile(thread, NULL, &iosb);
+ ok(res == STATUS_SUCCESS, "Failed to cancel I/O\n");
+ ok(U(iosb).Status == STATUS_SUCCESS, "iosb.Status got changed to
%lx\n", U(iosb).Status);
+ }
+ if (res == STATUS_NOT_IMPLEMENTED)
+ pNtCancelIoFileEx(ctx.pipe, NULL, &iosb);
+ ret = WaitForSingleObject(thread, 1000);
+ ok(ret == WAIT_OBJECT_0, "wait returned %lx\n", ret);
+ CloseHandle(thread);
+ CloseHandle(ctx.pipe);
+ ok(U(ctx.iosb).Status == 0xdeadbabe, "wrong status %lx\n",
U(ctx.iosb).Status);
+ ok(ctx.iosb.Information == 0xdeadbeef, "wrong info %Iu\n",
ctx.iosb.Information);
+
+ /* asynchronous i/o */
+ U(ctx.iosb).Status = 0xdeadbabe;
+ ctx.iosb.Information = 0xdeadbeef;
+ res = create_pipe(&ctx.pipe, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, 0 /*
OVERLAPPED */);
+ ok(!res, "NtCreateNamedPipeFile returned %lx\n", res);
+ event = CreateEventW(NULL, TRUE, FALSE, NULL);
+ ok(event != INVALID_HANDLE_VALUE, "Can't create event, GetLastError:
%lx\n", GetLastError());
+ res = listen_pipe(ctx.pipe, event, &ctx.iosb, FALSE);
+ ok(res == STATUS_PENDING, "NtFsControlFile returned %lx\n", res);
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL, &iosb);
+ todo_wine {
+ ok(res == STATUS_NOT_FOUND, "NtCancelSynchronousIoFile returned %lx\n",
res);
+ ok(U(iosb).Status == STATUS_NOT_FOUND, "iosb.Status got changed to %lx\n",
U(iosb).Status);
+ ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), &ctx.iosb, &iosb);
+ ok(res == STATUS_NOT_FOUND, "NtCancelSynchronousIoFile returned %lx\n",
res);
+ ok(U(iosb).Status == STATUS_NOT_FOUND, "iosb.Status got changed to %lx\n",
U(iosb).Status);
+ ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
+ }
+ ret = WaitForSingleObject(event, 0);
+ ok(ret == WAIT_TIMEOUT, "wait returned %lx\n", ret);
+ client = CreateFileW(testpipe, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING,
+ FILE_FLAG_OVERLAPPED, 0);
+ ok(client != INVALID_HANDLE_VALUE, "can't open pipe: %lu\n",
GetLastError());
+ ret = WaitForSingleObject(event, 0);
+ ok(ret == WAIT_OBJECT_0, "wait returned %lx\n", ret);
+ CloseHandle(ctx.pipe);
+ CloseHandle(event);
+ CloseHandle(client);
+}
+
static void _check_pipe_handle_state(int line, HANDLE handle, ULONG read, ULONG
completion)
{
IO_STATUS_BLOCK iosb;
@@ -2694,6 +2836,9 @@ START_TEST(pipe)
trace("starting cancelio tests\n");
test_cancelio();
+ trace("starting cancelsynchronousio tests\n");
+ test_cancelsynchronousio();
+
trace("starting byte read in byte mode client -> server\n");
read_pipe_test(PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE);
trace("starting byte read in message mode client -> server\n");
diff --git a/dlls/ntdll/unix/file.c b/dlls/ntdll/unix/file.c
index 738367dbb57..9e65698d54e 100644
--- a/dlls/ntdll/unix/file.c
+++ b/dlls/ntdll/unix/file.c
@@ -5985,6 +5985,15 @@ NTSTATUS WINAPI NtCancelIoFileEx( HANDLE handle, IO_STATUS_BLOCK
*io, IO_STATUS_
}
+/**************************************************************************
+ * NtCancelSynchronousIoFile (NTDLL.@)
+ */
+NTSTATUS WINAPI NtCancelSynchronousIoFile( HANDLE handle, IO_STATUS_BLOCK *io,
IO_STATUS_BLOCK *io_status )
+{
+ FIXME( "(%p,%p,%p) stub\n", handle, io, io_status );
+ return STATUS_NOT_IMPLEMENTED;
+}
+
/******************************************************************
* NtLockFile (NTDLL.@)
*/
diff --git a/dlls/ntdll/unix/loader.c b/dlls/ntdll/unix/loader.c
index f58a716d08c..a7294281910 100644
--- a/dlls/ntdll/unix/loader.c
+++ b/dlls/ntdll/unix/loader.c
@@ -139,6 +139,7 @@ static void * const syscalls[] =
NtCallbackReturn,
NtCancelIoFile,
NtCancelIoFileEx,
+ NtCancelSynchronousIoFile,
NtCancelTimer,
NtClearEvent,
NtClose,
diff --git a/include/winternl.h b/include/winternl.h
index 19354dd7ffb..7749116cf50 100644
--- a/include/winternl.h
+++ b/include/winternl.h
@@ -3948,6 +3948,7 @@ NTSYSAPI NTSTATUS WINAPI
NtAssignProcessToJobObject(HANDLE,HANDLE);
NTSYSAPI NTSTATUS WINAPI NtCallbackReturn(PVOID,ULONG,NTSTATUS);
NTSYSAPI NTSTATUS WINAPI NtCancelIoFile(HANDLE,PIO_STATUS_BLOCK);
NTSYSAPI NTSTATUS WINAPI NtCancelIoFileEx(HANDLE,PIO_STATUS_BLOCK,PIO_STATUS_BLOCK);
+NTSYSAPI NTSTATUS WINAPI
NtCancelSynchronousIoFile(HANDLE,PIO_STATUS_BLOCK,PIO_STATUS_BLOCK);
NTSYSAPI NTSTATUS WINAPI NtCancelTimer(HANDLE, BOOLEAN*);
NTSYSAPI NTSTATUS WINAPI NtClearEvent(HANDLE);
NTSYSAPI NTSTATUS WINAPI NtClose(HANDLE);
--
GitLab
https://gitlab.winehq.org/wine/wine/-/merge_requests/47
5:23 a.m.
New subject: [PATCH v3 3/4] ntdll: Partially implement NtCancelSynchronousIoFile.
From: Daniel Lehman <dlehman25(a)gmail.com>
Signed-off-by: Daniel Lehman <dlehman25(a)gmail.com>
---
dlls/ntdll/tests/pipe.c | 16 +---------------
dlls/ntdll/unix/file.c | 18 ++++++++++++++++--
server/async.c | 34 ++++++++++++++++++++++++++++++++++
server/protocol.def | 5 +++++
4 files changed, 56 insertions(+), 17 deletions(-)
diff --git a/dlls/ntdll/tests/pipe.c b/dlls/ntdll/tests/pipe.c
index 8e22acb8bb8..e9ed864d617 100644
--- a/dlls/ntdll/tests/pipe.c
+++ b/dlls/ntdll/tests/pipe.c
@@ -645,18 +645,14 @@ static void test_cancelsynchronousio(void)
/* bogus values */
res = pNtCancelSynchronousIoFile((HANDLE)0xdeadbeef, NULL, &iosb);
- todo_wine
ok(res == STATUS_INVALID_HANDLE, "NtCancelSynchronousIoFile returned
%lx\n", res);
res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL, NULL);
- todo_wine
ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL,
(IO_STATUS_BLOCK*)0xdeadbeef);
- todo_wine
ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
memset(&iosb, 0x55, sizeof(iosb));
res = pNtCancelSynchronousIoFile(GetCurrentThread(), (HANDLE)0xdeadbeef, &iosb);
- todo_wine
- ok(res == STATUS_ACCESS_VIOLATION || broken(res == STATUS_NOT_FOUND), /* Win<10
*/
+ ok(res == STATUS_ACCESS_VIOLATION || res == STATUS_NOT_FOUND, /* Wine & Win <
10 */
"NtCancelSynchronousIoFile returned %lx\n", res);
/* synchronous i/o */
@@ -672,13 +668,9 @@ static void test_cancelsynchronousio(void)
ok(ret == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
ret, GetLastError());
memset(&iosb, 0x55, sizeof(iosb));
res = pNtCancelSynchronousIoFile(thread, NULL, &iosb);
- todo_wine {
ok(res == STATUS_SUCCESS, "Failed to cancel I/O\n");
ok(U(iosb).Status == STATUS_SUCCESS, "iosb.Status got changed to %lx\n",
U(iosb).Status);
ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
- }
- if (res == STATUS_NOT_IMPLEMENTED)
- pNtCancelIoFileEx(ctx.pipe, NULL, &iosb);
ret = WaitForSingleObject(thread, 1000);
ok(ret == WAIT_OBJECT_0, "wait returned %lx\n", ret);
CloseHandle(thread);
@@ -698,7 +690,6 @@ static void test_cancelsynchronousio(void)
ok(ret == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
ret, GetLastError());
memset(&iosb, 0x55, sizeof(iosb));
res = pNtCancelSynchronousIoFile(thread, &iosb, &iosb);
- todo_wine {
ok(res == STATUS_NOT_FOUND, "NtCancelSynchronousIoFile returned %lx\n",
res);
res = pNtCancelSynchronousIoFile(NULL, &ctx.iosb, &iosb);
ok(res == STATUS_INVALID_HANDLE, "NtCancelSynchronousIoFile returned
%lx\n", res);
@@ -708,15 +699,12 @@ static void test_cancelsynchronousio(void)
ok(U(iosb).Status == STATUS_SUCCESS || broken(U(iosb).Status == STATUS_NOT_FOUND) /*
32-bit */,
"iosb.Status got changed to %lx\n", U(iosb).Status);
ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
- }
if (res == STATUS_NOT_FOUND)
{
res = pNtCancelSynchronousIoFile(thread, NULL, &iosb);
ok(res == STATUS_SUCCESS, "Failed to cancel I/O\n");
ok(U(iosb).Status == STATUS_SUCCESS, "iosb.Status got changed to
%lx\n", U(iosb).Status);
}
- if (res == STATUS_NOT_IMPLEMENTED)
- pNtCancelIoFileEx(ctx.pipe, NULL, &iosb);
ret = WaitForSingleObject(thread, 1000);
ok(ret == WAIT_OBJECT_0, "wait returned %lx\n", ret);
CloseHandle(thread);
@@ -735,7 +723,6 @@ static void test_cancelsynchronousio(void)
ok(res == STATUS_PENDING, "NtFsControlFile returned %lx\n", res);
memset(&iosb, 0x55, sizeof(iosb));
res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL, &iosb);
- todo_wine {
ok(res == STATUS_NOT_FOUND, "NtCancelSynchronousIoFile returned %lx\n",
res);
ok(U(iosb).Status == STATUS_NOT_FOUND, "iosb.Status got changed to %lx\n",
U(iosb).Status);
ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
@@ -744,7 +731,6 @@ static void test_cancelsynchronousio(void)
ok(res == STATUS_NOT_FOUND, "NtCancelSynchronousIoFile returned %lx\n",
res);
ok(U(iosb).Status == STATUS_NOT_FOUND, "iosb.Status got changed to %lx\n",
U(iosb).Status);
ok(U(iosb).Information == 0, "iosb.Information got changed to %Iu\n",
U(iosb).Information);
- }
ret = WaitForSingleObject(event, 0);
ok(ret == WAIT_TIMEOUT, "wait returned %lx\n", ret);
client = CreateFileW(testpipe, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING,
diff --git a/dlls/ntdll/unix/file.c b/dlls/ntdll/unix/file.c
index 9e65698d54e..6719fc23909 100644
--- a/dlls/ntdll/unix/file.c
+++ b/dlls/ntdll/unix/file.c
@@ -5990,8 +5990,22 @@ NTSTATUS WINAPI NtCancelIoFileEx( HANDLE handle, IO_STATUS_BLOCK
*io, IO_STATUS_
*/
NTSTATUS WINAPI NtCancelSynchronousIoFile( HANDLE handle, IO_STATUS_BLOCK *io,
IO_STATUS_BLOCK *io_status )
{
- FIXME( "(%p,%p,%p) stub\n", handle, io, io_status );
- return STATUS_NOT_IMPLEMENTED;
+ NTSTATUS status;
+
+ TRACE( "(%p %p %p)\n", handle, io, io_status );
+ if (io) FIXME("Unimplemented yet parameter\n");
+
+ SERVER_START_REQ( cancel_sync )
+ {
+ req->handle = wine_server_obj_handle( handle );
+ req->iosb = wine_server_client_ptr( io );
+ status = wine_server_call( req );
+ }
+ SERVER_END_REQ;
+
+ io_status->u.Status = status;
+ io_status->Information = 0;
+ return status;
}
/******************************************************************
diff --git a/server/async.c b/server/async.c
index 4832d69b7bf..26946b5f5ce 100644
--- a/server/async.c
+++ b/server/async.c
@@ -588,6 +588,27 @@ restart:
return woken;
}
+static int cancel_blocking( struct process *process, struct thread *thread, client_ptr_t
iosb )
+{
+ struct async *async;
+ int woken = 0;
+
+restart:
+ LIST_FOR_EACH_ENTRY( async, &process->asyncs, struct async, process_entry )
+ {
+ if (async->terminated || async->canceled) continue;
+ if (async->blocking && async->thread == thread &&
+ (!iosb || async->data.iosb == iosb))
+ {
+ async->canceled = 1;
+ fd_cancel_async( async->fd, async );
+ woken++;
+ goto restart;
+ }
+ }
+ return woken;
+}
+
void cancel_process_asyncs( struct process *process )
{
cancel_async( process, NULL, NULL, 0 );
@@ -731,6 +752,19 @@ struct async *find_pending_async( struct async_queue *queue )
return NULL;
}
+/* cancels sync I/O on a thread */
+DECL_HANDLER(cancel_sync)
+{
+ struct thread *thread = get_thread_from_handle( req->handle, THREAD_TERMINATE );
+
+ if (thread)
+ {
+ if (!cancel_blocking( current->process, thread, req->iosb ))
+ set_error( STATUS_NOT_FOUND );
+ release_object( thread );
+ }
+}
+
/* cancels all async I/O */
DECL_HANDLER(cancel_async)
{
diff --git a/server/protocol.def b/server/protocol.def
index a8044582ef8..afa39db41c9 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -2159,6 +2159,11 @@ enum message_type
#define SERIALINFO_PENDING_WRITE 0x04
#define SERIALINFO_PENDING_WAIT 0x08
+/* Cancel all sync io on a thread */
+@REQ(cancel_sync)
+ obj_handle_t handle; /* thread handle on which to cancel io */
+ client_ptr_t iosb; /* I/O status block (NULL=all) */
+@END
/* Create an async I/O */
@REQ(register_async)
--
GitLab
https://gitlab.winehq.org/wine/wine/-/merge_requests/47
18 Sep
18 Sep
2:52 a.m.
New subject: [PATCH v3 3/4] ntdll: Partially implement NtCancelSynchronousIoFile.
On 7/26/22 00:23, Daniel Lehman wrote:
NTSTATUS WINAPI NtCancelSynchronousIoFile( HANDLE
handle, IO_STATUS_BLOCK *io, IO_STATUS_BLOCK *io_status )
{
- FIXME( "(%p,%p,%p) stub\n", handle, io, io_status );
- return STATUS_NOT_IMPLEMENTED;
+ NTSTATUS status;
+
+ TRACE( "(%p %p %p)\n", handle, io, io_status );
+ if (io) FIXME("Unimplemented yet parameter\n");
+
+ SERVER_START_REQ( cancel_sync )
+ {
+ req->handle = wine_server_obj_handle( handle );
+ req->iosb = wine_server_client_ptr( io );
+ status = wine_server_call( req );
+ }
+ SERVER_END_REQ;
+
+ io_status->u.Status = status;
+ io_status->Information = 0;
+ return status;
}
I asked before, but I don't think I got an answer: what's unimplemented
about the "io" parameter? It's not obvious just from reading the function.
26 Jul
26 Jul
5:23 a.m.
New subject: [PATCH v3 4/4] kernelbase: Call NtCancelSynchronousIoFile in CancelSynchronousIo.
From: Daniel Lehman <dlehman25(a)gmail.com>
Signed-off-by: Daniel Lehman <dlehman25(a)gmail.com>
---
dlls/kernel32/tests/pipe.c | 8 --------
dlls/kernelbase/file.c | 6 +++---
2 files changed, 3 insertions(+), 11 deletions(-)
diff --git a/dlls/kernel32/tests/pipe.c b/dlls/kernel32/tests/pipe.c
index 55890cc9172..9481835b49b 100644
--- a/dlls/kernel32/tests/pipe.c
+++ b/dlls/kernel32/tests/pipe.c
@@ -4247,14 +4247,12 @@ static void test_CancelSynchronousIo(void)
SetLastError(0xdeadbeef);
res = pCancelSynchronousIo((HANDLE)0xdeadbeef);
ok(!res, "CancelSynchronousIo succeeded unexpectedly\n");
- todo_wine
ok(GetLastError() == ERROR_INVALID_HANDLE,
"In CancelSynchronousIo failure, expected ERROR_INVALID_HANDLE, got
%ld\n", GetLastError());
SetLastError(0xdeadbeef);
res = pCancelSynchronousIo(GetCurrentThread());
ok(!res, "CancelSynchronousIo succeeded unexpectedly\n");
- todo_wine
ok(GetLastError() == ERROR_NOT_FOUND,
"In CancelSynchronousIo failure, expected ERROR_NOT_FOUND, got %ld\n",
GetLastError());
@@ -4269,14 +4267,9 @@ static void test_CancelSynchronousIo(void)
ok(wait == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
wait, GetLastError());
SetLastError(0xdeadbeef);
res = pCancelSynchronousIo(thread);
- todo_wine
- {
ok(res, "CancelSynchronousIo failed with error %ld\n", GetLastError());
ok(GetLastError() == 0xdeadbeef,
"In CancelSynchronousIo failure, expected 0xdeadbeef got %ld\n",
GetLastError());
- }
- if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
- CancelIoEx(pipe, NULL);
wait = WaitForSingleObject(thread, 1000);
ok(wait == WAIT_OBJECT_0, "WaitForSingleObject returned %lx\n", wait);
CloseHandle(thread);
@@ -4294,7 +4287,6 @@ static void test_CancelSynchronousIo(void)
SetLastError(0xdeadbeef);
res = pCancelSynchronousIo(thread);
ok(!res, "CancelSynchronousIo succeeded unexpectedly\n");
- todo_wine
ok(GetLastError() == ERROR_NOT_FOUND,
"In CancelSynchronousIo failure, expected ERROR_NOT_FOUND, got %ld\n",
GetLastError());
file = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0,
0);
diff --git a/dlls/kernelbase/file.c b/dlls/kernelbase/file.c
index 8ae982294f6..f7ae75b35f6 100644
--- a/dlls/kernelbase/file.c
+++ b/dlls/kernelbase/file.c
@@ -2900,9 +2900,9 @@ BOOL WINAPI DECLSPEC_HOTPATCH CancelIoEx( HANDLE handle,
LPOVERLAPPED overlapped
*/
BOOL WINAPI DECLSPEC_HOTPATCH CancelSynchronousIo( HANDLE thread )
{
- FIXME( "(%p): stub\n", thread );
- SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
- return FALSE;
+ IO_STATUS_BLOCK io;
+
+ return set_ntstatus( NtCancelSynchronousIoFile( thread, NULL, &io ));
}
--
GitLab
https://gitlab.winehq.org/wine/wine/-/merge_requests/47
17 Sep
17 Sep
12:04 a.m.
@iamahuman @zfigura this ok to merge?
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8737
18 Sep
18 Sep
12:33 p.m.
Jinoh Kang (@iamahuman) commented about dlls/ntdll/tests/pipe.c:
+ HANDLE client;
+ IO_STATUS_BLOCK iosb;
+ struct synchronousio_thread_args ctx;
+
+ /* bogus values */
+ res = pNtCancelSynchronousIoFile((HANDLE)0xdeadbeef, NULL, &iosb);
+ todo_wine
+ ok(res == STATUS_INVALID_HANDLE, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL, NULL);
+ todo_wine
+ ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL,
(IO_STATUS_BLOCK*)0xdeadbeef);
+ todo_wine
+ ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = pNtCancelSynchronousIoFile(GetCurrentThread(), (HANDLE)0xdeadbeef, &iosb);
```suggestion:-0+0
res = pNtCancelSynchronousIoFile(GetCurrentThread(), (IO_STATUS_BLOCK*)0xdeadbeef,
&iosb);
```
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8769
12:33 p.m.
Jinoh Kang (@iamahuman) commented about dlls/ntdll/tests/pipe.c:
+ U(ctx.iosb).Status = 0xdeadbabe;
+ ctx.iosb.Information = 0xdeadbeef;
+ thread = CreateThread(NULL, 0, synchronousio_thread, &ctx, 0, 0);
+ /* wait for I/O to start, which transitions the pipe handle from signaled to
nonsignaled state. */
+ while ((ret = WaitForSingleObject(ctx.pipe, 0)) == WAIT_OBJECT_0) Sleep(1);
+ ok(ret == WAIT_TIMEOUT, "WaitForSingleObject returned %lu (error %lu)\n",
ret, GetLastError());
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = pNtCancelSynchronousIoFile(thread, &iosb, &iosb);
+ todo_wine {
+ ok(res == STATUS_NOT_FOUND, "NtCancelSynchronousIoFile returned %lx\n",
res);
+ res = pNtCancelSynchronousIoFile(NULL, &ctx.iosb, &iosb);
+ ok(res == STATUS_INVALID_HANDLE, "NtCancelSynchronousIoFile returned
%lx\n", res);
+ res = pNtCancelSynchronousIoFile(thread, &ctx.iosb, &iosb);
+ ok(res == STATUS_SUCCESS || broken(res == STATUS_NOT_FOUND) /* 32-bit */,
+ "Failed to cancel I/O\n");
+ ok(U(iosb).Status == STATUS_SUCCESS || broken(U(iosb).Status == STATUS_NOT_FOUND) /*
32-bit */,
Is this broken on WOW64 (32-bit application on 64-bit Windows), real
32-bit Windows, or both?
In any case, I suggest using appropriate flags to test if this is actually the broken
platform.
See `dlls/kernel32/tests/virtual.c` for the WOW64 case. For application bitness case, we
can test for the `_WIN64` macro.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8770
12:33 p.m.
Jinoh Kang (@iamahuman) commented about dlls/ntdll/tests/pipe.c:
/* bogus values */
res = pNtCancelSynchronousIoFile((HANDLE)0xdeadbeef, NULL, &iosb);
- todo_wine
ok(res == STATUS_INVALID_HANDLE, "NtCancelSynchronousIoFile returned
%lx\n", res);
res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL, NULL);
- todo_wine
ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
res = pNtCancelSynchronousIoFile(GetCurrentThread(), NULL,
(IO_STATUS_BLOCK*)0xdeadbeef);
- todo_wine
ok(res == STATUS_ACCESS_VIOLATION, "NtCancelSynchronousIoFile returned
%lx\n", res);
memset(&iosb, 0x55, sizeof(iosb));
res = pNtCancelSynchronousIoFile(GetCurrentThread(), (HANDLE)0xdeadbeef,
&iosb);
- todo_wine
- ok(res == STATUS_ACCESS_VIOLATION || broken(res == STATUS_NOT_FOUND), /* Win<10
*/
+ ok(res == STATUS_ACCESS_VIOLATION || res == STATUS_NOT_FOUND, /* Wine & Win <
10 */
This should be better left as `todo_wine`.
```suggestion:-0+0
todo_wine_if(res == STATUS_NOT_FOUND)
ok(res == STATUS_ACCESS_VIOLATION || broken(res == STATUS_NOT_FOUND), /* Win<10 */
```
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8771
12:33 p.m.
I've left a few more comments. Would you mind checking them out?
Anyway, thanks for your contribution!
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8772
12:40 p.m.
I asked before, but I don't think I got an answer:
what's unimplemented about the "io" parameter? It's not obvious just
from reading the function.
As shown in the tests, the implementation's behaviour regarding `io` is not precise.
On Windows 10, supplying an invalid address results in `STATUS_ACCESS_VIOLATION`; however,
this implementation (and Windows < 10) simply fails with `STATUS_NOT_FOUND`.
This is indicative of the Windows implementation actually doing *something* with the
block, so it's worth a FIXME until the behaviour matches Windows.
Also, the FIXME won't cause much noise as it's not a common case (e.g.
`CancelSynchronousIo` does not use it).
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8773
4:20 p.m.
On Sun Sep 18 12:40:19 2022 +0000, Jinoh Kang wrote:
it doesn't fit neatly into either
implemented or unimplemented. it appears to be used in some way, but not an important
one
after your question, i had added some wine tests that showed it affects the return value
on 32-bit vs 64-bit windows but not the overall intended behavior
how about a different phrase, like 'Unused parameter'?
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8785
I asked
before, but I don't think I got an answer: what's
unimplemented about the
"io" parameter? It's not obvious just from
reading the function.
As shown in the tests, the implementation's behaviour regarding `io` is
not precise.
On Windows 10, supplying an invalid address results in
`STATUS_ACCESS_VIOLATION`; however, this implementation (and Windows <
10) simply fails with `STATUS_NOT_FOUND`.
This is indicative of the Windows implementation actually doing
*something* with the block, so it's worth a FIXME until the behaviour
matches Windows.
Also, the FIXME won't cause much noise as it's not a common case (e.g.
`CancelSynchronousIo` does not use it).
4:27 p.m.
On 9/18/22 11:20, Daniel Lehman (@dlehman25) wrote:
On Sun Sep 18 12:40:19 2022 +0000, Jinoh Kang wrote:
it doesn't fit neatly into either
implemented or unimplemented. it appears to be used in some way, but not an important
one
after your question, i had added some wine tests that showed it affects the return value
on 32-bit vs 64-bit windows but not the overall intended behavior
how about a different phrase, like 'Unused parameter'?
But it's not unused. We're interpreting it as a filter. If that's not
correct, maybe we should remove that part of the implementation?
I asked
before, but I don't think I got an answer: what's
unimplemented about the
"io" parameter? It's not obvious just from
reading the function.
As shown in the tests, the implementation's behaviour regarding `io` is
not precise.
On Windows 10, supplying an invalid address results in
`STATUS_ACCESS_VIOLATION`; however, this implementation (and Windows <
10) simply fails with `STATUS_NOT_FOUND`.
This is indicative of the Windows implementation actually doing
*something* with the block, so it's worth a FIXME until the behaviour
matches Windows.
Also, the FIXME won't cause much noise as it's not a common case (e.g.
`CancelSynchronousIo` does not use it).
4:26 p.m.
On Sun Sep 18 12:33:03 2022 +0000, Jinoh Kang wrote:
```suggestion:-0+0
res = pNtCancelSynchronousIoFile(GetCurrentThread(),
(IO_STATUS_BLOCK*)0xdeadbeef, &iosb);
```
done
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8786
4:48 p.m.
On Sun Sep 18 12:33:04 2022 +0000, Jinoh Kang wrote:
Is this broken on WOW64 (32-bit application on 64-bit
Windows), real
32-bit Windows, or both?
In any case, I suggest using appropriate flags to test if this is
actually the broken platform.
See `dlls/kernel32/tests/virtual.c` for the WOW64 case. For application
bitness case, we can test for the `_WIN64` macro.
looks like just wow64. will use
the kernel32 method
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8788
19 Sep
19 Sep
2:34 p.m.
On Sun Sep 18 12:33:04 2022 +0000, Jinoh Kang wrote:
This should be better left as `todo_wine`.
```suggestion:-0+0
todo_wine_if(res == STATUS_NOT_FOUND)
ok(res == STATUS_ACCESS_VIOLATION || broken(res ==
STATUS_NOT_FOUND), /* Win<10 */
```
will do
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8825
2:35 p.m.
`We're interpreting it as a filter`
ah, right. i'll remove the message
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/47#note_8826
592
days inactive
647
days old
17 comments
5 participants
participants (5)
-
Daniel Lehman -
Daniel Lehman (＠dlehman25)
-
Jinoh Kang (＠iamahuman)
-
Zebediah Figura -
Zebediah Figura (she/her)