1 /* 2 * Copyright (C) 2010 David Xu <davidxu@freebsd.org>. 3 * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 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 16 * distribution. 17 * 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. 29 * 30 * $FreeBSD$ 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 SYM_FBP10(sym) __CONCAT(sym, _fbp10) 100 #define WEAK_REF(sym, alias) __weak_reference(sym, alias) 101 #define SYM_COMPAT(sym, impl, ver) __sym_compat(sym, impl, ver) 102 #define SYM_DEFAULT(sym, impl, ver) __sym_default(sym, impl, ver) 103 104 #define FB10_COMPAT(func, sym) \ 105 WEAK_REF(func, SYM_FB10(sym)); \ 106 SYM_COMPAT(sym, SYM_FB10(sym), FBSD_1.0) 107 108 #define FB10_COMPAT_PRIVATE(func, sym) \ 109 WEAK_REF(func, SYM_FBP10(sym)); \ 110 SYM_DEFAULT(sym, SYM_FBP10(sym), FBSDprivate_1.0) 111 112 static sem_t sem_alloc(unsigned int value, semid_t semid, int system_sem); 113 static void sem_free(sem_t sem); 114 115 static LIST_HEAD(, sem) named_sems = LIST_HEAD_INITIALIZER(&named_sems); 116 static pthread_mutex_t named_sems_mtx = PTHREAD_MUTEX_INITIALIZER; 117 118 FB10_COMPAT(_libc_sem_init_compat, sem_init); 119 FB10_COMPAT(_libc_sem_destroy_compat, sem_destroy); 120 FB10_COMPAT(_libc_sem_open_compat, sem_open); 121 FB10_COMPAT(_libc_sem_close_compat, sem_close); 122 FB10_COMPAT(_libc_sem_unlink_compat, sem_unlink); 123 FB10_COMPAT(_libc_sem_wait_compat, sem_wait); 124 FB10_COMPAT(_libc_sem_trywait_compat, sem_trywait); 125 FB10_COMPAT(_libc_sem_timedwait_compat, sem_timedwait); 126 FB10_COMPAT(_libc_sem_post_compat, sem_post); 127 FB10_COMPAT(_libc_sem_getvalue_compat, sem_getvalue); 128 129 static inline int 130 sem_check_validity(sem_t *sem) 131 { 132 133 if ((sem != NULL) && ((*sem)->magic == SEM_MAGIC)) 134 return (0); 135 else { 136 errno = EINVAL; 137 return (-1); 138 } 139 } 140 141 static void 142 sem_free(sem_t sem) 143 { 144 145 sem->magic = 0; 146 free(sem); 147 } 148 149 static sem_t 150 sem_alloc(unsigned int value, semid_t semid, int system_sem) 151 { 152 sem_t sem; 153 154 if (value > SEM_VALUE_MAX) { 155 errno = EINVAL; 156 return (NULL); 157 } 158 159 sem = (sem_t)malloc(sizeof(struct sem)); 160 if (sem == NULL) { 161 errno = ENOSPC; 162 return (NULL); 163 } 164 165 sem->count = (u_int32_t)value; 166 sem->nwaiters = 0; 167 sem->magic = SEM_MAGIC; 168 sem->semid = semid; 169 sem->syssem = system_sem; 170 return (sem); 171 } 172 173 int 174 _libc_sem_init_compat(sem_t *sem, int pshared, unsigned int value) 175 { 176 semid_t semid; 177 178 /* 179 * We always have to create the kernel semaphore if the 180 * threads library isn't present since libc's version of 181 * pthread_cond_wait() is just a stub that doesn't really 182 * wait. 183 */ 184 semid = (semid_t)SEM_USER; 185 if ((pshared != 0) && ksem_init(&semid, value) != 0) 186 return (-1); 187 188 *sem = sem_alloc(value, semid, pshared); 189 if ((*sem) == NULL) { 190 if (pshared != 0) 191 ksem_destroy(semid); 192 return (-1); 193 } 194 return (0); 195 } 196 197 int 198 _libc_sem_destroy_compat(sem_t *sem) 199 { 200 int retval; 201 202 if (sem_check_validity(sem) != 0) 203 return (-1); 204 205 /* 206 * If this is a system semaphore let the kernel track it otherwise 207 * make sure there are no waiters. 208 */ 209 if ((*sem)->syssem != 0) 210 retval = ksem_destroy((*sem)->semid); 211 else if ((*sem)->nwaiters > 0) { 212 errno = EBUSY; 213 retval = -1; 214 } 215 else { 216 retval = 0; 217 (*sem)->magic = 0; 218 } 219 220 if (retval == 0) 221 sem_free(*sem); 222 return (retval); 223 } 224 225 sem_t * 226 _libc_sem_open_compat(const char *name, int oflag, ...) 227 { 228 sem_t *sem; 229 sem_t s; 230 semid_t semid; 231 mode_t mode; 232 unsigned int value; 233 234 mode = 0; 235 value = 0; 236 237 if ((oflag & O_CREAT) != 0) { 238 va_list ap; 239 240 va_start(ap, oflag); 241 mode = va_arg(ap, int); 242 value = va_arg(ap, unsigned int); 243 va_end(ap); 244 } 245 /* 246 * we can be lazy and let the kernel handle the "oflag", 247 * we'll just merge duplicate IDs into our list. 248 */ 249 if (ksem_open(&semid, name, oflag, mode, value) == -1) 250 return (SEM_FAILED); 251 /* 252 * search for a duplicate ID, we must return the same sem_t * 253 * if we locate one. 254 */ 255 _pthread_mutex_lock(&named_sems_mtx); 256 LIST_FOREACH(s, &named_sems, entry) { 257 if (s->semid == semid) { 258 sem = s->backpointer; 259 _pthread_mutex_unlock(&named_sems_mtx); 260 return (sem); 261 } 262 } 263 sem = (sem_t *)malloc(sizeof(*sem)); 264 if (sem == NULL) 265 goto err; 266 *sem = sem_alloc(value, semid, 1); 267 if ((*sem) == NULL) 268 goto err; 269 LIST_INSERT_HEAD(&named_sems, *sem, entry); 270 (*sem)->backpointer = sem; 271 _pthread_mutex_unlock(&named_sems_mtx); 272 return (sem); 273 err: 274 _pthread_mutex_unlock(&named_sems_mtx); 275 ksem_close(semid); 276 if (sem != NULL) { 277 if (*sem != NULL) 278 sem_free(*sem); 279 else 280 errno = ENOSPC; 281 free(sem); 282 } else { 283 errno = ENOSPC; 284 } 285 return (SEM_FAILED); 286 } 287 288 int 289 _libc_sem_close_compat(sem_t *sem) 290 { 291 292 if (sem_check_validity(sem) != 0) 293 return (-1); 294 295 if ((*sem)->syssem == 0) { 296 errno = EINVAL; 297 return (-1); 298 } 299 300 _pthread_mutex_lock(&named_sems_mtx); 301 if (ksem_close((*sem)->semid) != 0) { 302 _pthread_mutex_unlock(&named_sems_mtx); 303 return (-1); 304 } 305 LIST_REMOVE((*sem), entry); 306 _pthread_mutex_unlock(&named_sems_mtx); 307 sem_free(*sem); 308 *sem = NULL; 309 free(sem); 310 return (0); 311 } 312 313 int 314 _libc_sem_unlink_compat(const char *name) 315 { 316 317 return (ksem_unlink(name)); 318 } 319 320 static int 321 enable_async_cancel(void) 322 { 323 int old; 324 325 _pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old); 326 return (old); 327 } 328 329 static void 330 restore_async_cancel(int val) 331 { 332 _pthread_setcanceltype(val, NULL); 333 } 334 335 static int 336 _umtx_wait_uint(volatile unsigned *mtx, unsigned id, const struct timespec *timeout) 337 { 338 if (timeout && (timeout->tv_sec < 0 || (timeout->tv_sec == 0 && 339 timeout->tv_nsec <= 0))) { 340 errno = ETIMEDOUT; 341 return (-1); 342 } 343 return _umtx_op(__DEVOLATILE(void *, mtx), 344 UMTX_OP_WAIT_UINT_PRIVATE, id, NULL, __DECONST(void*, timeout)); 345 } 346 347 static int 348 _umtx_wake(volatile void *mtx) 349 { 350 return _umtx_op(__DEVOLATILE(void *, mtx), UMTX_OP_WAKE_PRIVATE, 351 1, NULL, NULL); 352 } 353 354 #define TIMESPEC_SUB(dst, src, val) \ 355 do { \ 356 (dst)->tv_sec = (src)->tv_sec - (val)->tv_sec; \ 357 (dst)->tv_nsec = (src)->tv_nsec - (val)->tv_nsec; \ 358 if ((dst)->tv_nsec < 0) { \ 359 (dst)->tv_sec--; \ 360 (dst)->tv_nsec += 1000000000; \ 361 } \ 362 } while (0) 363 364 365 static void 366 sem_cancel_handler(void *arg) 367 { 368 sem_t *sem = arg; 369 370 atomic_add_int(&(*sem)->nwaiters, -1); 371 if ((*sem)->nwaiters && (*sem)->count) 372 _umtx_wake(&(*sem)->count); 373 } 374 375 int 376 _libc_sem_timedwait_compat(sem_t * __restrict sem, 377 const struct timespec * __restrict abstime) 378 { 379 struct timespec ts, ts2; 380 int val, retval, saved_cancel; 381 382 if (sem_check_validity(sem) != 0) 383 return (-1); 384 385 if ((*sem)->syssem != 0) { 386 saved_cancel = enable_async_cancel(); 387 retval = ksem_wait((*sem)->semid); 388 restore_async_cancel(saved_cancel); 389 return (retval); 390 } 391 392 retval = 0; 393 _pthread_testcancel(); 394 for (;;) { 395 while ((val = (*sem)->count) > 0) { 396 if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1)) 397 return (0); 398 } 399 if (retval) 400 break; 401 if (abstime) { 402 if (abstime->tv_nsec >= 1000000000 || abstime->tv_nsec < 0) { 403 errno = EINVAL; 404 return (-1); 405 } 406 clock_gettime(CLOCK_REALTIME, &ts); 407 TIMESPEC_SUB(&ts2, abstime, &ts); 408 } 409 atomic_add_int(&(*sem)->nwaiters, 1); 410 pthread_cleanup_push(sem_cancel_handler, sem); 411 saved_cancel = enable_async_cancel(); 412 retval = _umtx_wait_uint(&(*sem)->count, 0, abstime ? &ts2 : NULL); 413 restore_async_cancel(saved_cancel); 414 pthread_cleanup_pop(0); 415 atomic_add_int(&(*sem)->nwaiters, -1); 416 } 417 return (retval); 418 } 419 420 int 421 _libc_sem_wait_compat(sem_t *sem) 422 { 423 return _libc_sem_timedwait_compat(sem, NULL); 424 } 425 426 int 427 _libc_sem_trywait_compat(sem_t *sem) 428 { 429 int val; 430 431 if (sem_check_validity(sem) != 0) 432 return (-1); 433 434 if ((*sem)->syssem != 0) 435 return ksem_trywait((*sem)->semid); 436 437 while ((val = (*sem)->count) > 0) { 438 if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1)) 439 return (0); 440 } 441 errno = EAGAIN; 442 return (-1); 443 } 444 445 int 446 _libc_sem_post_compat(sem_t *sem) 447 { 448 449 if (sem_check_validity(sem) != 0) 450 return (-1); 451 452 if ((*sem)->syssem != 0) 453 return ksem_post((*sem)->semid); 454 455 atomic_add_rel_int(&(*sem)->count, 1); 456 457 if ((*sem)->nwaiters) 458 return _umtx_wake(&(*sem)->count); 459 return (0); 460 } 461 462 int 463 _libc_sem_getvalue_compat(sem_t * __restrict sem, int * __restrict sval) 464 { 465 int retval; 466 467 if (sem_check_validity(sem) != 0) 468 return (-1); 469 470 if ((*sem)->syssem != 0) 471 retval = ksem_getvalue((*sem)->semid, sval); 472 else { 473 *sval = (int)(*sem)->count; 474 retval = 0; 475 } 476 return (retval); 477 } 478