Coverage Report

Created: 2025-07-01 06:46

/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 */