wine-commits July 2015

wine-commits@winehq.org

2 participants
567 discussions

Sebastian Lackner : ntdll: Implement TpCallbackUnloadDllOnCompletion.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: 8965511957d3d9f92fa0d6f41e5961d8a867f927 URL: http://source.winehq.org/git/wine.git/?a=commit;h=8965511957d3d9f92fa0d6f41… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:58:23 2015 +0200 ntdll: Implement TpCallbackUnloadDllOnCompletion. --- dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/threadpool.c | 22 +++++++++++++++++++++- 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 03f3af2..134a3f7 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -978,6 +978,7 @@ @ stdcall TpCallbackReleaseMutexOnCompletion(ptr long) @ stdcall TpCallbackReleaseSemaphoreOnCompletion(ptr long long) @ stdcall TpCallbackSetEventOnCompletion(ptr long) +@ stdcall TpCallbackUnloadDllOnCompletion(ptr ptr) @ stdcall TpPostWork(ptr) @ stdcall TpReleaseCleanupGroup(ptr) @ stdcall TpReleaseCleanupGroupMembers(ptr long ptr) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index af4f620..eeb275f 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -210,6 +210,7 @@ struct threadpool_instance HANDLE semaphore; LONG semaphore_count; HANDLE event; + HMODULE library; } cleanup; }; @@ -1644,6 +1645,7 @@ static void CALLBACK threadpool_worker_proc( void *param ) instance.cleanup.semaphore = NULL; instance.cleanup.semaphore_count = 0; instance.cleanup.event = NULL; + instance.cleanup.library = NULL; switch (object->type) { @@ -1696,7 +1698,12 @@ static void CALLBACK threadpool_worker_proc( void *param ) } if (instance.cleanup.event) { - NtSetEvent( instance.cleanup.event, NULL ); + status = NtSetEvent( instance.cleanup.event, NULL ); + if (status != STATUS_SUCCESS) goto skip_cleanup; + } + if (instance.cleanup.library) + { + LdrUnloadDll( instance.cleanup.library ); } skip_cleanup: @@ -1893,6 +1900,19 @@ VOID WINAPI TpCallbackSetEventOnCompletion( TP_CALLBACK_INSTANCE *instance, HAND } /*********************************************************************** + * TpCallbackUnloadDllOnCompletion (NTDLL.@) + */ +VOID WINAPI TpCallbackUnloadDllOnCompletion( TP_CALLBACK_INSTANCE *instance, HMODULE module ) +{ + struct threadpool_instance *this = impl_from_TP_CALLBACK_INSTANCE( instance ); + + TRACE( "%p %p\n", instance, module ); + + if (!this->cleanup.library) + this->cleanup.library = module; +} + +/*********************************************************************** * TpPostWork (NTDLL.@) */ VOID WINAPI TpPostWork( TP_WORK *work )

1 0

Sebastian Lackner : ntdll: Implement TpCallbackSetEventOnCompletion.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: 15110b1770e61593a69a726a6a0238a895fd2b86 URL: http://source.winehq.org/git/wine.git/?a=commit;h=15110b1770e61593a69a726a6… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:57:53 2015 +0200 ntdll: Implement TpCallbackSetEventOnCompletion. --- dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/threadpool.c | 22 +++++++++++++++++++++- 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 8d89c58..03f3af2 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -977,6 +977,7 @@ @ stdcall TpCallbackMayRunLong(ptr) @ stdcall TpCallbackReleaseMutexOnCompletion(ptr long) @ stdcall TpCallbackReleaseSemaphoreOnCompletion(ptr long long) +@ stdcall TpCallbackSetEventOnCompletion(ptr long) @ stdcall TpPostWork(ptr) @ stdcall TpReleaseCleanupGroup(ptr) @ stdcall TpReleaseCleanupGroupMembers(ptr long ptr) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index 46ed810..af4f620 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -209,6 +209,7 @@ struct threadpool_instance HANDLE mutex; HANDLE semaphore; LONG semaphore_count; + HANDLE event; } cleanup; }; @@ -1642,6 +1643,7 @@ static void CALLBACK threadpool_worker_proc( void *param ) instance.cleanup.mutex = NULL; instance.cleanup.semaphore = NULL; instance.cleanup.semaphore_count = 0; + instance.cleanup.event = NULL; switch (object->type) { @@ -1689,7 +1691,12 @@ static void CALLBACK threadpool_worker_proc( void *param ) } if (instance.cleanup.semaphore) { - NtReleaseSemaphore( instance.cleanup.semaphore, instance.cleanup.semaphore_count, NULL ); + status = NtReleaseSemaphore( instance.cleanup.semaphore, instance.cleanup.semaphore_count, NULL ); + if (status != STATUS_SUCCESS) goto skip_cleanup; + } + if (instance.cleanup.event) + { + NtSetEvent( instance.cleanup.event, NULL ); } skip_cleanup: @@ -1873,6 +1880,19 @@ VOID WINAPI TpCallbackReleaseSemaphoreOnCompletion( TP_CALLBACK_INSTANCE *instan } /*********************************************************************** + * TpCallbackSetEventOnCompletion (NTDLL.@) + */ +VOID WINAPI TpCallbackSetEventOnCompletion( TP_CALLBACK_INSTANCE *instance, HANDLE event ) +{ + struct threadpool_instance *this = impl_from_TP_CALLBACK_INSTANCE( instance ); + + TRACE( "%p %p\n", instance, event ); + + if (!this->cleanup.event) + this->cleanup.event = event; +} + +/*********************************************************************** * TpPostWork (NTDLL.@) */ VOID WINAPI TpPostWork( TP_WORK *work )

