[PATCH v3 0/7] MR6911: Draft: ntdll: Add WaitCompletionPacket.

[Zhiyi Zhang (＠zhiyi)]

WaitCompletionPacket is a kernel object that, when associated with a target object and a completion object and when the target object is signaled, adds the completion information stored in itself to the completion object.

For React Native.

--
  v3: ntdll: Implement NtCancelWaitCompletionPacket().
      ntdll: Implement NtAssociateWaitCompletionPacket().
      ntdll: Implement NtCreateWaitCompletionPacket().
      ntdll/tests: Add NtCancelWaitCompletionPacket() tests.
      ntdll/tests: Add NtAssociateWaitCompletionPacket() tests.
      ntdll/tests: Add NtCreateWaitCompletionPacket() tests.
      ntdll/tests: Add WaitCompletionPacket object tests.

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

[PATCH v3 1/7] ntdll/tests: Add WaitCompletionPacket object tests.

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/ntdll/tests/om.c | 5 ++++-
 include/winternl.h    | 6 ++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/dlls/ntdll/tests/om.c b/dlls/ntdll/tests/om.c
index 06fb3c1bf23..8a62ba39893 100644
--- a/dlls/ntdll/tests/om.c
+++ b/dlls/ntdll/tests/om.c
@@ -2350,6 +2350,7 @@ static void test_object_types(void)
         TYPE( L"Token",         TOKEN, SYNCHRONIZE, 0 ),
         TYPE( L"Type",          TYPE, SYNCHRONIZE, 0 ),
         TYPE( L"UserApcReserve", USER_APC_RESERVE, 0, 0 ),
+        TYPE( L"WaitCompletionPacket", WAIT_COMPLETION_PACKET, SYNCHRONIZE, 1),
         TYPE( L"WindowStation", WINSTA, 0, 0 ),
 #undef TYPE
     };
@@ -2411,7 +2412,9 @@ static void test_object_types(void)
             break;
         }

