diff options
| -rw-r--r-- | old-makefile | 1 | ||||
| -rw-r--r-- | osdep/semaphore.h | 58 | ||||
| -rw-r--r-- | osdep/semaphore_osx.c | 121 | ||||
| -rw-r--r-- | wscript_build.py | 2 |
4 files changed, 181 insertions, 1 deletions
diff --git a/old-makefile b/old-makefile index 2c3c623eb8..9e2f7b0d3f 100644 --- a/old-makefile +++ b/old-makefile @@ -188,6 +188,7 @@ SOURCES = audio/audio.c \ options/path.c \ osdep/io.c \ osdep/numcores.c \ + osdep/semaphore_osx.c \ osdep/terminal-unix.c \ osdep/timer.c \ osdep/timer-linux.c \ diff --git a/osdep/semaphore.h b/osdep/semaphore.h new file mode 100644 index 0000000000..832f059df4 --- /dev/null +++ b/osdep/semaphore.h @@ -0,0 +1,58 @@ +#ifndef MP_SEMAPHORE_H_ +#define MP_SEMAPHORE_H_ + +#include <semaphore.h> + +// OSX provides non-working empty stubs, so we emulate them. +// This should be AS-safe, but cancellation issues were ignored. +// sem_getvalue() is not provided. +// sem_post() won't always correctly return an error on overflow. +// Process-shared semantics are not provided. + +#ifdef __APPLE__ + +#define MP_SEMAPHORE_EMULATION + +#include <pthread.h> + +#define MP_SEM_VALUE_MAX 4096 + +typedef struct { + int wakeup_pipe[2]; + pthread_mutex_t lock; + // protected by lock + unsigned int count; +} mp_sem_t; + +int mp_sem_init(mp_sem_t *sem, int pshared, unsigned int value); +int mp_sem_wait(mp_sem_t *sem); +int mp_sem_trywait(mp_sem_t *sem); +int mp_sem_timedwait(mp_sem_t *sem, const struct timespec *abs_timeout); +int mp_sem_post(mp_sem_t *sem); +int mp_sem_destroy(mp_sem_t *sem); + +#undef sem_init +#undef sem_wait +#undef sem_trywait +#undef sem_timedwait +#undef sem_post +#undef sem_getvalue +#undef sem_destroy +#undef sem_getvalue +#undef sem_t +#undef SEM_VALUE_MAX + +#define sem_init mp_sem_init +#define sem_wait mp_sem_wait +#define sem_trywait mp_sem_trywait +#define sem_timedwait mp_sem_timedwait +#define sem_post mp_sem_post +#define sem_destroy mp_sem_destroy +#define sem_t mp_sem_t +#define SEM_VALUE_MAX MP_SEM_VALUE_MAX + +#define sem_getvalue (void) + +#endif + +#endif diff --git a/osdep/semaphore_osx.c b/osdep/semaphore_osx.c new file mode 100644 index 0000000000..72173f9564 --- /dev/null +++ b/osdep/semaphore_osx.c @@ -0,0 +1,121 @@ +/* Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <unistd.h> +#include <poll.h> +#include <limits.h> +#include <sys/time.h> +#include <errno.h> + +#include "osdep/io.h" + +#include "semaphore.h" + +#ifdef MP_SEMAPHORE_EMULATION + +int mp_sem_init(mp_sem_t *sem, int pshared, unsigned int value) +{ + if (pshared) { + errno = ENOSYS; + return -1; + } + if (value > INT_MAX) { + errno = EINVAL; + return -1; + } + if (mp_make_wakeup_pipe(sem->wakeup_pipe) < 0) + return -1; + sem->count = 0; + pthread_mutex_init(&sem->lock, NULL); + return 0; +} + +int mp_sem_wait(mp_sem_t *sem) +{ + return mp_sem_timedwait(sem, NULL); +} + +int mp_sem_trywait(mp_sem_t *sem) +{ + int r = -1; + pthread_mutex_lock(&sem->lock); + if (sem->count == 0) { + char buf[1024]; + ssize_t s = read(sem->wakeup_pipe[0], buf, sizeof(buf)); + if (s > 0 && s <= INT_MAX - sem->count) // can't handle overflows correctly + sem->count += s; + } + if (sem->count > 0) { + sem->count -= 1; + r = 0; + } + pthread_mutex_unlock(&sem->lock); + if (r < 0) + errno = EAGAIN; + return r; +} + +int mp_sem_timedwait(mp_sem_t *sem, const struct timespec *abs_timeout) +{ + while (1) { + if (!mp_sem_trywait(sem)) + return 0; + + int timeout_ms = -1; + if (abs_timeout) { + timeout_ms = 0; + + // OSX does not provide clock_gettime() either. + struct timeval tv; + gettimeofday(&tv, NULL); + + if (abs_timeout->tv_sec >= tv.tv_sec) { + long long msec = (abs_timeout->tv_sec - tv.tv_sec) * 1000LL + + abs_timeout->tv_nsec / 1000LL / 1000LL - tv.tv_usec / 1000LL; + if (msec > INT_MAX) + msec = INT_MAX; + if (msec < 0) + msec = 0; + timeout_ms = msec; + } + } + struct pollfd fd = {.fd = sem->wakeup_pipe[0], .events = POLLIN}; + int r = poll(&fd, 1, timeout_ms); + if (r < 0) + return -1; + if (r == 0) { + errno = ETIMEDOUT; + return -1; + } + } +} + +int mp_sem_post(mp_sem_t *sem) +{ + if (write(sem->wakeup_pipe[1], &(char){0}, 1) == 1) + return 0; + // Actually we can't handle overflow fully correctly, because we can't + // check sem->count atomically, while still being AS-safe. + errno = EOVERFLOW; + return -1; +} + +int mp_sem_destroy(mp_sem_t *sem) +{ + close(sem->wakeup_pipe[0]); + close(sem->wakeup_pipe[1]); + pthread_mutex_destroy(&sem->lock); + return 0; +} + +#endif diff --git a/wscript_build.py b/wscript_build.py index 2f19c14f03..95161c134b 100644 --- a/wscript_build.py +++ b/wscript_build.py @@ -382,8 +382,8 @@ def build(ctx): ( "osdep/ar/HIDRemote.m", "cocoa" ), ( "osdep/macosx_application.m", "cocoa-application" ), ( "osdep/macosx_events.m", "cocoa" ), + ( "osdep/semaphore_osx.c" ), ( "osdep/path-macosx.m", "cocoa" ), - ( "osdep/path-win.c", "os-win32" ), ( "osdep/path-win.c", "os-cygwin" ), ( "osdep/glob-win.c", "glob-win32-replacement" ), |