1 0

Sebastian Lackner : ntdll/tests: Add tests for TpCallbackReleaseSemaphoreOnCompletion and finalization callback.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: 3dc1c6442aad69f15b0c44e0144815de31c65de9 URL: http://source.winehq.org/git/wine.git/?a=commit;h=3dc1c6442aad69f15b0c44e01… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:57:16 2015 +0200 ntdll/tests: Add tests for TpCallbackReleaseSemaphoreOnCompletion and finalization callback. --- dlls/ntdll/tests/threadpool.c | 68 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/dlls/ntdll/tests/threadpool.c b/dlls/ntdll/tests/threadpool.c index e920300..62bd064 100644 --- a/dlls/ntdll/tests/threadpool.c +++ b/dlls/ntdll/tests/threadpool.c @@ -25,6 +25,7 @@ static NTSTATUS (WINAPI *pTpAllocCleanupGroup)(TP_CLEANUP_GROUP **); static NTSTATUS (WINAPI *pTpAllocPool)(TP_POOL **,PVOID); static NTSTATUS (WINAPI *pTpAllocWork)(TP_WORK **,PTP_WORK_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *); static NTSTATUS (WINAPI *pTpCallbackMayRunLong)(TP_CALLBACK_INSTANCE *); +static VOID (WINAPI *pTpCallbackReleaseSemaphoreOnCompletion)(TP_CALLBACK_INSTANCE *,HANDLE,DWORD); static VOID (WINAPI *pTpPostWork)(TP_WORK *); static VOID (WINAPI *pTpReleaseCleanupGroup)(TP_CLEANUP_GROUP *); static VOID (WINAPI *pTpReleaseCleanupGroupMembers)(TP_CLEANUP_GROUP *,BOOL,PVOID); @@ -55,6 +56,7 @@ static BOOL init_threadpool(void) NTDLL_GET_PROC(TpAllocPool); NTDLL_GET_PROC(TpAllocWork); NTDLL_GET_PROC(TpCallbackMayRunLong); + NTDLL_GET_PROC(TpCallbackReleaseSemaphoreOnCompletion); NTDLL_GET_PROC(TpPostWork); NTDLL_GET_PROC(TpReleaseCleanupGroup); NTDLL_GET_PROC(TpReleaseCleanupGroupMembers); @@ -431,6 +433,71 @@ static void test_tp_group_cancel(void) CloseHandle(semaphores[1]); } +static void CALLBACK instance_semaphore_completion_cb(TP_CALLBACK_INSTANCE *instance, void *userdata) +{ + HANDLE *semaphores = userdata; + trace("Running instance completion callback\n"); + pTpCallbackReleaseSemaphoreOnCompletion(instance, semaphores[0], 1); +} + +static void CALLBACK instance_finalization_cb(TP_CALLBACK_INSTANCE *instance, void *userdata) +{ + HANDLE *semaphores = userdata; + DWORD result; + + trace("Running instance finalization callback\n"); + + result = WaitForSingleObject(semaphores[0], 100); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ReleaseSemaphore(semaphores[1], 1, NULL); +} + +static void test_tp_instance(void) +{ + TP_CALLBACK_ENVIRON environment; + HANDLE semaphores[2]; + NTSTATUS status; + TP_POOL *pool; + DWORD result; + + semaphores[0] = CreateSemaphoreW(NULL, 0, 1, NULL); + ok(semaphores[0] != NULL, "failed to create semaphore\n"); + semaphores[1] = CreateSemaphoreW(NULL, 0, 1, NULL); + ok(semaphores[1] != NULL, "failed to create semaphore\n"); + + /* allocate new threadpool */ + pool = NULL; + status = pTpAllocPool(&pool, NULL); + ok(!status, "TpAllocPool failed with status %x\n", status); + ok(pool != NULL, "expected pool != NULL\n"); + + /* test for TpCallbackReleaseSemaphoreOnCompletion */ + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + status = pTpSimpleTryPost(instance_semaphore_completion_cb, semaphores, &environment); + ok(!status, "TpSimpleTryPost failed with status %x\n", status); + result = WaitForSingleObject(semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + + /* test for finalization callback */ + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + environment.FinalizationCallback = instance_finalization_cb; + status = pTpSimpleTryPost(instance_semaphore_completion_cb, semaphores, &environment); + ok(!status, "TpSimpleTryPost failed with status %x\n", status); + result = WaitForSingleObject(semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphores[1], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + + /* cleanup */ + pTpReleasePool(pool); + CloseHandle(semaphores[0]); + CloseHandle(semaphores[1]); +} + START_TEST(threadpool) { if (!init_threadpool()) @@ -440,4 +507,5 @@ START_TEST(threadpool) test_tp_work(); test_tp_work_scheduler(); test_tp_group_cancel(); + test_tp_instance(); }

