+2012-05-25 Rayson Ho <rho@redhat.com>
+ Roland McGrath <roland@hack.frob.com>
+
+ * DESIGN-systemtap-probes.txt: New file.
+ * pthread_cond_broadcast.c: SystemTap probes.
+ * pthread_cond_init.c: Likewise.
+ * pthread_cond_signal.c: Likewise.
+ * pthread_cond_wait.c: Likewise.
+ * pthread_cond_destroy.c: Likewise.
+ * pthread_create.c: Likewise.
+ * pthread_join.c: Likewise.
+ * pthread_mutex_destroy.c: Likewise.
+ * pthread_mutex_init.c: Likewise.
+ * pthread_mutex_lock.c: Likewise.
+ * pthread_mutex_timedlock.c: Likewise.
+ * pthread_mutex_unlock.c: Likewise.
+ * pthread_rwlock_destroy.c: Likewise.
+ * pthread_rwlock_rdlock.c: Likewise.
+ * pthread_rwlock_unlock.c: Likewise.
+ * pthread_rwlock_wrlock.c: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/lowlevellock.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/lowlevellock.h: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S: Likewise.
+
2012-05-24 Roland McGrath <roland@hack.frob.com>
* pthread_create.c (start_thread): Define pthread_start LIBC_PROBE.
--- /dev/null
+Systemtap is a dynamic tracing/instrumenting tool available on Linux. Probes
+that are not fired at run time have close to zero overhead.
+
+The following probes are available for NPTL:
+
+Thread creation & Join Probes
+=============================
+pthread_create - probe for pthread_create
+ arg1 = pointer (pthread_t*) to thread
+ arg2 = pointer (pthread_attr_t*) to attr
+ arg3 = pointer (void *) to start_routine
+ arg4 = arguments to start_routine
+pthread_start - probe for actual thread creation
+ arg1 = struct pthread (members include thread ID, process ID)
+ arg2 = address of start_routine
+ arg3 = pointer to the list of arguments
+pthread_join - probe for pthread_join
+ arg1 = thread ID
+pthread_join_ret - probe for pthread_join return
+ arg1 = thread ID
+ arg2 = return value
+
+Lock-related Probes
+===================
+mutex_init - probe for pthread_mutex_init
+ arg1 = address of mutex lock
+mutex_acquired - probe for succ. return of pthread_mutex_lock
+ arg1 = address of mutex lock
+mutex_timedlock_acquired - probe for succ. return of pthread_mutex_timedlock
+ arg1 = address of mutex lock
+mutex_entry - probe for entry to the pthread_mutex_lock function
+ arg1 = address of mutex lock
+mutex_timedlock_entry - probe for entry to the pthread_mutex_timedlock function
+ arg1 = address of mutex lock, arg2 = address of timespec
+mutex_release - probe for pthread_mutex_unlock after the successful release of a
+ mutex lock
+ arg1 = address of mutex lock
+mutex_destroy - probe for pthread_mutex_destroy
+ arg1 = address of mutex lock
+
+wrlock_entry - probe for entry to the pthread_rwlock_wrlock function
+ arg1 = address of rw lock
+rdlock_entry - probe for entry to the pthread_rwlock_rdlock function
+ arg1 = address of rw lock
+
+rwlock_destroy - probe for pthread_rwlock_destroy
+ arg1 = address of rw lock
+wrlock_acquire_write - probe for pthread_rwlock_wrlock (after getting the lock)
+ arg1 = address of rw lock
+rdlock_acquire_read - probe for pthread_rwlock_rdlock after successfully getting
+ the lock
+ arg1 = address of rw lock
+rwlock_unlock - probe for pthread_rwlock_unlock
+ arg1 = address of rw lock
+
+lll_lock_wait - probe in low-level (assembly language) locking code, only fired
+ when futex/FUTEX_WAIT is called (i.e. when trying to acquire a
+ contented lock)
+ arg1 = pointer to futex
+ arg2 = flags passed to the futex system call
+lll_lock_wait_private - probe in low-level (assembly language) locking code,
+ only fired when futex/FUTEX_WAIT is called (i.e. when
+ trying to acquire a contented lock)
+ arg1 = pointer to futex
+
+lll_futex_wake - probe in low-level (assembly language) locking code, only fired
+ when futex (FUTEX_WAKE) is called
+ arg1 = pointer to futex
+ arg2 = number of processes to wake
+ arg3 = additional flags
+
+Condition variable Probes
+=========================
+cond_init - probe for pthread_cond_init
+ arg1 = condition
+ arg2 = attr
+cond_destroy - probe for pthread_cond_destroy
+ arg1 = cond
+cond_wait - probe for pthread_cond_wait
+ arg1 = condition
+ arg2 = mutex lock
+cond_timedwait - probe for pthread_cond_timedwait
+ arg1 = condition
+ arg2 = mutex lock
+ arg3 = timespec
+cond_signal - probe for pthread_cond_signal
+ arg1 = condition
+cond_broadcast - probe for pthread_cond_broadcast
+ arg1 = condition
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
#include <shlib-compat.h>
#include <kernel-features.h>
__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. */
-/* Copyright (C) 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <errno.h>
#include <shlib-compat.h>
#include "pthreadP.h"
+#include <stap-probe.h>
int
int pshared = (cond->__data.__mutex == (void *) ~0l)
? LLL_SHARED : LLL_PRIVATE;
+ LIBC_PROBE (cond_destroy, 1, cond);
+
/* Make sure we are alone. */
lll_lock (cond->__data.__lock, pshared);
if (nwaiters >= (1 << COND_NWAITERS_SHIFT))
{
/* Wake everybody on the associated mutex in case there are
- threads that have been requeued to it.
- Without this, pthread_cond_destroy could block potentially
- for a long time or forever, as it would depend on other
- thread's using the mutex.
- When all threads waiting on the mutex are woken up, pthread_cond_wait
- only waits for threads to acquire and release the internal
- condvar lock. */
+ threads that have been requeued to it.
+ Without this, pthread_cond_destroy could block potentially
+ for a long time or forever, as it would depend on other
+ thread's using the mutex.
+ When all threads waiting on the mutex are woken up, pthread_cond_wait
+ only waits for threads to acquire and release the internal
+ condvar lock. */
if (cond->__data.__mutex != NULL
&& cond->__data.__mutex != (void *) ~0l)
{
-/* Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
- Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <shlib-compat.h>
#include "pthreadP.h"
+#include <stap-probe.h>
int
? NULL : (void *) ~0l);
cond->__data.__broadcast_seq = 0;
+ LIBC_PROBE (cond_init, 2, cond, cond_attr);
+
return 0;
}
versioned_symbol (libpthread, __pthread_cond_init,
-/* Copyright (C) 2003, 2004, 2007 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.
#include <shlib-compat.h>
#include <kernel-features.h>
+#include <stap-probe.h>
int
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);
-/* Copyright (C) 2003,2004,2006,2007,2011 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.
#include <pthreadP.h>
#include <shlib-compat.h>
+#include <stap-probe.h>
struct _condvar_cleanup_buffer
(struct _condvar_cleanup_buffer *) arg;
unsigned int destroying;
int pshared = (cbuffer->cond->__data.__mutex == (void *) ~0l)
- ? LLL_SHARED : LLL_PRIVATE;
+ ? LLL_SHARED : LLL_PRIVATE;
/* We are going to modify shared data. */
lll_lock (cbuffer->cond->__data.__lock, pshared);
struct _condvar_cleanup_buffer cbuffer;
int err;
int pshared = (cond->__data.__mutex == (void *) ~0l)
- ? LLL_SHARED : LLL_PRIVATE;
+ ? LLL_SHARED : LLL_PRIVATE;
+
+ LIBC_PROBE (cond_wait, 2, cond, mutex);
/* Make sure we are alone. */
lll_lock (cond->__data.__lock, pshared);
-/* Copyright (C) 2002-2007,2008,2009,2010,2011 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
/* Pass the descriptor to the caller. */
*newthread = (pthread_t) pd;
+ LIBC_PROBE (pthread_create, 4, newthread, attr, start_routine, arg);
+
/* Start the thread. */
return create_thread (pd, iattr, STACK_VARIABLES_ARGS);
}
-/* Copyright (C) 2002, 2003, 2005, 2006 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <atomic.h>
#include "pthreadP.h"
+#include <stap-probe.h>
+
static void
cleanup (void *arg)
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. */
__free_tcb (pd);
}
+ LIBC_PROBE (pthread_join_ret, 3, threadid, result, pd->result);
+
return result;
}
-/* Copyright (C) 2002, 2003, 2005, 2006 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#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;
-/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#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. */
// 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)
-/* Copyright (C) 2002-2007, 2008, 2009 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <not-cancel.h>
#include "pthreadP.h"
#include <lowlevellock.h>
+#include <stap-probe.h>
#ifndef LLL_MUTEX_LOCK
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);
++mutex->__data.__nusers;
#endif
+ LIBC_PROBE (mutex_acquired, 1, mutex);
+
return 0;
}
++mutex->__data.__nusers;
#endif
+ LIBC_PROBE (mutex_acquired, 1, mutex);
+
return 0;
}
#ifndef __pthread_mutex_lock
-/* Copyright (C) 2002-2007, 2008 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <lowlevellock.h>
#include <not-cancel.h>
+#include <stap-probe.h>
+
int
pthread_mutex_timedlock (mutex, abstime)
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
int result = 0;
+ LIBC_PROBE (mutex_timedlock_entry, 2, mutex, abstime);
+
/* We must not check ABSTIME here. If the thread does not block
abstime must not be checked for a valid value. */
++mutex->__data.__count;
+ LIBC_PROBE (mutex_timedlock_acquired, 1, mutex);
+
return 0;
}
}
++mutex->__data.__count;
+ LIBC_PROBE (mutex_timedlock_acquired, 1, mutex);
+
return 0;
}
}
++mutex->__data.__count;
+ LIBC_PROBE (mutex_timedlock_acquired, 1, mutex);
+
return 0;
}
}
/* Record the ownership. */
mutex->__data.__owner = id;
++mutex->__data.__nusers;
+
+ LIBC_PROBE (mutex_timedlock_acquired, 1, mutex);
}
out:
-/* Copyright (C) 2002, 2003, 2005-2008, 2009 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <stdlib.h>
#include "pthreadP.h"
#include <lowlevellock.h>
+#include <stap-probe.h>
static int
internal_function
/* 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))
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:
return EINVAL;
}
+ LIBC_PROBE (mutex_release, 1, mutex);
return 0;
}
-/* Copyright (C) 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
<http://www.gnu.org/licenses/>. */
#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;
}
-/* Copyright (C) 2003,2004,2007,2011 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
/* Acquire read lock for RWLOCK. */
{
int result = 0;
+ LIBC_PROBE (rdlock_entry, 1, rwlock);
+
/* Make sure we are alone. */
lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
--rwlock->__data.__nr_readers;
result = EAGAIN;
}
+ else
+ LIBC_PROBE (rdlock_acquire_read, 1, rwlock);
break;
}
-/* Copyright (C) 2003, 2007 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.
#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;
-/* Copyright (C) 2003,2007,2011 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.
#include <lowlevellock.h>
#include <pthread.h>
#include <pthreadP.h>
+#include <stap-probe.h>
/* Acquire write lock for RWLOCK. */
{
int result = 0;
+ LIBC_PROBE (wrlock_entry, 1, rwlock);
+
/* Make sure we are alone. */
lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
{
/* Mark self as writer. */
rwlock->__data.__writer = THREAD_GETMEM (THREAD_SELF, tid);
+
+ LIBC_PROBE (wrlock_acquire_write, 1, rwlock);
break;
}
-/* Copyright (C) 2002-2007, 2009, 2010, 2011 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <kernel-features.h>
#include <lowlevellock.h>
+#include <stap-probe.h>
+
.text
#ifdef __ASSUME_PRIVATE_FUTEX
cmpl %edx, %eax /* NB: %edx == 2 */
jne 2f
-1: movl $SYS_futex, %eax
+1: LIBC_PROBE (lll_lock_wait_private, 1, %rdi)
+ movl $SYS_futex, %eax
syscall
2: movl %edx, %eax
cmpl %edx, %eax /* NB: %edx == 2 */
jne 2f
-1: movl $SYS_futex, %eax
+1: LIBC_PROBE (lll_lock_wait, 2, %rdi, %rsi)
+ movl $SYS_futex, %eax
syscall
2: movl %edx, %eax
-/* Copyright (C) 2002-2004, 2006-2008, 2009, 2012
- Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#ifndef _LOWLEVELLOCK_H
#define _LOWLEVELLOCK_H 1
+#include <stap-probe.h>
+
#ifndef __ASSEMBLER__
# include <time.h>
# include <sys/param.h>
do { \
int __ignore; \
register __typeof (nr) _nr __asm ("edx") = (nr); \
+ LIBC_PROBE (lll_futex_wake, 3, futex, nr, private); \
__asm __volatile ("syscall" \
: "=a" (__ignore) \
: "0" (SYS_futex), "D" (futex), \
"je 0f\n\t" \
"lock; cmpxchgl %4, %2\n\t" \
"jnz 1f\n\t" \
- "jmp 24f\n" \
+ "jmp 24f\n" \
"0:\tcmpxchgl %4, %2\n\t" \
"jnz 1f\n\t"
#endif
-/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009
- Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <kernel-features.h>
#include <pthread-pi-defines.h>
#include <pthread-errnos.h>
-
+#include <stap-probe.h>
.text
.align 16
__pthread_cond_broadcast:
+ LIBC_PROBE (cond_broadcast, 1, %rdi)
+
/* Get internal lock. */
movl $1, %esi
xorl %eax, %eax
-/* Copyright (C) 2002-2005, 2007, 2009 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <pthread-pi-defines.h>
#include <kernel-features.h>
#include <pthread-errnos.h>
+#include <stap-probe.h>
.text
.align 16
__pthread_cond_signal:
+ LIBC_PROBE (cond_signal, 1, %rdi)
+
/* Get internal lock. */
movq %rdi, %r8
movl $1, %esi
-/* Copyright (C) 2002-2005,2007,2009,2010,2011 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <lowlevelcond.h>
#include <pthread-pi-defines.h>
#include <pthread-errnos.h>
+#include <stap-probe.h>
#include <kernel-features.h>
cfi_adjust_cfa_offset(FRAME_SIZE)
cfi_remember_state
+ LIBC_PROBE (cond_timedwait, 3, %rdi, %rsi, %rdx)
+
cmpq $1000000000, 8(%rdx)
movl $EINVAL, %eax
jae 48f
-/* Copyright (C) 2002-2007, 2009, 2011 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <tcb-offsets.h>
#include <pthread-pi-defines.h>
#include <pthread-errnos.h>
+#include <stap-probe.h>
#include <kernel-features.h>
rsp + 32
+--------------------------+
rsp + 24 | old wake_seq value |
- +--------------------------+
+ +--------------------------+
rsp + 16 | mutex pointer |
- +--------------------------+
+ +--------------------------+
rsp + 8 | condvar pointer |
- +--------------------------+
+ +--------------------------+
rsp + 4 | old broadcast_seq value |
- +--------------------------+
+ +--------------------------+
rsp + 0 | old cancellation mode |
- +--------------------------+
+ +--------------------------+
*/
+ LIBC_PROBE (cond_wait, 2, %rdi, %rsi)
+
LP_OP(cmp) $-1, dep_mutex(%rdi)
- /* Prepare structure passed to cancellation handler. */
+ /* Prepare structure passed to cancellation handler. */
movq %rdi, 8(%rsp)
movq %rsi, 16(%rsp)
rsp + 32
+--------------------------+
rsp + 24 | unused |
- +--------------------------+
+ +--------------------------+
rsp + 16 | mutex pointer |
- +--------------------------+
+ +--------------------------+
rsp + 8 | condvar pointer |
- +--------------------------+
+ +--------------------------+
rsp + 4 | old broadcast_seq value |
- +--------------------------+
+ +--------------------------+
rsp + 0 | old cancellation mode |
- +--------------------------+
+ +--------------------------+
*/
movq %rax, 24(%rsp)
-/* Copyright (C) 2002, 2003, 2005, 2007, 2009 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <lowlevelrwlock.h>
#include <pthread-errnos.h>
#include <kernel-features.h>
-
+#include <stap-probe.h>
.text
.align 16
__pthread_rwlock_rdlock:
cfi_startproc
+
+ LIBC_PROBE (rdlock_entry, 1, %rdi)
+
xorq %r10, %r10
/* Get the lock. */
-/* Copyright (C) 2002, 2003, 2005, 2007, 2009 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
#include <lowlevelrwlock.h>
#include <pthread-errnos.h>
#include <kernel-features.h>
-
+#include <stap-probe.h>
.text
.align 16
__pthread_rwlock_wrlock:
cfi_startproc
+
+ LIBC_PROBE (wrlock_entry, 1, %rdi)
+
xorq %r10, %r10
/* Get the lock. */
projects / thirdparty / glibc.git / commitdiff
