Subversion Repositories openrisc_2011-10-31

/* Linuxthreads - a simple clone()-based implementation of Posix        */

/* threads for Linux.                                                   */

/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */

/*                                                                      */

/* This program is free software; you can redistribute it and/or        */

/* modify it under the terms of the GNU Library General Public License  */

/* as published by the Free Software Foundation; either version 2       */

/* of the License, or (at your option) any later version.               */

/*                                                                      */

/* This program is distributed in the hope that it will be useful,      */

/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */

/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */

/* GNU Library General Public License for more details.                 */

/* Semaphores a la POSIX 1003.1b */

#include <errno.h>

#include "pthread.h"

#include "semaphore.h"

#include "internals.h"

#include "spinlock.h"

#include "restart.h"

#include "queue.h"

#include <shlib-compat.h>

int __new_sem_init(sem_t *sem, int pshared, unsigned int value)

{

  if (value > SEM_VALUE_MAX) {

    errno = EINVAL;

    return -1;

  }

  if (pshared) {

    errno = ENOSYS;

    return -1;

  }

  __pthread_init_lock(&sem->__sem_lock);

  sem->__sem_value = value;

  sem->__sem_waiting = NULL;

  return 0;

}

/* Function called by pthread_cancel to remove the thread from

   waiting inside __new_sem_wait. */

static int new_sem_extricate_func(void *obj, pthread_descr th)

{

  volatile pthread_descr self = thread_self();

  sem_t *sem = obj;

  int did_remove = 0;

  __pthread_lock(&sem->__sem_lock, self);

  did_remove = remove_from_queue(&sem->__sem_waiting, th);

  __pthread_unlock(&sem->__sem_lock);

  return did_remove;

}

int __new_sem_wait(sem_t * sem)

{

  volatile pthread_descr self = thread_self();

  pthread_extricate_if extr;

  int already_canceled = 0;

  int spurious_wakeup_count;

  /* Set up extrication interface */

  extr.pu_object = sem;

  extr.pu_extricate_func = new_sem_extricate_func;

  __pthread_lock(&sem->__sem_lock, self);

  if (sem->__sem_value > 0) {

    sem->__sem_value--;

    __pthread_unlock(&sem->__sem_lock);

    return 0;

  }

  /* Register extrication interface */

  THREAD_SETMEM(self, p_sem_avail, 0);

  __pthread_set_own_extricate_if(self, &extr);

  /* Enqueue only if not already cancelled. */

  if (!(THREAD_GETMEM(self, p_canceled)

      && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))

    enqueue(&sem->__sem_waiting, self);

  else

    already_canceled = 1;

  __pthread_unlock(&sem->__sem_lock);

  if (already_canceled) {

    __pthread_set_own_extricate_if(self, 0);

    __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);

  }

  /* Wait for sem_post or cancellation, or fall through if already canceled */

  spurious_wakeup_count = 0;

  while (1)

    {

      suspend(self);

      if (THREAD_GETMEM(self, p_sem_avail) == 0

          && (THREAD_GETMEM(self, p_woken_by_cancel) == 0

              || THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))

        {

          /* Count resumes that don't belong to us. */

          spurious_wakeup_count++;

          continue;

        }

      break;

    }

  __pthread_set_own_extricate_if(self, 0);

  /* Terminate only if the wakeup came from cancellation. */

  /* Otherwise ignore cancellation because we got the semaphore. */

  if (THREAD_GETMEM(self, p_woken_by_cancel)

      && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {

    THREAD_SETMEM(self, p_woken_by_cancel, 0);

    __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);

  }

  /* We got the semaphore */

  return 0;

}

int __new_sem_trywait(sem_t * sem)

{

  int retval;

  __pthread_lock(&sem->__sem_lock, NULL);

  if (sem->__sem_value == 0) {

    errno = EAGAIN;

    retval = -1;

  } else {

    sem->__sem_value--;

    retval = 0;

  }

  __pthread_unlock(&sem->__sem_lock);

  return retval;

}

int __new_sem_post(sem_t * sem)