1 0

Sebastian Lackner : ntdll: Implement TpCallbackReleaseSemaphoreOnCompletion.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: eb39cb1323046778f4d7c34e3d78bf5840c26010 URL: http://source.winehq.org/git/wine.git/?a=commit;h=eb39cb1323046778f4d7c34e3… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:56:51 2015 +0200 ntdll: Implement TpCallbackReleaseSemaphoreOnCompletion. --- dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/threadpool.c | 29 ++++++++++++++++++++++++++++- 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 4ccb3e7..8d89c58 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -976,6 +976,7 @@ @ stdcall TpCallbackLeaveCriticalSectionOnCompletion(ptr ptr) @ stdcall TpCallbackMayRunLong(ptr) @ stdcall TpCallbackReleaseMutexOnCompletion(ptr long) +@ stdcall TpCallbackReleaseSemaphoreOnCompletion(ptr long long) @ stdcall TpPostWork(ptr) @ stdcall TpReleaseCleanupGroup(ptr) @ stdcall TpReleaseCleanupGroupMembers(ptr long ptr) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index 28dd88b..46ed810 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -207,6 +207,8 @@ struct threadpool_instance { CRITICAL_SECTION *critical_section; HANDLE mutex; + HANDLE semaphore; + LONG semaphore_count; } cleanup; }; @@ -1608,6 +1610,7 @@ static void CALLBACK threadpool_worker_proc( void *param ) struct threadpool *pool = param; LARGE_INTEGER timeout; struct list *ptr; + NTSTATUS status; TRACE( "starting worker thread for pool %p\n", pool ); @@ -1637,6 +1640,8 @@ static void CALLBACK threadpool_worker_proc( void *param ) instance.may_run_long = object->may_run_long; instance.cleanup.critical_section = NULL; instance.cleanup.mutex = NULL; + instance.cleanup.semaphore = NULL; + instance.cleanup.semaphore_count = 0; switch (object->type) { @@ -1679,9 +1684,15 @@ static void CALLBACK threadpool_worker_proc( void *param ) } if (instance.cleanup.mutex) { - NtReleaseMutant( instance.cleanup.mutex, NULL ); + status = NtReleaseMutant( instance.cleanup.mutex, NULL ); + if (status != STATUS_SUCCESS) goto skip_cleanup; + } + if (instance.cleanup.semaphore) + { + NtReleaseSemaphore( instance.cleanup.semaphore, instance.cleanup.semaphore_count, NULL ); } + skip_cleanup: RtlEnterCriticalSection( &pool->cs ); pool->num_busy_workers--; object->num_running_callbacks--; @@ -1846,6 +1857,22 @@ VOID WINAPI TpCallbackReleaseMutexOnCompletion( TP_CALLBACK_INSTANCE *instance, } /*********************************************************************** + * TpCallbackReleaseSemaphoreOnCompletion (NTDLL.@) + */ +VOID WINAPI TpCallbackReleaseSemaphoreOnCompletion( TP_CALLBACK_INSTANCE *instance, HANDLE semaphore, DWORD count ) +{ + struct threadpool_instance *this = impl_from_TP_CALLBACK_INSTANCE( instance ); + + TRACE( "%p %p %u\n", instance, semaphore, count ); + + if (!this->cleanup.semaphore) + { + this->cleanup.semaphore = semaphore; + this->cleanup.semaphore_count = count; + } +} + +/*********************************************************************** * TpPostWork (NTDLL.@) */ VOID WINAPI TpPostWork( TP_WORK *work )

1 0

