home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-sh64 / semaphore-helper.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  2.4 KB  |  102 lines

  1. #ifndef __ASM_SH64_SEMAPHORE_HELPER_H
  2. #define __ASM_SH64_SEMAPHORE_HELPER_H
  3.  
  4. /*
  5.  * This file is subject to the terms and conditions of the GNU General Public
  6.  * License.  See the file "COPYING" in the main directory of this archive
  7.  * for more details.
  8.  *
  9.  * include/asm-sh64/semaphore-helper.h
  10.  *
  11.  * Copyright (C) 2000, 2001  Paolo Alberelli
  12.  *
  13.  */
  14. #include <asm/errno.h>
  15.  
  16. /*
  17.  * SMP- and interrupt-safe semaphores helper functions.
  18.  *
  19.  * (C) Copyright 1996 Linus Torvalds
  20.  * (C) Copyright 1999 Andrea Arcangeli
  21.  */
  22.  
  23. /*
  24.  * These two _must_ execute atomically wrt each other.
  25.  *
  26.  * This is trivially done with load_locked/store_cond,
  27.  * which we have.  Let the rest of the losers suck eggs.
  28.  */
  29. static __inline__ void wake_one_more(struct semaphore * sem)
  30. {
  31.     atomic_inc((atomic_t *)&sem->sleepers);
  32. }
  33.  
  34. static __inline__ int waking_non_zero(struct semaphore *sem)
  35. {
  36.     unsigned long flags;
  37.     int ret = 0;
  38.  
  39.     spin_lock_irqsave(&semaphore_wake_lock, flags);
  40.     if (sem->sleepers > 0) {
  41.         sem->sleepers--;
  42.         ret = 1;
  43.     }
  44.     spin_unlock_irqrestore(&semaphore_wake_lock, flags);
  45.     return ret;
  46. }
  47.  
  48. /*
  49.  * waking_non_zero_interruptible:
  50.  *    1    got the lock
  51.  *    0    go to sleep
  52.  *    -EINTR    interrupted
  53.  *
  54.  * We must undo the sem->count down_interruptible() increment while we are
  55.  * protected by the spinlock in order to make atomic this atomic_inc() with the
  56.  * atomic_read() in wake_one_more(), otherwise we can race. -arca
  57.  */
  58. static __inline__ int waking_non_zero_interruptible(struct semaphore *sem,
  59.                         struct task_struct *tsk)
  60. {
  61.     unsigned long flags;
  62.     int ret = 0;
  63.  
  64.     spin_lock_irqsave(&semaphore_wake_lock, flags);
  65.     if (sem->sleepers > 0) {
  66.         sem->sleepers--;
  67.         ret = 1;
  68.     } else if (signal_pending(tsk)) {
  69.         atomic_inc(&sem->count);
  70.         ret = -EINTR;
  71.     }
  72.     spin_unlock_irqrestore(&semaphore_wake_lock, flags);
  73.     return ret;
  74. }
  75.  
  76. /*
  77.  * waking_non_zero_trylock:
  78.  *    1    failed to lock
  79.  *    0    got the lock
  80.  *
  81.  * We must undo the sem->count down_trylock() increment while we are
  82.  * protected by the spinlock in order to make atomic this atomic_inc() with the
  83.  * atomic_read() in wake_one_more(), otherwise we can race. -arca
  84.  */
  85. static __inline__ int waking_non_zero_trylock(struct semaphore *sem)
  86. {
  87.     unsigned long flags;
  88.     int ret = 1;
  89.  
  90.     spin_lock_irqsave(&semaphore_wake_lock, flags);
  91.     if (sem->sleepers <= 0)
  92.         atomic_inc(&sem->count);
  93.     else {
  94.         sem->sleepers--;
  95.         ret = 0;
  96.     }
  97.     spin_unlock_irqrestore(&semaphore_wake_lock, flags);
  98.     return ret;
  99. }
  100.  
  101. #endif /* __ASM_SH64_SEMAPHORE_HELPER_H */
  102.