{

  pthread_descr self = thread_self();

  pthread_descr th;

  struct pthread_request request;

  if (THREAD_GETMEM(self, p_in_sighandler) == NULL) {

    __pthread_lock(&sem->__sem_lock, self);

    if (sem->__sem_waiting == NULL) {

      if (sem->__sem_value >= SEM_VALUE_MAX) {

        /* Overflow */

        errno = ERANGE;

        __pthread_unlock(&sem->__sem_lock);

        return -1;

      }

      sem->__sem_value++;

      __pthread_unlock(&sem->__sem_lock);

    } else {

      th = dequeue(&sem->__sem_waiting);

      __pthread_unlock(&sem->__sem_lock);

      th->p_sem_avail = 1;

      WRITE_MEMORY_BARRIER();

      restart(th);

    }

  } else {

    /* If we're in signal handler, delegate post operation to

       the thread manager. */

    if (__pthread_manager_request < 0) {

      if (__pthread_initialize_manager() < 0) {

        errno = EAGAIN;

        return -1;

      }

    }

    request.req_kind = REQ_POST;

    request.req_args.post = sem;

    TEMP_FAILURE_RETRY(__libc_write(__pthread_manager_request,

                                    (char *) &request, sizeof(request)));

  }

  return 0;

}

int __new_sem_getvalue(sem_t * sem, int * sval)

{

  *sval = sem->__sem_value;

  return 0;

}

int __new_sem_destroy(sem_t * sem)

{

  if (sem->__sem_waiting != NULL) {

    __set_errno (EBUSY);

    return -1;

  }

  return 0;

}

sem_t *sem_open(const char *name, int oflag, ...)

{

  __set_errno (ENOSYS);

  return SEM_FAILED;

}

int sem_close(sem_t *sem)

{

  __set_errno (ENOSYS);

  return -1;

}

int sem_unlink(const char *name)

{

  __set_errno (ENOSYS);

  return -1;

}

int sem_timedwait(sem_t *sem, const struct timespec *abstime)

{

  pthread_descr self = thread_self();

  pthread_extricate_if extr;

  int already_canceled = 0;

  int spurious_wakeup_count;

  __pthread_lock(&sem->__sem_lock, self);

  if (sem->__sem_value > 0) {

    --sem->__sem_value;

    __pthread_unlock(&sem->__sem_lock);

    return 0;

  }

  if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000) {

    /* The standard requires that if the function would block and the

       time value is illegal, the function returns with an error.  */

    __pthread_unlock(&sem->__sem_lock);

    return EINVAL;

  }

  /* Set up extrication interface */

  extr.pu_object = sem;

  extr.pu_extricate_func = new_sem_extricate_func;

  /* Register extrication interface */

  THREAD_SETMEM(self, p_sem_avail, 0);

  __pthread_set_own_extricate_if(self, &extr);

  /* Enqueue only if not already cancelled. */

  if (!(THREAD_GETMEM(self, p_canceled)

      && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))

    enqueue(&sem->__sem_waiting, self);

  else

    already_canceled = 1;

  __pthread_unlock(&sem->__sem_lock);

  if (already_canceled) {

    __pthread_set_own_extricate_if(self, 0);

    __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);

  }

  spurious_wakeup_count = 0;

  while (1)

    {

      if (timedsuspend(self, abstime) == 0) {

        int was_on_queue;

        /* __pthread_lock will queue back any spurious restarts that

           may happen to it. */

        __pthread_lock(&sem->__sem_lock, self);

        was_on_queue = remove_from_queue(&sem->__sem_waiting, self);

        __pthread_unlock(&sem->__sem_lock);

        if (was_on_queue) {

          __pthread_set_own_extricate_if(self, 0);

          return ETIMEDOUT;

        }

        /* Eat the outstanding restart() from the signaller */

        suspend(self);

      }

      if (THREAD_GETMEM(self, p_sem_avail) == 0

          && (THREAD_GETMEM(self, p_woken_by_cancel) == 0

              || THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))

        {

          /* Count resumes that don't belong to us. */

          spurious_wakeup_count++;

          continue;

        }

      break;

    }

 __pthread_set_own_extricate_if(self, 0);

  /* Terminate only if the wakeup came from cancellation. */

  /* Otherwise ignore cancellation because we got the semaphore. */

  if (THREAD_GETMEM(self, p_woken_by_cancel)

      && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {

    THREAD_SETMEM(self, p_woken_by_cancel, 0);

    __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);

  }

  /* We got the semaphore */

  return 0;

}

versioned_symbol (libpthread, __new_sem_init, sem_init, GLIBC_2_1);

versioned_symbol (libpthread, __new_sem_wait, sem_wait, GLIBC_2_1);

versioned_symbol (libpthread, __new_sem_trywait, sem_trywait, GLIBC_2_1);

versioned_symbol (libpthread, __new_sem_post, sem_post, GLIBC_2_1);

versioned_symbol (libpthread, __new_sem_getvalue, sem_getvalue, GLIBC_2_1);

versioned_symbol (libpthread, __new_sem_destroy, sem_destroy, GLIBC_2_1);