Sebastian Lackner : ntdll: Implement TpCallbackReleaseMutexOnCompletion.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: 02ee5bb52da578a7ef71be104666983442e23512 URL: http://source.winehq.org/git/wine.git/?a=commit;h=02ee5bb52da578a7ef71be104… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:56:14 2015 +0200 ntdll: Implement TpCallbackReleaseMutexOnCompletion. Various internal details about the order and error handling of completion actions are documented in "Concurrent Programming on Windows" by Joe Duffy. --- dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/threadpool.c | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 5cfcfd7..4ccb3e7 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -975,6 +975,7 @@ @ stdcall TpAllocWork(ptr ptr ptr ptr) @ stdcall TpCallbackLeaveCriticalSectionOnCompletion(ptr ptr) @ stdcall TpCallbackMayRunLong(ptr) +@ stdcall TpCallbackReleaseMutexOnCompletion(ptr long) @ stdcall TpPostWork(ptr) @ stdcall TpReleaseCleanupGroup(ptr) @ stdcall TpReleaseCleanupGroupMembers(ptr long ptr) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index 21e5b7d..28dd88b 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -206,6 +206,7 @@ struct threadpool_instance struct { CRITICAL_SECTION *critical_section; + HANDLE mutex; } cleanup; }; @@ -1635,6 +1636,7 @@ static void CALLBACK threadpool_worker_proc( void *param ) instance.threadid = GetCurrentThreadId(); instance.may_run_long = object->may_run_long; instance.cleanup.critical_section = NULL; + instance.cleanup.mutex = NULL; switch (object->type) { @@ -1675,6 +1677,10 @@ static void CALLBACK threadpool_worker_proc( void *param ) { RtlLeaveCriticalSection( instance.cleanup.critical_section ); } + if (instance.cleanup.mutex) + { + NtReleaseMutant( instance.cleanup.mutex, NULL ); + } RtlEnterCriticalSection( &pool->cs ); pool->num_busy_workers--; @@ -1827,6 +1833,19 @@ NTSTATUS WINAPI TpCallbackMayRunLong( TP_CALLBACK_INSTANCE *instance ) } /*********************************************************************** + * TpCallbackReleaseMutexOnCompletion (NTDLL.@) + */ +VOID WINAPI TpCallbackReleaseMutexOnCompletion( TP_CALLBACK_INSTANCE *instance, HANDLE mutex ) +{ + struct threadpool_instance *this = impl_from_TP_CALLBACK_INSTANCE( instance ); + + TRACE( "%p %p\n", instance, mutex ); + + if (!this->cleanup.mutex) + this->cleanup.mutex = mutex; +} + +/*********************************************************************** * TpPostWork (NTDLL.@) */ VOID WINAPI TpPostWork( TP_WORK *work )

1 0

Sebastian Lackner : ntdll: Implement TpCallbackLeaveCriticalSectionOnCompletion.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: a9dd37be6827e7df90838c604404db1d112ebf42 URL: http://source.winehq.org/git/wine.git/?a=commit;h=a9dd37be6827e7df90838c604… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:55:52 2015 +0200 ntdll: Implement TpCallbackLeaveCriticalSectionOnCompletion. An instance can only have one completion of each type, trying to add a second one leads to an exception on Windows. --- dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/threadpool.c | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 5a698c4..5cfcfd7 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -973,6 +973,7 @@ @ stdcall TpAllocCleanupGroup(ptr) @ stdcall TpAllocPool(ptr ptr) @ stdcall TpAllocWork(ptr ptr ptr ptr) +@ stdcall TpCallbackLeaveCriticalSectionOnCompletion(ptr ptr) @ stdcall TpCallbackMayRunLong(ptr) @ stdcall TpPostWork(ptr) @ stdcall TpReleaseCleanupGroup(ptr) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index a0090c0..21e5b7d 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -203,6 +203,10 @@ struct threadpool_instance struct threadpool_object *object; DWORD threadid; BOOL may_run_long; + struct + { + CRITICAL_SECTION *critical_section; + } cleanup; }; /* internal threadpool group representation */ @@ -1630,6 +1634,7 @@ static void CALLBACK threadpool_worker_proc( void *param ) instance.object = object; instance.threadid = GetCurrentThreadId(); instance.may_run_long = object->may_run_long; + instance.cleanup.critical_section = NULL; switch (object->type) { @@ -1665,6 +1670,12 @@ static void CALLBACK threadpool_worker_proc( void *param ) TRACE( "callback %p returned\n", object->finalization_callback ); } + /* Execute cleanup tasks. */ + if (instance.cleanup.critical_section) + { + RtlLeaveCriticalSection( instance.cleanup.critical_section ); + } + RtlEnterCriticalSection( &pool->cs ); pool->num_busy_workers--; object->num_running_callbacks--; @@ -1753,6 +1764,19 @@ NTSTATUS WINAPI TpAllocWork( TP_WORK **out, PTP_WORK_CALLBACK callback, PVOID us } /*********************************************************************** + * TpCallbackLeaveCriticalSectionOnCompletion (NTDLL.@) + */ +VOID WINAPI TpCallbackLeaveCriticalSectionOnCompletion( TP_CALLBACK_INSTANCE *instance, CRITICAL_SECTION *crit ) +{ + struct threadpool_instance *this = impl_from_TP_CALLBACK_INSTANCE( instance ); + + TRACE( "%p %p\n", instance, crit ); + + if (!this->cleanup.critical_section) + this->cleanup.critical_section = crit; +} + +/*********************************************************************** * TpCallbackMayRunLong (NTDLL.@) */ NTSTATUS WINAPI TpCallbackMayRunLong( TP_CALLBACK_INSTANCE *instance )

