1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
|
/* $Id: EventQueue.cpp $ */
/** @file
* Event queue class declaration.
*/
/*
* Copyright (C) 2013-2023 Oracle and/or its affiliates.
*
* This file is part of VirtualBox base platform packages, as
* available from https://www.virtualbox.org.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, in version 3 of the
* License.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <https://www.gnu.org/licenses>.
*
* SPDX-License-Identifier: GPL-3.0-only
*/
/** @todo Adapt / update documentation! */
#include "VBox/com/EventQueue.h"
#include <iprt/asm.h>
#include <new> /* For bad_alloc. */
#include <iprt/err.h>
#include <iprt/semaphore.h>
#include <iprt/time.h>
#include <iprt/thread.h>
#include <iprt/log.h>
namespace com
{
// EventQueue class
////////////////////////////////////////////////////////////////////////////////
EventQueue::EventQueue(void)
: mUserCnt(0),
mShutdown(false)
{
int vrc = RTCritSectInit(&mCritSect);
AssertRC(vrc);
vrc = RTSemEventCreate(&mSemEvent);
AssertRC(vrc);
}
EventQueue::~EventQueue(void)
{
int vrc = RTCritSectDelete(&mCritSect);
AssertRC(vrc);
vrc = RTSemEventDestroy(mSemEvent);
AssertRC(vrc);
EventQueueListIterator it = mEvents.begin();
while (it != mEvents.end())
{
(*it)->Release();
it = mEvents.erase(it);
}
}
/**
* Process events pending on this event queue, and wait up to given timeout, if
* nothing is available.
*
* Must be called on same thread this event queue was created on.
*
* @param cMsTimeout The timeout specified as milliseconds. Use
* RT_INDEFINITE_WAIT to wait till an event is posted on the
* queue.
*
* @returns VBox status code
* @retval VINF_SUCCESS if one or more messages was processed.
* @retval VERR_TIMEOUT if cMsTimeout expired.
* @retval VERR_INVALID_CONTEXT if called on the wrong thread.
* @retval VERR_INTERRUPTED if interruptEventQueueProcessing was called.
* On Windows will also be returned when WM_QUIT is encountered.
* On Darwin this may also be returned when the native queue is
* stopped or destroyed/finished.
* @retval VINF_INTERRUPTED if the native system call was interrupted by a
* an asynchronous event delivery (signal) or just felt like returning
* out of bounds. On darwin it will also be returned if the queue is
* stopped.
*/
int EventQueue::processEventQueue(RTMSINTERVAL cMsTimeout)
{
size_t cNumEvents;
int vrc = RTCritSectEnter(&mCritSect);
if (RT_SUCCESS(vrc))
{
if (mUserCnt == 0) /* No concurrent access allowed. */
{
mUserCnt++;
cNumEvents = mEvents.size();
if (!cNumEvents)
{
int vrc2 = RTCritSectLeave(&mCritSect);
AssertRC(vrc2);
vrc = RTSemEventWaitNoResume(mSemEvent, cMsTimeout);
vrc2 = RTCritSectEnter(&mCritSect);
AssertRC(vrc2);
if (RT_SUCCESS(vrc))
{
if (mShutdown)
vrc = VERR_INTERRUPTED;
cNumEvents = mEvents.size();
}
}
if (RT_SUCCESS(vrc))
vrc = processPendingEvents(cNumEvents);
Assert(mUserCnt);
mUserCnt--;
}
else
vrc = VERR_WRONG_ORDER;
int vrc2 = RTCritSectLeave(&mCritSect);
if (RT_SUCCESS(vrc))
vrc = vrc2;
}
Assert(vrc != VERR_TIMEOUT || cMsTimeout != RT_INDEFINITE_WAIT);
return vrc;
}
/**
* Processes all pending events in the queue at the time of
* calling. Note: Does no initial locking, must be done by the
* caller!
*
* @return IPRT status code.
*/
int EventQueue::processPendingEvents(size_t cNumEvents)
{
if (!cNumEvents) /* Nothing to process? Bail out early. */
return VINF_SUCCESS;
int vrc = VINF_SUCCESS;
EventQueueListIterator it = mEvents.begin();
for (size_t i = 0;
i < cNumEvents
&& it != mEvents.end(); i++)
{
Event *pEvent = *it;
AssertPtr(pEvent);
mEvents.erase(it);
int vrc2 = RTCritSectLeave(&mCritSect);
AssertRC(vrc2);
pEvent->handler();
pEvent->Release();
vrc2 = RTCritSectEnter(&mCritSect);
AssertRC(vrc2);
it = mEvents.begin();
if (mShutdown)
{
vrc = VERR_INTERRUPTED;
break;
}
}
return vrc;
}
/**
* Interrupt thread waiting on event queue processing.
*
* Can be called on any thread.
*
* @returns VBox status code.
*/
int EventQueue::interruptEventQueueProcessing(void)
{
ASMAtomicWriteBool(&mShutdown, true);
return RTSemEventSignal(mSemEvent);
}
/**
* Posts an event to this event loop asynchronously.
*
* @param pEvent the event to post, must be allocated using |new|
* @return TRUE if successful and false otherwise
*/
BOOL EventQueue::postEvent(Event *pEvent)
{
int vrc = RTCritSectEnter(&mCritSect);
if (RT_SUCCESS(vrc))
{
try
{
if (pEvent)
{
pEvent->AddRef();
mEvents.push_back(pEvent);
}
else /* No locking, since we're already in our crit sect. */
mShutdown = true;
size_t cEvents = mEvents.size();
if (cEvents > _1K) /** @todo Make value configurable? */
{
static int s_cBitchedAboutLotEvents = 0;
if (s_cBitchedAboutLotEvents < 10)
LogRel(("Warning: Event queue received lots of events (%zu), expect delayed event handling (%d/10)\n",
cEvents, ++s_cBitchedAboutLotEvents));
}
/* Leave critical section before signalling event. */
vrc = RTCritSectLeave(&mCritSect);
if (RT_SUCCESS(vrc))
{
int vrc2 = RTSemEventSignal(mSemEvent);
AssertRC(vrc2);
}
}
catch (std::bad_alloc &ba)
{
NOREF(ba);
vrc = VERR_NO_MEMORY;
}
if (RT_FAILURE(vrc))
{
int vrc2 = RTCritSectLeave(&mCritSect);
AssertRC(vrc2);
}
}
return RT_SUCCESS(vrc) ? TRUE : FALSE;
}
}
/* namespace com */
|
