2 * Copyright (C) 2010 David Xu <davidxu@freebsd.org>.
3 * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice(s), this list of conditions and the following disclaimer as
11 * the first lines of this file unmodified other than the possible
12 * addition of one or more copyright notices.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice(s), this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
19 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
28 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 * Some notes about this implementation.
36 * This is mostly a simple implementation of POSIX semaphores that
37 * does not need threading. Any semaphore created is a kernel-based
38 * semaphore regardless of the pshared attribute. This is necessary
39 * because libc's stub for pthread_cond_wait() doesn't really wait,
40 * and it is not worth the effort impose this behavior on libc.
42 * All functions here are designed to be thread-safe so that a
43 * threads library need not provide wrappers except to make
44 * sem_wait() and sem_timedwait() cancellation points or to
45 * provide a faster userland implementation for non-pshared
48 * Also, this implementation of semaphores cannot really support
49 * real pshared semaphores. The sem_t is an allocated object
50 * and can't be seen by other processes when placed in shared
51 * memory. It should work across forks as long as the semaphore
52 * is created before any forks.
54 * The function sem_init() should be overridden by a threads
55 * library if it wants to provide a different userland version
56 * of semaphores. The functions sem_wait() and sem_timedwait()
57 * need to be wrapped to provide cancellation points. The function
58 * sem_post() may need to be wrapped to be signal-safe.
60 #include "namespace.h"
61 #include <sys/types.h>
62 #include <sys/queue.h>
63 #include <machine/atomic.h>
66 #include <sys/_semaphore.h>
73 #include "un-namespace.h"
74 #include "libc_private.h"
77 * Old semaphore definitions.
80 #define SEM_MAGIC ((u_int32_t) 0x09fa4012)
83 pthread_cond_t gtzero;
86 #define SEM_USER (NULL)
87 semid_t semid; /* semaphore id if kernel (shared) semaphore */
88 int syssem; /* 1 if kernel (shared) semaphore */
89 LIST_ENTRY(sem) entry;
90 struct sem **backpointer;
93 typedef struct sem* sem_t;
95 #define SEM_FAILED ((sem_t *)0)
96 #define SEM_VALUE_MAX __INT_MAX
98 #define SYM_FB10(sym) __CONCAT(sym, _fb10)
99 #define WEAK_REF(sym, alias) __weak_reference(sym, alias)
100 #define SYM_COMPAT(sym, impl, ver) __sym_compat(sym, impl, ver)
102 #define FB10_COMPAT(func, sym) \
103 WEAK_REF(func, SYM_FB10(sym)); \
104 SYM_COMPAT(sym, SYM_FB10(sym), FBSD_1.0)
106 static sem_t sem_alloc(unsigned int value, semid_t semid, int system_sem);
107 static void sem_free(sem_t sem);
109 static LIST_HEAD(, sem) named_sems = LIST_HEAD_INITIALIZER(named_sems);
110 static pthread_mutex_t named_sems_mtx = PTHREAD_MUTEX_INITIALIZER;
112 FB10_COMPAT(_libc_sem_init_compat, sem_init);
113 FB10_COMPAT(_libc_sem_destroy_compat, sem_destroy);
114 FB10_COMPAT(_libc_sem_open_compat, sem_open);
115 FB10_COMPAT(_libc_sem_close_compat, sem_close);
116 FB10_COMPAT(_libc_sem_unlink_compat, sem_unlink);
117 FB10_COMPAT(_libc_sem_wait_compat, sem_wait);
118 FB10_COMPAT(_libc_sem_trywait_compat, sem_trywait);
119 FB10_COMPAT(_libc_sem_timedwait_compat, sem_timedwait);
120 FB10_COMPAT(_libc_sem_post_compat, sem_post);
121 FB10_COMPAT(_libc_sem_getvalue_compat, sem_getvalue);
124 sem_check_validity(sem_t *sem)
127 if ((sem != NULL) && ((*sem)->magic == SEM_MAGIC))
144 sem_alloc(unsigned int value, semid_t semid, int system_sem)
148 if (value > SEM_VALUE_MAX) {
153 sem = (sem_t)malloc(sizeof(struct sem));
159 sem->count = (u_int32_t)value;
161 sem->magic = SEM_MAGIC;
163 sem->syssem = system_sem;
168 _libc_sem_init_compat(sem_t *sem, int pshared, unsigned int value)
173 * We always have to create the kernel semaphore if the
174 * threads library isn't present since libc's version of
175 * pthread_cond_wait() is just a stub that doesn't really
178 semid = (semid_t)SEM_USER;
179 if ((pshared != 0) && ksem_init(&semid, value) != 0)
182 *sem = sem_alloc(value, semid, pshared);
183 if ((*sem) == NULL) {
192 _libc_sem_destroy_compat(sem_t *sem)
196 if (sem_check_validity(sem) != 0)
200 * If this is a system semaphore let the kernel track it otherwise
201 * make sure there are no waiters.
203 if ((*sem)->syssem != 0)
204 retval = ksem_destroy((*sem)->semid);
205 else if ((*sem)->nwaiters > 0) {
220 _libc_sem_open_compat(const char *name, int oflag, ...)
231 if ((oflag & O_CREAT) != 0) {
235 mode = va_arg(ap, int);
236 value = va_arg(ap, unsigned int);
240 * we can be lazy and let the kernel handle the "oflag",
241 * we'll just merge duplicate IDs into our list.
243 if (ksem_open(&semid, name, oflag, mode, value) == -1)
246 * search for a duplicate ID, we must return the same sem_t *
249 _pthread_mutex_lock(&named_sems_mtx);
250 LIST_FOREACH(s, &named_sems, entry) {
251 if (s->semid == semid) {
252 sem = s->backpointer;
253 _pthread_mutex_unlock(&named_sems_mtx);
257 sem = (sem_t *)malloc(sizeof(*sem));
260 *sem = sem_alloc(value, semid, 1);
263 LIST_INSERT_HEAD(&named_sems, *sem, entry);
264 (*sem)->backpointer = sem;
265 _pthread_mutex_unlock(&named_sems_mtx);
268 _pthread_mutex_unlock(&named_sems_mtx);
283 _libc_sem_close_compat(sem_t *sem)
286 if (sem_check_validity(sem) != 0)
289 if ((*sem)->syssem == 0) {
294 _pthread_mutex_lock(&named_sems_mtx);
295 if (ksem_close((*sem)->semid) != 0) {
296 _pthread_mutex_unlock(&named_sems_mtx);
299 LIST_REMOVE((*sem), entry);
300 _pthread_mutex_unlock(&named_sems_mtx);
308 _libc_sem_unlink_compat(const char *name)
311 return (ksem_unlink(name));
315 _umtx_wait_uint(volatile unsigned *mtx, unsigned id, const struct timespec *timeout)
317 if (timeout && (timeout->tv_sec < 0 || (timeout->tv_sec == 0 &&
318 timeout->tv_nsec <= 0))) {
322 return _umtx_op(__DEVOLATILE(void *, mtx),
323 UMTX_OP_WAIT_UINT_PRIVATE, id, NULL, __DECONST(void*, timeout));
327 _umtx_wake(volatile void *mtx)
329 return _umtx_op(__DEVOLATILE(void *, mtx), UMTX_OP_WAKE_PRIVATE,
333 #define TIMESPEC_SUB(dst, src, val) \
335 (dst)->tv_sec = (src)->tv_sec - (val)->tv_sec; \
336 (dst)->tv_nsec = (src)->tv_nsec - (val)->tv_nsec; \
337 if ((dst)->tv_nsec < 0) { \
339 (dst)->tv_nsec += 1000000000; \
345 sem_cancel_handler(void *arg)
349 atomic_add_int(&(*sem)->nwaiters, -1);
350 if ((*sem)->nwaiters && (*sem)->count)
351 _umtx_wake(&(*sem)->count);
355 _libc_sem_timedwait_compat(sem_t * __restrict sem,
356 const struct timespec * __restrict abstime)
358 struct timespec ts, ts2;
361 if (sem_check_validity(sem) != 0)
364 if ((*sem)->syssem != 0) {
365 _pthread_cancel_enter(1);
366 retval = ksem_wait((*sem)->semid); /* XXX no timeout */
367 _pthread_cancel_leave(retval == -1);
372 _pthread_testcancel();
374 while ((val = (*sem)->count) > 0) {
375 if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1))
379 _pthread_testcancel();
383 if (abstime->tv_nsec >= 1000000000 || abstime->tv_nsec < 0) {
387 clock_gettime(CLOCK_REALTIME, &ts);
388 TIMESPEC_SUB(&ts2, abstime, &ts);
390 atomic_add_int(&(*sem)->nwaiters, 1);
391 pthread_cleanup_push(sem_cancel_handler, sem);
392 _pthread_cancel_enter(1);
393 retval = _umtx_wait_uint(&(*sem)->count, 0, abstime ? &ts2 : NULL);
394 _pthread_cancel_leave(0);
395 pthread_cleanup_pop(0);
396 atomic_add_int(&(*sem)->nwaiters, -1);
402 _libc_sem_wait_compat(sem_t *sem)
404 return _libc_sem_timedwait_compat(sem, NULL);
408 _libc_sem_trywait_compat(sem_t *sem)
412 if (sem_check_validity(sem) != 0)
415 if ((*sem)->syssem != 0)
416 return ksem_trywait((*sem)->semid);
418 while ((val = (*sem)->count) > 0) {
419 if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1))
427 _libc_sem_post_compat(sem_t *sem)
430 if (sem_check_validity(sem) != 0)
433 if ((*sem)->syssem != 0)
434 return ksem_post((*sem)->semid);
436 atomic_add_rel_int(&(*sem)->count, 1);
438 if ((*sem)->nwaiters)
439 return _umtx_wake(&(*sem)->count);
444 _libc_sem_getvalue_compat(sem_t * __restrict sem, int * __restrict sval)
448 if (sem_check_validity(sem) != 0)
451 if ((*sem)->syssem != 0)
452 retval = ksem_getvalue((*sem)->semid, sval);
454 *sval = (int)(*sem)->count;