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
|
/* $Id: EventQueue.cpp $ */
/** @file
* Event queue class declaration.
*/
/*
* Copyright (C) 2013-2020 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
/** @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 rc = RTCritSectInit(&mCritSect);
AssertRC(rc);
rc = RTSemEventCreate(&mSemEvent);
AssertRC(rc);
}
EventQueue::~EventQueue(void)
{
int rc = RTCritSectDelete(&mCritSect);
AssertRC(rc);
rc = RTSemEventDestroy(mSemEvent);
AssertRC(rc);
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 rc = RTCritSectEnter(&mCritSect);
if (RT_SUCCESS(rc))
{
if (mUserCnt == 0) /* No concurrent access allowed. */
{
mUserCnt++;
cNumEvents = mEvents.size();
if (!cNumEvents)
{
int rc2 = RTCritSectLeave(&mCritSect);
AssertRC(rc2);
rc = RTSemEventWaitNoResume(mSemEvent, cMsTimeout);
rc2 = RTCritSectEnter(&mCritSect);
AssertRC(rc2);
if (RT_SUCCESS(rc))
{
if (mShutdown)
rc = VERR_INTERRUPTED;
cNumEvents = mEvents.size();
}
}
if (RT_SUCCESS(rc))
rc = processPendingEvents(cNumEvents);
Assert(mUserCnt);
mUserCnt--;
}
else
rc = VERR_WRONG_ORDER;
int rc2 = RTCritSectLeave(&mCritSect);
if (RT_SUCCESS(rc))
rc = rc2;
}
Assert(rc != VERR_TIMEOUT || cMsTimeout != RT_INDEFINITE_WAIT);
return rc;
}
/**
* 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 rc = 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 rc2 = RTCritSectLeave(&mCritSect);
AssertRC(rc2);
pEvent->handler();
pEvent->Release();
rc2 = RTCritSectEnter(&mCritSect);
AssertRC(rc2);
it = mEvents.begin();
if (mShutdown)
{
rc = VERR_INTERRUPTED;
break;
}
}
return rc;
}
/**
* 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 rc = RTCritSectEnter(&mCritSect);
if (RT_SUCCESS(rc))
{
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. */
rc = RTCritSectLeave(&mCritSect);
if (RT_SUCCESS(rc))
{
int rc2 = RTSemEventSignal(mSemEvent);
AssertRC(rc2);
}
}
catch (std::bad_alloc &ba)
{
NOREF(ba);
rc = VERR_NO_MEMORY;
}
if (RT_FAILURE(rc))
{
int rc2 = RTCritSectLeave(&mCritSect);
AssertRC(rc2);
}
}
return RT_SUCCESS(rc) ? TRUE : FALSE;
}
}
/* namespace com */
|
