linuxthreads/oldsemaphore.c

   1 /*
   2  * This file contains the old semaphore code that we need to
   3  * preserve for glibc-2.0 backwards compatibility. Port to glibc 2.1
   4  * done by Cristian Gafton.
   5  */
   6
   7 /* Linuxthreads - a simple clone()-based implementation of Posix        */
   8 /* threads for Linux.                                                   */
   9 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
  10 /*                                                                      */
  11 /* This program is free software; you can redistribute it and/or        */
  12 /* modify it under the terms of the GNU Library General Public License  */
  13 /* as published by the Free Software Foundation; either version 2       */
  14 /* of the License, or (at your option) any later version.               */
  15 /*                                                                      */
  16 /* This program is distributed in the hope that it will be useful,      */
  17 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
  18 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
  19 /* GNU Library General Public License for more details.                 */
  20
  21 /* Semaphores a la POSIX 1003.1b */
  22 #include <shlib-compat.h>
  23 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
  24
  25 #include <errno.h>
  26 #include "pthread.h"
  27 #include "internals.h"
  28 #include "spinlock.h"
  29 #include "restart.h"
  30 #include "queue.h"
  31
  32 typedef struct {
  33     long int sem_status;
  34     int sem_spinlock;
  35 } old_sem_t;
  36
  37 /* Maximum value the semaphore can have.  */
  38 #define SEM_VALUE_MAX   ((int) ((~0u) >> 1))
  39
  40 static inline int sem_compare_and_swap(old_sem_t *sem, long oldval, long newval)
  41 {
  42     return compare_and_swap(&sem->sem_status, oldval, newval, &sem->sem_spinlock);
  43 }
  44
  45 /* The state of a semaphore is represented by a long int encoding
  46    either the semaphore count if >= 0 and no thread is waiting on it,
  47    or the head of the list of threads waiting for the semaphore.
  48    To distinguish the two cases, we encode the semaphore count N
  49    as 2N+1, so that it has the lowest bit set.
  50
  51    A sequence of sem_wait operations on a semaphore initialized to N
  52    result in the following successive states:
  53      2N+1, 2N-1, ..., 3, 1, &first_waiting_thread, &second_waiting_thread, ...
  54 */
  55
  56 static void sem_restart_list(pthread_descr waiting);
  57
  58 int __old_sem_init(old_sem_t *sem, int pshared, unsigned int value)
  59 {
  60     if (value > SEM_VALUE_MAX) {
  61         errno = EINVAL;
  62         return -1;
  63     }
  64     if (pshared) {
  65         errno = ENOSYS;
  66         return -1;
  67     }
  68   sem->sem_spinlock = 0;
  69   sem->sem_status = ((long)value << 1) + 1;
  70   return 0;
  71 }
  72
  73 /* Function called by pthread_cancel to remove the thread from
  74    waiting inside __old_sem_wait. Here we simply unconditionally
  75    indicate that the thread is to be woken, by returning 1. */
  76
  77 static int old_sem_extricate_func(void *obj, pthread_descr th)
  78 {
  79     return 1;
  80 }
  81
  82 int __old_sem_wait(old_sem_t * sem)
  83 {
  84     long oldstatus, newstatus;
  85     volatile pthread_descr self = thread_self();
  86     pthread_descr * th;
  87     pthread_extricate_if extr;
  88
  89     /* Set up extrication interface */
  90     extr.pu_object = 0;
  91     extr.pu_extricate_func = old_sem_extricate_func;
  92
  93     while (1) {
  94         /* Register extrication interface */
  95         __pthread_set_own_extricate_if(self, &extr);
  96         do {
  97             oldstatus = sem->sem_status;
  98             if ((oldstatus & 1) && (oldstatus != 1))
  99                 newstatus = oldstatus - 2;
 100             else {
 101                 newstatus = (long) self;
 102                 self->p_nextwaiting = (pthread_descr) oldstatus;
 103             }
 104         }
 105         while (! sem_compare_and_swap(sem, oldstatus, newstatus));
 106         if (newstatus & 1) {
 107             /* We got the semaphore. */
 108           __pthread_set_own_extricate_if(self, 0);
 109             return 0;
 110         }
 111         /* Wait for sem_post or cancellation */
 112         suspend(self);
 113         __pthread_set_own_extricate_if(self, 0);
 114
 115         /* This is a cancellation point */
 116         if (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE) {
 117             /* Remove ourselves from the waiting list if we're still on it */
 118             /* First check if we're at the head of the list. */
 119             do {
 120                 oldstatus = sem->sem_status;
 121                 if (oldstatus != (long) self) break;
 122                 newstatus = (long) self->p_nextwaiting;
 123             }
 124             while (! sem_compare_and_swap(sem, oldstatus, newstatus));
 125             /* Now, check if we're somewhere in the list.
 126                There's a race condition with sem_post here, but it does not matter:
 127                the net result is that at the time pthread_exit is called,
 128                self is no longer reachable from sem->sem_status. */
 129             if (oldstatus != (long) self && (oldstatus & 1) == 0) {
 130                 for (th = &(((pthread_descr) oldstatus)->p_nextwaiting);
 131                      *th != NULL && *th != (pthread_descr) 1;
 132                      th = &((*th)->p_nextwaiting)) {
 133                     if (*th == self) {
 134                         *th = self->p_nextwaiting;
 135                         break;
 136                     }
 137                 }
 138             }
 139             pthread_exit(PTHREAD_CANCELED);
 140         }
 141     }
 142 }
 143
 144 int __old_sem_trywait(old_sem_t * sem)
 145 {
 146   long oldstatus, newstatus;
 147
 148   do {
 149     oldstatus = sem->sem_status;
 150     if ((oldstatus & 1) == 0 || (oldstatus == 1)) {
 151       errno = EAGAIN;
 152       return -1;
 153     }
 154     newstatus = oldstatus - 2;
 155   }
 156   while (! sem_compare_and_swap(sem, oldstatus, newstatus));
 157   return 0;
 158 }
 159
 160 int __old_sem_post(old_sem_t * sem)
 161 {
 162   long oldstatus, newstatus;
 163
 164   do {
 165     oldstatus = sem->sem_status;
 166     if ((oldstatus & 1) == 0)
 167       newstatus = 3;
 168     else {
 169       if (oldstatus >= SEM_VALUE_MAX) {
 170         /* Overflow */
 171         errno = ERANGE;
 172         return -1;
 173       }
 174       newstatus = oldstatus + 2;
 175     }
 176   }
 177   while (! sem_compare_and_swap(sem, oldstatus, newstatus));
 178   if ((oldstatus & 1) == 0)
 179     sem_restart_list((pthread_descr) oldstatus);
 180   return 0;
 181 }
 182
 183 int __old_sem_getvalue(old_sem_t * sem, int * sval)
 184 {
 185   long status = sem->sem_status;
 186   if (status & 1)
 187     *sval = (int)((unsigned long) status >> 1);
 188   else
 189     *sval = 0;
 190   return 0;
 191 }
 192
 193 int __old_sem_destroy(old_sem_t * sem)
 194 {
 195   if ((sem->sem_status & 1) == 0) {
 196     errno = EBUSY;
 197     return -1;
 198   }
 199   return 0;
 200 }
 201
 202 /* Auxiliary function for restarting all threads on a waiting list,
 203    in priority order. */
 204
 205 static void sem_restart_list(pthread_descr waiting)
 206 {
 207   pthread_descr th, towake, *p;
 208
 209   /* Sort list of waiting threads by decreasing priority (insertion sort) */
 210   towake = NULL;
 211   while (waiting != (pthread_descr) 1) {
 212     th = waiting;
 213     waiting = waiting->p_nextwaiting;
 214     p = &towake;
 215     while (*p != NULL && th->p_priority < (*p)->p_priority)
 216       p = &((*p)->p_nextwaiting);
 217     th->p_nextwaiting = *p;
 218     *p = th;
 219   }
 220   /* Wake up threads in priority order */
 221   while (towake != NULL) {
 222     th = towake;
 223     towake = towake->p_nextwaiting;
 224     th->p_nextwaiting = NULL;
 225     restart(th);
 226   }
 227 }
 228
 229 compat_symbol (libpthread, __old_sem_init, sem_init, GLIBC_2_0);
 230 compat_symbol (libpthread, __old_sem_wait, sem_wait, GLIBC_2_0);
 231 compat_symbol (libpthread, __old_sem_trywait, sem_trywait, GLIBC_2_0);
 232 compat_symbol (libpthread, __old_sem_post, sem_post, GLIBC_2_0);
 233 compat_symbol (libpthread, __old_sem_getvalue, sem_getvalue, GLIBC_2_0);
 234 compat_symbol (libpthread, __old_sem_destroy, sem_destroy, GLIBC_2_0);
 235
 236 #endif