AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-23 03:10:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update.

Browse Source 
2002-12-05  Ulrich Drepper  <drepper@redhat.com>

	* sysdeps/unix/sysv/linux/Makefile (sysdep_routines): Remove
	lowlevellock.
	* sysdeps/unix/sysv/linux/i386/i486/libc-lowlevellock.S: New file.
	* sysdeps/unix/sysv/linux/i386/i586/libc-lowlevellock.S: New file.
	* sysdeps/unix/sysv/linux/i386/i686/libc-lowlevellock.S: New file.
	* sysdeps/pthread/bits/libc-lock.h: Use lowlevellock implementation
	for __libc_lock_* macros.
	* Makefile (routines): Add libc-lowlevellock.

2002-10-09  Roland McGrath  <roland@redhat.com>

	* sysdeps/pthread/bits/libc-lock.h (__libc_maybe_call): New macro.
	Under [__PIC__], call the function via the pointer fetched for
	comparison rather than a call by name that uses the PLT.
	(__libc_lock_init, __libc_rwlock_init, __libc_lock_fini)
	(__libc_rwlock_fini, __libc_lock_lock, __libc_rwlock_rdlock)
	(__libc_rwlock_wrlock, __libc_lock_trylock, __libc_rwlock_tryrdlock)
	(__libc_rwlock_trywrlock, __libc_lock_unlock, __libc_rwlock_unlock)
	(__libc_key_create, __libc_getspecific, __libc_setspecific): Use it.
This commit is contained in:
Ulrich Drepper 2002-12-05 20:04:54 +00:00
parent 240a3c78ea
commit 440d8bc2cd
6 changed files with 120 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
nptl/ChangeLog
View File

@ -1,3 +1,25 @@
2002-12-05 Ulrich Drepper <drepper@redhat.com>
* sysdeps/unix/sysv/linux/Makefile (sysdep_routines): Remove
lowlevellock.
* sysdeps/unix/sysv/linux/i386/i486/libc-lowlevellock.S: New file.
* sysdeps/unix/sysv/linux/i386/i586/libc-lowlevellock.S: New file.
* sysdeps/unix/sysv/linux/i386/i686/libc-lowlevellock.S: New file.
* sysdeps/pthread/bits/libc-lock.h: Use lowlevellock implementation
for __libc_lock_* macros.
* Makefile (routines): Add libc-lowlevellock.
2002-10-09 Roland McGrath <roland@redhat.com>
* sysdeps/pthread/bits/libc-lock.h (__libc_maybe_call): New macro.
Under [__PIC__], call the function via the pointer fetched for
comparison rather than a call by name that uses the PLT.
(__libc_lock_init, __libc_rwlock_init, __libc_lock_fini)
(__libc_rwlock_fini, __libc_lock_lock, __libc_rwlock_rdlock)
(__libc_rwlock_wrlock, __libc_lock_trylock, __libc_rwlock_tryrdlock)
(__libc_rwlock_trywrlock, __libc_lock_unlock, __libc_rwlock_unlock)
(__libc_key_create, __libc_getspecific, __libc_setspecific): Use it.
2002-12-04 Roland McGrath <roland@redhat.com> 2002-12-04 Roland McGrath <roland@redhat.com>
* forward.c (pthread_self): Use FORWARD3 macro to correct return type. * forward.c (pthread_self): Use FORWARD3 macro to correct return type.

2
nptl/Makefile
View File

@ -28,7 +28,7 @@ headers := pthread.h semaphore.h
extra-libs := libpthread extra-libs := libpthread
extra-libs-others := $(extra-libs) extra-libs-others := $(extra-libs)
routines = alloca_cutoff forward routines = alloca_cutoff forward libc-lowlevellock
shared-only-routines = forward shared-only-routines = forward
libpthread-routines = init events \ libpthread-routines = init events \

122
nptl/sysdeps/pthread/bits/libc-lock.h
View File

