src/xcalls/condvar/lowlevellock.h File Reference

Low level futex and lock implementation. More...

#include "tls-simple.h"

Go to the source code of this file.

Defines

#define _LOWLEVELLOCK_H   1
#define LOCK_INSTR   "lock;"
#define SYS_futex   240
#define FUTEX_WAIT   0
#define FUTEX_WAKE   1
#define FUTEX_LOCK_PI   6
#define FUTEX_UNLOCK_PI   7
#define FUTEX_TRYLOCK_PI   8
#define LLL_MUTEX_LOCK_INITIALIZER   (0)
#define LLL_MUTEX_LOCK_INITIALIZER_LOCKED   (1)
#define LLL_MUTEX_LOCK_INITIALIZER_WAITERS   (2)
#define LLL_EBX_LOAD
#define LLL_EBX_REG   "b"
#define LLL_ENTER_KERNEL   "int $0x80\n\t"
#define BUSY_WAIT_NOP   asm ("rep; nop")
#define LLL_STUB_UNWIND_INFO_START
#define LLL_STUB_UNWIND_INFO_END
#define LLL_STUB_UNWIND_INFO_3
#define LLL_STUB_UNWIND_INFO_4
#define lll_futex_wait(futex, val)
#define lll_futex_timed_wait(futex, val, timeout)
#define lll_futex_wake(futex, nr)
#define lll_mutex_trylock(futex)
#define lll_robust_mutex_trylock(futex, id)
#define lll_mutex_cond_trylock(futex)
#define lll_mutex_lock(futex)
#define lll_robust_mutex_lock(futex, id)
#define lll_mutex_cond_lock(futex)
#define lll_robust_mutex_cond_lock(futex, id)
#define lll_mutex_timedlock(futex, timeout)
#define lll_robust_mutex_timedlock(futex, timeout, id)
#define lll_mutex_unlock(futex)
#define lll_robust_mutex_unlock(futex)
#define lll_robust_mutex_dead(futex)
#define lll_futex_wake(futex, nr)
#define lll_mutex_islocked(futex)   (futex != 0)
#define LLL_LOCK_INITIALIZER   (0)
#define LLL_LOCK_INITIALIZER_LOCKED   (1)
#define lll_trylock(futex)
#define lll_lock(futex)
#define lll_unlock(futex)
#define lll_islocked(futex)   (futex != LLL_LOCK_INITIALIZER)
#define lll_wait_tid(tid)
#define lll_timedwait_tid(tid, abstime)
#define lll_cond_wait(cond)   __lll_cond_wait (cond)
#define lll_cond_timedwait(cond, abstime)   __lll_cond_timedwait (cond, abstime)
#define lll_cond_wake(cond)   __lll_cond_wake (cond)
#define lll_cond_broadcast(cond)   __lll_cond_broadcast (cond)

Typedefs

typedef int lll_lock_t

Functions

int __lll_mutex_lock_wait (int val, int *__futex) __attribute((regparm(2)))
int __lll_mutex_timedlock_wait (int val, int *__futex, const struct timespec *abstime) __attribute((regparm(3)))
int __lll_mutex_unlock_wake (int *__futex) __attribute((regparm(1)))
int __lll_lock_wait (int val, int *__futex) __attribute((regparm(2)))
int __lll_unlock_wake (int *__futex) __attribute((regparm(1)))
int lll_unlock_wake_cb (int *__futex)
int __lll_timedwait_tid (int *tid, const struct timespec *abstime) __attribute__((regparm(2)))
void __lll_cond_wait (pthread_cond_t *cond) __attribute((regparm(1)))
int __lll_cond_timedwait (pthread_cond_t *cond, const struct timespec *abstime) __attribute((regparm(2)))
void __lll_cond_wake (pthread_cond_t *cond) __attribute((regparm(1)))
void __lll_cond_broadcast (pthread_cond_t *cond) __attribute((regparm(1)))