1 0

Sebastian Lackner : ntdll: Implement instance objects and the TpCallbackMayRunLong function.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: eb974bcd7a4eb6e0205c6309f48b885701f3a56f URL: http://source.winehq.org/git/wine.git/?a=commit;h=eb974bcd7a4eb6e0205c6309f… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:55:30 2015 +0200 ntdll: Implement instance objects and the TpCallbackMayRunLong function. The instance is marked as long-running even if TpCallbackMayRunLong fails, a second call will lead to an exception on Windows. --- dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/tests/threadpool.c | 9 ++++ dlls/ntdll/threadpool.c | 98 ++++++++++++++++++++++++++++++++++++++----- 3 files changed, 98 insertions(+), 10 deletions(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 4b5ece5..5a698c4 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -973,6 +973,7 @@ @ stdcall TpAllocCleanupGroup(ptr) @ stdcall TpAllocPool(ptr ptr) @ stdcall TpAllocWork(ptr ptr ptr ptr) +@ stdcall TpCallbackMayRunLong(ptr) @ stdcall TpPostWork(ptr) @ stdcall TpReleaseCleanupGroup(ptr) @ stdcall TpReleaseCleanupGroupMembers(ptr long ptr) diff --git a/dlls/ntdll/tests/threadpool.c b/dlls/ntdll/tests/threadpool.c index 2d64471..e920300 100644 --- a/dlls/ntdll/tests/threadpool.c +++ b/dlls/ntdll/tests/threadpool.c @@ -24,6 +24,7 @@ static HMODULE hntdll = 0; static NTSTATUS (WINAPI *pTpAllocCleanupGroup)(TP_CLEANUP_GROUP **); static NTSTATUS (WINAPI *pTpAllocPool)(TP_POOL **,PVOID); static NTSTATUS (WINAPI *pTpAllocWork)(TP_WORK **,PTP_WORK_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *); +static NTSTATUS (WINAPI *pTpCallbackMayRunLong)(TP_CALLBACK_INSTANCE *); static VOID (WINAPI *pTpPostWork)(TP_WORK *); static VOID (WINAPI *pTpReleaseCleanupGroup)(TP_CLEANUP_GROUP *); static VOID (WINAPI *pTpReleaseCleanupGroupMembers)(TP_CLEANUP_GROUP *,BOOL,PVOID); @@ -53,6 +54,7 @@ static BOOL init_threadpool(void) NTDLL_GET_PROC(TpAllocCleanupGroup); NTDLL_GET_PROC(TpAllocPool); NTDLL_GET_PROC(TpAllocWork); + NTDLL_GET_PROC(TpCallbackMayRunLong); NTDLL_GET_PROC(TpPostWork); NTDLL_GET_PROC(TpReleaseCleanupGroup); NTDLL_GET_PROC(TpReleaseCleanupGroupMembers); @@ -312,8 +314,15 @@ static DWORD group_cancel_tid; static void CALLBACK group_cancel_cb(TP_CALLBACK_INSTANCE *instance, void *userdata) { HANDLE *semaphores = userdata; + NTSTATUS status; DWORD result; + trace("Running group cancel callback\n"); + + status = pTpCallbackMayRunLong(instance); + ok(status == STATUS_TOO_MANY_THREADS || broken(status == 1) /* Win Vista / 2008 */, + "expected STATUS_TOO_MANY_THREADS, got %08x\n", status); + result = WaitForSingleObject(semaphores[0], 1000); ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); ReleaseSemaphore(semaphores[1], 1, NULL); diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index 4ae81b0..a0090c0 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -173,6 +173,7 @@ struct threadpool_object PVOID userdata; PTP_CLEANUP_GROUP_CANCEL_CALLBACK group_cancel_callback; PTP_SIMPLE_CALLBACK finalization_callback; + BOOL may_run_long; HMODULE race_dll; /* information about the group, locked via .group->cs */ struct list group_entry; @@ -196,6 +197,14 @@ struct threadpool_object } u; }; +/* internal threadpool instance representation */ +struct threadpool_instance +{ + struct threadpool_object *object; + DWORD threadid; + BOOL may_run_long; +}; + /* internal threadpool group representation */ struct threadpool_group { @@ -223,6 +232,11 @@ static inline struct threadpool_group *impl_from_TP_CLEANUP_GROUP( TP_CLEANUP_GR return (struct threadpool_group *)group; } +static inline struct threadpool_instance *impl_from_TP_CALLBACK_INSTANCE( TP_CALLBACK_INSTANCE *instance ) +{ + return (struct threadpool_instance *)instance; +} + static void CALLBACK threadpool_worker_proc( void *param ); static void tp_object_submit( struct threadpool_object *object ); static void tp_object_shutdown( struct threadpool_object *object ); @@ -1375,6 +1389,7 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa object->userdata = userdata; object->group_cancel_callback = NULL; object->finalization_callback = NULL; + object->may_run_long = 0; object->race_dll = NULL; memset( &object->group_entry, 0, sizeof(object->group_entry) ); @@ -1393,9 +1408,14 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa object->group = impl_from_TP_CLEANUP_GROUP( environment->CleanupGroup ); object->group_cancel_callback = environment->CleanupGroupCancelCallback; object->finalization_callback = environment->FinalizationCallback; + object->may_run_long = environment->u.s.LongFunction != 0; object->race_dll = environment->RaceDll; - WARN( "environment not fully implemented yet\n" ); + if (environment->ActivationContext) + FIXME( "activation context not supported yet\n" ); + + if (environment->u.s.Persistent) + FIXME( "persistent threads not supported yet\n" ); } if (object->race_dll) @@ -1578,6 +1598,8 @@ static BOOL tp_object_release( struct threadpool_object *object ) */ static void CALLBACK threadpool_worker_proc( void *param ) { + TP_CALLBACK_INSTANCE *callback_instance; + struct threadpool_instance instance; struct threadpool *pool = param; LARGE_INTEGER timeout; struct list *ptr; @@ -1603,22 +1625,28 @@ static void CALLBACK threadpool_worker_proc( void *param ) pool->num_busy_workers++; RtlLeaveCriticalSection( &pool->cs ); + /* Initialize threadpool instance struct. */ + callback_instance = (TP_CALLBACK_INSTANCE *)&instance; + instance.object = object; + instance.threadid = GetCurrentThreadId(); + instance.may_run_long = object->may_run_long; + switch (object->type) { case TP_OBJECT_TYPE_SIMPLE: { - TRACE( "executing simple callback %p(NULL, %p)\n", - object->u.simple.callback, object->userdata ); - object->u.simple.callback( NULL, object->userdata ); + TRACE( "executing simple callback %p(%p, %p)\n", + object->u.simple.callback, callback_instance, object->userdata ); + object->u.simple.callback( callback_instance, object->userdata ); TRACE( "callback %p returned\n", object->u.simple.callback ); break; } case TP_OBJECT_TYPE_WORK: { - TRACE( "executing work callback %p(NULL, %p, %p)\n", - object->u.work.callback, object->userdata, object ); - object->u.work.callback( NULL, object->userdata, (TP_WORK *)object ); + TRACE( "executing work callback %p(%p, %p, %p)\n", + object->u.work.callback, callback_instance, object->userdata, object ); + object->u.work.callback( callback_instance, object->userdata, (TP_WORK *)object ); TRACE( "callback %p returned\n", object->u.work.callback ); break; } @@ -1631,9 +1659,9 @@ static void CALLBACK threadpool_worker_proc( void *param ) /* Execute finalization callback. */ if (object->finalization_callback) { - TRACE( "executing finalization callback %p(NULL, %p)\n", - object->finalization_callback, object->userdata ); - object->finalization_callback( NULL, object->userdata ); + TRACE( "executing finalization callback %p(%p, %p)\n", + object->finalization_callback, callback_instance, object->userdata ); + object->finalization_callback( callback_instance, object->userdata ); TRACE( "callback %p returned\n", object->finalization_callback ); } @@ -1725,6 +1753,56 @@ NTSTATUS WINAPI TpAllocWork( TP_WORK **out, PTP_WORK_CALLBACK callback, PVOID us } /*********************************************************************** + * TpCallbackMayRunLong (NTDLL.@) + */ +NTSTATUS WINAPI TpCallbackMayRunLong( TP_CALLBACK_INSTANCE *instance ) +{ + struct threadpool_instance *this = impl_from_TP_CALLBACK_INSTANCE( instance ); + struct threadpool_object *object = this->object; + struct threadpool *pool; + NTSTATUS status = STATUS_SUCCESS; + + TRACE( "%p\n", instance ); + + if (this->threadid != GetCurrentThreadId()) + { + ERR("called from wrong thread, ignoring\n"); + return STATUS_UNSUCCESSFUL; /* FIXME */ + } + + if (this->may_run_long) + return STATUS_SUCCESS; + + pool = object->pool; + RtlEnterCriticalSection( &pool->cs ); + + /* Start new worker threads if required. */ + if (pool->num_busy_workers >= pool->num_workers) + { + if (pool->num_workers < pool->max_workers) + { + HANDLE thread; + status = RtlCreateUserThread( GetCurrentProcess(), NULL, FALSE, NULL, 0, 0, + threadpool_worker_proc, pool, &thread, NULL ); + if (status == STATUS_SUCCESS) + { + interlocked_inc( &pool->refcount ); + pool->num_workers++; + NtClose( thread ); + } + } + else + { + status = STATUS_TOO_MANY_THREADS; + } + } + + RtlLeaveCriticalSection( &pool->cs ); + this->may_run_long = TRUE; + return status; +} + +/*********************************************************************** * TpPostWork (NTDLL.@) */ VOID WINAPI TpPostWork( TP_WORK *work )