-        ok( j < ARRAY_SIZE(all_types), "type %s not found\n", debugstr_w(tests[i].name) );
+        todo_wine_if(!lstrcmpW(tests[i].name, L"WaitCompletionPacket"))
+        ok( broken(!lstrcmpW(tests[i].name, L"WaitCompletionPacket") && j == ARRAY_SIZE(all_types)) /* Win7 doesn't have WaitCompletionPacket */
+            || j < ARRAY_SIZE(all_types), "type %s not found\n", debugstr_w(tests[i].name) );
     }
     for (j = 0; j < ARRAY_SIZE(all_types); j++)
     {
diff --git a/include/winternl.h b/include/winternl.h
index be7fd727abe..ae2689165f3 100644
--- a/include/winternl.h
+++ b/include/winternl.h
@@ -3661,6 +3661,12 @@ typedef struct _FILE_IO_COMPLETION_INFORMATION {
     IO_STATUS_BLOCK IoStatusBlock;
 } FILE_IO_COMPLETION_INFORMATION, *PFILE_IO_COMPLETION_INFORMATION;

+#define WAIT_COMPLETION_PACKET_QUERY_STATE      0x0001
+#define WAIT_COMPLETION_PACKET_GENERIC_EXECUTE  (STANDARD_RIGHTS_EXECUTE|WAIT_COMPLETION_PACKET_QUERY_STATE)
+#define WAIT_COMPLETION_PACKET_GENERIC_READ     (STANDARD_RIGHTS_READ|WAIT_COMPLETION_PACKET_QUERY_STATE)
+#define WAIT_COMPLETION_PACKET_GENERIC_WRITE    (STANDARD_RIGHTS_WRITE|WAIT_COMPLETION_PACKET_QUERY_STATE)
+#define WAIT_COMPLETION_PACKET_ALL_ACCESS       (STANDARD_RIGHTS_REQUIRED|WAIT_COMPLETION_PACKET_QUERY_STATE)
+
 typedef enum _HARDERROR_RESPONSE_OPTION {
   OptionAbortRetryIgnore,
   OptionOk,

[PATCH v3 2/7] ntdll/tests: Add NtCreateWaitCompletionPacket() tests.

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/ntdll/tests/file.c | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c
index 0d9b3653630..1cb8b15e5a6 100644
--- a/dlls/ntdll/tests/file.c
+++ b/dlls/ntdll/tests/file.c
@@ -56,6 +56,7 @@ static NTSTATUS (WINAPI *pNtAllocateReserveObject)( HANDLE *, const OBJECT_ATTRI
 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
                                        ULONG, ULONG, ULONG, PLARGE_INTEGER );
 static NTSTATUS (WINAPI *pNtCreateFile)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
+static NTSTATUS (WINAPI *pNtCreateWaitCompletionPacket)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
 static NTSTATUS (WINAPI *pNtOpenFile)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
 static NTSTATUS (WINAPI *pNtDeleteFile)(POBJECT_ATTRIBUTES ObjectAttributes);
 static NTSTATUS (WINAPI *pNtReadFile)(HANDLE hFile, HANDLE hEvent,
@@ -6892,6 +6893,42 @@ static void test_file_map_large_size(void)
     DeleteFileA(source);
 }

+static void test_create_wait_completion_packet(void)
+{
+    UNICODE_STRING name = RTL_CONSTANT_STRING(L"\BaseNamedObjects\test_create_waitcompletionpacket");
+    HANDLE handle, handle2;
+    OBJECT_ATTRIBUTES attr;
+    NTSTATUS status;
+
+    if (!pNtCreateWaitCompletionPacket)
+    {
+        todo_wine
+        win_skip("NtCreateWaitCompletionPacket is unavailable.\n");
+        return;
+    }
+
+    InitializeObjectAttributes(&attr, &name, 0, NULL, NULL);
+
+    /* Parameter checks */
+    status = pNtCreateWaitCompletionPacket(NULL, GENERIC_ALL, &attr);
+    ok(status == STATUS_ACCESS_VIOLATION, "Got unexpected status %#lx.\n", status);
+
+    status = pNtCreateWaitCompletionPacket(&handle, 0, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    pNtClose(handle);
+
+    status = pNtCreateWaitCompletionPacket(&handle, GENERIC_ALL, NULL);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    pNtClose(handle);
+
+    status = pNtCreateWaitCompletionPacket(&handle, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtCreateWaitCompletionPacket(&handle2, GENERIC_ALL, &attr);
+    ok(status == STATUS_OBJECT_NAME_COLLISION, "Got unexpected status %#lx.\n", status);
+    pNtClose(handle);
+}
+
 START_TEST(file)
 {
     HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
@@ -6912,6 +6949,7 @@ START_TEST(file)
     pNtAllocateReserveObject= (void *)GetProcAddress(hntdll, "NtAllocateReserveObject");
     pNtCreateMailslotFile   = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
     pNtCreateFile           = (void *)GetProcAddress(hntdll, "NtCreateFile");
+    pNtCreateWaitCompletionPacket = (void *)GetProcAddress(hntdll, "NtCreateWaitCompletionPacket");
     pNtOpenFile             = (void *)GetProcAddress(hntdll, "NtOpenFile");
     pNtDeleteFile           = (void *)GetProcAddress(hntdll, "NtDeleteFile");
     pNtReadFile             = (void *)GetProcAddress(hntdll, "NtReadFile");
@@ -6976,4 +7014,5 @@ START_TEST(file)
     test_mailslot_name();
     test_reparse_points();
     test_file_map_large_size();
+    test_create_wait_completion_packet();
 }

[PATCH v3 3/7] ntdll/tests: Add NtAssociateWaitCompletionPacket() tests.

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/ntdll/tests/file.c | 710 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 710 insertions(+)

diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c
index 1cb8b15e5a6..eec3928c77b 100644
--- a/dlls/ntdll/tests/file.c
+++ b/dlls/ntdll/tests/file.c
@@ -44,6 +44,8 @@
 #define IO_COMPLETION_ALL_ACCESS 0x001F0003
 #endif

+#define KEYEDEVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x0003)
+
 static BOOL     (WINAPI * pGetVolumePathNameW)(LPCWSTR, LPWSTR, DWORD);
 static UINT     (WINAPI *pGetSystemWow64DirectoryW)( LPWSTR, UINT );

@@ -53,8 +55,14 @@ static BOOL     (WINAPI *pRtlDosPathNameToNtPathName_U)( LPCWSTR, PUNICODE_STRIN
 static NTSTATUS (WINAPI *pRtlWow64EnableFsRedirectionEx)( ULONG, ULONG * );

static NTSTATUS (WINAPI *pNtAllocateReserveObject)( HANDLE *, const OBJECT_ATTRIBUTES *, MEMORY_RESERVE_OBJECT_TYPE );
+static NTSTATUS (WINAPI *pNtAssociateWaitCompletionPacket)(HANDLE, HANDLE, HANDLE, PVOID, PVOID,
+                                                           NTSTATUS, ULONG_PTR, PBOOLEAN);
+static NTSTATUS (WINAPI *pNtCreateEvent)(PHANDLE, ACCESS_MASK, const OBJECT_ATTRIBUTES *, EVENT_TYPE, BOOLEAN);
+static NTSTATUS (WINAPI *pNtCreateKeyedEvent)(HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, ULONG);
 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
                                        ULONG, ULONG, ULONG, PLARGE_INTEGER );
+static NTSTATUS (WINAPI *pNtCreateMutant)(PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, BOOLEAN);
+static NTSTATUS (WINAPI *pNtCreateSemaphore)(HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, LONG, LONG);
 static NTSTATUS (WINAPI *pNtCreateFile)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
 static NTSTATUS (WINAPI *pNtCreateWaitCompletionPacket)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
 static NTSTATUS (WINAPI *pNtOpenFile)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
@@ -75,9 +83,11 @@ static NTSTATUS (WINAPI *pNtFsControlFile) (HANDLE handle, HANDLE event, PIO_APC

static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG);
 static NTSTATUS (WINAPI *pNtOpenIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
+static NTSTATUS (WINAPI *pNtPulseEvent)(HANDLE, LONG *);
 static NTSTATUS (WINAPI *pNtQueryIoCompletion)(HANDLE, IO_COMPLETION_INFORMATION_CLASS, PVOID, ULONG, PULONG);
 static NTSTATUS (WINAPI *pNtRemoveIoCompletion)(HANDLE, PULONG_PTR, PULONG_PTR, PIO_STATUS_BLOCK, PLARGE_INTEGER);
 static NTSTATUS (WINAPI *pNtRemoveIoCompletionEx)(HANDLE,FILE_IO_COMPLETION_INFORMATION*,ULONG,ULONG*,LARGE_INTEGER*,BOOLEAN);
+static NTSTATUS (WINAPI *pNtSetEvent)(HANDLE, LONG *);
 static NTSTATUS (WINAPI *pNtSetIoCompletion)(HANDLE, ULONG_PTR, ULONG_PTR, NTSTATUS, SIZE_T);
 static NTSTATUS (WINAPI *pNtSetIoCompletionEx)(HANDLE, HANDLE, ULONG_PTR, ULONG_PTR, NTSTATUS, SIZE_T);
 static NTSTATUS (WINAPI *pNtSetInformationFile)(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS);
@@ -6929,6 +6939,698 @@ static void test_create_wait_completion_packet(void)
     pNtClose(handle);
 }

+struct test_wait_completion_packet_thread_info
+{
+    HANDLE client;
+    HANDLE completion;
+    HANDLE event;
+};
+
+static DWORD WINAPI test_associate_wait_completion_packet_child_thread(void *arg)
+{
+    struct test_wait_completion_packet_thread_info *info = arg;
+    ULONG_PTR key_context, apc_context;
+    LARGE_INTEGER timeout = {{0}};
+    BYTE send_buf[TEST_BUF_LEN];
+    ULONG completion_count;
+    IO_STATUS_BLOCK iosb;
+    DWORD written_bytes;
+    NTSTATUS status;
+
+    memset(send_buf, 0xc1, TEST_BUF_LEN);
+    WriteFile(info->client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+
+    timeout.QuadPart = -1000000;
+    status = pNtRemoveIoCompletion(info->completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 51, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 52, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 53, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    completion_count = get_pending_msgs(info->completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtSetEvent(info->event, NULL);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    return 0;
+}
+
+static void test_associate_wait_completion_packet(void)
+{
+    static const char pipe_name[] = "\\.\pipe\test_associate_wait_completion_packet";
+    UNICODE_STRING packet_name = RTL_CONSTANT_STRING(L"\BaseNamedObjects\test_associate_wait_completion_packet");
+    UNICODE_STRING packet_name2 = RTL_CONSTANT_STRING(L"\BaseNamedObjects\test_associate_wait_completion_packet2");
+    UNICODE_STRING mutant_name = RTL_CONSTANT_STRING(L"\BaseNamedObjects\test_associate_wait_completion_packet_mutant");
+    UNICODE_STRING keyed_event_name = RTL_CONSTANT_STRING(L"\BaseNamedObjects\test_associate_wait_completion_packet_keyed_event");
+    struct test_wait_completion_packet_thread_info thread_info;
+    HANDLE event, mutant, keyed_event, semaphore, thread;
+    BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN];
+    HANDLE completion, packet, packet2, server, client;
+    FILE_IO_COMPLETION_NOTIFICATION_INFORMATION info;
+    ULONG_PTR key_context, apc_context;
+    DWORD read_bytes, written_bytes;
+    FILE_COMPLETION_INFORMATION fci;
+    LARGE_INTEGER timeout = {{0}};
+    OVERLAPPED overlapped = {0};
+    OBJECT_ATTRIBUTES attr;
+    ULONG completion_count;
+    IO_STATUS_BLOCK iosb;
+    BOOLEAN signaled;
+    NTSTATUS status;
+
+    if (!pNtAssociateWaitCompletionPacket)
+    {
+        todo_wine
+        win_skip("NtAssociateWaitCompletionPacket is unavailable.\n");
+        return;
+    }
+
+    status = pNtCreateIoCompletion(&completion, IO_COMPLETION_ALL_ACCESS, NULL, 0);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    server = CreateNamedPipeA(pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                              PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024,
+                              1000, NULL);
+    ok(server != INVALID_HANDLE_VALUE, "CreateNamedPipe failed, error %lu.\n", GetLastError());
+    client = CreateFileA(pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+                         FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
+    ok(client != INVALID_HANDLE_VALUE, "CreateFile failed, error %lu.\n", GetLastError());
+
+    /* Test normal NtAssociateWaitCompletionPacket() calls */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(!is_signaled(packet), "Expected packet not signaled.\n");
+    /* ReadFile() should be called before NtAssociateWaitCompletionPacket(). Otherwise, the server
+     * object stays signaled */
+    memset(send_buf, 0xa1, TEST_BUF_LEN);
+    memset(recv_buf, 0xb2, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)1, (void *)2,
+                                              STATUS_SUCCESS, (ULONG_PTR)3, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+    ok(!is_signaled(packet), "Expected packet not signaled.\n");
+
+    /* Associating an already associated wait completion packet */
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)1, (void *)2,
+                                              STATUS_SUCCESS, (ULONG_PTR)3, &signaled);
+    ok(status == STATUS_INVALID_PARAMETER_1, "Got unexpected status %#lx.\n", status);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+    ok(!is_signaled(packet), "Expected packet not signaled.\n");
+
+    /* Associating an already queued wait completion packet */
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)1, (void *)2,
+                                              STATUS_SUCCESS, (ULONG_PTR)3, &signaled);
+    ok(status == STATUS_INVALID_PARAMETER_1, "Got unexpected status %#lx.\n", status);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 1, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 2, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 3, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) did not match send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+    ok(!is_signaled(packet), "Expected packet not signaled.\n");
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == WAIT_TIMEOUT, "Got unexpected status %#lx.\n", status);
+
+    /* Associating an already removed wait completion packet */
+    memset(send_buf, 0xa2, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)4, (void *)5,
+                                              STATUS_SUCCESS, (ULONG_PTR)6, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 4, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 5, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 6, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) did not match send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    /* Test associating wait completion packet before setting I/O completion */
+    memset(send_buf, 0xa3, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)7, (void *)8,
+                                              STATUS_SUCCESS, (ULONG_PTR)9, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    fci.CompletionPort = completion;
+    fci.CompletionKey = CKEY_FIRST;
+    iosb.Status = 0xdeadbeef;
+    status = pNtSetInformationFile(server, &iosb, &fci, sizeof(fci), FileCompletionInformation);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx.\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Unexpected completion count %ld.\n", completion_count);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 2, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 7, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 8, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 9, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) matched send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == CKEY_FIRST, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == (ULONG_PTR)&overlapped, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == TEST_BUF_LEN, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) did not match send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    /* Test associating wait completion packet after setting I/O completion for the same file */
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    signaled = FALSE;
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)10, (void *)11,
+                                              STATUS_SUCCESS, (ULONG_PTR)12, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == CKEY_FIRST, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == (ULONG_PTR)&overlapped, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == TEST_BUF_LEN, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) did not match send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 10, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 11, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 12, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) matched send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    /* Test associating wait completion packet after setting I/O completion for a new file */
+    status = pNtClose(client);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(server);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    server = CreateNamedPipeA(pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                              PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024,
+                              1000, NULL);
+    ok(server != INVALID_HANDLE_VALUE, "CreateNamedPipe failed, error %lu.\n", GetLastError());
+    client = CreateFileA(pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+                         FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
+    ok(client != INVALID_HANDLE_VALUE, "CreateFile failed, error %lu.\n", GetLastError());
+
+    memset(send_buf, 0xa4, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    fci.CompletionPort = completion;
+    fci.CompletionKey = CKEY_SECOND;
+    iosb.Status = 0xdeadbeef;
+    status = pNtSetInformationFile(server, &iosb, &fci, sizeof(fci), FileCompletionInformation);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx.\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    signaled = FALSE;
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)13, (void *)14,
+                                              STATUS_SUCCESS, (ULONG_PTR)15, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == TRUE, "Got unexpected signaled %d.\n", signaled);
+
+    /* Notice the wait completion packet gets added immediately when there is a completion set, even
+     * without writing to the file */
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 13, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 14, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 15, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) matched send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == CKEY_SECOND, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == (ULONG_PTR)&overlapped, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == TEST_BUF_LEN, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) did not match send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    /* Test file with FILE_SKIP_SET_EVENT_ON_HANDLE set */
+    status = pNtClose(client);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(server);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    server = CreateNamedPipeA(pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                              PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024,
+                              1000, NULL);
+    ok(server != INVALID_HANDLE_VALUE, "CreateNamedPipe failed, error %lu.\n", GetLastError());
+    client = CreateFileA(pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+                         FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
+    ok(client != INVALID_HANDLE_VALUE, "CreateFile failed, error %lu.\n", GetLastError());
+
+    info.Flags = FILE_SKIP_SET_EVENT_ON_HANDLE;
+    status = pNtSetInformationFile(server, &iosb, &info, sizeof(info), FileIoCompletionNotificationInformation);
+    ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08lx\n", status);
+    ok(!is_signaled(server), "Expected server not signaled\n");
+
+    memset(send_buf, 0xa4, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    signaled = FALSE;
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)16, (void *)17,
+                                              STATUS_SUCCESS, (ULONG_PTR)18, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    /* Test associating two wait completion packets */
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(client);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(server);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    server = CreateNamedPipeA(pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                              PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024,
+                              1000, NULL);
+    ok(server != INVALID_HANDLE_VALUE, "CreateNamedPipe failed, error %lu.\n", GetLastError());
+    client = CreateFileA(pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+                         FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
+    ok(client != INVALID_HANDLE_VALUE, "CreateFile failed, error %lu.\n", GetLastError());
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    InitializeObjectAttributes(&attr, &packet_name2, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet2, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    memset(send_buf, 0xa5, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)19, (void *)20,
+                                              STATUS_SUCCESS, (ULONG_PTR)21, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtAssociateWaitCompletionPacket(packet2, completion, server, (void *)22, (void *)23,
+                                              STATUS_SUCCESS, (ULONG_PTR)24, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 2, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 19, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 20, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 21, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    ok(!memcmp(send_buf, recv_buf, TEST_BUF_LEN),
+       "Receive buffer (%02x %02x %02x) did not match send buffer (%02x %02x %02x)\n", recv_buf[0],
+       recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2]);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 22, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 23, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 24, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtClose(packet2);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Test associating manual-reset events */
+    status = pNtCreateEvent(&event, GENERIC_ALL, NULL, NotificationEvent, 0);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, event, (void *)25, (void *)26,
+                                              STATUS_SUCCESS, (ULONG_PTR)27, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtPulseEvent(event, NULL);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 25, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 26, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 27, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    /* Test closing wait completion packets before the target object is signaled */
+    status = pNtAssociateWaitCompletionPacket(packet, completion, event, (void *)28, (void *)29,
+                                              STATUS_SUCCESS, (ULONG_PTR)30, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtPulseEvent(event, NULL);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    /* Test closing wait completion packets right after the target object is signaled */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, event, (void *)31, (void *)32,
+                                              STATUS_SUCCESS, (ULONG_PTR)33, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtPulseEvent(event, NULL);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtClose(event);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Test associating auto-reset events */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtCreateEvent(&event, GENERIC_ALL, NULL, SynchronizationEvent, 0);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, event, (void *)34, (void *)35,
+                                              STATUS_SUCCESS, (ULONG_PTR)36, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtSetEvent(event, NULL);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(!is_signaled(event), "Expected event not signaled.\n");
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+    ok(!is_signaled(event), "Expected event not signaled.\n");
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 34, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 35, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 36, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtClose(event);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Test that associating semaphores */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtCreateSemaphore(&semaphore, GENERIC_ALL, NULL, 1, 2);
+    ok( status == STATUS_SUCCESS, "Failed to create Semaphore(%08lx)\n", status );
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, semaphore, (void *)37, (void *)38,
+                                              STATUS_SUCCESS, (ULONG_PTR)39, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == TRUE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 37, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 38, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 39, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtClose(semaphore);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Test that associating mutexes is invalid */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, MUTANT_ALL_ACCESS, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    InitializeObjectAttributes(&attr, &mutant_name, 0, NULL, NULL);
+    status = pNtCreateMutant(&mutant, GENERIC_ALL, &attr, FALSE);
+    ok(status == STATUS_SUCCESS, "Failed to create Mutant(%08lx)\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, mutant, (void *)40, (void *)41,
+                                              STATUS_SUCCESS, (ULONG_PTR)41, &signaled);
+    ok(status == STATUS_INVALID_PARAMETER_3, "Got unexpected status %#lx.\n", status);
+
+    status = pNtClose(mutant);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Test that associating owned mutexes is invalid */
+    InitializeObjectAttributes(&attr, &mutant_name, 0, NULL, NULL);
+    status = pNtCreateMutant(&mutant, MUTANT_ALL_ACCESS, &attr, TRUE);
+    ok(status == STATUS_SUCCESS, "Failed to create Mutant(%08lx)\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, mutant, (void *)42, (void *)44,
+                                              STATUS_SUCCESS, (ULONG_PTR)44, &signaled);
+    ok(status == STATUS_INVALID_PARAMETER_3, "Got unexpected status %#lx.\n", status);
+
+    status = pNtClose(mutant);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Test that associating keyed events is invalid */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    InitializeObjectAttributes(&attr, &keyed_event_name, 0, NULL, NULL);
+    status = pNtCreateKeyedEvent(&keyed_event, KEYEDEVENT_ALL_ACCESS | SYNCHRONIZE, &attr, 0);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, keyed_event, (void *)45, (void *)46,
+                                              STATUS_SUCCESS, (ULONG_PTR)47, &signaled);
+    ok(status == STATUS_INVALID_PARAMETER_3, "Got unexpected status %#lx.\n", status);
+
+    status = pNtClose(keyed_event);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Test associating two targets for two completion packets in the current thread. Then in
+     * another thread, make the second target signaled to test that the completion packet for the
+     * second target gets added to the completion object */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    InitializeObjectAttributes(&attr, &packet_name2, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet2, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtCreateEvent(&event, GENERIC_ALL, NULL, NotificationEvent, 0);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    memset(send_buf, 0xa5, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, event, (void *)48, (void *)49,
+                                              STATUS_SUCCESS, (ULONG_PTR)50, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtAssociateWaitCompletionPacket(packet2, completion, server, (void *)51, (void *)52,
+                                              STATUS_SUCCESS, (ULONG_PTR)53, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    thread_info.client = client;
+    thread_info.completion = completion;
+    thread_info.event = event;
+    thread = CreateThread(NULL, 0, test_associate_wait_completion_packet_child_thread, &thread_info, 0, NULL);
+    WaitForSingleObject(event, INFINITE);
+    WaitForSingleObject(thread, INFINITE);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 48, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 49, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 50, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == STATUS_SUCCESS, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    status = pNtClose(thread);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(event);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(packet2);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Parameter checks */
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(NULL, completion, server, (void *)0xa, (void *)0xb,
+                                              STATUS_SUCCESS, (ULONG_PTR)0xc, &signaled);
+    ok(status == STATUS_INVALID_HANDLE, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(INVALID_HANDLE_VALUE, completion, server, (void *)0xa,
+                                              (void *)0xb, STATUS_SUCCESS, (ULONG_PTR)0xc, &signaled);
+    ok(status == STATUS_OBJECT_TYPE_MISMATCH, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, NULL, server, (void *)0xa, (void *)0xb,
+                                              STATUS_SUCCESS, (ULONG_PTR)0xc, &signaled);
+    ok(status == STATUS_INVALID_HANDLE, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, INVALID_HANDLE_VALUE, server, (void *)0xa,
+                                              (void *)0xb, STATUS_SUCCESS, (ULONG_PTR)0xc, &signaled);
+    ok(status == STATUS_OBJECT_TYPE_MISMATCH, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, NULL, (void *)0xa, (void *)0xb,
+                                              STATUS_SUCCESS, (ULONG_PTR)0xc, &signaled);
+    ok(status == STATUS_INVALID_HANDLE, "Got unexpected status %#lx.\n", status);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)0xa, (void *)0xb,
+                                              0xdeadbeef, (ULONG_PTR)0xc, NULL);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(key_context == 0xa, "Got unexpected completion key %Id\n", key_context);
+    ok(apc_context == 0xb, "Got unexpected completion value %Id\n", apc_context);
+    ok(iosb.Information == 0xc, "Got unexpected iosb.Information %Id\n", iosb.Information);
+    ok(iosb.Status == 0xdeadbeef, "Got unexpected iosb.Status %#lx\n", iosb.Status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Unexpected completion count %ld.\n", completion_count);
+
+    /* This test associates the wait completion packet with INVALID_HANDLE_VALUE, which will never
+     * be signaled */
+    status = pNtAssociateWaitCompletionPacket(packet, completion, INVALID_HANDLE_VALUE, (void *)0xa,
+                                              (void *)0xb, STATUS_SUCCESS, (ULONG_PTR)0xc, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    status = pNtRemoveIoCompletion(completion, &key_context, &apc_context, &iosb, &timeout);
+    ok(status == WAIT_TIMEOUT, "Got unexpected status %#lx.\n", status);
+
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(client);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(server);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(completion);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+}
+
 START_TEST(file)
 {
     HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
@@ -6947,7 +7649,12 @@ START_TEST(file)
     pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
     pRtlWow64EnableFsRedirectionEx = (void *)GetProcAddress(hntdll, "RtlWow64EnableFsRedirectionEx");
     pNtAllocateReserveObject= (void *)GetProcAddress(hntdll, "NtAllocateReserveObject");
+    pNtAssociateWaitCompletionPacket = (void *)GetProcAddress(hntdll, "NtAssociateWaitCompletionPacket");
+    pNtCreateEvent          = (void *)GetProcAddress(hntdll, "NtCreateEvent");
+    pNtCreateKeyedEvent     = (void *)GetProcAddress(hntdll, "NtCreateKeyedEvent");
     pNtCreateMailslotFile   = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
+    pNtCreateMutant         = (void *)GetProcAddress(hntdll, "NtCreateMutant");
+    pNtCreateSemaphore      = (void *)GetProcAddress(hntdll, "NtCreateSemaphore");
     pNtCreateFile           = (void *)GetProcAddress(hntdll, "NtCreateFile");
     pNtCreateWaitCompletionPacket = (void *)GetProcAddress(hntdll, "NtCreateWaitCompletionPacket");
     pNtOpenFile             = (void *)GetProcAddress(hntdll, "NtOpenFile");
@@ -6960,9 +7667,11 @@ START_TEST(file)
     pNtFsControlFile        = (void *)GetProcAddress(hntdll, "NtFsControlFile");
     pNtCreateIoCompletion   = (void *)GetProcAddress(hntdll, "NtCreateIoCompletion");
     pNtOpenIoCompletion     = (void *)GetProcAddress(hntdll, "NtOpenIoCompletion");
+    pNtPulseEvent           = (void *)GetProcAddress(hntdll, "NtPulseEvent");
     pNtQueryIoCompletion    = (void *)GetProcAddress(hntdll, "NtQueryIoCompletion");
     pNtRemoveIoCompletion   = (void *)GetProcAddress(hntdll, "NtRemoveIoCompletion");
     pNtRemoveIoCompletionEx = (void *)GetProcAddress(hntdll, "NtRemoveIoCompletionEx");
+    pNtSetEvent             = (void *)GetProcAddress(hntdll, "NtSetEvent");
     pNtSetIoCompletion      = (void *)GetProcAddress(hntdll, "NtSetIoCompletion");
     pNtSetIoCompletionEx    = (void *)GetProcAddress(hntdll, "NtSetIoCompletionEx");
     pNtSetInformationFile   = (void *)GetProcAddress(hntdll, "NtSetInformationFile");
@@ -7015,4 +7724,5 @@ START_TEST(file)
     test_reparse_points();
     test_file_map_large_size();
     test_create_wait_completion_packet();
+    test_associate_wait_completion_packet();
 }

[PATCH v3 4/7] ntdll/tests: Add NtCancelWaitCompletionPacket() tests.

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/ntdll/tests/file.c | 108 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)

diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c
index eec3928c77b..db954e9087c 100644
--- a/dlls/ntdll/tests/file.c
+++ b/dlls/ntdll/tests/file.c
@@ -57,6 +57,7 @@ static NTSTATUS (WINAPI *pRtlWow64EnableFsRedirectionEx)( ULONG, ULONG * );
 static NTSTATUS (WINAPI *pNtAllocateReserveObject)( HANDLE *, const OBJECT_ATTRIBUTES *, MEMORY_RESERVE_OBJECT_TYPE );
 static NTSTATUS (WINAPI *pNtAssociateWaitCompletionPacket)(HANDLE, HANDLE, HANDLE, PVOID, PVOID,
                                                            NTSTATUS, ULONG_PTR, PBOOLEAN);
+static NTSTATUS (WINAPI *pNtCancelWaitCompletionPacket)(HANDLE, BOOLEAN);
 static NTSTATUS (WINAPI *pNtCreateEvent)(PHANDLE, ACCESS_MASK, const OBJECT_ATTRIBUTES *, EVENT_TYPE, BOOLEAN);
 static NTSTATUS (WINAPI *pNtCreateKeyedEvent)(HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, ULONG);
 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
@@ -7631,6 +7632,111 @@ static void test_associate_wait_completion_packet(void)
     ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
 }

+static void test_cancel_wait_completion_packet(void)
+{
+    static const char pipe_name[] = "\\.\pipe\test_cancel_wait_completion_packet";
+    UNICODE_STRING packet_name = RTL_CONSTANT_STRING(L"\BaseNamedObjects\test_cancel_wait_completion_packet");
+    BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN];
+    HANDLE completion, packet, server, client;
+    DWORD read_bytes, written_bytes;
+    OVERLAPPED overlapped = {0};
+    OBJECT_ATTRIBUTES attr;
+    ULONG completion_count;
+    BOOLEAN signaled;
+    NTSTATUS status;
+
+    if (!pNtCancelWaitCompletionPacket)
+    {
+        todo_wine
+        win_skip("NtCancelWaitCompletionPacket is unavailable.\n");
+        return;
+    }
+
+    status = pNtCreateIoCompletion(&completion, IO_COMPLETION_ALL_ACCESS, NULL, 0);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    server = CreateNamedPipeA(pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                              PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024,
+                              1000, NULL);
+    ok(server != INVALID_HANDLE_VALUE, "CreateNamedPipe failed, error %lu.\n", GetLastError());
+    client = CreateFileA(pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+                         FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
+    ok(client != INVALID_HANDLE_VALUE, "CreateFile failed, error %lu.\n", GetLastError());
+
+    InitializeObjectAttributes(&attr, &packet_name, 0, NULL, NULL);
+    status = pNtCreateWaitCompletionPacket(&packet, GENERIC_ALL, &attr);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    /* Remove not associated packets */
+    status = pNtCancelWaitCompletionPacket(packet, TRUE);
+    ok(status == STATUS_CANCELLED, "Got unexpected status %#lx.\n", status);
+
+    /* ReadFile() should be called before NtAssociateWaitCompletionPacket(). Otherwise, the server
+     * object stays signaled */
+    memset(send_buf, 0xa1, TEST_BUF_LEN);
+    memset(recv_buf, 0xb2, TEST_BUF_LEN);
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    /* Cancel non-signaled packets */
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)1, (void *)2,
+                                              STATUS_SUCCESS, (ULONG_PTR)3, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtCancelWaitCompletionPacket(packet, FALSE);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    /* Cancel signaled packets */
+    ReadFile(server, recv_buf, TEST_BUF_LEN, &read_bytes, &overlapped);
+
+    status = pNtAssociateWaitCompletionPacket(packet, completion, server, (void *)1, (void *)2,
+                                              STATUS_SUCCESS, (ULONG_PTR)3, &signaled);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    ok(signaled == FALSE, "Got unexpected signaled %d.\n", signaled);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    WriteFile(client, send_buf, TEST_BUF_LEN, &written_bytes, NULL);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtCancelWaitCompletionPacket(packet, FALSE);
+    ok(status == STATUS_PENDING, "Got unexpected status %#lx.\n", status);
+    completion_count = get_pending_msgs(completion);
+    ok(completion_count == 1, "Got unexpected completion count %ld.\n", completion_count);
+
+    status = pNtCancelWaitCompletionPacket(packet, TRUE);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    completion_count = get_pending_msgs(completion);
+    ok(!completion_count, "Got unexpected completion count %ld.\n", completion_count);
+
+    /* Remove already removed packets */
+    status = pNtCancelWaitCompletionPacket(packet, TRUE);
+    ok(status == STATUS_CANCELLED, "Got unexpected status %#lx.\n", status);
+
+    /* Parameter checks */
+    status = pNtCancelWaitCompletionPacket(NULL, FALSE);
+    ok(status == STATUS_INVALID_HANDLE, "Got unexpected status %#lx.\n", status);
+
+    status = pNtCancelWaitCompletionPacket(INVALID_HANDLE_VALUE, FALSE);
+    ok(status == STATUS_OBJECT_TYPE_MISMATCH, "Got unexpected status %#lx.\n", status);
+
+    status = pNtClose(packet);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(client);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(server);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+    status = pNtClose(completion);
+    ok(status == STATUS_SUCCESS, "Got unexpected status %#lx.\n", status);
+}
+
 START_TEST(file)
 {
     HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
@@ -7650,6 +7756,7 @@ START_TEST(file)
     pRtlWow64EnableFsRedirectionEx = (void *)GetProcAddress(hntdll, "RtlWow64EnableFsRedirectionEx");
     pNtAllocateReserveObject= (void *)GetProcAddress(hntdll, "NtAllocateReserveObject");
     pNtAssociateWaitCompletionPacket = (void *)GetProcAddress(hntdll, "NtAssociateWaitCompletionPacket");
+    pNtCancelWaitCompletionPacket = (void *)GetProcAddress(hntdll, "NtCancelWaitCompletionPacket");
     pNtCreateEvent          = (void *)GetProcAddress(hntdll, "NtCreateEvent");
     pNtCreateKeyedEvent     = (void *)GetProcAddress(hntdll, "NtCreateKeyedEvent");
     pNtCreateMailslotFile   = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
@@ -7725,4 +7832,5 @@ START_TEST(file)
     test_file_map_large_size();
     test_create_wait_completion_packet();
     test_associate_wait_completion_packet();
+    test_cancel_wait_completion_packet();
 }

[PATCH v3 5/7] ntdll: Implement NtCreateWaitCompletionPacket().

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/ntdll/ntdll.spec       |  1 +
 dlls/ntdll/signal_arm64ec.c |  1 +
 dlls/ntdll/tests/om.c       |  1 -
 dlls/ntdll/unix/sync.c      | 26 ++++++++++++
 dlls/wow64/sync.c           | 21 ++++++++++
 include/winternl.h          |  1 +
 server/completion.c         | 84 ++++++++++++++++++++++++++++++++++++-
 server/directory.c          |  1 +
 server/object.h             |  1 +
 server/protocol.def         |  9 ++++
 10 files changed, 144 insertions(+), 2 deletions(-)

diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec
index 7c2e494e4ad..c089b4129a3 100644
--- a/dlls/ntdll/ntdll.spec
+++ b/dlls/ntdll/ntdll.spec
@@ -201,6 +201,7 @@
 @ stdcall -syscall NtCreateToken(ptr long ptr long ptr ptr ptr ptr ptr ptr ptr ptr ptr)
 @ stdcall -syscall NtCreateTransaction(ptr long ptr ptr long long long long ptr ptr)
 @ stdcall -syscall NtCreateUserProcess(ptr ptr long long ptr ptr long long ptr ptr ptr)
+@ stdcall -syscall NtCreateWaitCompletionPacket(ptr long ptr)
 # @ stub NtCreateWaitablePort
 @ stdcall -arch=i386 NtCurrentTeb()
 @ stdcall -syscall NtDebugActiveProcess(long long)
diff --git a/dlls/ntdll/signal_arm64ec.c b/dlls/ntdll/signal_arm64ec.c
index 0f4b55b60c4..af6c11d3cea 100644
--- a/dlls/ntdll/signal_arm64ec.c
+++ b/dlls/ntdll/signal_arm64ec.c
@@ -399,6 +399,7 @@ DEFINE_SYSCALL(NtCreateThreadEx, (HANDLE *handle, ACCESS_MASK access, OBJECT_ATT
 DEFINE_SYSCALL(NtCreateTimer, (HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr, TIMER_TYPE type))
 DEFINE_SYSCALL(NtCreateToken, (HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr, TOKEN_TYPE type, LUID *token_id, LARGE_INTEGER *expire, TOKEN_USER *user, TOKEN_GROUPS *groups, TOKEN_PRIVILEGES *privs, TOKEN_OWNER *owner, TOKEN_PRIMARY_GROUP *group, TOKEN_DEFAULT_DACL *dacl, TOKEN_SOURCE *source))
 DEFINE_SYSCALL(NtCreateTransaction, (HANDLE *handle, ACCESS_MASK mask, OBJECT_ATTRIBUTES *obj_attr, GUID *guid, HANDLE tm, ULONG options, ULONG isol_level, ULONG isol_flags, PLARGE_INTEGER timeout, UNICODE_STRING *description))
+DEFINE_SYSCALL(NtCreateWaitCompletionPacket, (HANDLE *handle, ACCESS_MASK mask, OBJECT_ATTRIBUTES *obj_attr))
 DEFINE_SYSCALL(NtCreateUserProcess, (HANDLE *process_handle_ptr, HANDLE *thread_handle_ptr, ACCESS_MASK process_access, ACCESS_MASK thread_access, OBJECT_ATTRIBUTES *process_attr, OBJECT_ATTRIBUTES *thread_attr, ULONG process_flags, ULONG thread_flags, RTL_USER_PROCESS_PARAMETERS *params, PS_CREATE_INFO *info, PS_ATTRIBUTE_LIST *ps_attr))
 DEFINE_SYSCALL(NtDebugActiveProcess, (HANDLE process, HANDLE debug))
 DEFINE_SYSCALL(NtDebugContinue, (HANDLE handle, CLIENT_ID *client, NTSTATUS status))
diff --git a/dlls/ntdll/tests/om.c b/dlls/ntdll/tests/om.c
index 8a62ba39893..ed3e48b421c 100644
--- a/dlls/ntdll/tests/om.c
+++ b/dlls/ntdll/tests/om.c
@@ -2412,7 +2412,6 @@ static void test_object_types(void)
             break;
         }

-        todo_wine_if(!lstrcmpW(tests[i].name, L"WaitCompletionPacket"))
         ok( broken(!lstrcmpW(tests[i].name, L"WaitCompletionPacket") && j == ARRAY_SIZE(all_types)) /* Win7 doesn't have WaitCompletionPacket */
             || j < ARRAY_SIZE(all_types), "type %s not found\n", debugstr_w(tests[i].name) );
     }
diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c
index 117915beb19..a5d9f830c2e 100644
--- a/dlls/ntdll/unix/sync.c
+++ b/dlls/ntdll/unix/sync.c
@@ -2872,6 +2872,32 @@ NTSTATUS WINAPI NtCreateTransaction( HANDLE *handle, ACCESS_MASK mask, OBJECT_AT
     return STATUS_SUCCESS;
 }

+/***********************************************************************
+ *           NtCreateWaitCompletionPacket (NTDLL.@)
+ */
+NTSTATUS WINAPI NtCreateWaitCompletionPacket( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr )
+{
+    struct object_attributes *objattr;
+    unsigned int ret;
+    data_size_t len;
+
+    TRACE( "%p, %08x, %p\n", handle, (int)access, attr );
+
+    *handle = 0;
+    if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
+
+    SERVER_START_REQ( create_completion_packet )
+    {
+        req->access = access;
+        wine_server_add_data( req, objattr, len );
+        if (!(ret = wine_server_call( req )))
+            *handle = wine_server_ptr_handle( reply->handle );
+    }
+    SERVER_END_REQ;
+    free( objattr );
+    return ret;
+}
+
 /***********************************************************************
  *           NtCommitTransaction (NTDLL.@)
  */
diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c
index 537e695cc87..4cf4d3b6f2a 100644
--- a/dlls/wow64/sync.c
+++ b/dlls/wow64/sync.c
@@ -1858,6 +1858,27 @@ NTSTATUS WINAPI wow64_NtCreateTransaction( UINT *args )
 }

+/**********************************************************************
+ *           wow64_NtCreateWaitCompletionPacket
+ */
+NTSTATUS WINAPI wow64_NtCreateWaitCompletionPacket( UINT *args )
+{
+    ULONG *handle_ptr = get_ptr( &args );
+    ACCESS_MASK access = get_ulong( &args );
+    OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
+
+    struct object_attr64 attr;
+    HANDLE handle = 0;
+    NTSTATUS status;
+
+    *handle_ptr = 0;
+    status = NtCreateWaitCompletionPacket( &handle, access, objattr_32to64( &attr, attr32 ));
+    put_handle( handle_ptr, handle );
+
+    return status;
+}
+
+
 /**********************************************************************
  *           wow64_NtCommitTransaction
  */
diff --git a/include/winternl.h b/include/winternl.h
index ae2689165f3..2137965ebef 100644
--- a/include/winternl.h
+++ b/include/winternl.h
@@ -4502,6 +4502,7 @@ NTSYSAPI NTSTATUS  WINAPI NtCreateThreadEx(HANDLE*,ACCESS_MASK,OBJECT_ATTRIBUTES
 NTSYSAPI NTSTATUS  WINAPI NtCreateTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*, TIMER_TYPE);
 NTSYSAPI NTSTATUS  WINAPI NtCreateToken(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,TOKEN_TYPE,PLUID,PLARGE_INTEGER,PTOKEN_USER,PTOKEN_GROUPS,PTOKEN_PRIVILEGES,PTOKEN_OWNER,PTOKEN_PRIMARY_GROUP,PTOKEN_DEFAULT_DACL,PTOKEN_SOURCE);
 NTSYSAPI NTSTATUS  WINAPI NtCreateTransaction(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,LPGUID,HANDLE,ULONG,ULONG,ULONG,PLARGE_INTEGER,PUNICODE_STRING);
+NTSYSAPI NTSTATUS  WINAPI NtCreateWaitCompletionPacket(HANDLE *,ACCESS_MASK,OBJECT_ATTRIBUTES *);
 NTSYSAPI NTSTATUS  WINAPI NtCreateUserProcess(HANDLE*,HANDLE*,ACCESS_MASK,ACCESS_MASK,OBJECT_ATTRIBUTES*,OBJECT_ATTRIBUTES*,ULONG,ULONG,RTL_USER_PROCESS_PARAMETERS*,PS_CREATE_INFO*,PS_ATTRIBUTE_LIST*);
 NTSYSAPI NTSTATUS  WINAPI NtDebugActiveProcess(HANDLE,HANDLE);
 NTSYSAPI NTSTATUS  WINAPI NtDebugContinue(HANDLE,CLIENT_ID*,NTSTATUS);
diff --git a/server/completion.c b/server/completion.c
index a2028a89823..4bf264f379d 100644
--- a/server/completion.c
+++ b/server/completion.c
@@ -36,7 +36,6 @@
 #include "handle.h"
 #include "request.h"

-
 static const WCHAR completion_name[] = {'I','o','C','o','m','p','l','e','t','i','o','n'};

struct type_descr completion_type =
@@ -79,6 +78,11 @@ struct completion
     unsigned int        depth;
 };

+struct completion_packet
+{
+    struct object      obj;                       /* object header */
+};
+
 static void completion_wait_dump( struct object*, int );
 static int completion_wait_signaled( struct object *obj, struct wait_queue_entry *entry );
 static void completion_wait_satisfied( struct object *obj, struct wait_queue_entry *entry );
@@ -319,6 +323,61 @@ void add_completion( struct completion *completion, apc_param_t ckey, apc_param_
     if (!list_empty( &completion->queue )) signal_sync( completion->sync );
 }

+static const WCHAR completion_packet_name[] = {'W','a','i','t','C','o','m','p','l','e','t','i','o','n','P','a','c','k','e','t'};
+
+struct type_descr completion_packet_type =
+{
+    { completion_packet_name, sizeof(completion_packet_name) }, /* name */
+    WAIT_COMPLETION_PACKET_ALL_ACCESS | SYNCHRONIZE,            /* valid_access */
+    {                                                           /* mapping */
+         WAIT_COMPLETION_PACKET_GENERIC_READ,
+         WAIT_COMPLETION_PACKET_GENERIC_WRITE,
+         WAIT_COMPLETION_PACKET_GENERIC_EXECUTE,
+         WAIT_COMPLETION_PACKET_ALL_ACCESS
+    },
+};
+
+static void completion_packet_dump( struct object *, int );
+
+static const struct object_ops completion_packet_ops =
+{
+    sizeof(struct completion_packet), /* size */
+    &completion_packet_type,          /* type */
+    completion_packet_dump,           /* dump */
+    no_add_queue,                     /* add_queue */
+    NULL,                             /* remove_queue */
+    NULL,                             /* signaled */
+    NULL,                             /* satisfied */
+    no_signal,                        /* signal */
+    no_get_fd,                        /* get_fd */
+    default_get_sync,                 /* get_sync */
+    default_map_access,               /* map_access */
+    default_get_sd,                   /* get_sd */
+    default_set_sd,                   /* set_sd */
+    default_get_full_name,            /* get_full_name */
+    no_lookup_name,                   /* lookup_name */
+    directory_link_name,              /* link_name */
+    default_unlink_name,              /* unlink_name */
+    no_open_file,                     /* open_file */
+    no_kernel_obj_list,               /* get_kernel_obj_list */
+    no_close_handle,                  /* close_handle */
+    no_destroy                        /* destroy */
+};
+
+static void completion_packet_dump( struct object *obj, int verbose )
+{
+    assert( obj->ops == &completion_packet_ops );
+    fprintf( stderr, "WaitCompletionPacket\n" );
+}
+
+static struct completion_packet *create_completion_packet( struct object *root,
+                                                           const struct unicode_str *name,
+                                                           unsigned int attr,
+                                                           const struct security_descriptor *sd )
+{
+    return create_named_object( root, &completion_packet_ops, name, attr, sd );
+}
+
 /* create a completion */
 DECL_HANDLER(create_completion)
 {
@@ -454,3 +513,26 @@ DECL_HANDLER(query_completion)

release_object( completion );
 }
+
+/* create a wait completion packet */
+DECL_HANDLER(create_completion_packet)
+{
+    struct completion_packet *packet;
+    struct unicode_str name;
+    struct object *root;
+    const struct security_descriptor *sd;
+    const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, &root );
+
+    if (!objattr) return;
+    if ((packet = create_completion_packet( root, &name, objattr->attributes, sd )))
+    {
+        if (get_error() == STATUS_OBJECT_NAME_EXISTS)
+            reply->handle = alloc_handle( current->process, packet, req->access, objattr->attributes );
+        else
+            reply->handle = alloc_handle_no_access_check( current->process, packet,
+                                                          req->access, objattr->attributes );
+        release_object( packet );
+    }
+
+    if (root) release_object( root );
+}
diff --git a/server/directory.c b/server/directory.c
index c56c216d6d5..bbb89304bed 100644
--- a/server/directory.c
+++ b/server/directory.c
@@ -165,6 +165,7 @@ static struct type_descr *types[] =
     &key_type,
     &apc_reserve_type,
     &completion_reserve_type,