Detailed Description

Low level futex and lock implementation.

Definition in file lowlevellock.h.


Define Documentation

#define lll_futex_timed_wait ( futex,
val,
timeout   ) 

Value:

({                                                                            \
    int __status;                                                             \
    register __typeof (val) _val asm ("edx") = (val);                         \
    __asm __volatile (LLL_EBX_LOAD                                            \
                      LLL_ENTER_KERNEL                                        \
                      LLL_EBX_LOAD                                            \
                      : "=a" (__status)                                       \
                      : "0" (SYS_futex), LLL_EBX_REG (futex), "S" (timeout),  \
                        "c" (FUTEX_WAIT), "d" (_val),                         \
                        "i" (offsetof (tcbhead_t, sysinfo))                   \
                      : "memory");                                            \
    __status;                                                                 \
  })

Definition at line 171 of file lowlevellock.h.

#define lll_futex_wait ( futex,
val   ) 

Value:

({                                                                            \
    int __status;                                                             \
    register __typeof (val) _val asm ("edx") = (val);                         \
    __asm __volatile (LLL_EBX_LOAD                                            \
                      LLL_ENTER_KERNEL                                        \
                      LLL_EBX_LOAD                                            \
                      : "=a" (__status)                                       \
                      : "0" (SYS_futex), LLL_EBX_REG (futex), "S" (0),        \
                        "c" (FUTEX_WAIT), "d" (_val),                         \
                        "i" (offsetof (tcbhead_t, sysinfo))                   \
                      : "memory");                                            \
    __status;                                                                 \
  })

Definition at line 155 of file lowlevellock.h.

Referenced by futex_wait().

#define lll_futex_wake ( futex,
nr   ) 

Value:

do {                                                                          \
    int __ignore;                                                             \
    register __typeof (nr) _nr asm ("edx") = (nr);                            \
    __asm __volatile (LLL_EBX_LOAD                                            \
                      LLL_ENTER_KERNEL                                        \
                      LLL_EBX_LOAD                                            \
                      : "=a" (__ignore)                                       \
                      : "0" (SYS_futex), LLL_EBX_REG (futex),                 \
                        "c" (FUTEX_WAKE), "d" (_nr),                          \
                        "i" (0) /* phony, to align next arg's number */,      \
                        "i" (offsetof (tcbhead_t, sysinfo)));                 \
  } while (0)

Definition at line 425 of file lowlevellock.h.

#define lll_futex_wake ( futex,
nr   ) 

Value:

do {                                                                          \
    int __ignore;                                                             \
    register __typeof (nr) _nr asm ("edx") = (nr);                            \
    __asm __volatile (LLL_EBX_LOAD                                            \
                      LLL_ENTER_KERNEL                                        \
                      LLL_EBX_LOAD                                            \
                      : "=a" (__ignore)                                       \
                      : "0" (SYS_futex), LLL_EBX_REG (futex),                 \
                        "c" (FUTEX_WAKE), "d" (_nr),                          \
                        "i" (0) /* phony, to align next arg's number */,      \
                        "i" (offsetof (tcbhead_t, sysinfo)));                 \
  } while (0)

Definition at line 425 of file lowlevellock.h.

Referenced by futex_wake().

#define lll_lock ( futex   ) 

Value:

(void) ({ int ignore1, ignore2;                                       \
            __asm __volatile ("cmpl $0, %%gs:%P6\n\t"                         \
                              "je 0f\n\t"                                     \
                              "lock\n"                                        \
                              "0:\tcmpxchgl %1, %2\n\t"                       \
                              "jnz _L_lock_%=\n\t"                            \
                              ".subsection 1\n\t"                             \
                              ".type _L_lock_%=,@function\n"                  \
                              "_L_lock_%=:\n"                                 \
                              "1:\tleal %2, %%ecx\n"                          \
                              "2:\tcall __lll_mutex_lock_wait\n"              \
                              "3:\tjmp 18f\n"                                 \
                              "4:\t.size _L_lock_%=, 4b-1b\n\t"               \
                              ".previous\n"                                   \
                              LLL_STUB_UNWIND_INFO_3                          \
                              "18:"                                           \
                              : "=a" (ignore1), "=c" (ignore2), "=m" (futex)  \
                              : "0" (0), "1" (1), "m" (futex),                \
                                "i" (offsetof (tcbhead_t, multiple_threads))  \
                              : "memory"); })