1 0

Sebastian Lackner : ntdll: Implement threadpool RaceDll environment variable.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: 8fc2430c2a5359fbad811c7f7f51eb0b262ba456 URL: http://source.winehq.org/git/wine.git/?a=commit;h=8fc2430c2a5359fbad811c7f7… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:53:44 2015 +0200 ntdll: Implement threadpool RaceDll environment variable. --- dlls/ntdll/threadpool.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index 0133e66..4ae81b0 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -173,6 +173,7 @@ struct threadpool_object PVOID userdata; PTP_CLEANUP_GROUP_CANCEL_CALLBACK group_cancel_callback; PTP_SIMPLE_CALLBACK finalization_callback; + HMODULE race_dll; /* information about the group, locked via .group->cs */ struct list group_entry; BOOL is_group_member; @@ -1374,6 +1375,7 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa object->userdata = userdata; object->group_cancel_callback = NULL; object->finalization_callback = NULL; + object->race_dll = NULL; memset( &object->group_entry, 0, sizeof(object->group_entry) ); object->is_group_member = FALSE; @@ -1391,10 +1393,14 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa object->group = impl_from_TP_CLEANUP_GROUP( environment->CleanupGroup ); object->group_cancel_callback = environment->CleanupGroupCancelCallback; object->finalization_callback = environment->FinalizationCallback; + object->race_dll = environment->RaceDll; WARN( "environment not fully implemented yet\n" ); } + if (object->race_dll) + LdrAddRefDll( 0, object->race_dll ); + TRACE( "allocated object %p of type %u\n", object, object->type ); /* For simple callbacks we have to run tp_object_submit before adding this object @@ -1560,6 +1566,9 @@ static BOOL tp_object_release( struct threadpool_object *object ) tp_threadpool_unlock( object->pool ); + if (object->race_dll) + LdrUnloadDll( object->race_dll ); + RtlFreeHeap( GetProcessHeap(), 0, object ); return TRUE; }

