poll-win.cpp@ 28863

Last change on this file since 28863 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 16.8 KB

Line
1	/* $Id: poll-win.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2	/** @file
3	* IPRT - Polling I/O Handles, Windows Implementation.
4	*
5	* @todo merge poll-win.cpp and poll-posix.cpp, there is lots of common code.
6	*/
7
8	/*
9	* Copyright (C) 2010 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* The contents of this file may alternatively be used under the terms
20	* of the Common Development and Distribution License Version 1.0
21	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
22	* VirtualBox OSE distribution, in which case the provisions of the
23	* CDDL are applicable instead of those of the GPL.
24	*
25	* You may elect to license modified versions of this file under the
26	* terms and conditions of either the GPL or the CDDL or both.
27	*/
28
29
30	/*******************************************************************************
31	* Header Files *
32	*******************************************************************************/
33	#include <Windows.h>
34
35	#include <iprt/poll.h>
36	#include "internal/iprt.h"
37
38	#include <iprt/asm.h>
39	#include <iprt/assert.h>
40	#include <iprt/err.h>
41	#include <iprt/mem.h>
42	#include <iprt/pipe.h>
43	#include <iprt/string.h>
44	#include <iprt/thread.h>
45	#include <iprt/time.h>
46
47	#include "internal/pipe.h"
48	#define IPRT_INTERNAL_SOCKET_POLLING_ONLY
49	#include "internal/socket.h"
50	#include "internal/magics.h"
51
52
53	/*******************************************************************************
54	* Structures and Typedefs *
55	*******************************************************************************/
56	/**
57	* Handle entry in a poll set.
58	*/
59	typedef struct RTPOLLSETHNDENT
60	{
61	/** The handle type. */
62	RTHANDLETYPE enmType;
63	/** The handle ID. */
64	uint32_t id;
65	/** The events we're waiting for here. */
66	uint32_t fEvents;
67	/** Set if this is the final entry for this handle.
68	* If the handle is entered more than once, this will be clear for all but
69	* the last entry. */
70	bool fFinalEntry;
71	/** The handle union. */
72	RTHANDLEUNION u;
73	} RTPOLLSETHNDENT;
74	/** Pointer to a handle entry. */
75	typedef RTPOLLSETHNDENT *PRTPOLLSETHNDENT;
76
77
78	/**
79	* Poll set data, Windows.
80	*/
81	typedef struct RTPOLLSETINTERNAL
82	{
83	/** The magic value (RTPOLLSET_MAGIC). */
84	uint32_t u32Magic;
85	/** Set when someone is polling or making changes. */
86	bool volatile fBusy;
87
88	/** The number of valid handles in the set. */
89	uint32_t cHandles;
90	/** The native handles. */
91	HANDLE ahNative[MAXIMUM_WAIT_OBJECTS];
92	/** Array of handles and IDs. */
93	RTPOLLSETHNDENT aHandles[MAXIMUM_WAIT_OBJECTS];
94	} RTPOLLSETINTERNAL;
95
96
97	/**
98	* Common worker for RTPoll and RTPollNoResume
99	*/
100	static int rtPollNoResumeWorker(RTPOLLSETINTERNAL pThis, RTMSINTERVAL cMillies, uint32_t pfEvents, uint32_t *pid)
101	{
102	int rc;
103
104	if (RT_UNLIKELY(pThis->cHandles == 0 && cMillies == RT_INDEFINITE_WAIT))
105	return VERR_DEADLOCK;
106
107	/*
108	* Check for special case, RTThreadSleep...
109	*/
110	uint32_t const cHandles = pThis->cHandles;
111	if (cHandles == 0)
112	{
113	rc = RTThreadSleep(cMillies);
114	if (RT_SUCCESS(rc))
115	rc = VERR_TIMEOUT;
116	return rc;
117	}
118
119	/*
120	* Check + prepare the handles before waiting.
121	*/
122	uint32_t fEvents = 0;
123	bool const fNoWait = cMillies == 0;
124	uint32_t i;
125	for (i = 0; i < cHandles; i++)
126	{
127	switch (pThis->aHandles[i].enmType)
128	{
129	case RTHANDLETYPE_PIPE:
130	fEvents = rtPipePollStart(pThis->aHandles[i].u.hPipe, pThis, pThis->aHandles[i].fEvents,
131	pThis->aHandles[i].fFinalEntry, fNoWait);
132	break;
133
134	case RTHANDLETYPE_SOCKET:
135	fEvents = rtSocketPollStart(pThis->aHandles[i].u.hSocket, pThis, pThis->aHandles[i].fEvents,
136	pThis->aHandles[i].fFinalEntry, fNoWait);
137	break;
138
139	default:
140	AssertFailed();
141	fEvents = UINT32_MAX;
142	break;
143	}
144	if (fEvents)
145	break;
146	}
147	if ( fEvents
148	\|\| fNoWait)
149	{
150
151	if (pid)
152	*pid = pThis->aHandles[i].id;
153	if (pfEvents)
154	*pfEvents = fEvents;
155	rc = !fEvents
156	? VERR_TIMEOUT
157	: fEvents != UINT32_MAX
158	? VINF_SUCCESS
159	: VERR_INTERNAL_ERROR_4;
160
161	/* clean up */
162	if (!fNoWait)
163	while (i-- > 0)
164	{
165	switch (pThis->aHandles[i].enmType)
166	{
167	case RTHANDLETYPE_PIPE:
168	rtPipePollDone(pThis->aHandles[i].u.hPipe, pThis->aHandles[i].fEvents,
169	pThis->aHandles[i].fFinalEntry);
170	break;
171
172	case RTHANDLETYPE_SOCKET:
173	rtSocketPollDone(pThis->aHandles[i].u.hSocket, pThis->aHandles[i].fEvents,
174	pThis->aHandles[i].fFinalEntry);
175	break;
176
177	default:
178	AssertFailed();
179	break;
180	}
181	}
182
183	return rc;
184	}
185
186	/*
187	* Wait.
188	*/
189	DWORD dwRc = WaitForMultipleObjectsEx(cHandles, &pThis->ahNative[0],
190	FALSE /fWaitAll /,
191	cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies,
192	TRUE /fAlertable/);
193	if ( dwRc >= WAIT_OBJECT_0
194	&& dwRc < WAIT_OBJECT_0 + cHandles)
195	rc = VERR_INTERRUPTED;
196	else if (dwRc == WAIT_TIMEOUT)
197	rc = VERR_TIMEOUT;
198	else if (dwRc == WAIT_IO_COMPLETION)
199	rc = VERR_INTERRUPTED;
200	else if (dwRc == WAIT_FAILED)
201	rc = RTErrConvertFromWin32(GetLastError());
202	else
203	{
204	AssertMsgFailed(("%u (%#x)\n", dwRc, dwRc));
205	rc = VERR_INTERNAL_ERROR_5;
206	}
207
208	/*
209	* Get event (if pending) and do wait cleanup.
210	*/
211	i = cHandles;
212	while (i-- > 0)
213	{
214	fEvents = 0;
215	switch (pThis->aHandles[i].enmType)
216	{
217	case RTHANDLETYPE_PIPE:
218	rtPipePollDone(pThis->aHandles[i].u.hPipe, pThis->aHandles[i].fEvents,
219	pThis->aHandles[i].fFinalEntry);
220	break;
221
222	case RTHANDLETYPE_SOCKET:
223	rtSocketPollDone(pThis->aHandles[i].u.hSocket, pThis->aHandles[i].fEvents,
224	pThis->aHandles[i].fFinalEntry);
225	break;
226
227	default:
228	AssertFailed();
229	break;
230	}
231	if (fEvents)
232	{
233	Assert(fEvents != UINT32_MAX);
234	if (pfEvents)
235	*pfEvents = fEvents;
236	if (pid)
237	*pid = pThis->aHandles[i].id;
238	rc = VINF_SUCCESS;
239	}
240	}
241
242	return rc;
243	}
244
245
246	RTDECL(int) RTPoll(RTPOLLSET hPollSet, RTMSINTERVAL cMillies, uint32_t pfEvents, uint32_t pid)
247	{
248	RTPOLLSETINTERNAL *pThis = hPollSet;
249	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
250	AssertReturn(pThis->u32Magic == RTPOLLSET_MAGIC, VERR_INVALID_HANDLE);
251	AssertPtrNull(pfEvents);
252	AssertPtrNull(pid);
253
254	/*
255	* Set the busy flag and do the job.
256	*/
257	AssertReturn(ASMAtomicCmpXchgBool(&pThis->fBusy, true, false), VERR_CONCURRENT_ACCESS);
258
259	int rc;
260	if (cMillies == RT_INDEFINITE_WAIT \|\| cMillies == 0)
261	{
262	do rc = rtPollNoResumeWorker(pThis, cMillies, pfEvents, pid);
263	while (rc == VERR_INTERRUPTED);
264	}
265	else
266	{
267	uint64_t MsStart = RTTimeMilliTS();
268	rc = rtPollNoResumeWorker(pThis, cMillies, pfEvents, pid);
269	while (RT_UNLIKELY(rc == VERR_INTERRUPTED))
270	{
271	if (RTTimeMilliTS() - MsStart >= cMillies)
272	{
273	rc = VERR_TIMEOUT;
274	break;
275	}
276	rc = rtPollNoResumeWorker(pThis, cMillies, pfEvents, pid);
277	}
278	}
279
280	ASMAtomicWriteBool(&pThis->fBusy, false);
281
282	return rc;
283	}
284
285
286	RTDECL(int) RTPollNoResume(RTPOLLSET hPollSet, RTMSINTERVAL cMillies, uint32_t pfEvents, uint32_t pid)
287	{
288	RTPOLLSETINTERNAL *pThis = hPollSet;
289	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
290	AssertReturn(pThis->u32Magic == RTPOLLSET_MAGIC, VERR_INVALID_HANDLE);
291	AssertPtrNull(pfEvents);
292	AssertPtrNull(pid);
293
294	/*
295	* Set the busy flag and do the job.
296	*/
297	AssertReturn(ASMAtomicCmpXchgBool(&pThis->fBusy, true, false), VERR_CONCURRENT_ACCESS);
298
299	int rc = rtPollNoResumeWorker(pThis, cMillies, pfEvents, pid);
300
301	ASMAtomicWriteBool(&pThis->fBusy, false);
302
303	return rc;
304	}
305
306
307	RTDECL(int) RTPollSetCreate(PRTPOLLSET phPollSet)
308	{
309	AssertPtrReturn(phPollSet, VERR_INVALID_POINTER);
310	RTPOLLSETINTERNAL pThis = (RTPOLLSETINTERNAL )RTMemAllocZ(sizeof(RTPOLLSETINTERNAL));
311	if (!pThis)
312	return VERR_NO_MEMORY;
313
314	pThis->u32Magic = RTPOLLSET_MAGIC;
315	pThis->fBusy = false;
316	pThis->cHandles = 0;
317	for (size_t i = 0; i < RT_ELEMENTS(pThis->ahNative); i++)
318	pThis->ahNative[i] = INVALID_HANDLE_VALUE;
319
320	*phPollSet = pThis;
321	return VINF_SUCCESS;
322	}
323
324
325	RTDECL(int) RTPollSetDestroy(RTPOLLSET hPollSet)
326	{
327	RTPOLLSETINTERNAL *pThis = hPollSet;
328	if (pThis == NIL_RTPOLLSET)
329	return VINF_SUCCESS;
330	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
331	AssertReturn(pThis->u32Magic == RTPOLLSET_MAGIC, VERR_INVALID_HANDLE);
332	AssertReturn(ASMAtomicCmpXchgBool(&pThis->fBusy, true, false), VERR_CONCURRENT_ACCESS);
333
334	ASMAtomicWriteU32(&pThis->u32Magic, ~RTPOLLSET_MAGIC);
335	RTMemFree(pThis);
336
337	return VINF_SUCCESS;
338	}
339
340
341	RTDECL(int) RTPollSetAdd(RTPOLLSET hPollSet, PCRTHANDLE pHandle, uint32_t fEvents, uint32_t id)
342	{
343	/*
344	* Validate the input (tedious).
345	*/
346	RTPOLLSETINTERNAL *pThis = hPollSet;
347	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
348	AssertReturn(pThis->u32Magic == RTPOLLSET_MAGIC, VERR_INVALID_HANDLE);
349	AssertReturn(!(fEvents & ~RTPOLL_EVT_VALID_MASK), VERR_INVALID_PARAMETER);
350	AssertReturn(fEvents, VERR_INVALID_PARAMETER);
351	AssertReturn(id != UINT32_MAX, VERR_INVALID_PARAMETER);
352
353	if (!pHandle)
354	return VINF_SUCCESS;
355	AssertPtrReturn(pHandle, VERR_INVALID_POINTER);
356	AssertReturn(pHandle->enmType > RTHANDLETYPE_INVALID && pHandle->enmType < RTHANDLETYPE_END, VERR_INVALID_PARAMETER);
357
358	/*
359	* Set the busy flag and do the job.
360	*/
361	AssertReturn(ASMAtomicCmpXchgBool(&pThis->fBusy, true, false), VERR_CONCURRENT_ACCESS);
362
363	int rc = VINF_SUCCESS;
364	HANDLE hNative = INVALID_HANDLE_VALUE;
365	RTHANDLEUNION uh;
366	uh.uInt = 0;
367	switch (pHandle->enmType)
368	{
369	case RTHANDLETYPE_PIPE:
370	uh.hPipe = pHandle->u.hPipe;
371	if (uh.hPipe != NIL_RTPIPE)
372	rc = rtPipePollGetHandle(uh.hPipe, fEvents, &hNative);
373	break;
374
375	case RTHANDLETYPE_SOCKET:
376	uh.hSocket = pHandle->u.hSocket;
377	if (uh.hSocket != NIL_RTSOCKET)
378	rc = rtSocketPollGetHandle(uh.hSocket, fEvents, &hNative);
379	break;
380
381	case RTHANDLETYPE_FILE:
382	AssertMsgFailed(("Files are always ready for reading/writing and thus not pollable. Use native APIs for special devices.\n"));
383	rc = VERR_POLL_HANDLE_NOT_POLLABLE;
384	break;
385
386	case RTHANDLETYPE_THREAD:
387	AssertMsgFailed(("Thread handles are currently not pollable\n"));
388	rc = VERR_POLL_HANDLE_NOT_POLLABLE;
389	break;
390
391	default:
392	AssertMsgFailed(("\n"));
393	rc = VERR_POLL_HANDLE_NOT_POLLABLE;
394	break;
395	}
396	if ( RT_SUCCESS(rc)
397	&& hNative != INVALID_HANDLE_VALUE)
398	{
399	uint32_t const i = pThis->cHandles;
400
401	/* Check that the handle ID doesn't exist already. */
402	uint32_t iPrev = UINT32_MAX;
403	uint32_t j = i;
404	while (j-- > 0)
405	{
406	if (pThis->aHandles[j].id == id)
407	{
408	rc = VERR_POLL_HANDLE_ID_EXISTS;
409	break;
410	}
411	if ( pThis->aHandles[j].enmType == pHandle->enmType
412	&& pThis->aHandles[j].u.uInt == uh.uInt)
413	iPrev = j;
414	}
415
416	/* Check that we won't overflow the poll set now. */
417	if ( RT_SUCCESS(rc)
418	&& i + 1 > RT_ELEMENTS(pThis->ahNative))
419	rc = VERR_POLL_SET_IS_FULL;
420	if (RT_SUCCESS(rc))
421	{
422	/* Add the handles to the two parallel arrays. */
423	pThis->ahNative[i] = hNative;
424	pThis->aHandles[i].enmType = pHandle->enmType;
425	pThis->aHandles[i].u = uh;
426	pThis->aHandles[i].id = id;
427	pThis->aHandles[i].fEvents = fEvents;
428	pThis->aHandles[i].fFinalEntry = true;
429	pThis->cHandles = i + 1;
430
431	if (iPrev != UINT32_MAX)
432	{
433	Assert(pThis->aHandles[i].fFinalEntry);
434	pThis->aHandles[i].fFinalEntry = false;
435	}
436
437	rc = VINF_SUCCESS;
438	}
439	}
440
441	ASMAtomicWriteBool(&pThis->fBusy, false);
442	return rc;
443	}
444
445
446	RTDECL(int) RTPollSetRemove(RTPOLLSET hPollSet, uint32_t id)
447	{
448	/*
449	* Validate the input.
450	*/
451	RTPOLLSETINTERNAL *pThis = hPollSet;
452	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
453	AssertReturn(pThis->u32Magic == RTPOLLSET_MAGIC, VERR_INVALID_HANDLE);
454	AssertReturn(id != UINT32_MAX, VERR_INVALID_PARAMETER);
455
456	/*
457	* Set the busy flag and do the job.
458	*/
459	AssertReturn(ASMAtomicCmpXchgBool(&pThis->fBusy, true, false), VERR_CONCURRENT_ACCESS);
460
461	int rc = VERR_POLL_HANDLE_ID_NOT_FOUND;
462	uint32_t i = pThis->cHandles;
463	while (i-- > 0)
464	if (pThis->aHandles[i].id == id)
465	{
466	/* Save some details for the duplicate searching. */
467	bool fFinalEntry = pThis->aHandles[i].fFinalEntry;
468	RTHANDLETYPE enmType = pThis->aHandles[i].enmType;
469	RTHANDLEUNION uh = pThis->aHandles[i].u;
470
471	/* Remove the entry. */
472	pThis->cHandles--;
473	size_t const cToMove = pThis->cHandles - i;
474	if (cToMove)
475	{
476	memmove(&pThis->aHandles[i], &pThis->aHandles[i + 1], cToMove * sizeof(pThis->aHandles[i]));
477	memmove(&pThis->ahNative[i], &pThis->ahNative[i + 1], cToMove * sizeof(pThis->ahNative[i]));
478	}
479
480	/* Check for duplicate and set the fFinalEntry flag. */
481	if (fFinalEntry)
482	while (i-- > 0)
483	if ( pThis->aHandles[i].u.uInt == uh.uInt
484	&& pThis->aHandles[i].enmType == enmType)
485	{
486	Assert(!pThis->aHandles[i].fFinalEntry);
487	pThis->aHandles[i].fFinalEntry = true;
488	break;
489	}
490
491	rc = VINF_SUCCESS;
492	break;
493	}
494
495	ASMAtomicWriteBool(&pThis->fBusy, false);
496	return rc;
497	}
498
499
500	RTDECL(int) RTPollSetQueryHandle(RTPOLLSET hPollSet, uint32_t id, PRTHANDLE pHandle)
501	{
502	/*
503	* Validate the input.
504	*/
505	RTPOLLSETINTERNAL *pThis = hPollSet;
506	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
507	AssertReturn(pThis->u32Magic == RTPOLLSET_MAGIC, VERR_INVALID_HANDLE);
508	AssertReturn(id != UINT32_MAX, VERR_INVALID_PARAMETER);
509	AssertPtrNullReturn(pHandle, VERR_INVALID_POINTER);
510
511	/*
512	* Set the busy flag and do the job.
513	*/
514	AssertReturn(ASMAtomicCmpXchgBool(&pThis->fBusy, true, false), VERR_CONCURRENT_ACCESS);
515
516	int rc = VERR_POLL_HANDLE_ID_NOT_FOUND;
517	uint32_t i = pThis->cHandles;
518	while (i-- > 0)
519	if (pThis->aHandles[i].id == id)
520	{
521	if (pHandle)
522	{
523	pHandle->enmType = pThis->aHandles[i].enmType;
524	pHandle->u = pThis->aHandles[i].u;
525	}
526	rc = VINF_SUCCESS;
527	break;
528	}
529
530	ASMAtomicWriteBool(&pThis->fBusy, false);
531	return rc;
532	}
533
534
535	RTDECL(uint32_t) RTPollSetGetCount(RTPOLLSET hPollSet)
536	{
537	/*
538	* Validate the input.
539	*/
540	RTPOLLSETINTERNAL *pThis = hPollSet;
541	AssertPtrReturn(pThis, UINT32_MAX);
542	AssertReturn(pThis->u32Magic == RTPOLLSET_MAGIC, UINT32_MAX);
543
544	/*
545	* Set the busy flag and do the job.
546	*/
547	AssertReturn(ASMAtomicCmpXchgBool(&pThis->fBusy, true, false), UINT32_MAX);
548	uint32_t cHandles = pThis->cHandles;
549	ASMAtomicWriteBool(&pThis->fBusy, false);
550
551	return cHandles;
552	}
553

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r3/win/poll-win.cpp@ 28863

Download in other formats: