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  */
  31
  32 #include <sys/semaphore.h>
  33
  34 #include <stdlib.h>
  35 #include <errno.h>
  36 #include <pthread.h>
  37
  38 #include "pthread_private.h"
  39
  40 #define _SEM_CHECK_VALIDITY(sem)                \
  41         if ((sem) == NULL || *(sem) == NULL ||  \
  42             (*(sem))->magic != SEM_MAGIC) {     \
  43                 errno = EINVAL;                 \
  44                 retval = -1;                    \
  45                 goto RETURN;                    \
  46         }
  47
  48 int
  49 _sem_init(sem_t *sem, int pshared, unsigned int value)
  50 {
  51         int     retval;
  52
  53         /*
  54          * Range check the arguments.
  55          */
  56         if (pshared != 0) {
  57                 /*
  58                  * The user wants a semaphore that can be shared among
  59                  * processes, which this implementation can't do.  Sounds like a
  60                  * permissions problem to me (yeah right).
  61                  */
  62                 errno = EPERM;
  63                 retval = -1;
  64                 goto RETURN;
  65         }
  66
  67         if (value > SEM_VALUE_MAX) {
  68                 errno = EINVAL;
  69                 retval = -1;
  70                 goto RETURN;
  71         }
  72
  73         *sem = (sem_t)malloc(sizeof(struct sem));
  74         if (*sem == NULL) {
  75                 errno = ENOSPC;
  76                 retval = -1;
  77                 goto RETURN;
  78         }
  79
  80         /*
  81          * Initialize the semaphore.
  82          */
  83         if (pthread_mutex_init(&(*sem)->lock, NULL) != 0) {
  84                 free(*sem);
  85                 errno = ENOSPC;
  86                 retval = -1;
  87                 goto RETURN;
  88         }
  89
  90         if (pthread_cond_init(&(*sem)->gtzero, NULL) != 0) {
  91                 pthread_mutex_destroy(&(*sem)->lock);
  92                 free(*sem);
  93                 errno = ENOSPC;
  94                 retval = -1;
  95                 goto RETURN;
  96         }
  97
  98         (*sem)->count = (u_int32_t)value;
  99         (*sem)->nwaiters = 0;
 100         (*sem)->magic = SEM_MAGIC;
 101
 102         retval = 0;
 103   RETURN:
 104         return retval;
 105 }
 106
 107 int
 108 _sem_destroy(sem_t *sem)
 109 {
 110         int     retval;
 111
 112         _SEM_CHECK_VALIDITY(sem);
 113
 114         /* Make sure there are no waiters. */
 115         pthread_mutex_lock(&(*sem)->lock);
 116         if ((*sem)->nwaiters > 0) {
 117                 pthread_mutex_unlock(&(*sem)->lock);
 118                 errno = EBUSY;
 119                 retval = -1;
 120                 goto RETURN;
 121         }
 122         pthread_mutex_unlock(&(*sem)->lock);
 123
 124         pthread_mutex_destroy(&(*sem)->lock);
 125         pthread_cond_destroy(&(*sem)->gtzero);
 126         (*sem)->magic = 0;
 127
 128         free(*sem);
 129
 130         retval = 0;
 131   RETURN:
 132         return retval;
 133 }
 134
 135 sem_t *
 136 _sem_open(const char *name, int oflag, ...)
 137 {
 138         errno = ENOSYS;
 139         return SEM_FAILED;
 140 }
 141
 142 int
 143 _sem_close(sem_t *sem)
 144 {
 145         errno = ENOSYS;
 146         return -1;
 147 }
 148
 149 int
 150 _sem_unlink(const char *name)
 151 {
 152         errno = ENOSYS;
 153         return -1;
 154 }
 155
 156 int
 157 _sem_wait(sem_t *sem)
 158 {
 159         int     retval;
 160
 161         _thread_enter_cancellation_point();
 162
 163         _SEM_CHECK_VALIDITY(sem);
 164
 165         pthread_mutex_lock(&(*sem)->lock);
 166
 167         while ((*sem)->count == 0) {
 168                 (*sem)->nwaiters++;
 169                 pthread_cond_wait(&(*sem)->gtzero, &(*sem)->lock);
 170                 (*sem)->nwaiters--;
 171         }
 172         (*sem)->count--;
 173
 174         pthread_mutex_unlock(&(*sem)->lock);
 175
 176         retval = 0;
 177   RETURN:
 178         _thread_leave_cancellation_point();
 179         return retval;
 180 }
 181
 182 int
 183 _sem_trywait(sem_t *sem)
 184 {
 185         int     retval;
 186
 187         _SEM_CHECK_VALIDITY(sem);
 188
 189         pthread_mutex_lock(&(*sem)->lock);
 190
 191         if ((*sem)->count > 0) {
 192                 (*sem)->count--;
 193                 retval = 0;
 194         } else {
 195                 errno = EAGAIN;
 196                 retval = -1;
 197         }
 198
 199         pthread_mutex_unlock(&(*sem)->lock);
 200
 201   RETURN:
 202         return retval;
 203 }
 204
 205 int
 206 _sem_post(sem_t *sem)
 207 {
 208         int     retval;
 209
 210         _SEM_CHECK_VALIDITY(sem);
 211
 212         /*
 213          * sem_post() is required to be safe to call from within signal
 214          * handlers.  Thus, we must defer signals.
 215          */
 216         _thread_kern_sig_defer();
 217
 218         pthread_mutex_lock(&(*sem)->lock);
 219
 220         (*sem)->count++;
 221         if ((*sem)->nwaiters > 0)
 222                 pthread_cond_signal(&(*sem)->gtzero);
 223
 224         pthread_mutex_unlock(&(*sem)->lock);
 225
 226         _thread_kern_sig_undefer();
 227         retval = 0;
 228   RETURN:
 229         return retval;
 230 }
 231
 232 int
 233 _sem_getvalue(sem_t *sem, int *sval)
 234 {
 235         int     retval;
 236
 237         _SEM_CHECK_VALIDITY(sem);
 238
 239         pthread_mutex_lock(&(*sem)->lock);
 240         *sval = (int)(*sem)->count;
 241         pthread_mutex_unlock(&(*sem)->lock);
 242
 243         retval = 0;
 244   RETURN:
 245         return retval;
 246 }
 247
 248 __strong_reference(_sem_init, sem_init);
 249 __strong_reference(_sem_destroy, sem_destroy);
 250 __strong_reference(_sem_open, sem_open);
 251 __strong_reference(_sem_close, sem_close);
 252 __strong_reference(_sem_unlink, sem_unlink);
 253 __strong_reference(_sem_wait, sem_wait);
 254 __strong_reference(_sem_trywait, sem_trywait);
 255 __strong_reference(_sem_post, sem_post);
 256 __strong_reference(_sem_getvalue, sem_getvalue);