@ -24,9 +24,24 @@
#define __need_NULL #define __need_NULL
#include <stddef.h> #include <stddef.h>
/* Fortunately Linux now has a mean to do locking which is realtime
safe without the aid of the thread library. We also need no fancy
options like error checking mutexes etc. We only need simple
locks, maybe recursive. This can be easily and cheaply implemented
using futexes. We will use them everywhere except in ld.so since
ld.so might be used on old kernels with a different libc.so. */
#ifdef _LIBC
# include <lowlevellock.h>
#endif
/* Mutex type. */ /* Mutex type. */
#if defined(_LIBC) || defined(_IO_MTSAFE_IO) #if defined _LIBC || defined _IO_MTSAFE_IO
# if defined NOT_IN_libc || !defined _LIBC
typedef pthread_mutex_t __libc_lock_t; typedef pthread_mutex_t __libc_lock_t;
# else
typedef int __libc_lock_t;
# endif
typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t; typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
# ifdef __USE_UNIX98 # ifdef __USE_UNIX98
typedef pthread_rwlock_t __libc_rwlock_t; typedef pthread_rwlock_t __libc_rwlock_t;
@ -65,12 +80,22 @@ typedef pthread_key_t __libc_key_t;
initialized locks must be set to one due to the lack of normal initialized locks must be set to one due to the lack of normal
atomic operations.) */ atomic operations.) */
#if __LT_SPINLOCK_INIT == 0 #if defined _LIBC && !defined NOT_IN_libc
# if LLL_LOCK_INITIALIZER == 0
# define __libc_lock_define_initialized(CLASS,NAME) \ # define __libc_lock_define_initialized(CLASS,NAME) \
CLASS __libc_lock_t NAME; CLASS __libc_lock_t NAME;
# else
# define __libc_lock_define_initialized(CLASS,NAME) \
CLASS __libc_lock_t NAME = LLL_LOCK_INITIALIZER;
# endif
#else #else
# if __LT_SPINLOCK_INIT == 0
# define __libc_lock_define_initialized(CLASS,NAME) \
CLASS __libc_lock_t NAME;
# else
# define __libc_lock_define_initialized(CLASS,NAME) \ # define __libc_lock_define_initialized(CLASS,NAME) \
CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER; CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER;
# endif
#endif #endif
#define __libc_rwlock_define_initialized(CLASS,NAME) \ #define __libc_rwlock_define_initialized(CLASS,NAME) \
@ -83,12 +108,32 @@ typedef pthread_key_t __libc_key_t;
#define _LIBC_LOCK_RECURSIVE_INITIALIZER \ #define _LIBC_LOCK_RECURSIVE_INITIALIZER \
{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP} {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
/* If we check for a weakly referenced symbol and then perform a
normal jump to it te code generated for some platforms in case of
PIC is unnecessarily slow. What would happen is that the function
is first referenced as data and then it is called indirectly
through the PLT. We can make this a direct jump. */
#ifdef __PIC__
# define __libc_maybe_call(FUNC, ARGS, ELSE) \
(__extension__ ({ __typeof (FUNC) *_fn = (FUNC); \
_fn != NULL ? (*_fn) ARGS : ELSE; }))
#else
# define __libc_maybe_call(FUNC, ARGS, ELSE) \
(FUNC != NULL ? FUNC ARGS : ELSE)
#endif
/* Initialize the named lock variable, leaving it in a consistent, unlocked /* Initialize the named lock variable, leaving it in a consistent, unlocked
state. */ state. */
#define __libc_lock_init(NAME) \ #if defined _LIBC && !defined NOT_IN_libc
(__pthread_mutex_init != NULL ? __pthread_mutex_init (&(NAME), NULL) : 0); # define __libc_lock_init(NAME) (NAME) = LLL_LOCK_INITIALIZER;
#else
# define __libc_lock_init(NAME) \
__libc_maybe_call (__pthread_mutex_init, (&(NAME), NULL), 0)
#endif
#define __libc_rwlock_init(NAME) \ #define __libc_rwlock_init(NAME) \
(__pthread_rwlock_init != NULL ? __pthread_rwlock_init (&(NAME), NULL) : 0); __libc_maybe_call (__pthread_rwlock_init, (&(NAME), NULL), 0)
/* Same as last but this time we initialize a recursive mutex. */ /* Same as last but this time we initialize a recursive mutex. */
#define __libc_lock_init_recursive(NAME) \ #define __libc_lock_init_recursive(NAME) \
@ -106,46 +151,67 @@ typedef pthread_key_t __libc_key_t;
/* Finalize the named lock variable, which must be locked. It cannot be /* Finalize the named lock variable, which must be locked. It cannot be
used again until __libc_lock_init is called again on it. This must be used again until __libc_lock_init is called again on it. This must be
called on a lock variable before the containing storage is reused. */ called on a lock variable before the containing storage is reused. */
#define __libc_lock_fini(NAME) \ #if defined _LIBC && !defined NOT_IN_libc
(__pthread_mutex_destroy != NULL ? __pthread_mutex_destroy (&(NAME)) : 0); # define __libc_lock_fini(NAME) (0)
#else
# define __libc_lock_fini(NAME) \
__libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
#endif
#define __libc_rwlock_fini(NAME) \ #define __libc_rwlock_fini(NAME) \
(__pthread_rwlock_destroy != NULL ? __pthread_rwlock_destroy (&(NAME)) : 0); __libc_maybe_call (__pthread_rwlock_destroy, (&(NAME)), 0)
/* Finalize recursive named lock. */ /* Finalize recursive named lock. */
#define __libc_lock_fini_recursive(NAME) __libc_lock_fini ((NAME).mutex) #define __libc_lock_fini_recursive(NAME) \
__libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
/* Lock the named lock variable. */ /* Lock the named lock variable. */
#define __libc_lock_lock(NAME) \ #if defined _LIBC && !defined NOT_IN_libc
(__pthread_mutex_lock != NULL ? __pthread_mutex_lock (&(NAME)) : 0); # define __libc_lock_lock(NAME) \
lll_lock (NAME);
#else
# define __libc_lock_lock(NAME) \
__libc_maybe_call (__pthread_mutex_lock, (&(NAME)), 0)
#endif
#define __libc_rwlock_rdlock(NAME) \ #define __libc_rwlock_rdlock(NAME) \
(__pthread_rwlock_rdlock != NULL ? __pthread_rwlock_rdlock (&(NAME)) : 0); __libc_maybe_call (__pthread_rwlock_rdlock, (&(NAME)), 0)
#define __libc_rwlock_wrlock(NAME) \ #define __libc_rwlock_wrlock(NAME) \
(__pthread_rwlock_wrlock != NULL ? __pthread_rwlock_wrlock (&(NAME)) : 0); __libc_maybe_call (__pthread_rwlock_wrlock, (&(NAME)), 0)
/* Lock the recursive named lock variable. */ /* Lock the recursive named lock variable. */
#define __libc_lock_lock_recursive(NAME) __libc_lock_lock ((NAME).mutex) #define __libc_lock_lock_recursive(NAME) \
__libc_maybe_call (__pthread_mutex_lock, (&(NAME)), 0)
/* Try to lock the named lock variable. */ /* Try to lock the named lock variable. */
#define __libc_lock_trylock(NAME) \ #if defined _LIBC && !defined NOT_IN_libc
(__pthread_mutex_trylock != NULL ? __pthread_mutex_trylock (&(NAME)) : 0) # define __libc_lock_trylock(NAME) \
lll_trylock (NAME)
#else
# define __libc_lock_trylock(NAME) \
__libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
#endif
#define __libc_rwlock_tryrdlock(NAME) \ #define __libc_rwlock_tryrdlock(NAME) \
(__pthread_rwlock_tryrdlock != NULL \ __libc_maybe_call (__pthread_rwlock_tryrdlock, (&(NAME)), 0)
? __pthread_rwlock_tryrdlock (&(NAME)) : 0)
#define __libc_rwlock_trywrlock(NAME) \ #define __libc_rwlock_trywrlock(NAME) \
(__pthread_rwlock_trywrlock != NULL \ __libc_maybe_call (__pthread_rwlock_trywrlock, (&(NAME)), 0)
? __pthread_rwlock_trywrlock (&(NAME)) : 0)
/* Try to lock the recursive named lock variable. */ /* Try to lock the recursive named lock variable. */
#define __libc_lock_trylock_recursive(NAME) __libc_lock_trylock ((NAME).mutex) #define __libc_lock_trylock_recursive(NAME) \
__libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
/* Unlock the named lock variable. */ /* Unlock the named lock variable. */
#define __libc_lock_unlock(NAME) \ #if defined _LIBC && !defined NOT_IN_libc
(__pthread_mutex_unlock != NULL ? __pthread_mutex_unlock (&(NAME)) : 0); # define __libc_lock_unlock(NAME) \
lll_unlock (NAME);
#else
# define __libc_lock_unlock(NAME) \
__libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
#endif
#define __libc_rwlock_unlock(NAME) \ #define __libc_rwlock_unlock(NAME) \
(__pthread_rwlock_unlock != NULL ? __pthread_rwlock_unlock (&(NAME)) : 0); __libc_maybe_call (__pthread_rwlock_unlock, (&(NAME)), 0)
/* Unlock the recursive named lock variable. */ /* Unlock the recursive named lock variable. */
#define __libc_lock_unlock_recursive(NAME) __libc_lock_unlock ((NAME).mutex) #define __libc_lock_unlock_recursive(NAME) \
__libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
/* Define once control variable. */ /* Define once control variable. */
@ -194,15 +260,15 @@ typedef pthread_key_t __libc_key_t;
/* Create thread-specific key. */ /* Create thread-specific key. */
#define __libc_key_create(KEY, DESTRUCTOR) \ #define __libc_key_create(KEY, DESTRUCTOR) \
(__pthread_key_create != NULL ? __pthread_key_create (KEY, DESTRUCTOR) : 1) __libc_maybe_call (__pthread_key_create, (KEY, DESTRUCTOR), 1)
/* Get thread-specific data. */ /* Get thread-specific data. */
#define __libc_getspecific(KEY) \ #define __libc_getspecific(KEY) \
(__pthread_getspecific != NULL ? __pthread_getspecific (KEY) : NULL) __libc_maybe_call (__pthread_getspecific, (KEY), NULL)
/* Set thread-specific data. */ /* Set thread-specific data. */
#define __libc_setspecific(KEY, VALUE) \ #define __libc_setspecific(KEY, VALUE) \
(__pthread_setspecific != NULL ? __pthread_setspecific (KEY, VALUE) : 0) __libc_maybe_call (__pthread_setspecific, (KEY, VALUE), 0)
/* Register handlers to execute before and after `fork'. Note that the /* Register handlers to execute before and after `fork'. Note that the

2
nptl/sysdeps/unix/sysv/linux/Makefile
View File

@ -18,7 +18,7 @@
# 02111-1307 USA. */ # 02111-1307 USA. */
ifeq ($(subdir),nptl) ifeq ($(subdir),nptl)
sysdep_routines += register-atfork unregister-atfork fork-gen lowlevellock sysdep_routines += register-atfork unregister-atfork fork-gen
libpthread-sysdep_routines += pt-fork libpthread-sysdep_routines += pt-fork
endif endif

1
nptl/sysdeps/unix/sysv/linux/i386/i586/libc-lowlevellock.S Normal file
View File

@ -0,0 +1 @@
#include "lowlevellock.S"

1
nptl/sysdeps/unix/sysv/linux/i386/i686/libc-lowlevellock.S Normal file
View File

@ -0,0 +1 @@
#include "lowlevellock.S"