Definition at line 493 of file lowlevellock.h.

#define lll_mutex_cond_lock ( futex   ) 

Value:

(void) ({ int ignore1, ignore2;                                       \
            __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                \
                              "jnz _L_mutex_cond_lock_%=\n\t"                 \
                              ".subsection 1\n\t"                             \
                              ".type _L_mutex_cond_lock_%=,@function\n"       \
                              "_L_mutex_cond_lock_%=:\n"                      \
                              "1:\tleal %2, %%ecx\n"                          \
                              "2:\tcall __lll_mutex_lock_wait\n"              \
                              "3:\tjmp 18f\n"                                 \
                              "4:\t.size _L_mutex_cond_lock_%=, 4b-1b\n\t"    \
                              ".previous\n"                                   \
                              LLL_STUB_UNWIND_INFO_3                          \
                              "18:"                                           \
                              : "=a" (ignore1), "=c" (ignore2), "=m" (futex)  \
                              : "0" (0), "1" (2), "m" (futex)                 \
                              : "memory"); })

Definition at line 290 of file lowlevellock.h.

#define lll_mutex_cond_trylock ( futex   ) 

Value:

({ int ret;                                                                   \
     __asm __volatile (LOCK_INSTR "cmpxchgl %2, %1"                           \
                       : "=a" (ret), "=m" (futex)                             \
                       : "r" (LLL_MUTEX_LOCK_INITIALIZER_WAITERS),            \
                          "m" (futex), "0" (LLL_MUTEX_LOCK_INITIALIZER)       \
                       : "memory");                                           \
     ret; })

Definition at line 239 of file lowlevellock.h.

#define lll_mutex_lock ( futex   ) 

Value:

(void) ({ int ignore1, ignore2;                                       \
            __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                \
                              "jnz _L_mutex_lock_%=\n\t"                      \
                              ".subsection 1\n\t"                             \
                              ".type _L_mutex_lock_%=,@function\n"            \
                              "_L_mutex_lock_%=:\n"                           \
                              "1:\tleal %2, %%ecx\n"                          \
                              "2:\tcall __lll_mutex_lock_wait\n"              \
                              "3:\tjmp 18f\n"                                 \
                              "4:\t.size _L_mutex_lock_%=, 4b-1b\n\t"         \
                              ".previous\n"                                   \
                              LLL_STUB_UNWIND_INFO_3                          \
                              "18:"                                           \
                              : "=a" (ignore1), "=c" (ignore2), "=m" (futex)  \
                              : "0" (0), "1" (1), "m" (futex)                 \
                              : "memory"); })

Definition at line 249 of file lowlevellock.h.

#define lll_mutex_timedlock ( futex,
timeout   ) 

Value:

({ int result, ignore1, ignore2;                                              \
     __asm __volatile (LOCK_INSTR "cmpxchgl %1, %3\n\t"                       \
                       "jnz _L_mutex_timedlock_%=\n\t"                        \
                       ".subsection 1\n\t"                                    \
                       ".type _L_mutex_timedlock_%=,@function\n"              \
                       "_L_mutex_timedlock_%=:\n"                             \
                       "1:\tleal %3, %%ecx\n"                                 \
                       "0:\tmovl %7, %%edx\n"                                 \
                       "2:\tcall __lll_mutex_timedlock_wait\n"                \
                       "3:\tjmp 18f\n"                                        \
                       "4:\t.size _L_mutex_timedlock_%=, 4b-1b\n\t"           \
                       ".previous\n"                                          \
                       LLL_STUB_UNWIND_INFO_4                                 \
                       "18:"                                                  \
                       : "=a" (result), "=c" (ignore1), "=&d" (ignore2),      \
                         "=m" (futex)                                         \
                       : "0" (0), "1" (1), "m" (futex), "m" (timeout)         \
                       : "memory");                                           \
     result; })