+    &completion_packet_type,
 };

static void object_type_dump( struct object *obj, int verbose )
diff --git a/server/object.h b/server/object.h
index 1bf439338d4..5df9b380f0c 100644
--- a/server/object.h
+++ b/server/object.h
@@ -353,6 +353,7 @@ extern struct type_descr mapping_type;
 extern struct type_descr key_type;
 extern struct type_descr apc_reserve_type;
 extern struct type_descr completion_reserve_type;
+extern struct type_descr completion_packet_type;

#define KEYEDEVENT_WAIT       0x0001
 #define KEYEDEVENT_WAKE       0x0002
diff --git a/server/protocol.def b/server/protocol.def
index 22470e33ae0..3b7e8efbde4 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -3884,6 +3884,15 @@ struct handle_info
 @END

+/* create a wait completion packet */
+@REQ(create_completion_packet)
+    unsigned int access;          /* desired access */
+    VARARG(objattr,object_attributes); /* object attributes */
+@REPLY
+    obj_handle_t handle;          /* wait completion packet handle */
+@END
+
+
 /* check for associated completion and push msg */
 @REQ(add_fd_completion)
     obj_handle_t   handle;        /* async' object */

[PATCH v3 6/7] ntdll: Implement NtAssociateWaitCompletionPacket().

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/ntdll/ntdll.spec       |   1 +
 dlls/ntdll/signal_arm64ec.c |   1 +
 dlls/ntdll/tests/file.c     |   1 -
 dlls/ntdll/unix/sync.c      |  28 +++++
 dlls/wow64/sync.c           |  19 ++++
 include/winternl.h          |   1 +
 server/async.c              |   2 +-
 server/completion.c         | 217 +++++++++++++++++++++++++++++++++++-
 server/fd.c                 |   2 +-
 server/file.h               |   3 +-
 server/object.c             |   1 +
 server/object.h             |   1 +
 server/process.c            |   2 +-
 server/protocol.def         |  14 +++
 server/thread.c             |  16 +++
 server/thread.h             |   2 +
 16 files changed, 301 insertions(+), 10 deletions(-)

diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec
index c089b4129a3..05f40a8bdf3 100644
--- a/dlls/ntdll/ntdll.spec
+++ b/dlls/ntdll/ntdll.spec
@@ -153,6 +153,7 @@
 @ stub -syscall=0x004c NtApphelpCacheControl
 @ stdcall -syscall NtAreMappedFilesTheSame(ptr ptr)
 @ stdcall -syscall NtAssignProcessToJobObject(long long)
+@ stdcall -syscall NtAssociateWaitCompletionPacket(ptr ptr ptr ptr ptr long ptr ptr)
 @ stdcall -syscall=0x0005 NtCallbackReturn(ptr long long)
 @ stdcall -syscall=0x005d NtCancelIoFile(long ptr)
 @ stdcall -syscall NtCancelIoFileEx(long ptr ptr)
diff --git a/dlls/ntdll/signal_arm64ec.c b/dlls/ntdll/signal_arm64ec.c
index af6c11d3cea..f942a6c966c 100644
--- a/dlls/ntdll/signal_arm64ec.c
+++ b/dlls/ntdll/signal_arm64ec.c
@@ -358,6 +358,7 @@ DEFINE_WRAPPED_SYSCALL(NtAllocateVirtualMemoryEx, (HANDLE process, PVOID *ret, S
 DEFINE_SYSCALL(NtApphelpCacheControl, (ULONG class, void *context))
 DEFINE_SYSCALL(NtAreMappedFilesTheSame, (PVOID addr1, PVOID addr2))
 DEFINE_SYSCALL(NtAssignProcessToJobObject, (HANDLE job, HANDLE process))
+DEFINE_SYSCALL(NtAssociateWaitCompletionPacket,(HANDLE packet, HANDLE completion, HANDLE target, void *key_context, void *apc_context, NTSTATUS io_status, ULONG_PTR io_status_information, BOOLEAN *already_signaled))
 DEFINE_SYSCALL(NtCallbackReturn, (void *ret_ptr, ULONG ret_len, NTSTATUS status))
 DEFINE_SYSCALL(NtCancelIoFile, (HANDLE handle, IO_STATUS_BLOCK *io_status))
 DEFINE_SYSCALL(NtCancelIoFileEx, (HANDLE handle, IO_STATUS_BLOCK *io, IO_STATUS_BLOCK *io_status))
diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c
index db954e9087c..3304bf1cc88 100644
--- a/dlls/ntdll/tests/file.c
+++ b/dlls/ntdll/tests/file.c
@@ -7001,7 +7001,6 @@ static void test_associate_wait_completion_packet(void)

if (!pNtAssociateWaitCompletionPacket)
     {
-        todo_wine
         win_skip("NtAssociateWaitCompletionPacket is unavailable.\n");
         return;
     }
diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c
index a5d9f830c2e..d19428e9cbf 100644
--- a/dlls/ntdll/unix/sync.c
+++ b/dlls/ntdll/unix/sync.c
@@ -2872,6 +2872,34 @@ NTSTATUS WINAPI NtCreateTransaction( HANDLE *handle, ACCESS_MASK mask, OBJECT_AT
     return STATUS_SUCCESS;
 }

+/***********************************************************************
+ *           NtAssociateWaitCompletionPacket (NTDLL.@)
+ */
+NTSTATUS WINAPI NtAssociateWaitCompletionPacket( HANDLE packet, HANDLE completion, HANDLE target,
+        void *key_context, void *apc_context, NTSTATUS status, ULONG_PTR information,
+        BOOLEAN *already_signaled )
+{
+    NTSTATUS ret;
+
+    TRACE( "%p, %p, %p, %p, %p, %#x, %ld, %p\n", packet, completion, target, key_context,
+           apc_context, (int)status, information, already_signaled );
+
+    SERVER_START_REQ( associate_completion_packet )
+    {
+        req->packet = wine_server_obj_handle( packet );
+        req->completion = wine_server_obj_handle( completion );
+        req->target = wine_server_obj_handle( target );
+        req->ckey = wine_server_client_ptr( key_context );
+        req->cvalue = wine_server_client_ptr( apc_context );
+        req->information = information;
+        req->status = status;
+        if (!(ret = wine_server_call( req )) && already_signaled)
+            *already_signaled = reply->already_signaled;
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
 /***********************************************************************
  *           NtCreateWaitCompletionPacket (NTDLL.@)
  */
diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c
index 4cf4d3b6f2a..1920c956790 100644
--- a/dlls/wow64/sync.c
+++ b/dlls/wow64/sync.c
@@ -1858,6 +1858,25 @@ NTSTATUS WINAPI wow64_NtCreateTransaction( UINT *args )
 }

+/**********************************************************************
+ *           wow64_NtAssociateWaitCompletionPacket
+ */
+NTSTATUS WINAPI wow64_NtAssociateWaitCompletionPacket( UINT *args )
+{
+    HANDLE packet = get_handle( &args );
+    HANDLE completion = get_handle( &args );
+    HANDLE target = get_handle( &args );
+    void *key_context = get_ptr( &args );
+    void *apc_context = get_ptr( &args );
+    LONG io_status = get_ulong( &args );
+    ULONG_PTR io_status_information = get_ulong( &args );
+    BOOLEAN *already_signaled = get_ptr( &args );
+
+    return NtAssociateWaitCompletionPacket( packet, completion, target, key_context, apc_context,
+                                            io_status, io_status_information, already_signaled );
+}
+
+
 /**********************************************************************
  *           wow64_NtCreateWaitCompletionPacket
  */
diff --git a/include/winternl.h b/include/winternl.h
index 2137965ebef..26a0598ee24 100644
--- a/include/winternl.h
+++ b/include/winternl.h
@@ -4459,6 +4459,7 @@ NTSYSAPI NTSTATUS  WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,ULONG_PTR,SIZE_T
 NTSYSAPI NTSTATUS  WINAPI NtAllocateVirtualMemoryEx(HANDLE,PVOID*,SIZE_T*,ULONG,ULONG,MEM_EXTENDED_PARAMETER*,ULONG);
 NTSYSAPI NTSTATUS  WINAPI NtAreMappedFilesTheSame(PVOID,PVOID);
 NTSYSAPI NTSTATUS  WINAPI NtAssignProcessToJobObject(HANDLE,HANDLE);
+NTSYSAPI NTSTATUS  WINAPI NtAssociateWaitCompletionPacket(HANDLE,HANDLE,HANDLE,void *,void *,NTSTATUS,ULONG_PTR,BOOLEAN *);
 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);
diff --git a/server/async.c b/server/async.c
index 1ed241dcb65..110c2e183ca 100644
--- a/server/async.c
+++ b/server/async.c
@@ -482,7 +482,7 @@ static void add_async_completion( struct async *async, apc_param_t cvalue, unsig
                                   apc_param_t information )
 {
     if (async->fd && !async->completion) async->completion = fd_get_completion( async->fd, &async->comp_key );
-    if (async->completion) add_completion( async->completion, async->comp_key, cvalue, status, information );
+    if (async->completion) add_completion( async->completion, async->comp_key, cvalue, status, information, NULL );
 }

/* store the result of the client-side async callback */
diff --git a/server/completion.c b/server/completion.c
index 4bf264f379d..6baaaacdb33 100644
--- a/server/completion.c
+++ b/server/completion.c
@@ -57,6 +57,7 @@ struct comp_msg
     apc_param_t   cvalue;
     apc_param_t   information;
     unsigned int  status;
+    struct completion_packet *packet; /* the completion packet this msg is from or NULL */
 };

struct completion_wait
@@ -81,8 +82,20 @@ struct completion
 struct completion_packet
 {
     struct object      obj;                       /* object header */
+    struct list        entry;                     /* list entry in the target object wait completion packet queue */
+    struct object     *target;                    /* target object this packet waits for */
+    struct completion *completion;                /* completion object */
+    apc_param_t        ckey;                      /* key context */
+    apc_param_t        cvalue;                    /* apc context */
+    apc_param_t        information;               /* IO_STATUS_BLOCK information */
+    unsigned int       status;                    /* completion status */
+    unsigned int       in_target_packet_queue: 1; /* whether the packet is in the wait queue of the target */
+    unsigned int       in_completion_queue: 1;    /* whether the packet is in the completion queue */
+    unsigned int       pad: 30;                   /* padding */
 };

+static void remove_completion_packet_msg( struct comp_msg *msg );
+
 static void completion_wait_dump( struct object*, int );
 static int completion_wait_signaled( struct object *obj, struct wait_queue_entry *entry );
 static void completion_wait_satisfied( struct object *obj, struct wait_queue_entry *entry );
@@ -156,6 +169,7 @@ static void completion_wait_satisfied( struct object *obj, struct wait_queue_ent
     list_remove( &msg->queue_entry );
     if (wait->msg) free( wait->msg );
     wait->msg = msg;
+    remove_completion_packet_msg( msg );
 }

static void completion_dump( struct object*, int );
@@ -300,7 +314,7 @@ struct completion *get_completion_obj( struct process *process, obj_handle_t han
 }

void add_completion( struct completion *completion, apc_param_t ckey, apc_param_t cvalue,
-                     unsigned int status, apc_param_t information )
+                     unsigned int status, apc_param_t information, struct completion_packet *packet )
 {
     struct comp_msg *msg = mem_alloc( sizeof( *msg ) );
     struct completion_wait *wait;
@@ -308,6 +322,7 @@ void add_completion( struct completion *completion, apc_param_t ckey, apc_param_
     if (!msg)
         return;

+    msg->packet = packet;
     msg->ckey = ckey;
     msg->cvalue = cvalue;
     msg->status = status;
@@ -338,6 +353,7 @@ struct type_descr completion_packet_type =
 };

static void completion_packet_dump( struct object *, int );
+static void completion_packet_destroy( struct object * );

static const struct object_ops completion_packet_ops =
 {
@@ -361,13 +377,26 @@ static const struct object_ops completion_packet_ops =
     no_open_file,                     /* open_file */
     no_kernel_obj_list,               /* get_kernel_obj_list */
     no_close_handle,                  /* close_handle */
-    no_destroy                        /* destroy */
+    completion_packet_destroy         /* destroy */
 };

static void completion_packet_dump( struct object *obj, int verbose )
 {
+    struct completion_packet *packet = (struct completion_packet *)obj;
+
     assert( obj->ops == &completion_packet_ops );
-    fprintf( stderr, "WaitCompletionPacket\n" );
+    fprintf( stderr, "WaitCompletionPacket target=%p completion=%p ckey=%llx cvalue=%llx "
+             "information=%llx status=%#x in_target_packet_queue=%d in_completion_queue=%d\n",
+             packet->target, packet->completion, (long long unsigned int)packet->ckey,
+             (long long unsigned int)packet->cvalue, (long long unsigned int)packet->information,
+             packet->status, packet->in_target_packet_queue, packet->in_completion_queue );
+}
+
+static struct completion_packet *get_completion_packet_obj( struct process *process,
+                                                            obj_handle_t handle,
+                                                            unsigned int access )
+{
+    return (struct completion_packet *)get_handle_obj( process, handle, access, &completion_packet_ops );
 }

static struct completion_packet *create_completion_packet( struct object *root,
@@ -375,7 +404,110 @@ static struct completion_packet *create_completion_packet( struct object *root,
                                                            unsigned int attr,
                                                            const struct security_descriptor *sd )
 {
-    return create_named_object( root, &completion_packet_ops, name, attr, sd );
+    struct completion_packet *packet;
+
+    if ((packet = create_named_object( root, &completion_packet_ops, name, attr, sd ))
+        && get_error() != STATUS_OBJECT_NAME_EXISTS)
+    {
+        packet->target = NULL;
+        packet->completion = NULL;
+        packet->ckey = 0;
+        packet->cvalue = 0;
+        packet->information = 0;
+        packet->status = 0;
+        packet->in_target_packet_queue = 0;
+        packet->in_completion_queue = 0;
+    }
+    return packet;
+}
+
+/* try to wake up completion packets in the object when it's signaled */
+void wake_up_completion_packets( struct object *obj )
+{
+    struct completion_packet *packet;
+
+    if (list_empty( &obj->completion_packet_queue ))
+        return;
+
+    if (!is_obj_signaled( obj ))
+        return;
+
+    LIST_FOR_EACH_ENTRY( packet, &obj->completion_packet_queue, struct completion_packet, entry )
+    {
+        assert( packet->in_target_packet_queue );
+        assert( packet->target );
+        assert( !packet->in_completion_queue );
+        assert( packet->completion );
+
+        list_remove( &packet->entry );
+        release_object( packet->target );
+        packet->in_target_packet_queue = 0;
+        packet->target = NULL;
+        packet->in_completion_queue = 1;
+        add_completion( packet->completion, packet->ckey, packet->cvalue, packet->status,
+                        packet->information, packet );
+    }
+}
+
+static void cancel_completion_packet( struct completion_packet *packet )
+{
+    struct comp_msg *comp_msg;
+
+    if (packet->in_target_packet_queue)
+    {
+        assert( packet->target );
+        list_remove( &packet->entry );
+        packet->in_target_packet_queue = 0;
+    }
+
+    if (packet->in_completion_queue)
+    {
+        assert( packet->completion );
+        LIST_FOR_EACH_ENTRY( comp_msg, &packet->completion->queue, struct comp_msg, queue_entry )
+        {
+            if (comp_msg->packet == packet)
+            {
+                list_remove( &comp_msg->queue_entry );
+                free( comp_msg );
+                packet->completion->depth--;
+                break;
+            }
+        }
+
+        packet->in_completion_queue = 0;
+    }
+
+    if (packet->target)
+    {
+        release_object( packet->target );
+        packet->target = NULL;
+    }
+
+    if (packet->completion)
+    {
+        release_object( packet->completion );
+        packet->completion = NULL;
+    }
+}
+
+static void completion_packet_destroy( struct object *obj )
+{
+    struct completion_packet *packet = (struct completion_packet *)obj;
+
+    cancel_completion_packet( packet );
+}
+
+static void remove_completion_packet_msg( struct comp_msg *msg )
+{
+    if (!msg->packet)
+        return;
+
+    assert( msg->packet->in_completion_queue );
+    assert( msg->packet->completion );
+    release_object( msg->packet->completion );
+    msg->packet->completion = NULL;
+    msg->packet->in_completion_queue = 0;
+    msg->packet = NULL;
 }

/* create a completion */
@@ -426,7 +558,7 @@ DECL_HANDLER(add_completion)
         return;
     }

-    add_completion( completion, req->ckey, req->cvalue, req->status, req->information );
+    add_completion( completion, req->ckey, req->cvalue, req->status, req->information, NULL );

if (reserve) release_object( reserve );
     release_object( completion );
@@ -474,6 +606,7 @@ DECL_HANDLER(remove_completion)
         reply->cvalue = msg->cvalue;
         reply->status = msg->status;
         reply->information = msg->information;
+        remove_completion_packet_msg( msg );
         free( msg );
         reply->wait_handle = 0;
         if (list_empty( &completion->queue )) reset_sync( completion->sync );
@@ -536,3 +669,77 @@ DECL_HANDLER(create_completion_packet)

if (root) release_object( root );
 }