1 0

Sebastian Lackner : ntdll: Add support for threadpool finalization callback.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: fa114f122b066e1b9b0f90d45c5a2ce33be386d5 URL: http://source.winehq.org/git/wine.git/?a=commit;h=fa114f122b066e1b9b0f90d45… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:53:26 2015 +0200 ntdll: Add support for threadpool finalization callback. --- dlls/ntdll/threadpool.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index 93d9b28..0133e66 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -172,6 +172,7 @@ struct threadpool_object struct threadpool_group *group; PVOID userdata; PTP_CLEANUP_GROUP_CANCEL_CALLBACK group_cancel_callback; + PTP_SIMPLE_CALLBACK finalization_callback; /* information about the group, locked via .group->cs */ struct list group_entry; BOOL is_group_member; @@ -1372,6 +1373,7 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa object->group = NULL; object->userdata = userdata; object->group_cancel_callback = NULL; + object->finalization_callback = NULL; memset( &object->group_entry, 0, sizeof(object->group_entry) ); object->is_group_member = FALSE; @@ -1388,6 +1390,7 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa object->group = impl_from_TP_CLEANUP_GROUP( environment->CleanupGroup ); object->group_cancel_callback = environment->CleanupGroupCancelCallback; + object->finalization_callback = environment->FinalizationCallback; WARN( "environment not fully implemented yet\n" ); } @@ -1616,6 +1619,15 @@ static void CALLBACK threadpool_worker_proc( void *param ) break; } + /* Execute finalization callback. */ + if (object->finalization_callback) + { + TRACE( "executing finalization callback %p(NULL, %p)\n", + object->finalization_callback, object->userdata ); + object->finalization_callback( NULL, object->userdata ); + TRACE( "callback %p returned\n", object->finalization_callback ); + } + RtlEnterCriticalSection( &pool->cs ); pool->num_busy_workers--; object->num_running_callbacks--;

1 0

Sebastian Lackner : ntdll/tests: Add tests for threadpool group cancel callback.
by Alexandre Julliard 02 Jul '15

02 Jul '15