Definition at line 329 of file lowlevellock.h.

#define lll_mutex_trylock ( futex   ) 

Value:

({ int ret;                                                                   \
     __asm __volatile (LOCK_INSTR "cmpxchgl %2, %1"                           \
                       : "=a" (ret), "=m" (futex)                             \
                       : "r" (LLL_MUTEX_LOCK_INITIALIZER_LOCKED), "m" (futex),\
                         "0" (LLL_MUTEX_LOCK_INITIALIZER)                     \
                       : "memory");                                           \
     ret; })

Definition at line 219 of file lowlevellock.h.

#define lll_mutex_unlock ( futex   ) 

Value:

(void) ({ int ignore;                                                         \
            __asm __volatile (LOCK_INSTR "subl $1, %0\n\t"                    \
                              "jne _L_mutex_unlock_%=\n\t"                    \
                              ".subsection 1\n\t"                             \
                              ".type _L_mutex_unlock_%=,@function\n"          \
                              "_L_mutex_unlock_%=:\n"                         \
                              "1:\tleal %0, %%eax\n"                          \
                              "2:\tcall __lll_mutex_unlock_wake\n"            \
                              "3:\tjmp 18f\n"                                 \
                              "4:\t.size _L_mutex_unlock_%=, 4b-1b\n\t"       \
                              ".previous\n"                                   \
                              LLL_STUB_UNWIND_INFO_3                          \
                              "18:"                                           \
                              : "=m" (futex), "=&a" (ignore)                  \
                              : "m" (futex)                                   \
                              : "memory"); })

Definition at line 373 of file lowlevellock.h.

#define lll_robust_mutex_cond_lock ( futex,
id   ) 

Value:

({ int result, ignore;                                                \
     __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                       \
                       "jnz _L_robust_mutex_cond_lock_%=\n\t"                 \
                       ".subsection 1\n\t"                                    \
                       ".type _L_robust_mutex_cond_lock_%=,@function\n"       \
                       "_L_robust_mutex_cond_lock_%=:\n"                      \
                       "1:\tleal %2, %%ecx\n"                                 \
                       "2:\tcall __lll_robust_mutex_lock_wait\n"              \
                       "3:\tjmp 18f\n"                                        \
                       "4:\t.size _L_robust_mutex_cond_lock_%=, 4b-1b\n\t"    \
                       ".previous\n"                                          \
                       LLL_STUB_UNWIND_INFO_3                                 \
                       "18:"                                                  \
                       : "=a" (result), "=c" (ignore), "=m" (futex)           \
                       : "0" (0), "1" (id | FUTEX_WAITERS), "m" (futex)       \
                       : "memory");                                           \
     result; })

Definition at line 309 of file lowlevellock.h.

#define lll_robust_mutex_dead ( futex   ) 

Value:

(void) ({ int __ignore;                                               \
            register int _nr asm ("edx") = 1;                                 \
            __asm __volatile (LOCK_INSTR "orl %5, (%2)\n\t"                   \
                              LLL_EBX_LOAD                                    \
                              LLL_ENTER_KERNEL                                \
                              LLL_EBX_LOAD                                    \
                              : "=a" (__ignore)                               \
                              : "0" (SYS_futex), LLL_EBX_REG (&(futex)),      \
                                "c" (FUTEX_WAKE), "d" (_nr),                  \
                                "i" (FUTEX_OWNER_DIED),                       \
                                "i" (offsetof (tcbhead_t, sysinfo))); })

