nptl/sysdeps/unix/sysv/linux/sh/lowlevellock.h

   1 /* Copyright (C) 2003 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, write to the Free
  16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17    02111-1307 USA.  */
  18
  19 #ifndef _LOWLEVELLOCK_H
  20 #define _LOWLEVELLOCK_H 1
  21
  22 #include <time.h>
  23 #include <sys/param.h>
  24 #include <bits/pthreadtypes.h>
  25
  26 #define SYS_futex               240
  27 #define FUTEX_WAIT              0
  28 #define FUTEX_WAKE              1
  29
  30
  31 /* Initializer for compatibility lock.  */
  32 #define LLL_MUTEX_LOCK_INITIALIZER (0)
  33
  34 extern int __lll_mutex_lock_wait (int val, int *__futex) attribute_hidden;
  35 extern int __lll_mutex_timedlock_wait (int val, int *__futex,
  36                                        const struct timespec *abstime)
  37      attribute_hidden;
  38 extern int __lll_mutex_unlock_wake (int *__futex) attribute_hidden;
  39
  40
  41 #define lll_mutex_trylock(futex) \
  42   ({ unsigned char __result; \
  43      __asm __volatile ("\
  44         .align 2\n\
  45         mova 1f,r0\n\
  46         nop\n\
  47         mov r15,r1\n\
  48         mov #-8,r15\n\
  49      0: mov.l @%1,r2\n\
  50         cmp/eq r2,%3\n\
  51         bf 1f\n\
  52         mov.l %2,@%1\n\
  53      1: mov r1,r15\n\
  54         mov #-1,%0\n\
  55         negc %0,%0"\
  56         : "=r" (__result) : "r" (&(futex)), "r" (1), "r" (0) \
  57         : "r0", "r1", "r2", "t", "memory"); \
  58      __result; })
  59
  60 #define lll_mutex_lock(futex) \
  61   (void) ({ int __result, val, *__futex = &(futex); \
  62             __asm __volatile ("\
  63                 .align 2\n\
  64                 mova 1f,r0\n\
  65                 mov r15,r1\n\
  66                 mov #-6,r15\n\
  67              0: mov.l @%2,%0\n\
  68                 add %0,%1\n\
  69                 mov.l %1,@%2\n\
  70              1: mov r1,r15"\
  71                 : "=&r" (__result), "=&r" (val) : "r" (__futex), "1" (1) \
  72                 : "r0", "r1", "memory"); \
  73             if (__result) \
  74               __lll_mutex_lock_wait (__result, __futex); })
  75
  76 #define lll_mutex_timedlock(futex, timeout) \
  77   ({ int __result, val, *__futex = &(futex); \
  78      __asm __volatile ("\
  79         .align 2\n\
  80         mova 1f,r0\n\
  81         mov r15,r1\n\
  82         mov #-6,r15\n\
  83      0: mov.l @%2,%0\n\
  84         add %0,%1\n\
  85         mov.l %1,@%2\n\
  86      1: mov r1,r15"\
  87         : "=&r" (__result), "=&r" (val) : "r" (__futex), "1" (1) \
  88         : "r0", "r1", "memory"); \
  89     if (__result) \
  90       __result = __lll_mutex_timedlock_wait (__result, __futex, timeout); \
  91     __result; })
  92
  93 #define lll_mutex_unlock(futex) \
  94   (void) ({ int __result, *__futex = &(futex); \
  95             __asm __volatile ("\
  96                 .align 2\n\
  97                 mova 1f,r0\n\
  98                 mov r15,r1\n\
  99                 mov #-6,r15\n\
 100              0: mov.l @%1,%0\n\
 101                 add #-1,%0\n\
 102                 mov.l %0,@%1\n\
 103              1: mov r1,r15"\
 104                 : "=&r" (__result) : "r" (__futex) \
 105                 : "r0", "r1", "memory"); \
 106             if (__result) \
 107               __lll_mutex_unlock_wake (__futex); })
 108
 109 #define lll_mutex_islocked(futex) \
 110   (futex != 0)
 111
 112
 113 /* We have a separate internal lock implementation which is not tied
 114    to binary compatibility.  */
 115
 116 /* Type for lock object.  */
 117 typedef int lll_lock_t;
 118
 119 /* Initializers for lock.  */
 120 #define LLL_LOCK_INITIALIZER            (1)
 121 #define LLL_LOCK_INITIALIZER_LOCKED     (0)
 122
 123
 124 extern int __lll_lock_wait (int val, int *__futex) attribute_hidden;
 125 extern int __lll_unlock_wake (int *__futex) attribute_hidden;
 126 extern int lll_unlock_wake_cb (int *__futex) attribute_hidden;
 127
 128
 129 /* The states of a lock are:
 130     1  -  untaken
 131     0  -  taken by one user
 132    <0  -  taken by more users */
 133
 134
 135 #define lll_trylock(futex) \
 136   ({ unsigned char __result; \
 137      __asm __volatile ("\
 138         .align 2\n\
 139         mova 1f,r0\n\
 140         nop\n\
 141         mov r15,r1\n\
 142         mov #-8,r15\n\
 143      0: mov.l @%1,r2\n\
 144         cmp/eq r2,%3\n\
 145         bf 1f\n\
 146         mov.l %2,@%1\n\
 147      1: mov r1,r15\n\
 148         mov #-1,%0\n\
 149         negc %0,%0"\
 150         : "=r" (__result) : "r" (&(futex)), "r" (0), "r" (1) \
 151         : "r0", "r1", "r2", "t", "memory"); \
 152      __result; })
 153
 154 #define lll_lock(futex) \
 155   (void) ({ int __result, val, *__futex = &(futex); \
 156             __asm __volatile ("\
 157                 .align 2\n\
 158                 mova 1f,r0\n\
 159                 mov r15,r1\n\
 160                 mov #-6,r15\n\
 161              0: mov.l @%2,%0\n\
 162                 add %0,%1\n\
 163                 mov.l %1,@%2\n\
 164              1: mov r1,r15"\
 165                 : "=&r" (__result), "=&r" (val) : "r" (__futex), "1" (-1) \
 166                 : "r0", "r1", "memory"); \
 167             if (val < 0) \
 168               __lll_lock_wait (__result, __futex); })
 169
 170 #define lll_unlock(futex) \
 171   (void) ({ int __result, *__futex = &(futex); \
 172             __asm __volatile ("\
 173                 .align 2\n\
 174                 mova 1f,r0\n\
 175                 mov r15,r1\n\
 176                 mov #-6,r15\n\
 177              0: mov.l @%1,%0\n\
 178                 add #1,%0\n\
 179                 mov.l %0,@%1\n\
 180              1: mov r1,r15"\
 181                 : "=&r" (__result) : "r" (__futex) \
 182                 : "r0", "r1", "memory"); \
 183             if (__result <= 0) \
 184               __lll_unlock_wake (__futex); })
 185
 186 #define lll_islocked(futex) \
 187   (futex <= 0)
 188
 189
 190 /* The kernel notifies a process with uses CLONE_CLEARTID via futex
 191    wakeup when the clone terminates.  The memory location contains the
 192    thread ID while the clone is running and is reset to zero
 193    afterwards.  */
 194
 195 extern int __lll_wait_tid (int *tid) attribute_hidden;
 196 #define lll_wait_tid(tid) \
 197   do { \
 198     __typeof (tid) *__tid = &(tid); \
 199     if (*__tid != 0) \
 200       __lll_wait_tid (__tid); \
 201   } while (0)
 202
 203 extern int __lll_timedwait_tid (int *tid, const struct timespec *abstime)
 204      attribute_hidden;
 205 #define lll_timedwait_tid(tid, abstime) \
 206   ({ \
 207     int __result = 0; \
 208     if (tid != 0) \
 209       { \
 210         if (abstime == NULL || abstime->tv_nsec >= 1000000000) \
 211           __result = EINVAL; \
 212         else \
 213           __result = __lll_timedwait_tid (&tid, abstime); \
 214       } \
 215     __result; })
 216
 217
 218 extern int __lll_wake_tid (int *tid) attribute_hidden;
 219 #define lll_wake_tid(tid) \
 220   do { \
 221     (tid) = 0; \
 222     ___lll_wake_tid (&tid); \
 223   } while (0)
 224
 225
 226 /* Conditional variable handling.  */
 227
 228 extern void __lll_cond_wait (pthread_cond_t *cond) attribute_hidden;
 229 extern int __lll_cond_timedwait (pthread_cond_t *cond,
 230                                  const struct timespec *abstime)
 231      attribute_hidden;
 232 extern void __lll_cond_wake (pthread_cond_t *cond) attribute_hidden;
 233 extern void __lll_cond_broadcast (pthread_cond_t *cond) attribute_hidden;
 234
 235
 236 #define lll_cond_wait(cond) \
 237   __lll_cond_wait (cond)
 238 #define lll_cond_timedwait(cond, abstime) \
 239   __lll_cond_timedwait (cond, abstime)
 240 #define lll_cond_wake(cond) \
 241   __lll_cond_wake (cond)
 242 #define lll_cond_broadcast(cond) \
 243   __lll_cond_broadcast (cond)
 244
 245 #endif  /* lowlevellock.h */