/src/FreeRDP/winpr/libwinpr/pool/work.c
Line | Count | Source (jump to first uncovered line) |
1 | | /** |
2 | | * WinPR: Windows Portable Runtime |
3 | | * Thread Pool API (Work) |
4 | | * |
5 | | * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com> |
6 | | * |
7 | | * Licensed under the Apache License, Version 2.0 (the "License"); |
8 | | * you may not use this file except in compliance with the License. |
9 | | * You may obtain a copy of the License at |
10 | | * |
11 | | * http://www.apache.org/licenses/LICENSE-2.0 |
12 | | * |
13 | | * Unless required by applicable law or agreed to in writing, software |
14 | | * distributed under the License is distributed on an "AS IS" BASIS, |
15 | | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
16 | | * See the License for the specific language governing permissions and |
17 | | * limitations under the License. |
18 | | */ |
19 | | |
20 | | #include <winpr/config.h> |
21 | | |
22 | | #include <winpr/assert.h> |
23 | | #include <winpr/crt.h> |
24 | | #include <winpr/pool.h> |
25 | | #include <winpr/library.h> |
26 | | |
27 | | #include "pool.h" |
28 | | #include "../log.h" |
29 | | #define TAG WINPR_TAG("pool") |
30 | | |
31 | | #ifdef WINPR_THREAD_POOL |
32 | | |
33 | | #ifdef _WIN32 |
34 | | static INIT_ONCE init_once_module = INIT_ONCE_STATIC_INIT; |
35 | | static PTP_WORK(WINAPI* pCreateThreadpoolWork)(PTP_WORK_CALLBACK pfnwk, PVOID pv, |
36 | | PTP_CALLBACK_ENVIRON pcbe); |
37 | | static VOID(WINAPI* pCloseThreadpoolWork)(PTP_WORK pwk); |
38 | | static VOID(WINAPI* pSubmitThreadpoolWork)(PTP_WORK pwk); |
39 | | static BOOL(WINAPI* pTrySubmitThreadpoolCallback)(PTP_SIMPLE_CALLBACK pfns, PVOID pv, |
40 | | PTP_CALLBACK_ENVIRON pcbe); |
41 | | static VOID(WINAPI* pWaitForThreadpoolWorkCallbacks)(PTP_WORK pwk, BOOL fCancelPendingCallbacks); |
42 | | |
43 | | static BOOL CALLBACK init_module(PINIT_ONCE once, PVOID param, PVOID* context) |
44 | | { |
45 | | HMODULE kernel32 = LoadLibraryA("kernel32.dll"); |
46 | | |
47 | | if (kernel32) |
48 | | { |
49 | | pCreateThreadpoolWork = GetProcAddressAs(kernel32, "CreateThreadpoolWork", void*); |
50 | | pCloseThreadpoolWork = GetProcAddressAs(kernel32, "CloseThreadpoolWork", void*); |
51 | | pSubmitThreadpoolWork = GetProcAddressAs(kernel32, "SubmitThreadpoolWork", void*); |
52 | | pTrySubmitThreadpoolCallback = |
53 | | GetProcAddressAs(kernel32, "TrySubmitThreadpoolCallback", void*); |
54 | | pWaitForThreadpoolWorkCallbacks = |
55 | | GetProcAddressAs(kernel32, "WaitForThreadpoolWorkCallbacks", void*); |
56 | | } |
57 | | |
58 | | return TRUE; |
59 | | } |
60 | | #endif |
61 | | |
62 | | static TP_CALLBACK_ENVIRON DEFAULT_CALLBACK_ENVIRONMENT = { |
63 | | 1, /* Version */ |
64 | | NULL, /* Pool */ |
65 | | NULL, /* CleanupGroup */ |
66 | | NULL, /* CleanupGroupCancelCallback */ |
67 | | NULL, /* RaceDll */ |
68 | | NULL, /* FinalizationCallback */ |
69 | | { 0 } /* Flags */ |
70 | | }; |
71 | | |
72 | | PTP_WORK winpr_CreateThreadpoolWork(PTP_WORK_CALLBACK pfnwk, PVOID pv, PTP_CALLBACK_ENVIRON pcbe) |
73 | 0 | { |
74 | 0 | PTP_WORK work = NULL; |
75 | | #ifdef _WIN32 |
76 | | InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL); |
77 | | |
78 | | if (pCreateThreadpoolWork) |
79 | | return pCreateThreadpoolWork(pfnwk, pv, pcbe); |
80 | | |
81 | | #endif |
82 | 0 | work = (PTP_WORK)calloc(1, sizeof(TP_WORK)); |
83 | |
|
84 | 0 | if (work) |
85 | 0 | { |
86 | 0 | if (!pcbe) |
87 | 0 | { |
88 | 0 | pcbe = &DEFAULT_CALLBACK_ENVIRONMENT; |
89 | 0 | pcbe->Pool = GetDefaultThreadpool(); |
90 | 0 | } |
91 | |
|
92 | 0 | work->CallbackEnvironment = pcbe; |
93 | 0 | work->WorkCallback = pfnwk; |
94 | 0 | work->CallbackParameter = pv; |
95 | 0 | #ifndef _WIN32 |
96 | |
|
97 | 0 | if (pcbe->CleanupGroup) |
98 | 0 | ArrayList_Append(pcbe->CleanupGroup->groups, work); |
99 | |
|
100 | 0 | #endif |
101 | 0 | } |
102 | |
|
103 | 0 | return work; |
104 | 0 | } |
105 | | |
106 | | VOID winpr_CloseThreadpoolWork(PTP_WORK pwk) |
107 | 0 | { |
108 | | #ifdef _WIN32 |
109 | | InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL); |
110 | | |
111 | | if (pCloseThreadpoolWork) |
112 | | { |
113 | | pCloseThreadpoolWork(pwk); |
114 | | return; |
115 | | } |
116 | | |
117 | | #else |
118 | |
|
119 | 0 | WINPR_ASSERT(pwk); |
120 | 0 | WINPR_ASSERT(pwk->CallbackEnvironment); |
121 | 0 | if (pwk->CallbackEnvironment->CleanupGroup) |
122 | 0 | ArrayList_Remove(pwk->CallbackEnvironment->CleanupGroup->groups, pwk); |
123 | |
|
124 | 0 | #endif |
125 | 0 | free(pwk); |
126 | 0 | } |
127 | | |
128 | | VOID winpr_SubmitThreadpoolWork(PTP_WORK pwk) |
129 | 0 | { |
130 | 0 | PTP_POOL pool = NULL; |
131 | 0 | PTP_CALLBACK_INSTANCE callbackInstance = NULL; |
132 | | #ifdef _WIN32 |
133 | | InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL); |
134 | | |
135 | | if (pSubmitThreadpoolWork) |
136 | | { |
137 | | pSubmitThreadpoolWork(pwk); |
138 | | return; |
139 | | } |
140 | | |
141 | | #endif |
142 | |
|
143 | 0 | WINPR_ASSERT(pwk); |
144 | 0 | WINPR_ASSERT(pwk->CallbackEnvironment); |
145 | 0 | pool = pwk->CallbackEnvironment->Pool; |
146 | 0 | callbackInstance = (PTP_CALLBACK_INSTANCE)calloc(1, sizeof(TP_CALLBACK_INSTANCE)); |
147 | |
|
148 | 0 | if (callbackInstance) |
149 | 0 | { |
150 | 0 | callbackInstance->Work = pwk; |
151 | 0 | CountdownEvent_AddCount(pool->WorkComplete, 1); |
152 | 0 | if (!Queue_Enqueue(pool->PendingQueue, callbackInstance)) |
153 | 0 | free(callbackInstance); |
154 | 0 | } |
155 | | // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): Queue_Enqueue takes ownership of callbackInstance |
156 | 0 | } |
157 | | |
158 | | BOOL winpr_TrySubmitThreadpoolCallback(WINPR_ATTR_UNUSED PTP_SIMPLE_CALLBACK pfns, |
159 | | WINPR_ATTR_UNUSED PVOID pv, |
160 | | WINPR_ATTR_UNUSED PTP_CALLBACK_ENVIRON pcbe) |
161 | 0 | { |
162 | | #ifdef _WIN32 |
163 | | InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL); |
164 | | |
165 | | if (pTrySubmitThreadpoolCallback) |
166 | | return pTrySubmitThreadpoolCallback(pfns, pv, pcbe); |
167 | | |
168 | | #endif |
169 | 0 | WLog_ERR(TAG, "TrySubmitThreadpoolCallback is not implemented"); |
170 | 0 | return FALSE; |
171 | 0 | } |
172 | | |
173 | | VOID winpr_WaitForThreadpoolWorkCallbacks(PTP_WORK pwk, |
174 | | WINPR_ATTR_UNUSED BOOL fCancelPendingCallbacks) |
175 | 0 | { |
176 | 0 | HANDLE event = NULL; |
177 | 0 | PTP_POOL pool = NULL; |
178 | |
|
179 | | #ifdef _WIN32 |
180 | | InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL); |
181 | | |
182 | | if (pWaitForThreadpoolWorkCallbacks) |
183 | | { |
184 | | pWaitForThreadpoolWorkCallbacks(pwk, fCancelPendingCallbacks); |
185 | | return; |
186 | | } |
187 | | |
188 | | #endif |
189 | 0 | WINPR_ASSERT(pwk); |
190 | 0 | WINPR_ASSERT(pwk->CallbackEnvironment); |
191 | | |
192 | 0 | pool = pwk->CallbackEnvironment->Pool; |
193 | 0 | WINPR_ASSERT(pool); |
194 | | |
195 | 0 | event = CountdownEvent_WaitHandle(pool->WorkComplete); |
196 | |
|
197 | 0 | if (WaitForSingleObject(event, INFINITE) != WAIT_OBJECT_0) |
198 | 0 | WLog_ERR(TAG, "error waiting on work completion"); |
199 | 0 | } |
200 | | |
201 | | #endif /* WINPR_THREAD_POOL defined */ |