2 * poll_windows: poll compatibility wrapper for Windows
3 * Copyright © 2012-2013 RealVNC Ltd.
4 * Copyright © 2009-2010 Pete Batard <pete@akeo.ie>
5 * With contributions from Michael Plante, Orin Eman et al.
6 * Parts of poll implementation from libusb-win32, by Stephan Meyer et al.
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * poll() and pipe() Windows compatibility layer for libusb 1.0
27 * The way this layer works is by using OVERLAPPED with async I/O transfers, as
28 * OVERLAPPED have an associated event which is flagged for I/O completion.
30 * For USB pollable async I/O, you would typically:
31 * - obtain a Windows HANDLE to a file or device that has been opened in
33 * - call usbi_create_fd with this handle to obtain a custom fd.
34 * Note that if you need simultaneous R/W access, you need to call create_fd
35 * twice, once in RW_READ and once in RW_WRITE mode to obtain 2 separate
37 * - leave the core functions call the poll routine and flag POLLIN/POLLOUT
39 * The pipe pollable synchronous I/O works using the overlapped event associated
40 * with a fake pipe. The read/write functions are only meant to be used in that
49 // Uncomment to debug the polling layer
50 //#define DEBUG_POLL_WINDOWS
51 #if defined(DEBUG_POLL_WINDOWS)
52 #define poll_dbg usbi_dbg
54 // MSVC++ < 2005 cannot use a variadic argument and non MSVC
55 // compilers produce warnings if parenthesis are ommitted.
56 #if defined(_MSC_VER) && (_MSC_VER < 1400)
63 #if defined(_PREFAST_)
64 #pragma warning(disable:28719)
67 #define CHECK_INIT_POLLING do {if(!is_polling_set) init_polling();} while(0)
70 const struct winfd INVALID_WINFD = {-1, INVALID_HANDLE_VALUE, NULL, NULL, NULL, RW_NONE};
71 struct winfd poll_fd[MAX_FDS];
74 CRITICAL_SECTION mutex; // lock for fds
75 // Additional variables for XP CancelIoEx partial emulation
76 HANDLE original_handle;
81 BOOLEAN is_polling_set = FALSE;
83 static volatile LONG compat_spinlock = 0;
85 #if !defined(_WIN32_WCE)
86 // CancelIoEx, available on Vista and later only, provides the ability to cancel
87 // a single transfer (OVERLAPPED) when used. As it may not be part of any of the
88 // platform headers, we hook into the Kernel32 system DLL directly to seek it.
89 static BOOL (__stdcall *pCancelIoEx)(HANDLE, LPOVERLAPPED) = NULL;
90 #define Use_Duplicate_Handles (pCancelIoEx == NULL)
92 static inline void setup_cancel_io(void)
94 HMODULE hKernel32 = GetModuleHandleA("KERNEL32");
95 if (hKernel32 != NULL) {
96 pCancelIoEx = (BOOL (__stdcall *)(HANDLE,LPOVERLAPPED))
97 GetProcAddress(hKernel32, "CancelIoEx");
99 usbi_dbg("Will use CancelIo%s for I/O cancellation",
100 Use_Duplicate_Handles?"":"Ex");
103 static inline BOOL cancel_io(int _index)
105 if ((_index < 0) || (_index >= MAX_FDS)) {
109 if ( (poll_fd[_index].fd < 0) || (poll_fd[_index].handle == INVALID_HANDLE_VALUE)
110 || (poll_fd[_index].handle == 0) || (poll_fd[_index].overlapped == NULL) ) {
113 if (poll_fd[_index].itransfer && poll_fd[_index].cancel_fn) {
114 // Cancel outstanding transfer via the specific callback
115 (*poll_fd[_index].cancel_fn)(poll_fd[_index].itransfer);
118 if (pCancelIoEx != NULL) {
119 return (*pCancelIoEx)(poll_fd[_index].handle, poll_fd[_index].overlapped);
121 if (_poll_fd[_index].thread_id == GetCurrentThreadId()) {
122 return CancelIo(poll_fd[_index].handle);
124 usbi_warn(NULL, "Unable to cancel I/O that was started from another thread");
128 #define Use_Duplicate_Handles FALSE
130 static __inline void setup_cancel_io()
132 // No setup needed on WinCE
135 static __inline BOOL cancel_io(int _index)
137 if ((_index < 0) || (_index >= MAX_FDS)) {
140 if ( (poll_fd[_index].fd < 0) || (poll_fd[_index].handle == INVALID_HANDLE_VALUE)
141 || (poll_fd[_index].handle == 0) || (poll_fd[_index].overlapped == NULL) ) {
144 if (poll_fd[_index].itransfer && poll_fd[_index].cancel_fn) {
145 // Cancel outstanding transfer via the specific callback
146 (*poll_fd[_index].cancel_fn)(poll_fd[_index].itransfer);
153 void init_polling(void)
157 while (InterlockedExchange((LONG *)&compat_spinlock, 1) == 1) {
160 if (!is_polling_set) {
162 for (i=0; i<MAX_FDS; i++) {
163 poll_fd[i] = INVALID_WINFD;
164 _poll_fd[i].original_handle = INVALID_HANDLE_VALUE;
165 _poll_fd[i].thread_id = 0;
166 InitializeCriticalSection(&_poll_fd[i].mutex);
168 is_polling_set = TRUE;
170 InterlockedExchange((LONG *)&compat_spinlock, 0);
173 // Internal function to retrieve the table index (and lock the fd mutex)
174 static int _fd_to_index_and_lock(int fd)
181 for (i=0; i<MAX_FDS; i++) {
182 if (poll_fd[i].fd == fd) {
183 EnterCriticalSection(&_poll_fd[i].mutex);
184 // fd might have changed before we got to critical
185 if (poll_fd[i].fd != fd) {
186 LeaveCriticalSection(&_poll_fd[i].mutex);
195 static OVERLAPPED *create_overlapped(void)
197 OVERLAPPED *overlapped = (OVERLAPPED*) calloc(1, sizeof(OVERLAPPED));
198 if (overlapped == NULL) {
201 overlapped->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
202 if(overlapped->hEvent == NULL) {
209 static void free_overlapped(OVERLAPPED *overlapped)
211 if (overlapped == NULL)
214 if ( (overlapped->hEvent != 0)
215 && (overlapped->hEvent != INVALID_HANDLE_VALUE) ) {
216 CloseHandle(overlapped->hEvent);
221 void exit_polling(void)
225 while (InterlockedExchange((LONG *)&compat_spinlock, 1) == 1) {
228 if (is_polling_set) {
229 is_polling_set = FALSE;
231 for (i=0; i<MAX_FDS; i++) {
232 // Cancel any async I/O (handle can be invalid)
234 // If anything was pending on that I/O, it should be
235 // terminating, and we should be able to access the fd
236 // mutex lock before too long
237 EnterCriticalSection(&_poll_fd[i].mutex);
238 free_overlapped(poll_fd[i].overlapped);
239 if (Use_Duplicate_Handles) {
240 // Close duplicate handle
241 if (_poll_fd[i].original_handle != INVALID_HANDLE_VALUE) {
242 CloseHandle(poll_fd[i].handle);
245 poll_fd[i] = INVALID_WINFD;
246 LeaveCriticalSection(&_poll_fd[i].mutex);
247 DeleteCriticalSection(&_poll_fd[i].mutex);
250 InterlockedExchange((LONG *)&compat_spinlock, 0);
254 * Create a fake pipe.
255 * As libusb only uses pipes for signaling, all we need from a pipe is an
256 * event. To that extent, we create a single wfd and overlapped as a means
257 * to access that event.
259 int usbi_pipe(int filedes[2])
262 OVERLAPPED* overlapped;
266 overlapped = create_overlapped();
268 if (overlapped == NULL) {
271 // The overlapped must have status pending for signaling to work in poll
272 overlapped->Internal = STATUS_PENDING;
273 overlapped->InternalHigh = 0;
275 for (i=0; i<MAX_FDS; i++) {
276 if (poll_fd[i].fd < 0) {
277 EnterCriticalSection(&_poll_fd[i].mutex);
278 // fd might have been allocated before we got to critical
279 if (poll_fd[i].fd >= 0) {
280 LeaveCriticalSection(&_poll_fd[i].mutex);
284 // Use index as the unique fd number
286 // Read end of the "pipe"
287 filedes[0] = poll_fd[i].fd;
288 // We can use the same handle for both ends
289 filedes[1] = filedes[0];
291 poll_fd[i].handle = DUMMY_HANDLE;
292 poll_fd[i].overlapped = overlapped;
293 // There's no polling on the write end, so we just use READ for our needs
294 poll_fd[i].rw = RW_READ;
295 _poll_fd[i].original_handle = INVALID_HANDLE_VALUE;
296 LeaveCriticalSection(&_poll_fd[i].mutex);
300 free_overlapped(overlapped);
305 * Create both an fd and an OVERLAPPED from an open Windows handle, so that
306 * it can be used with our polling function
307 * The handle MUST support overlapped transfers (usually requires CreateFile
308 * with FILE_FLAG_OVERLAPPED)
309 * Return a pollable file descriptor struct, or INVALID_WINFD on error
311 * Note that the fd returned by this function is a per-transfer fd, rather
312 * than a per-session fd and cannot be used for anything else but our
313 * custom functions (the fd itself points to the NUL: device)
314 * if you plan to do R/W on the same handle, you MUST create 2 fds: one for
315 * read and one for write. Using a single R/W fd is unsupported and will
316 * produce unexpected results
318 struct winfd usbi_create_fd(HANDLE handle, int access_mode, struct usbi_transfer *itransfer, cancel_transfer *cancel_fn)
321 struct winfd wfd = INVALID_WINFD;
322 OVERLAPPED* overlapped = NULL;
326 if ((handle == 0) || (handle == INVALID_HANDLE_VALUE)) {
327 return INVALID_WINFD;
330 wfd.itransfer = itransfer;
331 wfd.cancel_fn = cancel_fn;
333 if ((access_mode != RW_READ) && (access_mode != RW_WRITE)) {
334 usbi_warn(NULL, "only one of RW_READ or RW_WRITE are supported.\n"
335 "If you want to poll for R/W simultaneously, create multiple fds from the same handle.");
336 return INVALID_WINFD;
338 if (access_mode == RW_READ) {
344 overlapped = create_overlapped();
345 if(overlapped == NULL) {
346 return INVALID_WINFD;
349 for (i=0; i<MAX_FDS; i++) {
350 if (poll_fd[i].fd < 0) {
351 EnterCriticalSection(&_poll_fd[i].mutex);
352 // fd might have been removed before we got to critical
353 if (poll_fd[i].fd >= 0) {
354 LeaveCriticalSection(&_poll_fd[i].mutex);
357 // Use index as the unique fd number
359 // Attempt to emulate some of the CancelIoEx behaviour on platforms
360 // that don't have it
361 if (Use_Duplicate_Handles) {
362 _poll_fd[i].thread_id = GetCurrentThreadId();
363 if (!DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(),
364 &wfd.handle, 0, TRUE, DUPLICATE_SAME_ACCESS)) {
365 usbi_dbg("could not duplicate handle for CancelIo - using original one");
367 // Make sure we won't close the original handle on fd deletion then
368 _poll_fd[i].original_handle = INVALID_HANDLE_VALUE;
370 _poll_fd[i].original_handle = handle;
375 wfd.overlapped = overlapped;
376 memcpy(&poll_fd[i], &wfd, sizeof(struct winfd));
377 LeaveCriticalSection(&_poll_fd[i].mutex);
381 free_overlapped(overlapped);
382 return INVALID_WINFD;
385 static void _free_index(int _index)
387 // Cancel any async IO (Don't care about the validity of our handles for this)
389 // close the duplicate handle (if we have an actual duplicate)
390 if (Use_Duplicate_Handles) {
391 if (_poll_fd[_index].original_handle != INVALID_HANDLE_VALUE) {
392 CloseHandle(poll_fd[_index].handle);
394 _poll_fd[_index].original_handle = INVALID_HANDLE_VALUE;
395 _poll_fd[_index].thread_id = 0;
397 free_overlapped(poll_fd[_index].overlapped);
398 poll_fd[_index] = INVALID_WINFD;
402 * Release a pollable file descriptor.
404 * Note that the associated Windows handle is not closed by this call
406 void usbi_free_fd(struct winfd *wfd)
412 _index = _fd_to_index_and_lock(wfd->fd);
417 *wfd = INVALID_WINFD;
418 LeaveCriticalSection(&_poll_fd[_index].mutex);
422 * The functions below perform various conversions between fd, handle and OVERLAPPED
424 struct winfd fd_to_winfd(int fd)
432 return INVALID_WINFD;
434 for (i=0; i<MAX_FDS; i++) {
435 if (poll_fd[i].fd == fd) {
436 EnterCriticalSection(&_poll_fd[i].mutex);
437 // fd might have been deleted before we got to critical
438 if (poll_fd[i].fd != fd) {
439 LeaveCriticalSection(&_poll_fd[i].mutex);
442 memcpy(&wfd, &poll_fd[i], sizeof(struct winfd));
443 LeaveCriticalSection(&_poll_fd[i].mutex);
447 return INVALID_WINFD;
450 struct winfd handle_to_winfd(HANDLE handle)
457 if ((handle == 0) || (handle == INVALID_HANDLE_VALUE))
458 return INVALID_WINFD;
460 for (i=0; i<MAX_FDS; i++) {
461 if (poll_fd[i].handle == handle) {
462 EnterCriticalSection(&_poll_fd[i].mutex);
463 // fd might have been deleted before we got to critical
464 if (poll_fd[i].handle != handle) {
465 LeaveCriticalSection(&_poll_fd[i].mutex);
468 memcpy(&wfd, &poll_fd[i], sizeof(struct winfd));
469 LeaveCriticalSection(&_poll_fd[i].mutex);
473 return INVALID_WINFD;
476 struct winfd overlapped_to_winfd(OVERLAPPED* overlapped)
483 if (overlapped == NULL)
484 return INVALID_WINFD;
486 for (i=0; i<MAX_FDS; i++) {
487 if (poll_fd[i].overlapped == overlapped) {
488 EnterCriticalSection(&_poll_fd[i].mutex);
489 // fd might have been deleted before we got to critical
490 if (poll_fd[i].overlapped != overlapped) {
491 LeaveCriticalSection(&_poll_fd[i].mutex);
494 memcpy(&wfd, &poll_fd[i], sizeof(struct winfd));
495 LeaveCriticalSection(&_poll_fd[i].mutex);
499 return INVALID_WINFD;
503 * POSIX poll equivalent, using Windows OVERLAPPED
504 * Currently, this function only accepts one of POLLIN or POLLOUT per fd
505 * (but you can create multiple fds from the same handle for read and write)
507 int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout)
510 int _index, object_index, triggered;
511 HANDLE *handles_to_wait_on;
512 int *handle_to_index;
513 DWORD nb_handles_to_wait_on = 0;
519 handles_to_wait_on = (HANDLE*) calloc(nfds+1, sizeof(HANDLE)); // +1 for fd_update
520 handle_to_index = (int*) calloc(nfds, sizeof(int));
521 if ((handles_to_wait_on == NULL) || (handle_to_index == NULL)) {
527 for (i = 0; i < nfds; ++i) {
530 // Only one of POLLIN or POLLOUT can be selected with this version of poll (not both)
531 if ((fds[i].events & ~POLLIN) && (!(fds[i].events & POLLOUT))) {
532 fds[i].revents |= POLLERR;
534 usbi_warn(NULL, "unsupported set of events");
539 _index = _fd_to_index_and_lock(fds[i].fd);
540 poll_dbg("fd[%d]=%d: (overlapped=%p) got events %04X", i, poll_fd[_index].fd, poll_fd[_index].overlapped, fds[i].events);
542 if ( (_index < 0) || (poll_fd[_index].handle == INVALID_HANDLE_VALUE)
543 || (poll_fd[_index].handle == 0) || (poll_fd[_index].overlapped == NULL)) {
544 fds[i].revents |= POLLNVAL | POLLERR;
547 LeaveCriticalSection(&_poll_fd[_index].mutex);
549 usbi_warn(NULL, "invalid fd");
554 // IN or OUT must match our fd direction
555 if ((fds[i].events & POLLIN) && (poll_fd[_index].rw != RW_READ)) {
556 fds[i].revents |= POLLNVAL | POLLERR;
558 usbi_warn(NULL, "attempted POLLIN on fd without READ access");
559 LeaveCriticalSection(&_poll_fd[_index].mutex);
564 if ((fds[i].events & POLLOUT) && (poll_fd[_index].rw != RW_WRITE)) {
565 fds[i].revents |= POLLNVAL | POLLERR;
567 usbi_warn(NULL, "attempted POLLOUT on fd without WRITE access");
568 LeaveCriticalSection(&_poll_fd[_index].mutex);
573 // The following macro only works if overlapped I/O was reported pending
574 if ( (HasOverlappedIoCompleted(poll_fd[_index].overlapped))
575 || (HasOverlappedIoCompletedSync(poll_fd[_index].overlapped)) ) {
576 poll_dbg(" completed");
577 // checks above should ensure this works:
578 fds[i].revents = fds[i].events;
581 handles_to_wait_on[nb_handles_to_wait_on] = poll_fd[_index].overlapped->hEvent;
582 handle_to_index[nb_handles_to_wait_on] = i;
583 nb_handles_to_wait_on++;
585 LeaveCriticalSection(&_poll_fd[_index].mutex);
588 // If nothing was triggered, wait on all fds that require it
589 if ((timeout != 0) && (triggered == 0) && (nb_handles_to_wait_on != 0)) {
591 poll_dbg("starting infinite wait for %d handles...", (int)nb_handles_to_wait_on);
593 poll_dbg("starting %d ms wait for %d handles...", timeout, (int)nb_handles_to_wait_on);
595 ret = WaitForMultipleObjects(nb_handles_to_wait_on, handles_to_wait_on,
596 FALSE, (timeout<0)?INFINITE:(DWORD)timeout);
597 object_index = ret-WAIT_OBJECT_0;
598 if ((object_index >= 0) && ((DWORD)object_index < nb_handles_to_wait_on)) {
599 poll_dbg(" completed after wait");
600 i = handle_to_index[object_index];
601 _index = _fd_to_index_and_lock(fds[i].fd);
602 fds[i].revents = fds[i].events;
605 LeaveCriticalSection(&_poll_fd[_index].mutex);
607 } else if (ret == WAIT_TIMEOUT) {
608 poll_dbg(" timed out");
609 triggered = 0; // 0 = timeout
612 triggered = -1; // error
617 if (handles_to_wait_on != NULL) {
618 free(handles_to_wait_on);
620 if (handle_to_index != NULL) {
621 free(handle_to_index);
627 * close a fake pipe fd
629 int usbi_close(int fd)
636 _index = _fd_to_index_and_lock(fd);
641 free_overlapped(poll_fd[_index].overlapped);
642 poll_fd[_index] = INVALID_WINFD;
643 LeaveCriticalSection(&_poll_fd[_index].mutex);
649 * synchronous write for fake "pipe" signaling
651 ssize_t usbi_write(int fd, const void *buf, size_t count)
658 if (count != sizeof(unsigned char)) {
659 usbi_err(NULL, "this function should only used for signaling");
663 _index = _fd_to_index_and_lock(fd);
665 if ( (_index < 0) || (poll_fd[_index].overlapped == NULL) ) {
668 LeaveCriticalSection(&_poll_fd[_index].mutex);
673 poll_dbg("set pipe event (fd = %d, thread = %08X)", _index, GetCurrentThreadId());
674 SetEvent(poll_fd[_index].overlapped->hEvent);
675 poll_fd[_index].overlapped->Internal = STATUS_WAIT_0;
676 // If two threads write on the pipe at the same time, we need to
677 // process two separate reads => use the overlapped as a counter
678 poll_fd[_index].overlapped->InternalHigh++;
680 LeaveCriticalSection(&_poll_fd[_index].mutex);
681 return sizeof(unsigned char);
685 * synchronous read for fake "pipe" signaling
687 ssize_t usbi_read(int fd, void *buf, size_t count)
695 if (count != sizeof(unsigned char)) {
696 usbi_err(NULL, "this function should only used for signaling");
700 _index = _fd_to_index_and_lock(fd);
707 if (WaitForSingleObject(poll_fd[_index].overlapped->hEvent, INFINITE) != WAIT_OBJECT_0) {
708 usbi_warn(NULL, "waiting for event failed: %d", (int)GetLastError());
713 poll_dbg("clr pipe event (fd = %d, thread = %08X)", _index, GetCurrentThreadId());
714 poll_fd[_index].overlapped->InternalHigh--;
715 // Don't reset unless we don't have any more events to process
716 if (poll_fd[_index].overlapped->InternalHigh <= 0) {
717 ResetEvent(poll_fd[_index].overlapped->hEvent);
718 poll_fd[_index].overlapped->Internal = STATUS_PENDING;
721 r = sizeof(unsigned char);
724 LeaveCriticalSection(&_poll_fd[_index].mutex);