Definition at line 411 of file lowlevellock.h.

#define lll_robust_mutex_lock ( futex,
id   ) 

Value:

({ int result, ignore;                                                \
     __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                       \
                       "jnz _L_robust_mutex_lock_%=\n\t"                      \
                       ".subsection 1\n\t"                                    \
                       ".type _L_robust_mutex_lock_%=,@function\n"            \
                       "_L_robust_mutex_lock_%=:\n"                           \
                       "1:\tleal %2, %%ecx\n"                                 \
                       "2:\tcall __lll_robust_mutex_lock_wait\n"              \
                       "3:\tjmp 18f\n"                                        \
                       "4:\t.size _L_robust_mutex_lock_%=, 4b-1b\n\t"         \
                       ".previous\n"                                          \
                       LLL_STUB_UNWIND_INFO_3                                 \
                       "18:"                                                  \
                       : "=a" (result), "=c" (ignore), "=m" (futex)           \
                       : "0" (0), "1" (id), "m" (futex)                       \
                       : "memory");                                           \
     result; })

Definition at line 268 of file lowlevellock.h.

#define lll_robust_mutex_timedlock ( futex,
timeout,
id   ) 

Value:

({ int result, ignore1, ignore2;                                              \
     __asm __volatile (LOCK_INSTR "cmpxchgl %1, %3\n\t"                       \
                       "jnz _L_robust_mutex_timedlock_%=\n\t"                 \
                       ".subsection 1\n\t"                                    \
                       ".type _L_robust_mutex_timedlock_%=,@function\n"       \
                       "_L_robust_mutex_timedlock_%=:\n"                      \
                       "1:\tleal %3, %%ecx\n"                                 \
                       "0:\tmovl %7, %%edx\n"                                 \
                       "2:\tcall __lll_robust_mutex_timedlock_wait\n"         \
                       "3:\tjmp 18f\n"                                        \
                       "4:\t.size _L_robust_mutex_timedlock_%=, 4b-1b\n\t"    \
                       ".previous\n"                                          \
                       LLL_STUB_UNWIND_INFO_4                                 \
                       "18:"                                                  \
                       : "=a" (result), "=c" (ignore1), "=&d" (ignore2),      \
                         "=m" (futex)                                         \
                       : "0" (0), "1" (id), "m" (futex), "m" (timeout)        \
                       : "memory");                                           \
     result; })

Definition at line 351 of file lowlevellock.h.

#define lll_robust_mutex_trylock ( futex,
id   ) 

Value:

({ int ret;                                                                   \
     __asm __volatile (LOCK_INSTR "cmpxchgl %2, %1"                           \
                       : "=a" (ret), "=m" (futex)                             \
                       : "r" (id), "m" (futex),                               \
                         "0" (LLL_MUTEX_LOCK_INITIALIZER)                     \
                       : "memory");                                           \
     ret; })

Definition at line 229 of file lowlevellock.h.

#define lll_robust_mutex_unlock ( futex   ) 

Value:

(void) ({ int ignore;                                                         \
            __asm __volatile (LOCK_INSTR "andl %2, %0\n\t"                    \
                              "jne _L_robust_mutex_unlock_%=\n\t"             \
                              ".subsection 1\n\t"                             \
                              ".type _L_robust_mutex_unlock_%=,@function\n"   \
                              "_L_robust_mutex_unlock_%=:\n\t"                \
                              "1:\tleal %0, %%eax\n"                          \
                              "2:\tcall __lll_mutex_unlock_wake\n"            \
                              "3:\tjmp 18f\n"                                 \
                              "4:\t.size _L_robust_mutex_unlock_%=, 4b-1b\n\t"\
                              ".previous\n"                                   \
                              LLL_STUB_UNWIND_INFO_3                          \
                              "18:"                                           \
                              : "=m" (futex), "=&a" (ignore)                  \
                              : "i" (FUTEX_WAITERS), "m" (futex)              \
                              : "memory"); })