+
+/* associate a wait completion packet */
+DECL_HANDLER(associate_completion_packet)
+{
+    struct completion_packet *packet;
+    struct completion *completion;
+    struct object *target, *sync;
+
+    packet = get_completion_packet_obj( current->process, req->packet, WAIT_COMPLETION_PACKET_QUERY_STATE );
+    if (!packet)
+        return;
+
+    if (packet->in_target_packet_queue || packet->in_completion_queue)
+    {
+        release_object( packet );
+        set_error( STATUS_INVALID_PARAMETER_1 );
+        return;
+    }
+
+    target = get_handle_obj( current->process, req->target, SYNCHRONIZE, NULL );
+    if (!target)
+    {
+        release_object( packet );
+        return;
+    }
+
+    /* mutexs and keyed events are not allowed for associating with wait completion packets */
+    if (target->ops->type == &mutex_type || target->ops->type == &keyed_event_type)
+    {
+        release_object( target );
+        release_object( packet );
+        set_error( STATUS_INVALID_PARAMETER_3 );
+        return;
+    }
+
+    completion = get_completion_obj( current->process, req->completion, IO_COMPLETION_MODIFY_STATE );
+    if (!completion)
+    {
+        release_object( target );
+        release_object( packet );
+        return;
+    }
+
+    assert( !packet->completion );
+    assert( !packet->in_completion_queue );
+    assert( !packet->target );
+    assert( !packet->in_target_packet_queue );
+
+    packet->completion = (struct completion *)grab_object( completion );
+    packet->ckey = req->ckey;
+    packet->cvalue = req->cvalue;
+    packet->information = req->information;
+    packet->status = req->status;
+
+    if (is_obj_signaled( target ))
+    {
+        packet->in_completion_queue = 1;
+        add_completion( packet->completion, packet->ckey, packet->cvalue, packet->status,
+                        packet->information, packet );
+        reply->already_signaled = 1;
+    }
+    else
+    {
+        packet->target = grab_object( target );
+        sync = target->ops->get_sync( target );
+        list_add_tail( &sync->completion_packet_queue, &packet->entry );
+        packet->in_target_packet_queue = 1;
+        release_object( sync );
+        reply->already_signaled = 0;
+    }
+    release_object( completion );
+    release_object( target );
+    release_object( packet );
+}
diff --git a/server/fd.c b/server/fd.c
index 663f497b7a9..b3af7c1b063 100644
--- a/server/fd.c
+++ b/server/fd.c
@@ -3017,7 +3017,7 @@ DECL_HANDLER(add_fd_completion)
     if (fd)
     {
         if (fd->completion && (req->async || !(fd->comp_flags & FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)))
-            add_completion( fd->completion, fd->comp_key, req->cvalue, req->status, req->information );
+            add_completion( fd->completion, fd->comp_key, req->cvalue, req->status, req->information, NULL );
         release_object( fd );
     }
 }