Module: wine Branch: master Commit: e8d4b403863c436b6944b67987f0341d5602204c URL: http://source.winehq.org/git/wine.git/?a=commit;h=e8d4b403863c436b6944b6798… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:53:09 2015 +0200 ntdll/tests: Add tests for threadpool group cancel callback. --- dlls/ntdll/tests/threadpool.c | 116 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) diff --git a/dlls/ntdll/tests/threadpool.c b/dlls/ntdll/tests/threadpool.c index b261cd1..2d64471 100644 --- a/dlls/ntdll/tests/threadpool.c +++ b/dlls/ntdll/tests/threadpool.c @@ -307,6 +307,121 @@ static void test_tp_work_scheduler(void) pTpReleasePool(pool); } +static DWORD group_cancel_tid; + +static void CALLBACK group_cancel_cb(TP_CALLBACK_INSTANCE *instance, void *userdata) +{ + HANDLE *semaphores = userdata; + DWORD result; + trace("Running group cancel callback\n"); + result = WaitForSingleObject(semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ReleaseSemaphore(semaphores[1], 1, NULL); +} + +static void CALLBACK group_cancel_cleanup_release_cb(void *object, void *userdata) +{ + HANDLE *semaphores = userdata; + trace("Running group cancel cleanup release callback\n"); + group_cancel_tid = GetCurrentThreadId(); + ReleaseSemaphore(semaphores[0], 1, NULL); +} + +static void CALLBACK group_cancel_cleanup_increment_cb(void *object, void *userdata) +{ + trace("Running group cancel cleanup increment callback\n"); + group_cancel_tid = GetCurrentThreadId(); + InterlockedIncrement((LONG *)userdata); +} + +static void CALLBACK unexpected_cb(TP_CALLBACK_INSTANCE *instance, void *userdata) +{ + ok(0, "Unexpected callback\n"); +} + +static void test_tp_group_cancel(void) +{ + TP_CALLBACK_ENVIRON environment; + TP_CLEANUP_GROUP *group; + LONG userdata, userdata2; + HANDLE semaphores[2]; + NTSTATUS status; + TP_WORK *work; + TP_POOL *pool; + DWORD result; + int i; + + semaphores[0] = CreateSemaphoreA(NULL, 0, 1, NULL); + ok(semaphores[0] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + semaphores[1] = CreateSemaphoreA(NULL, 0, 1, NULL); + ok(semaphores[1] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + + /* allocate new threadpool with only one thread */ + pool = NULL; + status = pTpAllocPool(&pool, NULL); + ok(!status, "TpAllocPool failed with status %x\n", status); + ok(pool != NULL, "expected pool != NULL\n"); + pTpSetPoolMaxThreads(pool, 1); + + /* allocate a cleanup group */ + group = NULL; + status = pTpAllocCleanupGroup(&group); + ok(!status, "TpAllocCleanupGroup failed with status %x\n", status); + ok(group != NULL, "expected pool != NULL\n"); + + /* test execution of cancellation callback */ + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + status = pTpSimpleTryPost(group_cancel_cb, semaphores, &environment); + ok(!status, "TpSimpleTryPost failed with status %x\n", status); + + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + environment.CleanupGroup = group; + environment.CleanupGroupCancelCallback = group_cancel_cleanup_release_cb; + status = pTpSimpleTryPost(unexpected_cb, NULL, &environment); + ok(!status, "TpSimpleTryPost failed with status %x\n", status); + + group_cancel_tid = 0xdeadbeef; + pTpReleaseCleanupGroupMembers(group, TRUE, semaphores); + result = WaitForSingleObject(semaphores[1], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n", + GetCurrentThreadId(), group_cancel_tid); + + /* test cancellation callback for objects with multiple instances */ + work = NULL; + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + environment.CleanupGroup = group; + environment.CleanupGroupCancelCallback = group_cancel_cleanup_increment_cb; + status = pTpAllocWork(&work, work_cb, &userdata, &environment); + ok(!status, "TpAllocWork failed with status %x\n", status); + ok(work != NULL, "expected work != NULL\n"); + + /* post 10 identical work items at once */ + userdata = userdata2 = 0; + for (i = 0; i < 10; i++) + pTpPostWork(work); + + /* check if we get multiple cancellation callbacks */ + group_cancel_tid = 0xdeadbeef; + pTpReleaseCleanupGroupMembers(group, TRUE, &userdata2); + ok(userdata <= 8, "expected userdata <= 8, got %u\n", userdata); + ok(userdata2 == 1, "expected only one cancellation callback, got %u\n", userdata2); + ok(group_cancel_tid == GetCurrentThreadId(), "expected tid %x, got %x\n", + GetCurrentThreadId(), group_cancel_tid); + + /* cleanup */ + pTpReleaseCleanupGroup(group); + pTpReleasePool(pool); + CloseHandle(semaphores[0]); + CloseHandle(semaphores[1]); +} + START_TEST(threadpool) { if (!init_threadpool()) @@ -315,4 +430,5 @@ START_TEST(threadpool) test_tp_simple(); test_tp_work(); test_tp_work_scheduler(); + test_tp_group_cancel(); }

1 0

← Newer
1
...
48
49
50
51
52
53
54
...
57
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-commits July 2015