Definition at line 392 of file lowlevellock.h.

#define LLL_STUB_UNWIND_INFO_3

Value:

LLL_STUB_UNWIND_INFO_START                                      \
"10:\t" ".byte  0x40 + (2b-1b) # DW_CFA_advance_loc\n\t"        \
LLL_STUB_UNWIND_INFO_END

Definition at line 131 of file lowlevellock.h.

#define LLL_STUB_UNWIND_INFO_4

Value:

LLL_STUB_UNWIND_INFO_START                                      \
"10:\t" ".byte  0x40 + (0b-1b) # DW_CFA_advance_loc\n\t"        \
        ".byte  0x16    # DW_CFA_val_expression\n\t"            \
        ".uleb128 0x8\n\t"                                      \
        ".uleb128 20f-19f\n"                                    \
"19:\t" ".byte  0x78    # DW_OP_breg8\n\t"                      \
        ".sleb128 3b-0b\n"                                      \
"20:\t" ".byte  0x40 + (2b-0b) # DW_CFA_advance_loc\n\t"        \
LLL_STUB_UNWIND_INFO_END

Definition at line 143 of file lowlevellock.h.

#define LLL_STUB_UNWIND_INFO_END

Value:

".byte  0x16    # DW_CFA_val_expression\n\t"            \
        ".uleb128 0x8\n\t"                                      \
        ".uleb128 12f-11f\n"                                    \
"11:\t" ".byte  0x78    # DW_OP_breg8\n\t"                      \
        ".sleb128 3b-2b\n"                                      \
"12:\t" ".byte  0x40 + (3b-2b-1) # DW_CFA_advance_loc\n\t"      \
        ".byte  0x16    # DW_CFA_val_expression\n\t"            \
        ".uleb128 0x8\n\t"                                      \
        ".uleb128 16f-13f\n"                                    \
"13:\t" ".byte  0x78    # DW_OP_breg8\n\t"                      \
        ".sleb128 15f-14f\n\t"                                  \
        ".byte  0x0d    # DW_OP_const4s\n"                      \
"14:\t" ".4byte 3b-.\n\t"                                       \
        ".byte  0x1c    # DW_OP_minus\n\t"                      \
        ".byte  0x0d    # DW_OP_const4s\n"                      \
"15:\t" ".4byte 18f-.\n\t"                                      \
        ".byte  0x22    # DW_OP_plus\n"                         \
"16:\t" ".align 4\n"                                            \
"17:\t" ".previous\n"

Definition at line 104 of file lowlevellock.h.

#define LLL_STUB_UNWIND_INFO_START

Value:

".section       .eh_frame,\"a\",@progbits\n"            \
"5:\t"  ".long  7f-6f   # Length of Common Information Entry\n" \
"6:\t"  ".long  0x0     # CIE Identifier Tag\n\t"               \
        ".byte  0x1     # CIE Version\n\t"                      \
        ".ascii \"zR\\0\"       # CIE Augmentation\n\t"         \
        ".uleb128 0x1   # CIE Code Alignment Factor\n\t"        \
        ".sleb128 -4    # CIE Data Alignment Factor\n\t"        \
        ".byte  0x8     # CIE RA Column\n\t"                    \
        ".uleb128 0x1   # Augmentation size\n\t"                \
        ".byte  0x1b    # FDE Encoding (pcrel sdata4)\n\t"      \
        ".byte  0xc     # DW_CFA_def_cfa\n\t"                   \
        ".uleb128 0x4\n\t"                                      \
        ".uleb128 0x0\n\t"                                      \
        ".align 4\n"                                            \
