Signed-off-by: Daniel Lehman dlehman25@gmail.com
-- v3: kernelbase: Call NtCancelSynchronousIoFile in CancelSynchronousIo. ntdll: Partially implement NtCancelSynchronousIoFile. ntdll: Add NtCancelSynchronousIoFile stub. kernel32/tests: Add tests for CancelSynchronousIo.
From: Daniel Lehman dlehman25@gmail.com
Signed-off-by: Daniel Lehman dlehman25@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(); }
From: Daniel Lehman dlehman25@gmail.com
Signed-off-by: Daniel Lehman dlehman25@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);
From: Daniel Lehman dlehman25@gmail.com
Signed-off-by: Daniel Lehman dlehman25@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)
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.
From: Daniel Lehman dlehman25@gmail.com
Signed-off-by: Daniel Lehman dlehman25@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 )); }
@iamahuman @zfigura this ok to merge?
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); ```
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.
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 */ ```
I've left a few more comments. Would you mind checking them out?
Anyway, thanks for your contribution!
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).
On Sun Sep 18 12:40:19 2022 +0000, Jinoh Kang wrote:
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).
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'?
On 9/18/22 11:20, Daniel Lehman (@dlehman25) wrote:
On Sun Sep 18 12:40:19 2022 +0000, Jinoh Kang wrote:
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).
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?
On Sun Sep 18 12:33:03 2022 +0000, Jinoh Kang wrote:
res = pNtCancelSynchronousIoFile(GetCurrentThread(), (IO_STATUS_BLOCK*)0xdeadbeef, &iosb);
done
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
On Sun Sep 18 12:33:04 2022 +0000, Jinoh Kang wrote:
This should be better left as `todo_wine`.
todo_wine_if(res == STATUS_NOT_FOUND) ok(res == STATUS_ACCESS_VIOLATION || broken(res == STATUS_NOT_FOUND), /* Win<10 */
will do
`We're interpreting it as a filter`
ah, right. i'll remove the message
-
Daniel Lehman -
Daniel Lehman (＠dlehman25)
-
Jinoh Kang (＠iamahuman)
-
Zebediah Figura -
Zebediah Figura (she/her)