This is the mail archive of the
systemtap@sourceware.org
mailing list for the systemtap project.
Re: [PATCH] Adding systemtap probe points in pthread library (slightly revised again)
On Wed, 2011-01-12 at 21:07 +0100, Bert Wesarg wrote:
> I'm not familiar with this macro, but I suspect that the first
> argument will be the name of the probe. In this case 'newthread'. Is
> this intended? There is no 'newthread' probe documented in
> nptl/DESIGN-systemtap-probes.txt but a 'create' probe. Also, there is
> a parameter named 'newthread'. I must also missed the 'start' probe.
Thanks Bert and Roland for the comments. I've fixed the documentation,
and I've added new code that uses the ASM probe. Please review my patch
again:
What is it?
This is a patch against the "remotes/origin/roland/systemtap" branch. It
adds SystemTap probe points to the Pthread library to allow developers
and system administrators to trace and debug pthread programs.
ChangeLog:
* nptl/DESIGN-systemtap-probes.txt: New file.
* nptl/pthread_create.c: SystemTap probes.
* nptl/pthread_join.c: Likewise.
* nptl/pthread_mutex_destroy.c: Likewise.
* nptl/pthread_mutex_init.c: Likewise.
* nptl/pthread_mutex_lock.c: Likewise.
* nptl/pthread_mutex_unlock.c: Likewise.
* nptl/pthread_rwlock_destroy.c: Likewise.
* nptl/pthread_rwlock_rdlock.c: Likewise.
* nptl/pthread_rwlock_unlock.c: Likewise.
* nptl/pthread_rwlock_wrlock.c: Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S: Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h: Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S:
Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S: Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S:
Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S: Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S:
Likewise.
* nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S:
Likewise.
Testing:
- no regressions with or without systemtap probes compiled into pthread
- compilation works with or without systemtap enabled
diff --git a/nptl/DESIGN-systemtap-probes.txt
b/nptl/DESIGN-systemtap-probes.txt
index e69de29..0425824 100644
--- a/nptl/DESIGN-systemtap-probes.txt
+++ b/nptl/DESIGN-systemtap-probes.txt
@@ -0,0 +1,40 @@
+Systemtap is a dynamic tracing/instrumenting tool available on Linux.
Probes that are not fired at run time have close to zero performance
overhead.
+
+The following probes are available for NPTL:
+
+Thread creation & Join Probes
+=============================
+pthread_create - probe for pthread_create(3) - arg1 = start_routine,
arg2 = arguments
+pthread_start - probe for actual thread creation, arg1 = struct pthread
(members include thread ID, process ID)
+pthread_join - probe for pthread_join(3) - arg1 = thread ID
+pthread_join_ret - probe for pthread_join(3) return - arg1 = thread ID,
arg2 = return value
+
+Lock-related Probes
+===================
+mutex_init - probe for pthread_mutex_init(3) - arg1 = address of
mutex lock
+mutex_acquired - probe for pthread_mutex_lock(3) - arg1 = address of
mutex lock
+mutex_block - probe for resume from _possible_ mutex block event -
arg1 = address of mutex lock
+mutex_entry - probe for entry to the pthread_mutex_lock(3) function -
arg1 = address of mutex lock
+mutex_release - probe for pthread_mutex_unlock(3) after the successful
release of a mutex lock - arg1 = address of mutex lock
+mutex_destroy - probe for pthread_mutex_destroy(3) - arg1 = address of
mutex lock
+
+wrlock_entry - probe for entry to the pthread_rwlock_wrlock(3) function
- arg1 = address of rw lock
+rdlock_entry - probe for entry to the pthread_rwlock_rdlock(3) function
- arg1 = address of rw lock
+
+rwlock_destroy - probe for pthread_rwlock_destroy(3) - arg1 = address
of rw lock
+rwlock_acquire_write - probe for pthread_rwlock_wrlock(3) - arg1 =
address of rw lock
+rdlock_acquire_read - probe for pthread_rwlock_rdlock(3) after
successfully getting the lock - - arg1 = address of rw lock
+rwlock_unlock - probe for pthread_rwlock_unlock(3) - arg1 = address of
rw lock
+
+lll_futex_wait - probe in low-level (assembly language) locking
code, only fired when futex(2) is called (i.e. when trying to acquire a
contented lock)
+lll_futex_wait_private - probe in low-level (assembly language) locking
code, only fired when futex(2) is called (i.e. when trying to acquire a
contented lock)
+lll_futex_wake - probe in low-level (assembly language) locking
code, only fired when futex(2) is called (FUTEX_WAIT)
+
+Condition variable Probes
+=========================
+cond_init - probe for pthread_cond_init(3) - arg1 = condition, arg2 =
attr
+cond_destroy- probe for pthread_condattr_destroy(3) - arg1 = attr
+cond_wait - probe for pthread_cond_wait(3) - arg1 = condition, arg2 =
mutex lock
+cond_timedwait - probe for pthread_cond_timedwait(3) - arg1 =
condition, arg2 = mutex lock, arg3 = timespec
+cond_signal - probe for pthread_cond_signal(3) - arg1 = condition
+cond_broadcast - probe for pthread_cond_broadcast(3) - arg1 = condition
diff --git a/nptl/pthread_cond_broadcast.c
b/nptl/pthread_cond_broadcast.c
index 22523c2..713fc42 100644
--- a/nptl/pthread_cond_broadcast.c
+++ b/nptl/pthread_cond_broadcast.c
@@ -23,6 +23,7 @@
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
#include <shlib-compat.h>
#include <kernel-features.h>
@@ -32,8 +33,11 @@ int
__pthread_cond_broadcast (cond)
pthread_cond_t *cond;
{
+ LIBC_PROBE (cond_broadcast, 1, cond);
+
int pshared = (cond->__data.__mutex == (void *) ~0l)
? LLL_SHARED : LLL_PRIVATE;
/* Make sure we are alone. */
diff --git a/nptl/pthread_cond_init.c b/nptl/pthread_cond_init.c
index 65c01b1..caec6ca 100644
--- a/nptl/pthread_cond_init.c
+++ b/nptl/pthread_cond_init.c
@@ -20,6 +20,7 @@
#include <shlib-compat.h>
#include "pthreadP.h"
+#include <stap-probe.h>
int
@@ -42,6 +43,8 @@ __pthread_cond_init (cond, cond_attr)
? NULL : (void *) ~0l);
cond->__data.__broadcast_seq = 0;
+ LIBC_PROBE (cond_init, 2, cond, cond_attr);
+
return 0;
}
versioned_symbol (libpthread, __pthread_cond_init,
diff --git a/nptl/pthread_cond_signal.c b/nptl/pthread_cond_signal.c
index 023bbb5..6615f21 100644
--- a/nptl/pthread_cond_signal.c
+++ b/nptl/pthread_cond_signal.c
@@ -35,6 +35,8 @@ __pthread_cond_signal (cond)
int pshared = (cond->__data.__mutex == (void *) ~0l)
? LLL_SHARED : LLL_PRIVATE;
+ LIBC_PROBE (cond_signal, 1, cond);
+
/* Make sure we are alone. */
lll_lock (cond->__data.__lock, pshared);
diff --git a/nptl/pthread_cond_timedwait.c
b/nptl/pthread_cond_timedwait.c
index 7278ec4..4e4e33d 100644
--- a/nptl/pthread_cond_timedwait.c
+++ b/nptl/pthread_cond_timedwait.c
@@ -65,7 +65,7 @@ __pthread_cond_timedwait (cond, mutex, abstime)
int pshared = (cond->__data.__mutex == (void *) ~0l)
? LLL_SHARED : LLL_PRIVATE;
- /* Make sure we are along. */
+ /* Make sure we are alone. */
lll_lock (cond->__data.__lock, pshared);
/* Now we can release the mutex. */
diff --git a/nptl/pthread_cond_wait.c b/nptl/pthread_cond_wait.c
index 670fba5..aee6a99 100644
--- a/nptl/pthread_cond_wait.c
+++ b/nptl/pthread_cond_wait.c
@@ -23,6 +23,7 @@
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
#include <shlib-compat.h>
@@ -101,7 +102,9 @@ __pthread_cond_wait (cond, mutex)
int pshared = (cond->__data.__mutex == (void *) ~0l)
? LLL_SHARED : LLL_PRIVATE;
- /* Make sure we are along. */
+ LIBC_PROBE (cond_wait, 2, cond, mutex);
+
+ /* Make sure we are alone. */
lll_lock (cond->__data.__lock, pshared);
/* Now we can release the mutex. */
diff --git a/nptl/pthread_condattr_destroy.c
b/nptl/pthread_condattr_destroy.c
index e6d069e..9c84278 100644
--- a/nptl/pthread_condattr_destroy.c
+++ b/nptl/pthread_condattr_destroy.c
@@ -25,6 +25,8 @@ __pthread_condattr_destroy (attr)
pthread_condattr_t *attr;
{
/* Nothing to be done. */
+
+ LIBC_PROBE (cond_destroy, 1, attr);
return 0;
}
strong_alias (__pthread_condattr_destroy, pthread_condattr_destroy)
diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c
index 4075dd9..d574cc5 100644
--- a/nptl/pthread_create.c
+++ b/nptl/pthread_create.c
@@ -556,6 +556,8 @@ __pthread_create_2_1 (newthread, attr,
start_routine, arg)
/* Pass the descriptor to the caller. */
*newthread = (pthread_t) pd;
+ LIBC_PROBE (pthread_create, 2, start_routine, arg);
+
/* Start the thread. */
return create_thread (pd, iattr, STACK_VARIABLES_ARGS);
}
diff --git a/nptl/pthread_join.c b/nptl/pthread_join.c
index 6a87a8b..609e2cf 100644
--- a/nptl/pthread_join.c
+++ b/nptl/pthread_join.c
@@ -23,6 +23,8 @@
#include <atomic.h>
#include "pthreadP.h"
+#include <stap-probe.h>
+
static void
cleanup (void *arg)
@@ -55,6 +57,8 @@ pthread_join (threadid, thread_return)
struct pthread *self = THREAD_SELF;
int result = 0;
+ LIBC_PROBE (pthread_join, 1, threadid);
+
/* During the wait we change to asynchronous cancellation. If we
are canceled the thread we are waiting for must be marked as
un-wait-ed for again. */
@@ -110,5 +114,7 @@ pthread_join (threadid, thread_return)
__free_tcb (pd);
}
+ LIBC_PROBE (pthread_join_ret, 3, threadid, result, pd->result);
+
return result;
}
diff --git a/nptl/pthread_mutex_destroy.c b/nptl/pthread_mutex_destroy.c
index e2c9f8a..45c80b8 100644
--- a/nptl/pthread_mutex_destroy.c
+++ b/nptl/pthread_mutex_destroy.c
@@ -20,11 +20,15 @@
#include <errno.h>
#include "pthreadP.h"
+#include <stap-probe.h>
+
int
__pthread_mutex_destroy (mutex)
pthread_mutex_t *mutex;
{
+ LIBC_PROBE (mutex_destroy, 1, mutex);
+
if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) == 0
&& mutex->__data.__nusers != 0)
return EBUSY;
diff --git a/nptl/pthread_mutex_init.c b/nptl/pthread_mutex_init.c
index d9b1ef0..a025a38 100644
--- a/nptl/pthread_mutex_init.c
+++ b/nptl/pthread_mutex_init.c
@@ -24,6 +24,8 @@
#include <kernel-features.h>
#include "pthreadP.h"
+#include <stap-probe.h>
+
static const struct pthread_mutexattr default_attr =
{
/* Default is a normal mutex, not shared between processes. */
@@ -135,6 +137,8 @@ __pthread_mutex_init (mutex, mutexattr)
// mutex->__spins = 0; already done by memset
// mutex->__next = NULL; already done by memset
+ LIBC_PROBE (mutex_init, 1, mutex);
+
return 0;
}
strong_alias (__pthread_mutex_init, pthread_mutex_init)
diff --git a/nptl/pthread_mutex_lock.c b/nptl/pthread_mutex_lock.c
index 50dc188..010d43e 100644
--- a/nptl/pthread_mutex_lock.c
+++ b/nptl/pthread_mutex_lock.c
@@ -24,6 +24,7 @@
#include <not-cancel.h>
#include "pthreadP.h"
#include <lowlevellock.h>
+#include <stap-probe.h>
#ifndef LLL_MUTEX_LOCK
@@ -48,6 +49,9 @@ __pthread_mutex_lock (mutex)
assert (sizeof (mutex->__size) >= sizeof (mutex->__data));
unsigned int type = PTHREAD_MUTEX_TYPE (mutex);
+
+ LIBC_PROBE (mutex_entry, 1, mutex);
+
if (__builtin_expect (type & ~PTHREAD_MUTEX_KIND_MASK_NP, 0))
return __pthread_mutex_lock_full (mutex);
@@ -60,6 +64,8 @@ __pthread_mutex_lock (mutex)
/* Normal mutex. */
LLL_MUTEX_LOCK (mutex);
assert (mutex->__data.__owner == 0);
+
+ LIBC_PROBE (mutex_block, 1, mutex);
}
else if (__builtin_expect (type == PTHREAD_MUTEX_RECURSIVE_NP, 1))
{
@@ -83,6 +89,8 @@ __pthread_mutex_lock (mutex)
assert (mutex->__data.__owner == 0);
mutex->__data.__count = 1;
+
+ LIBC_PROBE (mutex_block, 1, mutex);
}
else if (__builtin_expect (type == PTHREAD_MUTEX_ADAPTIVE_NP, 1))
{
@@ -108,6 +116,8 @@ __pthread_mutex_lock (mutex)
}
while (LLL_MUTEX_TRYLOCK (mutex) != 0);
+ LIBC_PROBE (mutex_block, 1, mutex);
+
mutex->__data.__spins += (cnt - mutex->__data.__spins) / 8;
}
assert (mutex->__data.__owner == 0);
@@ -127,6 +137,8 @@ __pthread_mutex_lock (mutex)
++mutex->__data.__nusers;
#endif
+ LIBC_PROBE (mutex_acquired, 1, mutex);
+
return 0;
}
@@ -451,6 +463,8 @@ __pthread_mutex_lock_full (pthread_mutex_t *mutex)
}
while ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval);
+ LIBC_PROBE (mutex_block, 1, mutex);
+
assert (mutex->__data.__owner == 0);
mutex->__data.__count = 1;
}
@@ -467,6 +481,8 @@ __pthread_mutex_lock_full (pthread_mutex_t *mutex)
++mutex->__data.__nusers;
#endif
+ LIBC_PROBE (mutex_acquired, 1, mutex);
+
return 0;
}
#ifndef __pthread_mutex_lock
diff --git a/nptl/pthread_mutex_unlock.c b/nptl/pthread_mutex_unlock.c
index f9fe10b..479e500 100644
--- a/nptl/pthread_mutex_unlock.c
+++ b/nptl/pthread_mutex_unlock.c
@@ -22,6 +22,7 @@
#include <stdlib.h>
#include "pthreadP.h"
#include <lowlevellock.h>
+#include <stap-probe.h>
static int
internal_function
@@ -50,6 +51,9 @@ __pthread_mutex_unlock_usercnt (mutex, decr)
/* Unlock. */
lll_unlock (mutex->__data.__lock, PTHREAD_MUTEX_PSHARED (mutex));
+
+ LIBC_PROBE (mutex_release, 1, mutex);
+
return 0;
}
else if (__builtin_expect (type == PTHREAD_MUTEX_RECURSIVE_NP, 1))
@@ -272,6 +276,9 @@ __pthread_mutex_unlock_full (pthread_mutex_t *mutex,
int decr)
PTHREAD_MUTEX_PSHARED (mutex));
int oldprio = newval >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
+
+ LIBC_PROBE (mutex_release, 1, mutex);
+
return __pthread_tpp_change_priority (oldprio, -1);
default:
@@ -279,6 +286,7 @@ __pthread_mutex_unlock_full (pthread_mutex_t *mutex,
int decr)
return EINVAL;
}
+ LIBC_PROBE (mutex_release, 1, mutex);
return 0;
}
diff --git a/nptl/pthread_rwlock_destroy.c
b/nptl/pthread_rwlock_destroy.c
index 28fd24b..84aa693 100644
--- a/nptl/pthread_rwlock_destroy.c
+++ b/nptl/pthread_rwlock_destroy.c
@@ -18,12 +18,15 @@
02111-1307 USA. */
#include "pthreadP.h"
+#include <stap-probe.h>
int
__pthread_rwlock_destroy (rwlock)
pthread_rwlock_t *rwlock;
{
+ LIBC_PROBE (rwlock_destroy, 1, rwlock);
+
/* Nothing to be done. For now. */
return 0;
}
diff --git a/nptl/pthread_rwlock_rdlock.c b/nptl/pthread_rwlock_rdlock.c
index 31eb508..aee4011 100644
--- a/nptl/pthread_rwlock_rdlock.c
+++ b/nptl/pthread_rwlock_rdlock.c
@@ -22,6 +22,7 @@
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
/* Acquire read lock for RWLOCK. */
@@ -31,7 +32,9 @@ __pthread_rwlock_rdlock (rwlock)
{
int result = 0;
- /* Make sure we are along. */
+ LIBC_PROBE (rdlock_entry, 1, rwlock);
+
+ /* Make sure we are alone. */
lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
while (1)
@@ -49,6 +52,8 @@ __pthread_rwlock_rdlock (rwlock)
--rwlock->__data.__nr_readers;
result = EAGAIN;
}
+ else
+ LIBC_PROBE (rdlock_acquire_read, 1, rwlock);
break;
}
diff --git a/nptl/pthread_rwlock_unlock.c b/nptl/pthread_rwlock_unlock.c
index a7ef71a..a6e8d87 100644
--- a/nptl/pthread_rwlock_unlock.c
+++ b/nptl/pthread_rwlock_unlock.c
@@ -22,11 +22,14 @@
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
/* Unlock RWLOCK. */
int
__pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
{
+ LIBC_PROBE (rwlock_unlock, 1, rwlock);
+
lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
if (rwlock->__data.__writer)
rwlock->__data.__writer = 0;
diff --git a/nptl/pthread_rwlock_wrlock.c b/nptl/pthread_rwlock_wrlock.c
index 64fe970..41b13a9 100644
--- a/nptl/pthread_rwlock_wrlock.c
+++ b/nptl/pthread_rwlock_wrlock.c
@@ -22,6 +22,7 @@
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
/* Acquire write lock for RWLOCK. */
@@ -31,6 +32,8 @@ __pthread_rwlock_wrlock (rwlock)
{
int result = 0;
+ LIBC_PROBE (wrlock_entry, 1, rwlock);
+
/* Make sure we are along. */
lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
@@ -41,6 +44,9 @@ __pthread_rwlock_wrlock (rwlock)
{
/* Mark self as writer. */
rwlock->__data.__writer = THREAD_GETMEM (THREAD_SELF, tid);
+
+ LIBC_PROBE (rwlock_acquire_write, 1, rwlock);
+
break;
}
diff --git a/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
b/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
index 3195db2..0ffe43e 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
@@ -22,6 +22,15 @@
#include <kernel-features.h>
#include <lowlevellock.h>
+#if defined USE_STAP_PROBE && (defined IN_LIB || !defined NOT_IN_libc)
+ #include <stap-probe.h>
+ #define PTHREAD_PROBE_LL_LOCKWAIT_PRIVATE(arg1)
LIBC_PROBE_ASM(lll_futex_wait_private, arg1)
+ #define PTHREAD_PROBE_LL_LOCKWAIT(arg1)
LIBC_PROBE_ASM(lll_futex_wait, arg1)
+#else
+ #define PTHREAD_PROBE_LL_LOCKWAIT_PRIVATE(arg1)
+ #define PTHREAD_PROBE_LL_LOCKWAIT(arg1)
+#endif
+
.text
#ifdef __ASSUME_PRIVATE_FUTEX
@@ -91,7 +100,8 @@ __lll_lock_wait_private:
cmpl %edx, %eax /* NB: %edx == 2 */
jne 2f
-1: movl $SYS_futex, %eax
+1: PTHREAD_PROBE_LL_LOCKWAIT_PRIVATE (%rdi)
+ movl $SYS_futex, %eax
syscall
2: movl %edx, %eax
@@ -130,7 +140,8 @@ __lll_lock_wait:
cmpl %edx, %eax /* NB: %edx == 2 */
jne 2f
-1: movl $SYS_futex, %eax
+1: PTHREAD_PROBE_LL_LOCKWAIT (%rdi)
+ movl $SYS_futex, %eax
syscall
2: movl %edx, %eax
diff --git a/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h
b/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h
index 9b15bfb..5f1e264 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h
@@ -20,6 +20,12 @@
#ifndef _LOWLEVELLOCK_H
#define _LOWLEVELLOCK_H 1
+#if (defined USE_STAP_PROBE) && (defined IS_IN_libpthread)
+ #include <stap-probe.h>
+#else
+ #define LIBC_PROBE(arg1, arg2, arg3, arg4)
+#endif
+
#ifndef __ASSEMBLER__
# include <time.h>
# include <sys/param.h>
@@ -227,6 +233,7 @@ LLL_STUB_UNWIND_INFO_END
do { \
int __ignore; \
register __typeof (nr) _nr __asm ("edx") = (nr); \
+ LIBC_PROBE (lll_futex_wake, 2, futex, nr);
\
__asm __volatile ("syscall" \
: "=a" (__ignore) \
: "0" (SYS_futex), "D" (futex), \
diff --git
a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
index 224a560..c3e80dc 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
@@ -25,7 +25,7 @@
#include <kernel-features.h>
#include <pthread-pi-defines.h>
#include <pthread-errnos.h>
-
+#include <stap-probe.h>
.text
@@ -35,6 +35,10 @@
.align 16
__pthread_cond_broadcast:
+#if (defined USE_STAP_PROBE) && (defined IS_IN_libpthread)
+ LIBC_PROBE_ASM (cond_broadcast, %rdi)
+#endif
+
/* Get internal lock. */
movl $1, %esi
xorl %eax, %eax
diff --git a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
index d1d83a8..cabb396 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
@@ -24,6 +24,7 @@
#include <pthread-pi-defines.h>
#include <kernel-features.h>
#include <pthread-errnos.h>
+#include <stap-probe.h>
.text
@@ -34,6 +35,10 @@
.align 16
__pthread_cond_signal:
+#if (defined USE_STAP_PROBE) && (defined IS_IN_libpthread)
+ LIBC_PROBE_ASM (cond_signal, %rdi)
+#endif
+
/* Get internal lock. */
movq %rdi, %r8
movl $1, %esi
diff --git
a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
index e6535fb..5bab689 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
@@ -23,6 +23,7 @@
#include <lowlevelcond.h>
#include <pthread-pi-defines.h>
#include <pthread-errnos.h>
+#include <stap-probe.h>
#include <kernel-features.h>
@@ -41,6 +42,11 @@
__pthread_cond_timedwait:
.LSTARTCODE:
cfi_startproc
+
+#if (defined USE_STAP_PROBE) && (defined IS_IN_libpthread)
+ LIBC_PROBE_ASM (cond_timedwait, %rdi)
+#endif
+
#ifdef SHARED
cfi_personality(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect,
DW.ref.__gcc_personality_v0)
diff --git a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
index f5b929e..da6bf9b 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
@@ -23,6 +23,7 @@
#include <lowlevelcond.h>
#include <tcb-offsets.h>
#include <pthread-pi-defines.h>
+#include <stap-probe.h>
#include <kernel-features.h>
@@ -34,6 +35,11 @@
.type __pthread_cond_wait, @function
.align 16
__pthread_cond_wait:
+
+#if (defined USE_STAP_PROBE) && (defined IS_IN_libpthread)
+ LIBC_PROBE_ASM (cond_wait, %rdi)
+#endif
+
.LSTARTCODE:
cfi_startproc
#ifdef SHARED
diff --git a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S
b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S
index 35eb09c..efc3c20 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S
@@ -22,7 +22,7 @@
#include <lowlevelrwlock.h>
#include <pthread-errnos.h>
#include <kernel-features.h>
-
+#include <stap-probe.h>
.text
@@ -31,6 +31,11 @@
.align 16
__pthread_rwlock_rdlock:
cfi_startproc
+
+#if (defined USE_STAP_PROBE) && (defined IS_IN_libpthread)
+ LIBC_PROBE_ASM (rdlock_entry, %rdi)
+#endif
+
xorq %r10, %r10
/* Get the lock. */
diff --git a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S
b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S
index be6b8d8..4254cfc 100644
--- a/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S
+++ b/nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S
@@ -22,7 +22,7 @@
#include <lowlevelrwlock.h>
#include <pthread-errnos.h>
#include <kernel-features.h>
-
+#include <stap-probe.h>
.text
@@ -31,6 +31,11 @@
.align 16
__pthread_rwlock_wrlock:
cfi_startproc
+
+#if (defined USE_STAP_PROBE) && (defined IS_IN_libpthread)
+ LIBC_PROBE_ASM (wrlock_entry, %rdi)
+#endif
+
xorq %r10, %r10
/* Get the lock. */