Subversion Repositories openrisc

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

/* threads for Linux.                                                   */

/* Copyright (C) 1998 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.                 */

#include <bits/initspin.h>

/* There are 2 compare and swap synchronization primitives with

   different semantics:

        1. compare_and_swap, which has acquire semantics (i.e. it

        completes befor subsequent writes.)

        2. compare_and_swap_with_release_semantics, which has release

        semantics (it completes after previous writes.)

   For those platforms on which they are the same. HAS_COMPARE_AND_SWAP

   should be defined. For those platforms on which they are different,

   HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS has to be defined.  */

#ifndef HAS_COMPARE_AND_SWAP

#ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS

#define HAS_COMPARE_AND_SWAP

#endif

#endif

#if defined(TEST_FOR_COMPARE_AND_SWAP)

extern int __pthread_has_cas;

extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,

                                      int * spinlock);

static inline int compare_and_swap(long * ptr, long oldval, long newval,

                                   int * spinlock)

{

  if (__builtin_expect (__pthread_has_cas, 1))

    return __compare_and_swap(ptr, oldval, newval);

  else

    return __pthread_compare_and_swap(ptr, oldval, newval, spinlock);

}

#elif defined(HAS_COMPARE_AND_SWAP)

#ifdef IMPLEMENT_TAS_WITH_CAS

#define testandset(p) !__compare_and_swap((long int *) p, 0, 1)

#endif

#ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS

static inline int

compare_and_swap_with_release_semantics (long * ptr, long oldval,

                                         long newval, int * spinlock)

{

  return __compare_and_swap_with_release_semantics (ptr, oldval,

                                                    newval);

}

#endif

static inline int compare_and_swap(long * ptr, long oldval, long newval,

                                   int * spinlock)

{

  return __compare_and_swap(ptr, oldval, newval);

}

#else

extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,

                                      int * spinlock);

static inline int compare_and_swap(long * ptr, long oldval, long newval,

                                   int * spinlock)

{

  return __pthread_compare_and_swap(ptr, oldval, newval, spinlock);

}

#endif

#ifndef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS

#define compare_and_swap_with_release_semantics compare_and_swap

#define __compare_and_swap_with_release_semantics __compare_and_swap

#endif

/* Internal locks */

extern void internal_function __pthread_lock(struct _pthread_fastlock * lock,

                                             pthread_descr self);

extern int __pthread_unlock(struct _pthread_fastlock *lock);

static inline void __pthread_init_lock(struct _pthread_fastlock * lock)

{

  lock->__status = 0;

  lock->__spinlock = __LT_SPINLOCK_INIT;

}

static inline int __pthread_trylock (struct _pthread_fastlock * lock)

{

#if defined TEST_FOR_COMPARE_AND_SWAP

  if (!__pthread_has_cas)

#endif

#if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP

  {

    return (testandset(&lock->__spinlock) ? EBUSY : 0);

  }

#endif

#if defined HAS_COMPARE_AND_SWAP

  do {

    if (lock->__status != 0) return EBUSY;

  } while(! __compare_and_swap(&lock->__status, 0, 1));

  return 0;

#endif

}

/* Variation of internal lock used for pthread_mutex_t, supporting

   timed-out waits.  Warning: do not mix these operations with the above ones

   over the same lock object! */

extern void __pthread_alt_lock(struct _pthread_fastlock * lock,

                               pthread_descr self);

extern int __pthread_alt_timedlock(struct _pthread_fastlock * lock,

                               pthread_descr self, const struct timespec *abstime);

extern void __pthread_alt_unlock(struct _pthread_fastlock *lock);

static inline void __pthread_alt_init_lock(struct _pthread_fastlock * lock)

{

  lock->__status = 0;

  lock->__spinlock = __LT_SPINLOCK_INIT;

}

static inline int __pthread_alt_trylock (struct _pthread_fastlock * lock)

{

#if defined TEST_FOR_COMPARE_AND_SWAP

  if (!__pthread_has_cas)

#endif

#if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP

  {

    int res = EBUSY;

    if (testandset(&lock->__spinlock) == 0)

      {

        if (lock->__status == 0)

          {

            lock->__status = 1;

            WRITE_MEMORY_BARRIER();

            res = 0;

          }

        lock->__spinlock = __LT_SPINLOCK_INIT;

      }

    return res;

  }

#endif

#if defined HAS_COMPARE_AND_SWAP

  do {

    if (lock->__status != 0) return EBUSY;

  } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));

  return 0;

#endif

}

/* Operations on pthread_atomic, which is defined in internals.h */

static inline long atomic_increment(struct pthread_atomic *pa)

{

    long oldval;

    do {

        oldval = pa->p_count;

    } while (!compare_and_swap(&pa->p_count, oldval, oldval + 1, &pa->p_spinlock));

    return oldval;

}

static inline long atomic_decrement(struct pthread_atomic *pa)

{

    long oldval;

    do {

        oldval = pa->p_count;

    } while (!compare_and_swap(&pa->p_count, oldval, oldval - 1, &pa->p_spinlock));

    return oldval;

}

static inline void

__pthread_set_own_extricate_if (pthread_descr self, pthread_extricate_if *peif)

{

  /* Only store a non-null peif if the thread has cancellation enabled.

     Otherwise pthread_cancel will unconditionally call the extricate handler,

     and restart the thread giving rise to forbidden spurious wakeups. */

  if (peif == NULL

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

    {

      /* If we are removing the extricate interface, we need to synchronize

         against pthread_cancel so that it does not continue with a pointer

         to a deallocated pthread_extricate_if struct! The thread lock

         is (ab)used for this synchronization purpose. */

      if (peif == NULL)

        __pthread_lock (THREAD_GETMEM(self, p_lock), self);

      THREAD_SETMEM(self, p_extricate, peif);

      if (peif == NULL)

        __pthread_unlock (THREAD_GETMEM(self, p_lock));

    }

}