1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (C) 2010 David Xu <davidxu@freebsd.org>.
5 * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice(s), this list of conditions and the following disclaimer as
13 * the first lines of this file unmodified other than the possible
14 * addition of one or more copyright notices.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice(s), this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /*
34 * Some notes about this implementation.
35 *
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.
41 *
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
46 * semaphores.
47 *
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.
53 *
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.
59 */
60 #include "namespace.h"
61 #include <sys/types.h>
62 #include <sys/queue.h>
63 #include <machine/atomic.h>
64 #include <errno.h>
65 #include <sys/umtx.h>
66 #include <sys/_semaphore.h>
67 #include <limits.h>
68 #include <fcntl.h>
69 #include <pthread.h>
70 #include <stdarg.h>
71 #include <stdlib.h>
72 #include <time.h>
73 #include "un-namespace.h"
74 #include "libc_private.h"
75
76 /*
77 * Old semaphore definitions.
78 */
79 struct sem {
80 #define SEM_MAGIC ((u_int32_t) 0x09fa4012)
81 u_int32_t magic;
82 pthread_mutex_t lock;
83 pthread_cond_t gtzero;
84 u_int32_t count;
85 u_int32_t nwaiters;
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;
91 };
92
93 typedef struct sem* sem_t;
94
95 #define SEM_FAILED ((sem_t *)0)
96 #define SEM_VALUE_MAX __INT_MAX
97
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)
101
102 #define FB10_COMPAT(func, sym) \
103 WEAK_REF(func, SYM_FB10(sym)); \
104 SYM_COMPAT(sym, SYM_FB10(sym), FBSD_1.0)
105
106 static sem_t sem_alloc(unsigned int value, semid_t semid, int system_sem);
107 static void sem_free(sem_t sem);
108
109 static LIST_HEAD(, sem) named_sems = LIST_HEAD_INITIALIZER(named_sems);
110 static pthread_mutex_t named_sems_mtx = PTHREAD_MUTEX_INITIALIZER;
111
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);
122
123 static inline int
sem_check_validity(sem_t * sem)124 sem_check_validity(sem_t *sem)
125 {
126
127 if ((sem != NULL) && ((*sem)->magic == SEM_MAGIC))
128 return (0);
129 else {
130 errno = EINVAL;
131 return (-1);
132 }
133 }
134
135 static void
sem_free(sem_t sem)136 sem_free(sem_t sem)
137 {
138
139 sem->magic = 0;
140 free(sem);
141 }
142
143 static sem_t
sem_alloc(unsigned int value,semid_t semid,int system_sem)144 sem_alloc(unsigned int value, semid_t semid, int system_sem)
145 {
146 sem_t sem;
147
148 if (value > SEM_VALUE_MAX) {
149 errno = EINVAL;
150 return (NULL);
151 }
152
153 sem = (sem_t)malloc(sizeof(struct sem));
154 if (sem == NULL) {
155 errno = ENOSPC;
156 return (NULL);
157 }
158
159 sem->count = (u_int32_t)value;
160 sem->nwaiters = 0;
161 sem->magic = SEM_MAGIC;
162 sem->semid = semid;
163 sem->syssem = system_sem;
164 return (sem);
165 }
166
167 int
_libc_sem_init_compat(sem_t * sem,int pshared,unsigned int value)168 _libc_sem_init_compat(sem_t *sem, int pshared, unsigned int value)
169 {
170 semid_t semid;
171
172 /*
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
176 * wait.
177 */
178 semid = (semid_t)SEM_USER;
179 if ((pshared != 0) && ksem_init(&semid, value) != 0)
180 return (-1);
181
182 *sem = sem_alloc(value, semid, pshared);
183 if ((*sem) == NULL) {
184 if (pshared != 0)
185 ksem_destroy(semid);
186 return (-1);
187 }
188 return (0);
189 }
190
191 int
_libc_sem_destroy_compat(sem_t * sem)192 _libc_sem_destroy_compat(sem_t *sem)
193 {
194 int retval;
195
196 if (sem_check_validity(sem) != 0)
197 return (-1);
198
199 /*
200 * If this is a system semaphore let the kernel track it otherwise
201 * make sure there are no waiters.
202 */
203 if ((*sem)->syssem != 0)
204 retval = ksem_destroy((*sem)->semid);
205 else if ((*sem)->nwaiters > 0) {
206 errno = EBUSY;
207 retval = -1;
208 }
209 else {
210 retval = 0;
211 (*sem)->magic = 0;
212 }
213
214 if (retval == 0)
215 sem_free(*sem);
216 return (retval);
217 }
218
219 sem_t *
_libc_sem_open_compat(const char * name,int oflag,...)220 _libc_sem_open_compat(const char *name, int oflag, ...)
221 {
222 sem_t *sem;
223 sem_t s;
224 semid_t semid;
225 mode_t mode;
226 unsigned int value;
227
228 mode = 0;
229 value = 0;
230
231 if ((oflag & O_CREAT) != 0) {
232 va_list ap;
233
234 va_start(ap, oflag);
235 mode = va_arg(ap, int);
236 value = va_arg(ap, unsigned int);
237 va_end(ap);
238 }
239 /*
240 * we can be lazy and let the kernel handle the "oflag",
241 * we'll just merge duplicate IDs into our list.
242 */
243 if (ksem_open(&semid, name, oflag, mode, value) == -1)
244 return (SEM_FAILED);
245 /*
246 * search for a duplicate ID, we must return the same sem_t *
247 * if we locate one.
248 */
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);
254 return (sem);
255 }
256 }
257 sem = (sem_t *)malloc(sizeof(*sem));
258 if (sem == NULL)
259 goto err;
260 *sem = sem_alloc(value, semid, 1);
261 if ((*sem) == NULL)
262 goto err;
263 LIST_INSERT_HEAD(&named_sems, *sem, entry);
264 (*sem)->backpointer = sem;
265 _pthread_mutex_unlock(&named_sems_mtx);
266 return (sem);
267 err:
268 _pthread_mutex_unlock(&named_sems_mtx);
269 ksem_close(semid);
270 if (sem != NULL) {
271 if (*sem != NULL)
272 sem_free(*sem);
273 else
274 errno = ENOSPC;
275 free(sem);
276 } else {
277 errno = ENOSPC;
278 }
279 return (SEM_FAILED);
280 }
281
282 int
_libc_sem_close_compat(sem_t * sem)283 _libc_sem_close_compat(sem_t *sem)
284 {
285
286 if (sem_check_validity(sem) != 0)
287 return (-1);
288
289 if ((*sem)->syssem == 0) {
290 errno = EINVAL;
291 return (-1);
292 }
293
294 _pthread_mutex_lock(&named_sems_mtx);
295 if (ksem_close((*sem)->semid) != 0) {
296 _pthread_mutex_unlock(&named_sems_mtx);
297 return (-1);
298 }
299 LIST_REMOVE((*sem), entry);
300 _pthread_mutex_unlock(&named_sems_mtx);
301 sem_free(*sem);
302 *sem = NULL;
303 free(sem);
304 return (0);
305 }
306
307 int
_libc_sem_unlink_compat(const char * name)308 _libc_sem_unlink_compat(const char *name)
309 {
310
311 return (ksem_unlink(name));
312 }
313
314 static int
_umtx_wait_uint(volatile unsigned * mtx,unsigned id,const struct timespec * abstime)315 _umtx_wait_uint(volatile unsigned *mtx, unsigned id, const struct timespec *abstime)
316 {
317 struct _umtx_time *tm_p, timeout;
318 size_t tm_size;
319
320 if (abstime == NULL) {
321 tm_p = NULL;
322 tm_size = 0;
323 } else {
324 timeout._clockid = CLOCK_REALTIME;
325 timeout._flags = UMTX_ABSTIME;
326 timeout._timeout = *abstime;
327 tm_p = &timeout;
328 tm_size = sizeof(timeout);
329 }
330 return _umtx_op(__DEVOLATILE(void *, mtx),
331 UMTX_OP_WAIT_UINT_PRIVATE, id,
332 (void *)tm_size, __DECONST(void*, tm_p));
333 }
334
335 static int
_umtx_wake(volatile void * mtx)336 _umtx_wake(volatile void *mtx)
337 {
338 return _umtx_op(__DEVOLATILE(void *, mtx), UMTX_OP_WAKE_PRIVATE,
339 1, NULL, NULL);
340 }
341
342 #define TIMESPEC_SUB(dst, src, val) \
343 do { \
344 (dst)->tv_sec = (src)->tv_sec - (val)->tv_sec; \
345 (dst)->tv_nsec = (src)->tv_nsec - (val)->tv_nsec; \
346 if ((dst)->tv_nsec < 0) { \
347 (dst)->tv_sec--; \
348 (dst)->tv_nsec += 1000000000; \
349 } \
350 } while (0)
351
352
353 static void
sem_cancel_handler(void * arg)354 sem_cancel_handler(void *arg)
355 {
356 sem_t *sem = arg;
357
358 atomic_add_int(&(*sem)->nwaiters, -1);
359 if ((*sem)->nwaiters && (*sem)->count)
360 _umtx_wake(&(*sem)->count);
361 }
362
363 int
_libc_sem_timedwait_compat(sem_t * __restrict sem,const struct timespec * __restrict abstime)364 _libc_sem_timedwait_compat(sem_t * __restrict sem,
365 const struct timespec * __restrict abstime)
366 {
367 int val, retval;
368
369 if (sem_check_validity(sem) != 0)
370 return (-1);
371
372 if ((*sem)->syssem != 0) {
373 _pthread_cancel_enter(1);
374 retval = ksem_wait((*sem)->semid); /* XXX no timeout */
375 _pthread_cancel_leave(retval == -1);
376 return (retval);
377 }
378
379 retval = 0;
380 _pthread_testcancel();
381 for (;;) {
382 while ((val = (*sem)->count) > 0) {
383 if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1))
384 return (0);
385 }
386 if (retval) {
387 _pthread_testcancel();
388 break;
389 }
390 if (abstime) {
391 if (abstime->tv_nsec >= 1000000000 || abstime->tv_nsec < 0) {
392 errno = EINVAL;
393 return (-1);
394 }
395 }
396 atomic_add_int(&(*sem)->nwaiters, 1);
397 pthread_cleanup_push(sem_cancel_handler, sem);
398 _pthread_cancel_enter(1);
399 retval = _umtx_wait_uint(&(*sem)->count, 0, abstime);
400 _pthread_cancel_leave(0);
401 pthread_cleanup_pop(0);
402 atomic_add_int(&(*sem)->nwaiters, -1);
403 }
404 return (retval);
405 }
406
407 int
_libc_sem_wait_compat(sem_t * sem)408 _libc_sem_wait_compat(sem_t *sem)
409 {
410 return _libc_sem_timedwait_compat(sem, NULL);
411 }
412
413 int
_libc_sem_trywait_compat(sem_t * sem)414 _libc_sem_trywait_compat(sem_t *sem)
415 {
416 int val;
417
418 if (sem_check_validity(sem) != 0)
419 return (-1);
420
421 if ((*sem)->syssem != 0)
422 return ksem_trywait((*sem)->semid);
423
424 while ((val = (*sem)->count) > 0) {
425 if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1))
426 return (0);
427 }
428 errno = EAGAIN;
429 return (-1);
430 }
431
432 int
_libc_sem_post_compat(sem_t * sem)433 _libc_sem_post_compat(sem_t *sem)
434 {
435
436 if (sem_check_validity(sem) != 0)
437 return (-1);
438
439 if ((*sem)->syssem != 0)
440 return ksem_post((*sem)->semid);
441
442 atomic_add_rel_int(&(*sem)->count, 1);
443 rmb();
444 if ((*sem)->nwaiters)
445 return _umtx_wake(&(*sem)->count);
446 return (0);
447 }
448
449 int
_libc_sem_getvalue_compat(sem_t * __restrict sem,int * __restrict sval)450 _libc_sem_getvalue_compat(sem_t * __restrict sem, int * __restrict sval)
451 {
452 int retval;
453
454 if (sem_check_validity(sem) != 0)
455 return (-1);
456
457 if ((*sem)->syssem != 0)
458 retval = ksem_getvalue((*sem)->semid, sval);
459 else {
460 *sval = (int)(*sem)->count;
461 retval = 0;
462 }
463 return (retval);
464 }
465