compiler/pthread/semaphore.c

   1 /*
   2     Copyright (C) 2015 Szilard Biro
   3
   4     This software is provided 'as-is', without any express or implied
   5     warranty. In no event will the authors be held liable for any damages
   6     arising from the use of this software.
   7
   8     Permission is granted to anyone to use this software for any purpose,
   9     including commercial applications, and to alter it and redistribute it
  10     freely, subject to the following restrictions:
  11
  12     1. The origin of this software must not be misrepresented; you must not
  13          claim that you wrote the original software. If you use this software
  14          in a product, an acknowledgment in the product documentation would be
  15          appreciated but is not required.
  16     2. Altered source versions must be plainly marked as such, and must not be
  17          misrepresented as being the original software.
  18     3. This notice may not be removed or altered from any source distribution.
  19 */
  20
  21 #include <proto/exec.h>
  22
  23 #include <stdlib.h>
  24 #include <fcntl.h>
  25
  26 #include "semaphore.h"
  27 #include "debug.h"
  28
  29 #ifndef EOVERFLOW
  30 #define EOVERFLOW EINVAL
  31 #endif
  32
  33 static struct List semaphores;
  34 static struct SignalSemaphore sema_sem;
  35 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
  36
  37 static void _Init_Semaphore(void)
  38 {
  39     DB2(bug("%s()\n", __FUNCTION__));
  40
  41     InitSemaphore(&sema_sem);
  42     NEWLIST(&semaphores);
  43 }
  44
  45 sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value)
  46 {
  47     sem_t *sem;
  48
  49     D(bug("%s(%s, %d, %u, %u)\n", __FUNCTION__, name, oflag, mode, value));
  50
  51     pthread_once(&once_control, _Init_Semaphore);
  52
  53     if (name == NULL)
  54     {
  55         errno = EINVAL;
  56         return SEM_FAILED;
  57     }
  58
  59     ObtainSemaphore(&sema_sem);
  60     sem = (sem_t *)FindName(&semaphores, (STRPTR)name);
  61     if (sem != NULL)
  62     {
  63         if ((oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
  64         {
  65             ReleaseSemaphore(&sema_sem);
  66             errno = EEXIST;
  67             return SEM_FAILED;
  68         }
  69     }
  70     else
  71     {
  72         if (!(oflag & O_CREAT))
  73         {
  74             ReleaseSemaphore(&sema_sem);
  75             errno = ENOENT;
  76             return SEM_FAILED;
  77         }
  78
  79         sem = malloc(sizeof(sem_t));
  80         if (sem == NULL)
  81         {
  82             ReleaseSemaphore(&sema_sem);
  83             errno = ENOMEM;
  84             return SEM_FAILED;
  85         }
  86
  87         if (sem_init(sem, 0, value))
  88         {
  89             free(sem);
  90             ReleaseSemaphore(&sema_sem);
  91             return SEM_FAILED;
  92         }
  93         // TODO: this string should be duplicated
  94         sem->node.ln_Name = (char *)name;
  95         AddTail(&semaphores, (struct Node *)sem);
  96     }
  97     ReleaseSemaphore(&sema_sem);
  98
  99     return sem;
 100 }
 101
 102 int sem_close(sem_t *sem)
 103 {
 104     D(bug("%s(%p)\n", __FUNCTION__, sem));
 105
 106     return 0;
 107 }
 108
 109 int sem_unlink(const char *name)
 110 {
 111     sem_t *sem;
 112
 113     D(bug("%s(%s)\n", __FUNCTION__, name));
 114
 115     pthread_once(&once_control, _Init_Semaphore);
 116
 117     if (name == NULL)
 118     {
 119         errno = EINVAL;
 120         return -1;
 121     }
 122
 123     ObtainSemaphore(&sema_sem);
 124     sem = (sem_t *)FindName(&semaphores, (STRPTR)name);
 125
 126     if (sem == NULL)
 127     {
 128         ReleaseSemaphore(&sema_sem);
 129         errno = ENOENT;
 130         return -1;
 131     }
 132
 133     if (sem_destroy(sem) != 0)
 134     {
 135         ReleaseSemaphore(&sema_sem);
 136         return -1;
 137     }
 138
 139     Remove((struct Node *)sem);
 140     free(sem);
 141     ReleaseSemaphore(&sema_sem);
 142
 143     return 0;
 144 }
 145
 146 int sem_init(sem_t *sem, int pshared, unsigned int value)
 147 {
 148     D(bug("%s(%p, %d, %u)\n", __FUNCTION__, sem, pshared, value));
 149
 150     if (sem == NULL || value > (unsigned int)SEM_VALUE_MAX)
 151     {
 152         errno = EINVAL;
 153         return -1;
 154     }
 155
 156     sem->value = value;
 157     sem->waiters_count = 0;
 158     pthread_mutex_init(&sem->lock, NULL);
 159     pthread_cond_init(&sem->count_nonzero, NULL);
 160
 161     return 0;
 162 }
 163
 164 int sem_destroy(sem_t *sem)
 165 {
 166     D(bug("%s(%p)\n", __FUNCTION__, sem));
 167
 168     if (sem == NULL)
 169     {
 170         errno = EINVAL;
 171         return -1;
 172     }
 173
 174     if (pthread_mutex_trylock(&sem->lock) != 0)
 175     {
 176         errno = EBUSY;
 177         return -1;
 178     }
 179
 180     pthread_mutex_unlock(&sem->lock);
 181     pthread_mutex_destroy(&sem->lock);
 182     pthread_cond_destroy(&sem->count_nonzero);
 183     sem->value = sem->waiters_count = 0;
 184
 185     return 0;
 186 }
 187
 188 int sem_trywait(sem_t *sem)
 189 {
 190     int result = 0;
 191
 192     D(bug("%s(%p)\n", __FUNCTION__, sem));
 193
 194     if (sem == NULL)
 195     {
 196         errno = EINVAL;
 197         return -1;
 198     }
 199
 200     pthread_mutex_lock(&sem->lock);
 201
 202     if (sem->value > 0)
 203         sem->value--;
 204     else
 205         result = EAGAIN;
 206
 207     pthread_mutex_unlock(&sem->lock);
 208
 209     if (result != 0)
 210     {
 211         errno = result;
 212         return -1;
 213     }
 214
 215     return 0;
 216 }
 217
 218 int sem_timedwait(sem_t *sem, const struct timespec *abstime)
 219 {
 220     int result = 0;
 221
 222     D(bug("%s(%p, %p)\n", __FUNCTION__, sem, abstime));
 223
 224     if (sem == NULL)
 225     {
 226         errno = EINVAL;
 227         return -1;
 228     }
 229
 230     pthread_mutex_lock(&sem->lock);
 231
 232     sem->waiters_count++;
 233
 234     while (sem->value == 0 && result == 0)
 235         result = pthread_cond_timedwait(&sem->count_nonzero, &sem->lock, abstime);
 236
 237     sem->waiters_count--;
 238
 239     if (result != 0)
 240     {
 241         pthread_mutex_unlock(&sem->lock);
 242         errno = result;
 243         return -1;
 244     }
 245
 246     sem->value--;
 247
 248     pthread_mutex_unlock(&sem->lock);
 249
 250     return 0;
 251 }
 252
 253 int sem_wait(sem_t *sem)
 254 {
 255     D(bug("%s(%p)\n", __FUNCTION__, sem));
 256
 257     return sem_timedwait(sem, NULL);
 258 }
 259
 260 int sem_post(sem_t *sem)
 261 {
 262     D(bug("%s(%p)\n", __FUNCTION__, sem));
 263
 264     if (sem == NULL)
 265     {
 266         errno = EINVAL;
 267         return -1;
 268     }
 269
 270     pthread_mutex_lock(&sem->lock);
 271
 272     if (sem->value >= SEM_VALUE_MAX)
 273     {
 274         pthread_mutex_unlock(&sem->lock);
 275         errno = EOVERFLOW;
 276         return -1;
 277     }
 278
 279     sem->value++;
 280
 281     if (sem->waiters_count > 0)
 282         pthread_cond_signal(&sem->count_nonzero);
 283
 284     pthread_mutex_unlock(&sem->lock);
 285
 286     return 0;
 287 }
 288
 289 int sem_getvalue(sem_t *sem, int *sval)
 290 {
 291     D(bug("%s(%p)\n", __FUNCTION__, sem));
 292
 293     if (sem == NULL || sval == NULL)
 294     {
 295         errno = EINVAL;
 296         return -1;
 297     }
 298
 299     // if one or more threads are waiting to lock the semaphore,
 300     // then return the negative of the waiters
 301     if (pthread_mutex_trylock(&sem->lock) == 0)
 302     {
 303         if (sem->lock.incond)
 304             *sval = -sem->waiters_count;
 305         else
 306             *sval = sem->value;
 307         pthread_mutex_unlock(&sem->lock);
 308     }
 309     else
 310     {
 311         // TODO: should I lock the mutex here?
 312         *sval = -sem->waiters_count;
 313     }
 314
 315     return 0;
 316 }