lib/libc_r/uthread/uthread_sem.c

   1 /*
   2  * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice(s), this list of conditions and the following disclaimer as
  10  *    the first lines of this file unmodified other than the possible
  11  *    addition of one or more copyright notices.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice(s), this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
  21  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  24  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  26  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  27  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/lib/libc_r/uthread/uthread_sem.c,v 1.3.2.5 2002/10/22 14:44:03 fjoe Exp $
  30  * $DragonFly: src/lib/libc_r/uthread/uthread_sem.c,v 1.3 2005/05/30 20:50:53 joerg Exp $
  31  */
  32
  33 #include <stdlib.h>
  34 #include <errno.h>
  35 #include <semaphore.h>
  36 #include <pthread.h>
  37 #include "pthread_private.h"
  38
  39 #define _SEM_CHECK_VALIDITY(sem)                \
  40         if ((*(sem))->magic != SEM_MAGIC) {     \
  41                 errno = EINVAL;                 \
  42                 retval = -1;                    \
  43                 goto RETURN;                    \
  44         }
  45
  46 int
  47 _sem_init(sem_t *sem, int pshared, unsigned int value)
  48 {
  49         int     retval;
  50
  51         /*
  52          * Range check the arguments.
  53          */
  54         if (pshared != 0) {
  55                 /*
  56                  * The user wants a semaphore that can be shared among
  57                  * processes, which this implementation can't do.  Sounds like a
  58                  * permissions problem to me (yeah right).
  59                  */
  60                 errno = EPERM;
  61                 retval = -1;
  62                 goto RETURN;
  63         }
  64
  65         if (value > SEM_VALUE_MAX) {
  66                 errno = EINVAL;
  67                 retval = -1;
  68                 goto RETURN;
  69         }
  70
  71         *sem = (sem_t)malloc(sizeof(struct sem));
  72         if (*sem == NULL) {
  73                 errno = ENOSPC;
  74                 retval = -1;
  75                 goto RETURN;
  76         }
  77
  78         /*
  79          * Initialize the semaphore.
  80          */
  81         if (pthread_mutex_init(&(*sem)->lock, NULL) != 0) {
  82                 free(*sem);
  83                 errno = ENOSPC;
  84                 retval = -1;
  85                 goto RETURN;
  86         }
  87
  88         if (pthread_cond_init(&(*sem)->gtzero, NULL) != 0) {
  89                 pthread_mutex_destroy(&(*sem)->lock);
  90                 free(*sem);
  91                 errno = ENOSPC;
  92                 retval = -1;
  93                 goto RETURN;
  94         }
  95
  96         (*sem)->count = (u_int32_t)value;
  97         (*sem)->nwaiters = 0;
  98         (*sem)->magic = SEM_MAGIC;
  99
 100         retval = 0;
 101   RETURN:
 102         return retval;
 103 }
 104
 105 int
 106 _sem_destroy(sem_t *sem)
 107 {
 108         int     retval;
 109
 110         _SEM_CHECK_VALIDITY(sem);
 111
 112         /* Make sure there are no waiters. */
 113         pthread_mutex_lock(&(*sem)->lock);
 114         if ((*sem)->nwaiters > 0) {
 115                 pthread_mutex_unlock(&(*sem)->lock);
 116                 errno = EBUSY;
 117                 retval = -1;
 118                 goto RETURN;
 119         }
 120         pthread_mutex_unlock(&(*sem)->lock);
 121
 122         pthread_mutex_destroy(&(*sem)->lock);
 123         pthread_cond_destroy(&(*sem)->gtzero);
 124         (*sem)->magic = 0;
 125
 126         free(*sem);
 127
 128         retval = 0;
 129   RETURN:
 130         return retval;
 131 }
 132
 133 sem_t *
 134 _sem_open(const char *name, int oflag, ...)
 135 {
 136         errno = ENOSYS;
 137         return SEM_FAILED;
 138 }
 139
 140 int
 141 _sem_close(sem_t *sem)
 142 {
 143         errno = ENOSYS;
 144         return -1;
 145 }
 146
 147 int
 148 _sem_unlink(const char *name)
 149 {
 150         errno = ENOSYS;
 151         return -1;
 152 }
 153
 154 int
 155 _sem_wait(sem_t *sem)
 156 {
 157         int     retval;
 158
 159         _thread_enter_cancellation_point();
 160
 161         _SEM_CHECK_VALIDITY(sem);
 162
 163         pthread_mutex_lock(&(*sem)->lock);
 164
 165         while ((*sem)->count == 0) {
 166                 (*sem)->nwaiters++;
 167                 pthread_cond_wait(&(*sem)->gtzero, &(*sem)->lock);
 168                 (*sem)->nwaiters--;
 169         }
 170         (*sem)->count--;
 171
 172         pthread_mutex_unlock(&(*sem)->lock);
 173
 174         retval = 0;
 175   RETURN:
 176         _thread_leave_cancellation_point();
 177         return retval;
 178 }
 179
 180 int
 181 _sem_trywait(sem_t *sem)
 182 {
 183         int     retval;
 184
 185         _SEM_CHECK_VALIDITY(sem);
 186
 187         pthread_mutex_lock(&(*sem)->lock);
 188
 189         if ((*sem)->count > 0) {
 190                 (*sem)->count--;
 191                 retval = 0;
 192         } else {
 193                 errno = EAGAIN;
 194                 retval = -1;
 195         }
 196
 197         pthread_mutex_unlock(&(*sem)->lock);
 198
 199   RETURN:
 200         return retval;
 201 }
 202
 203 int
 204 _sem_post(sem_t *sem)
 205 {
 206         int     retval;
 207
 208         _SEM_CHECK_VALIDITY(sem);
 209
 210         /*
 211          * sem_post() is required to be safe to call from within signal
 212          * handlers.  Thus, we must defer signals.
 213          */
 214         _thread_kern_sig_defer();
 215
 216         pthread_mutex_lock(&(*sem)->lock);
 217
 218         (*sem)->count++;
 219         if ((*sem)->nwaiters > 0)
 220                 pthread_cond_signal(&(*sem)->gtzero);
 221
 222         pthread_mutex_unlock(&(*sem)->lock);
 223
 224         _thread_kern_sig_undefer();
 225         retval = 0;
 226   RETURN:
 227         return retval;
 228 }
 229
 230 int
 231 _sem_getvalue(sem_t *sem, int *sval)
 232 {
 233         int     retval;
 234
 235         _SEM_CHECK_VALIDITY(sem);
 236
 237         pthread_mutex_lock(&(*sem)->lock);
 238         *sval = (int)(*sem)->count;
 239         pthread_mutex_unlock(&(*sem)->lock);
 240
 241         retval = 0;
 242   RETURN:
 243         return retval;
 244 }
 245
 246 __strong_reference(_sem_init, sem_init);
 247 __strong_reference(_sem_destroy, sem_destroy);
 248 __strong_reference(_sem_open, sem_open);
 249 __strong_reference(_sem_close, sem_close);
 250 __strong_reference(_sem_unlink, sem_unlink);
 251 __strong_reference(_sem_wait, sem_wait);
 252 __strong_reference(_sem_trywait, sem_trywait);
 253 __strong_reference(_sem_post, sem_post);
 254 __strong_reference(_sem_getvalue, sem_getvalue);