/* * libusb synchronization on Microsoft Windows * * Copyright © 2010 Michael Plante * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include #include "libusbi.h" struct usbi_cond_perthread { struct list_head list; DWORD tid; HANDLE event; }; int usbi_mutex_static_lock(usbi_mutex_static_t *mutex) { if (!mutex) return EINVAL; while (InterlockedExchange(mutex, 1) == 1) SleepEx(0, TRUE); return 0; } int usbi_mutex_static_unlock(usbi_mutex_static_t *mutex) { if (!mutex) return EINVAL; InterlockedExchange(mutex, 0); return 0; } int usbi_mutex_init(usbi_mutex_t *mutex) { if (!mutex) return EINVAL; *mutex = CreateMutex(NULL, FALSE, NULL); if (!*mutex) return ENOMEM; return 0; } int usbi_mutex_lock(usbi_mutex_t *mutex) { DWORD result; if (!mutex) return EINVAL; result = WaitForSingleObject(*mutex, INFINITE); if (result == WAIT_OBJECT_0 || result == WAIT_ABANDONED) return 0; // acquired (ToDo: check that abandoned is ok) else return EINVAL; // don't know how this would happen // so don't know proper errno } int usbi_mutex_unlock(usbi_mutex_t *mutex) { if (!mutex) return EINVAL; if (ReleaseMutex(*mutex)) return 0; else return EPERM; } int usbi_mutex_trylock(usbi_mutex_t *mutex) { DWORD result; if (!mutex) return EINVAL; result = WaitForSingleObject(*mutex, 0); if (result == WAIT_OBJECT_0 || result == WAIT_ABANDONED) return 0; // acquired (ToDo: check that abandoned is ok) else if (result == WAIT_TIMEOUT) return EBUSY; else return EINVAL; // don't know how this would happen // so don't know proper error } int usbi_mutex_destroy(usbi_mutex_t *mutex) { // It is not clear if CloseHandle failure is due to failure to unlock. // If so, this should be errno=EBUSY. if (!mutex || !CloseHandle(*mutex)) return EINVAL; *mutex = NULL; return 0; } int usbi_cond_init(usbi_cond_t *cond) { if (!cond) return EINVAL; list_init(&cond->waiters); list_init(&cond->not_waiting); return 0; } int usbi_cond_destroy(usbi_cond_t *cond) { // This assumes no one is using this anymore. The check MAY NOT BE safe. struct usbi_cond_perthread *pos, *next_pos; if(!cond) return EINVAL; if (!list_empty(&cond->waiters)) return EBUSY; // (!see above!) list_for_each_entry_safe(pos, next_pos, &cond->not_waiting, list, struct usbi_cond_perthread) { CloseHandle(pos->event); list_del(&pos->list); free(pos); } return 0; } int usbi_cond_broadcast(usbi_cond_t *cond) { // Assumes mutex is locked; this is not in keeping with POSIX spec, but // libusb does this anyway, so we simplify by not adding more sync // primitives to the CV definition! int fail = 0; struct usbi_cond_perthread *pos; if (!cond) return EINVAL; list_for_each_entry(pos, &cond->waiters, list, struct usbi_cond_perthread) { if (!SetEvent(pos->event)) fail = 1; } // The wait function will remove its respective item from the list. return fail ? EINVAL : 0; } __inline static int usbi_cond_intwait(usbi_cond_t *cond, usbi_mutex_t *mutex, DWORD timeout_ms) { struct usbi_cond_perthread *pos; int r, found = 0; DWORD r2, tid = GetCurrentThreadId(); if (!cond || !mutex) return EINVAL; list_for_each_entry(pos, &cond->not_waiting, list, struct usbi_cond_perthread) { if(tid == pos->tid) { found = 1; break; } } if (!found) { pos = calloc(1, sizeof(struct usbi_cond_perthread)); if (!pos) return ENOMEM; // This errno is not POSIX-allowed. pos->tid = tid; pos->event = CreateEvent(NULL, FALSE, FALSE, NULL); // auto-reset. if (!pos->event) { free(pos); return ENOMEM; } list_add(&pos->list, &cond->not_waiting); } list_del(&pos->list); // remove from not_waiting list. list_add(&pos->list, &cond->waiters); r = usbi_mutex_unlock(mutex); if (r) return r; r2 = WaitForSingleObject(pos->event, timeout_ms); r = usbi_mutex_lock(mutex); if (r) return r; list_del(&pos->list); list_add(&pos->list, &cond->not_waiting); if (r2 == WAIT_OBJECT_0) return 0; else if (r2 == WAIT_TIMEOUT) return ETIMEDOUT; else return EINVAL; } // N.B.: usbi_cond_*wait() can also return ENOMEM, even though pthread_cond_*wait cannot! int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex) { return usbi_cond_intwait(cond, mutex, INFINITE); } int usbi_cond_timedwait(usbi_cond_t *cond, usbi_mutex_t *mutex, const struct timeval *tv) { DWORD millis; millis = (DWORD)(tv->tv_sec * 1000) + (tv->tv_usec / 1000); /* round up to next millisecond */ if (tv->tv_usec % 1000) millis++; return usbi_cond_intwait(cond, mutex, millis); } int usbi_tls_key_create(usbi_tls_key_t *key) { if (!key) return EINVAL; *key = TlsAlloc(); if (*key == TLS_OUT_OF_INDEXES) return ENOMEM; else return 0; } void *usbi_tls_key_get(usbi_tls_key_t key) { return TlsGetValue(key); } int usbi_tls_key_set(usbi_tls_key_t key, void *value) { if (TlsSetValue(key, value)) return 0; else return EINVAL; } int usbi_tls_key_delete(usbi_tls_key_t key) { if (TlsFree(key)) return 0; else return EINVAL; } int usbi_get_tid(void) { return (int)GetCurrentThreadId(); }