diff --git a/server/file.h b/server/file.h
index 567194bf00a..8cdb78700c9 100644
--- a/server/file.h
+++ b/server/file.h
@@ -29,6 +29,7 @@ struct fd;
 struct mapping;
 struct async_queue;
 struct completion;
+struct completion_packet;
 struct reserve;

/* server-side representation of I/O status block */
@@ -240,7 +241,7 @@ extern struct dir *get_dir_obj( struct process *process, obj_handle_t handle, un
 extern struct completion *get_completion_obj( struct process *process, obj_handle_t handle, unsigned int access );
 extern struct reserve *get_completion_reserve_obj( struct process *process, obj_handle_t handle, unsigned int access );
 extern void add_completion( struct completion *completion, apc_param_t ckey, apc_param_t cvalue,
-                            unsigned int status, apc_param_t information );
+                            unsigned int status, apc_param_t information, struct completion_packet *packet );
 extern void cleanup_thread_completion( struct thread *thread );

/* serial port functions */
diff --git a/server/object.c b/server/object.c
index 28bda0db77b..75afe8cdd2e 100644
--- a/server/object.c
+++ b/server/object.c
@@ -311,6 +311,7 @@ void *alloc_object( const struct object_ops *ops )
         obj->name         = NULL;
         obj->sd           = NULL;
         list_init( &obj->wait_queue );
+        list_init( &obj->completion_packet_queue );
 #ifdef DEBUG_OBJECTS
         list_add_head( &object_list, &obj->obj_list );
 #endif
diff --git a/server/object.h b/server/object.h
index 5df9b380f0c..f93466d369a 100644
--- a/server/object.h
+++ b/server/object.h
@@ -117,6 +117,7 @@ struct object
     unsigned int              handle_count;/* handle count */
     const struct object_ops  *ops;
     struct list               wait_queue;
+    struct list               completion_packet_queue;
     struct object_name       *name;
     struct security_descriptor *sd;
     unsigned int              is_permanent:1;
diff --git a/server/process.c b/server/process.c
index 9b3b0b8fc6c..f5dbf8bbdf4 100644
--- a/server/process.c
+++ b/server/process.c
@@ -277,7 +277,7 @@ static struct job *get_job_obj( struct process *process, obj_handle_t handle, un
 static void add_job_completion( struct job *job, apc_param_t msg, apc_param_t pid )
 {
     if (job->completion_port)
-        add_completion( job->completion_port, job->completion_key, pid, STATUS_SUCCESS, msg );
+        add_completion( job->completion_port, job->completion_key, pid, STATUS_SUCCESS, msg, NULL );
 }

static void add_job_completion_existing_processes( struct job *job, struct job *completion_job )
diff --git a/server/protocol.def b/server/protocol.def
index 3b7e8efbde4..35ae85e619a 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -3893,6 +3893,20 @@ struct handle_info
 @END

+/* Associate a wait completion packet */
+@REQ(associate_completion_packet)
+    obj_handle_t  packet;         /* wait completion packet handle */
+    obj_handle_t  completion;     /* completion handle */
+    obj_handle_t  target;         /* target object handle */
+    apc_param_t   ckey;           /* completion key */
+    apc_param_t   cvalue;         /* completion value */
+    apc_param_t   information;    /* IO_STATUS_BLOCK information */
+    unsigned int  status;         /* completion status */
+@REPLY
+    int           already_signaled; /* whether the object is already signaled */
+@END
+
+
 /* check for associated completion and push msg */
 @REQ(add_fd_completion)
     obj_handle_t   handle;        /* async' object */
diff --git a/server/thread.c b/server/thread.c
index 05ec6a4ec00..cd4b459638d 100644
--- a/server/thread.c
+++ b/server/thread.c
@@ -1336,6 +1336,20 @@ static int select_on( const union select_op *select_op, data_size_t op_size, cli
     return 0;
 }

+/* check if an object is signaled for wait completion packets */
+int is_obj_signaled( struct object *obj )
+{
+    struct object *sync;
+    int signaled;
+
+    sync = obj->ops->get_sync( obj );
+    signaled = sync->ops->signaled( sync, NULL );
+    if (signaled)
+        sync->ops->satisfied( sync, NULL );
+    release_object( sync );
+    return signaled;
+}
+
 /* attempt to wake threads sleeping on the object wait queue */
 void wake_up( struct object *obj, int max )
 {
@@ -1350,6 +1364,8 @@ void wake_up( struct object *obj, int max )
         /* restart at the head of the list since a wake up can change the object wait queue */
         ptr = &obj->wait_queue;
     }
+
+    wake_up_completion_packets( obj );
 }