"7:\t"  ".long  17f-8f  # FDE Length\n"                         \
"8:\t"  ".long  8b-5b   # FDE CIE offset\n\t"                   \
        ".long  1b-.    # FDE initial location\n\t"             \
        ".long  4b-1b   # FDE address range\n\t"                \
        ".uleb128 0x0   # Augmentation size\n\t"                \
        ".byte  0x16    # DW_CFA_val_expression\n\t"            \
        ".uleb128 0x8\n\t"                                      \
        ".uleb128 10f-9f\n"                                     \
"9:\t"  ".byte  0x78    # DW_OP_breg8\n\t"                      \
        ".sleb128 3b-1b\n"

Definition at line 79 of file lowlevellock.h.

#define lll_timedwait_tid ( tid,
abstime   ) 

Value:

({                                                                            \
    int __result = 0;                                                         \
    if (tid != 0)                                                             \
      {                                                                       \
        if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)           \
          __result = EINVAL;                                                  \
        else                                                                  \
          __result = __lll_timedwait_tid (&tid, abstime);                     \
      }                                                                       \
    __result; })

Definition at line 570 of file lowlevellock.h.

#define lll_trylock ( futex   ) 

Value:

({ unsigned char ret;                                                         \
     __asm __volatile ("cmpl $0, %%gs:%P5\n\t"                                \
                       "je 0f\n\t"                                            \
                       "lock\n"                                               \
                       "0:\tcmpxchgl %2, %1; setne %0"                        \
                       : "=a" (ret), "=m" (futex)                             \
                       : "r" (LLL_MUTEX_LOCK_INITIALIZER_LOCKED), "m" (futex),\
                         "0" (LLL_MUTEX_LOCK_INITIALIZER),                    \
                         "i" (offsetof (tcbhead_t, multiple_threads))         \
                       : "memory");                                           \
     ret; })

Definition at line 479 of file lowlevellock.h.

#define lll_unlock ( futex   ) 

Value:

(void) ({ int ignore;                                                         \
            __asm __volatile ("cmpl $0, %%gs:%P3\n\t"                         \
                              "je 0f\n\t"                                     \
                              "lock\n"                                        \
                              "0:\tsubl $1,%0\n\t"                            \
                              "jne _L_unlock_%=\n\t"                          \
                              ".subsection 1\n\t"                             \
                              ".type _L_unlock_%=,@function\n"                \
                              "_L_unlock_%=:\n"                               \
                              "1:\tleal %0, %%eax\n"                          \
                              "2:\tcall __lll_mutex_unlock_wake\n"            \
                              "3:\tjmp 18f\n\t"                               \
                              "4:\t.size _L_unlock_%=, 4b-1b\n\t"             \
                              ".previous\n"                                   \
                              LLL_STUB_UNWIND_INFO_3                          \
                              "18:"                                           \
                              : "=m" (futex), "=&a" (ignore)                  \
                              : "m" (futex),                                  \
                                "i" (offsetof (tcbhead_t, multiple_threads))  \
                              : "memory"); })

Definition at line 516 of file lowlevellock.h.

#define lll_wait_tid ( tid   ) 

Value:

do {                                                                          \
    int __ignore;                                                             \
    register __typeof (tid) _tid asm ("edx") = (tid);                         \
    if (_tid != 0)                                                            \
      __asm __volatile (LLL_EBX_LOAD                                          \
                        "1:\tmovl %1, %%eax\n\t"                              \
                        LLL_ENTER_KERNEL                                      \
                        "cmpl $0, (%%ebx)\n\t"                                \
                        "jne 1b\n\t"                                          \
                        LLL_EBX_LOAD                                          \
                        : "=&a" (__ignore)                                    \
                        : "i" (SYS_futex), LLL_EBX_REG (&tid), "S" (0),       \
                          "c" (FUTEX_WAIT), "d" (_tid),                       \
                          "i" (offsetof (tcbhead_t, sysinfo))                 \
                        : "memory");                                          \
  } while (0)

Definition at line 550 of file lowlevellock.h.


Generated on Wed Dec 9 20:32:41 2009 for xCalls by  doxygen 1.4.7