/* return the apc queue to use for a given apc type */
diff --git a/server/thread.h b/server/thread.h
index 58081be7481..53f1c624c66 100644
--- a/server/thread.h
+++ b/server/thread.h
@@ -118,6 +118,8 @@ extern int wake_thread_queue_entry( struct wait_queue_entry *entry );
 extern int add_queue( struct object *obj, struct wait_queue_entry *entry );
 extern void remove_queue( struct object *obj, struct wait_queue_entry *entry );
 extern void kill_thread( struct thread *thread, int violent_death );
+extern int is_obj_signaled( struct object *obj );
+extern void wake_up_completion_packets( struct object *obj );
 extern void wake_up( struct object *obj, int max );
 extern int thread_queue_apc( struct process *process, struct thread *thread, struct object *owner, const union apc_call *call_data );
 extern void thread_cancel_apc( struct thread *thread, struct object *owner, enum apc_type type );

[PATCH v3 7/7] ntdll: Implement NtCancelWaitCompletionPacket().

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/ntdll/ntdll.spec       |  1 +
 dlls/ntdll/signal_arm64ec.c |  1 +
 dlls/ntdll/tests/file.c     |  1 -
 dlls/ntdll/unix/sync.c      | 20 ++++++++++++++++++++
 dlls/wow64/sync.c           | 12 ++++++++++++
 include/winternl.h          |  1 +
 server/completion.c         | 27 +++++++++++++++++++++++++++
 server/protocol.def         |  7 +++++++
 8 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec
index 05f40a8bdf3..c0d552a0c4b 100644
--- a/dlls/ntdll/ntdll.spec
+++ b/dlls/ntdll/ntdll.spec
@@ -159,6 +159,7 @@
 @ stdcall -syscall NtCancelIoFileEx(long ptr ptr)
 @ stdcall -syscall NtCancelSynchronousIoFile(long ptr ptr)
 @ stdcall -syscall=0x0061 NtCancelTimer(long ptr)
+@ stdcall -syscall NtCancelWaitCompletionPacket(ptr long)
 @ stdcall -syscall=0x003e NtClearEvent(long)
 @ stdcall -syscall=0x000f NtClose(long)
 @ stdcall -syscall=0x003b NtCloseObjectAuditAlarm(ptr long long)
diff --git a/dlls/ntdll/signal_arm64ec.c b/dlls/ntdll/signal_arm64ec.c
index f942a6c966c..441db7f0ead 100644
--- a/dlls/ntdll/signal_arm64ec.c
+++ b/dlls/ntdll/signal_arm64ec.c
@@ -364,6 +364,7 @@ DEFINE_SYSCALL(NtCancelIoFile, (HANDLE handle, IO_STATUS_BLOCK *io_status))
 DEFINE_SYSCALL(NtCancelIoFileEx, (HANDLE handle, IO_STATUS_BLOCK *io, IO_STATUS_BLOCK *io_status))
 DEFINE_SYSCALL(NtCancelSynchronousIoFile, (HANDLE handle, IO_STATUS_BLOCK *io, IO_STATUS_BLOCK *io_status))
 DEFINE_SYSCALL(NtCancelTimer, (HANDLE handle, BOOLEAN *state))
+DEFINE_SYSCALL(NtCancelWaitCompletionPacket, (HANDLE packet, BOOLEAN remove_signaled))
 DEFINE_SYSCALL(NtClearEvent, (HANDLE handle))
 DEFINE_SYSCALL(NtClose, (HANDLE handle))
 DEFINE_SYSCALL(NtCloseObjectAuditAlarm, (UNICODE_STRING *subsystem, HANDLE handle, BOOLEAN onclose))
diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c
index 3304bf1cc88..785667be9a0 100644
--- a/dlls/ntdll/tests/file.c
+++ b/dlls/ntdll/tests/file.c
@@ -7646,7 +7646,6 @@ static void test_cancel_wait_completion_packet(void)

if (!pNtCancelWaitCompletionPacket)
     {
-        todo_wine
         win_skip("NtCancelWaitCompletionPacket is unavailable.\n");
         return;
     }
diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c
index d19428e9cbf..3c7c9fe3c5a 100644
--- a/dlls/ntdll/unix/sync.c
+++ b/dlls/ntdll/unix/sync.c
@@ -2900,6 +2900,26 @@ NTSTATUS WINAPI NtAssociateWaitCompletionPacket( HANDLE packet, HANDLE completio
     return ret;
 }

+/***********************************************************************
+ *           NtCancelWaitCompletionPacket (NTDLL.@)
+ */
+NTSTATUS WINAPI NtCancelWaitCompletionPacket( HANDLE packet, BOOLEAN remove_signaled )
+{
+    NTSTATUS status;
+
+    TRACE( "%p, %d\n", packet, remove_signaled );
+
+    SERVER_START_REQ( cancel_completion_packet )
+    {
+        req->packet = wine_server_obj_handle( packet );
+        req->remove_signaled = remove_signaled;
+        status = wine_server_call( req );
+    }
+    SERVER_END_REQ;
+    return status;
+}
+
+
 /***********************************************************************
  *           NtCreateWaitCompletionPacket (NTDLL.@)
  */
diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c
index 1920c956790..c57801c9348 100644
--- a/dlls/wow64/sync.c
+++ b/dlls/wow64/sync.c
@@ -1877,6 +1877,18 @@ NTSTATUS WINAPI wow64_NtAssociateWaitCompletionPacket( UINT *args )
 }

+/**********************************************************************
+ *           wow64_NtCancelWaitCompletionPacket
+ */
+NTSTATUS WINAPI wow64_NtCancelWaitCompletionPacket( UINT *args )
+{
+    HANDLE packet = get_handle( &args );
+    BOOLEAN remove_signaled = get_ulong( &args );
+
+    return NtCancelWaitCompletionPacket( packet, remove_signaled );
+}
+
+
 /**********************************************************************
  *           wow64_NtCreateWaitCompletionPacket
  */
diff --git a/include/winternl.h b/include/winternl.h
index 26a0598ee24..69364eb7ab4 100644
--- a/include/winternl.h
+++ b/include/winternl.h
@@ -4465,6 +4465,7 @@ 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 NtCancelWaitCompletionPacket(HANDLE, BOOLEAN);
 NTSYSAPI NTSTATUS  WINAPI NtClearEvent(HANDLE);
 NTSYSAPI NTSTATUS  WINAPI NtClose(HANDLE);
 NTSYSAPI NTSTATUS  WINAPI NtCloseObjectAuditAlarm(PUNICODE_STRING,HANDLE,BOOLEAN);
diff --git a/server/completion.c b/server/completion.c
index 6baaaacdb33..c182f3fd7a0 100644
--- a/server/completion.c
+++ b/server/completion.c
@@ -743,3 +743,30 @@ DECL_HANDLER(associate_completion_packet)
     release_object( target );
     release_object( packet );
 }
+
+/* cancel a wait completion packet */
+DECL_HANDLER(cancel_completion_packet)
+{
+    struct completion_packet *packet;
+
+    packet = get_completion_packet_obj( current->process, req->packet, WAIT_COMPLETION_PACKET_QUERY_STATE );
+    if (!packet)
+        return;
+
+    if (!packet->in_target_packet_queue && !packet->in_completion_queue)
+    {
+        set_error( STATUS_CANCELLED );
+        release_object( packet );
+        return;
+    }
+
+    if (packet->in_completion_queue && !req->remove_signaled)
+    {
+        set_error( STATUS_PENDING );
+        release_object( packet );
+        return;
+    }
+
+    cancel_completion_packet( packet );
+    release_object( packet );
+}
diff --git a/server/protocol.def b/server/protocol.def
index 35ae85e619a..40538089151 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -3907,6 +3907,13 @@ struct handle_info
 @END

+/* Cancel a wait completion packet */
+@REQ(cancel_completion_packet)
+    obj_handle_t  packet;         /* wait completion packet handle */
+    int           remove_signaled;/* whether to remove signaled packet */
+@END
+
+
 /* check for associated completion and push msg */
 @REQ(add_fd_completion)
     obj_handle_t   handle;        /* async' object */

[PATCH v3 0/7] MR6911: ntdll: Add WaitCompletionPacket.

[Zhiyi Zhang (＠zhiyi)]

v3: Rebase after the recent event sync work. Added tests to show that mutex and keyed events are not supported for wait completion packets. Added tests for cross-thread wait completion packets. Use the correct handle allocation pattern for wait completion packets.