Update.
2002-12-06 Ulrich Drepper <drepper@redhat.com> * misc/syslog.c (log_cleanup): New function. (openlog): Use log_cleanup instead of __libc_mutex_unlock. (closelog): Likewise. * elf/dl-close.c: Use __rtld_lock_* macros instead of __libc_lock_*. * elf/dl-iteratephdr.c: Likewise. * elf/dl-lookup.c: Likewise. * elf/dl-misc.c: Likewise. * elf/dl-open.c: Likewise. * elf/dl-support.c: Likewise. * elf/rtld.c: Likewise. * sysdeps/generic/ldsodefs.h: Likewise. * sysdeps/generic/bits/libc-lock.h: Define __rtld_lock_* macros. * sysdeps/mach/bits/libc-lock.h: Likewise. * sysdeps/mach/hurd/bits/libc-lock.h: Likewise. * dirent/bug-readdir1.c (main): Don't call closedir, just close
This commit is contained in:
Ulrich Drepper
parent
d5ddad4ff4
commit
d3c9f89525
20
ChangeLog
20
ChangeLog
|
|
@ -1,3 +1,21 @@
|
|||
2002-12-06 Ulrich Drepper <drepper@redhat.com>
|
||||
|
||||
* misc/syslog.c (log_cleanup): New function.
|
||||
(openlog): Use log_cleanup instead of __libc_mutex_unlock.
|
||||
(closelog): Likewise.
|
||||
|
||||
* elf/dl-close.c: Use __rtld_lock_* macros instead of __libc_lock_*.
|
||||
* elf/dl-iteratephdr.c: Likewise.
|
||||
* elf/dl-lookup.c: Likewise.
|
||||
* elf/dl-misc.c: Likewise.
|
||||
* elf/dl-open.c: Likewise.
|
||||
* elf/dl-support.c: Likewise.
|
||||
* elf/rtld.c: Likewise.
|
||||
* sysdeps/generic/ldsodefs.h: Likewise.
|
||||
* sysdeps/generic/bits/libc-lock.h: Define __rtld_lock_* macros.
|
||||
* sysdeps/mach/bits/libc-lock.h: Likewise.
|
||||
* sysdeps/mach/hurd/bits/libc-lock.h: Likewise.
|
||||
|
||||
2002-12-06 Roland McGrath <roland@redhat.com>
|
||||
|
||||
* sysdeps/generic/libc-tls.c (__libc_setup_tls): Cope with zero ALIGN.
|
||||
|
|
@ -56,7 +74,7 @@
|
|||
|
||||
2002-12-05 Ulrich Drepper <drepper@redhat.com>
|
||||
|
||||
* dirent/bug-readdir1.c (main): Don't call closedir, just close on
|
||||
* dirent/bug-readdir1.c (main): Don't call closedir, just close
|
||||
the file descriptor. This is testing what the bug report was about.
|
||||
|
||||
2002-12-04 Ulrich Drepper <drepper@redhat.com>
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
of libc. */
|
||||
#define __libc_lock_define(CLASS,NAME)
|
||||
#define __libc_lock_define_recursive(CLASS,NAME)
|
||||
#define __rtld_lock_define_recursive(CLASS,NAME)
|
||||
#define __libc_rwlock_define(CLASS,NAME)
|
||||
|
||||
/* Define an initialized lock variable NAME with storage class CLASS. */
|
||||
|
|
@ -47,6 +48,7 @@
|
|||
|
||||
/* Same as last but this time we initialize a recursive mutex. */
|
||||
#define __libc_lock_init_recursive(NAME)
|
||||
#define __rtld_lock_init_recursive(NAME)
|
||||
|
||||
/* 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
|
||||
|
|
@ -64,6 +66,7 @@
|
|||
|
||||
/* Lock the recursive named lock variable. */
|
||||
#define __libc_lock_lock_recursive(NAME)
|
||||
#define __rtld_lock_lock_recursive(NAME)
|
||||
|
||||
/* Try to lock the named lock variable. */
|
||||
#define __libc_lock_trylock(NAME) 0
|
||||
|
|
@ -79,6 +82,7 @@
|
|||
|
||||
/* Unlock the recursive named lock variable. */
|
||||
#define __libc_lock_unlock_recursive(NAME)
|
||||
#define __rtld_lock_unlock_recursive(NAME)
|
||||
|
||||
|
||||
/* Define once control variable. */
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ _dl_close (void *_map)
|
|||
_dl_signal_error (0, map->l_name, NULL, N_("shared object not open"));
|
||||
|
||||
/* Acquire the lock. */
|
||||
__libc_lock_lock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
||||
|
||||
/* Decrement the reference count. */
|
||||
if (map->l_opencount > 1 || map->l_type != lt_loaded)
|
||||
|
|
@ -139,7 +139,7 @@ _dl_close (void *_map)
|
|||
/* One decrement the object itself, not the dependencies. */
|
||||
--map->l_opencount;
|
||||
|
||||
__libc_lock_unlock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -422,7 +422,7 @@ _dl_close (void *_map)
|
|||
free (list);
|
||||
|
||||
/* Release the lock. */
|
||||
__libc_lock_unlock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
}
|
||||
libc_hidden_def (_dl_close)
|
||||
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ __dl_iterate_phdr (int (*callback) (struct dl_phdr_info *info,
|
|||
int ret = 0;
|
||||
|
||||
/* Make sure we are alone. */
|
||||
__libc_lock_lock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
||||
|
||||
for (l = GL(dl_loaded); l != NULL; l = l->l_next)
|
||||
{
|
||||
|
|
@ -49,7 +49,7 @@ __dl_iterate_phdr (int (*callback) (struct dl_phdr_info *info,
|
|||
}
|
||||
|
||||
/* Release the lock. */
|
||||
__libc_lock_unlock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ add_dependency (struct link_map *undef_map, struct link_map *map)
|
|||
return 0;
|
||||
|
||||
/* Make sure nobody can unload the object while we are at it. */
|
||||
__libc_lock_lock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
||||
|
||||
/* Determine whether UNDEF_MAP already has a reference to MAP. First
|
||||
look in the normal dependencies. */
|
||||
|
|
@ -186,7 +186,7 @@ add_dependency (struct link_map *undef_map, struct link_map *map)
|
|||
|
||||
out:
|
||||
/* Release the lock. */
|
||||
__libc_lock_unlock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -258,9 +258,9 @@ _dl_debug_vdprintf (int fd, int tag_p, const char *fmt, va_list arg)
|
|||
__writev (fd, iov, niov);
|
||||
else
|
||||
{
|
||||
__libc_lock_lock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
||||
__writev (fd, iov, niov);
|
||||
__libc_lock_unlock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
}
|
||||
#else
|
||||
__writev (fd, iov, niov);
|
||||
|
|
|
|||
|
|
@ -486,7 +486,7 @@ _dl_open (const char *file, int mode, const void *caller)
|
|||
_dl_signal_error (EINVAL, file, NULL, N_("invalid mode for dlopen()"));
|
||||
|
||||
/* Make sure we are alone. */
|
||||
__libc_lock_lock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
||||
|
||||
args.file = file;
|
||||
args.mode = mode;
|
||||
|
|
@ -500,7 +500,7 @@ _dl_open (const char *file, int mode, const void *caller)
|
|||
#endif
|
||||
|
||||
/* Release the lock. */
|
||||
__libc_lock_unlock_recursive (GL(dl_load_lock));
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
|
||||
if (__builtin_expect (errstring != NULL, 0))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ size_t _dl_phnum;
|
|||
This must be a recursive lock since the initializer function of
|
||||
the loaded object might as well require a call to this function.
|
||||
At this time it is not anymore a problem to modify the tables. */
|
||||
__libc_lock_define_initialized_recursive (, _dl_load_lock)
|
||||
__rtld_lock_define_initialized_recursive (, _dl_load_lock)
|
||||
|
||||
|
||||
#ifdef HAVE_AUX_VECTOR
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ struct rtld_global _rtld_global =
|
|||
._dl_correct_cache_id = _DL_CACHE_DEFAULT_ID,
|
||||
._dl_hwcap_mask = HWCAP_IMPORTANT,
|
||||
#ifdef _LIBC_REENTRANT
|
||||
._dl_load_lock = _LIBC_LOCK_RECURSIVE_INITIALIZER
|
||||
._dl_load_lock = _RTLD_LOCK_RECURSIVE_INITIALIZER
|
||||
#endif
|
||||
};
|
||||
strong_alias (_rtld_global, _rtld_local);
|
||||
|
|
|
|||
|
|
@ -1,3 +1,7 @@
|
|||
2002-12-06 Ulrich Drepper <drepper@redhat.com>
|
||||
|
||||
* sysdeps/pthread/bits/libc-lock.h: Define __rtld_lock_* macros.
|
||||
|
||||
2002-12-05 Roland McGrath <roland@redhat.com>
|
||||
|
||||
* pthread.c (__pthread_initialize_minimal)
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ typedef pthread_rwlock_t __libc_rwlock_t;
|
|||
# else
|
||||
typedef struct __libc_rwlock_opaque__ __libc_rwlock_t;
|
||||
# endif
|
||||
typedef __libc_lock_recursive_t __rtld_lock_recursive_t;
|
||||
#else
|
||||
typedef struct __libc_lock_opaque__ __libc_lock_t;
|
||||
typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
|
||||
|
|
@ -54,6 +55,8 @@ typedef pthread_key_t __libc_key_t;
|
|||
CLASS __libc_rwlock_t NAME;
|
||||
#define __libc_lock_define_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME;
|
||||
#define __rtld_lock_define_recursive(CLASS,NAME) \
|
||||
CLASS __rtld_lock_recursive_t NAME;
|
||||
|
||||
/* Define an initialized lock variable NAME with storage class CLASS.
|
||||
|
||||
|
|
@ -82,12 +85,17 @@ typedef pthread_key_t __libc_key_t;
|
|||
#define _LIBC_LOCK_RECURSIVE_INITIALIZER \
|
||||
{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
|
||||
|
||||
#define __rtld_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __rtld_lock_recursive_t NAME = _RTLD_LOCK_RECURSIVE_INITIALIZER;
|
||||
#define _RTLD_LOCK_RECURSIVE_INITIALIZER \
|
||||
{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
|
||||
|
||||
#ifdef __PIC__
|
||||
#define __libc_maybe_call(FUNC, ARGS, ELSE) \
|
||||
# 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) \
|
||||
# define __libc_maybe_call(FUNC, ARGS, ELSE) \
|
||||
(FUNC != NULL ? FUNC ARGS : ELSE)
|
||||
#endif
|
||||
|
||||
|
|
@ -110,6 +118,8 @@ typedef pthread_key_t __libc_key_t;
|
|||
__pthread_mutexattr_destroy (&__attr); \
|
||||
} \
|
||||
} while (0);
|
||||
#define __rtld_lock_init_recursive(NAME) \
|
||||
__libc_lock_init_recursive (NAME)
|
||||
|
||||
/* 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
|
||||
|
|
@ -121,6 +131,7 @@ typedef pthread_key_t __libc_key_t;
|
|||
|
||||
/* Finalize recursive named lock. */
|
||||
#define __libc_lock_fini_recursive(NAME) __libc_lock_fini ((NAME).mutex)
|
||||
#define __rtld_lock_fini_recursive(NAME) __libc_lock_fini_recursive (NAME)
|
||||
|
||||
/* Lock the named lock variable. */
|
||||
#define __libc_lock_lock(NAME) \
|
||||
|
|
@ -132,6 +143,7 @@ typedef pthread_key_t __libc_key_t;
|
|||
|
||||
/* Lock the recursive named lock variable. */
|
||||
#define __libc_lock_lock_recursive(NAME) __libc_lock_lock ((NAME).mutex)
|
||||
#define __rtld_lock_lock_recursive(NAME) __libc_lock_lock_recursive (NAME)
|
||||
|
||||
/* Try to lock the named lock variable. */
|
||||
#define __libc_lock_trylock(NAME) \
|
||||
|
|
@ -143,6 +155,8 @@ typedef pthread_key_t __libc_key_t;
|
|||
|
||||
/* Try to lock the recursive named lock variable. */
|
||||
#define __libc_lock_trylock_recursive(NAME) __libc_lock_trylock ((NAME).mutex)
|
||||
#define __rtld_lock_trylock_recursive(NAME) \
|
||||
__libc_lock_trylock_recursive (NAME)
|
||||
|
||||
/* Unlock the named lock variable. */
|
||||
#define __libc_lock_unlock(NAME) \
|
||||
|
|
@ -152,6 +166,7 @@ typedef pthread_key_t __libc_key_t;
|
|||
|
||||
/* Unlock the recursive named lock variable. */
|
||||
#define __libc_lock_unlock_recursive(NAME) __libc_lock_unlock ((NAME).mutex)
|
||||
#define __rtld_lock_unlock_recursive(NAME) __libc_lock_unlock_recursive (NAME)
|
||||
|
||||
|
||||
/* Define once control variable. */
|
||||
|
|
|
|||
|
|
@ -1,3 +1,22 @@
|
|||
2002-12-06 Ulrich Drepper <drepper@redhat.com>
|
||||
|
||||
* Makefile (tests): Comment out tst-locale2 for now.
|
||||
(CFLAGS-flockfile.c, CFLAGS-funlockfile.c): Define to -D_IO_MTSAFE_IO.
|
||||
|
||||
* sysdeps/unix/sysv/linux/Makefile: Define CFLAGS-fork.c to
|
||||
-D_IO_MTSAFE_IO.
|
||||
* sysdeps/unix/sysv/linux/fork.c: Include <bits/stdio-lock.h>.
|
||||
Use _IO_lock_init instead of explicit assignment.
|
||||
|
||||
* sysdeps/pthread/bits/libc-lock.h: Define __rtld_lock_* macros.
|
||||
Define __libc_lock_* and __libc_lock_recursive macros with
|
||||
lowlevellock macros, not pthread mutexes.
|
||||
|
||||
* flockfile.c: Include <bits/stdio-lock.h>. Use _IO_lock_lock instead
|
||||
of pthread_mutex_lock.
|
||||
* funlockfile.c: Include <bits/stdio-lock.h>. Use _IO_lock_unlock
|
||||
instead of pthread_mutex_unlock.
|
||||
|
||||
2002-12-06 Roland McGrath <roland@redhat.com>
|
||||
|
||||
* allocatestack.c (__stack_user): Use uninitialized defn.
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ tests = tst-mutex1 tst-mutex2 tst-mutex3 tst-mutex4 tst-mutex5 tst-mutex6 \
|
|||
tst-stack1 \
|
||||
tst-unload \
|
||||
tst-sysconf \
|
||||
tst-locale1 tst-locale2
|
||||
tst-locale1 #tst-locale2 <--- commented out until compiler is fixed
|
||||
|
||||
LDFLAGS-pthread.so = -Wl,--enable-new-dtags,-z,nodelete,-z,initfirst
|
||||
|
||||
|
|
@ -155,6 +155,9 @@ omit-deps += crti
|
|||
CFLAGS-pt-initfini.s = -g0 -fPIC -fno-inline-functions
|
||||
endif
|
||||
|
||||
CFLAGS-flockfile.c = -D_IO_MTSAFE_IO
|
||||
CFLAGS-funlockfile.c = -D_IO_MTSAFE_IO
|
||||
|
||||
ifeq ($(build-static),yes)
|
||||
tests-static += tst-locale1 tst-locale2
|
||||
endif
|
||||
|
|
|
|||
|
|
@ -20,12 +20,13 @@
|
|||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <libio.h>
|
||||
#include <bits/stdio-lock.h>
|
||||
|
||||
|
||||
void
|
||||
flockfile (stream)
|
||||
FILE *stream;
|
||||
{
|
||||
pthread_mutex_lock (stream->_lock);
|
||||
_IO_lock_lock (*stream->_lock);
|
||||
}
|
||||
strong_alias (flockfile, _IO_flockfile)
|
||||
|
|
|
|||
|
|
@ -20,12 +20,13 @@
|
|||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <libio.h>
|
||||
#include <bits/stdio-lock.h>
|
||||
|
||||
|
||||
void
|
||||
funlockfile (stream)
|
||||
FILE *stream;
|
||||
{
|
||||
pthread_mutex_unlock (stream->_lock);
|
||||
_IO_lock_unlock (*stream->_lock);
|
||||
}
|
||||
strong_alias (funlockfile, _IO_funlockfile)
|
||||
|
|
|
|||
|
|
@ -33,16 +33,19 @@
|
|||
ld.so might be used on old kernels with a different libc.so. */
|
||||
#ifdef _LIBC
|
||||
# include <lowlevellock.h>
|
||||
# include <tls.h>
|
||||
#endif
|
||||
|
||||
/* Mutex type. */
|
||||
#if defined _LIBC || defined _IO_MTSAFE_IO
|
||||
# if defined NOT_IN_libc || !defined _LIBC
|
||||
# if (defined NOT_IN_libc && !defined IS_IN_libpthread) || !defined _LIBC
|
||||
typedef pthread_mutex_t __libc_lock_t;
|
||||
typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
|
||||
# else
|
||||
typedef int __libc_lock_t;
|
||||
typedef struct { int lock; int cnt; void *owner; } __libc_lock_recursive_t;
|
||||
# endif
|
||||
typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
|
||||
typedef struct { pthread_mutex_t mutex; } __rtld_lock_recursive_t;
|
||||
# ifdef __USE_UNIX98
|
||||
typedef pthread_rwlock_t __libc_rwlock_t;
|
||||
# else
|
||||
|
|
@ -70,6 +73,8 @@ typedef pthread_key_t __libc_key_t;
|
|||
CLASS __libc_rwlock_t NAME;
|
||||
#define __libc_lock_define_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME;
|
||||
#define __rtld_lock_define_recursive(CLASS,NAME) \
|
||||
CLASS __rtld_lock_recursive_t NAME;
|
||||
|
||||
/* Define an initialized lock variable NAME with storage class CLASS.
|
||||
|
||||
|
|
@ -80,7 +85,7 @@ typedef pthread_key_t __libc_key_t;
|
|||
initialized locks must be set to one due to the lack of normal
|
||||
atomic operations.) */
|
||||
|
||||
#if defined _LIBC && !defined NOT_IN_libc
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# if LLL_LOCK_INITIALIZER == 0
|
||||
# define __libc_lock_define_initialized(CLASS,NAME) \
|
||||
CLASS __libc_lock_t NAME;
|
||||
|
|
@ -103,11 +108,27 @@ typedef pthread_key_t __libc_key_t;
|
|||
|
||||
/* Define an initialized recursive lock variable NAME with storage
|
||||
class CLASS. */
|
||||
#define __libc_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# if LLL_LOCK_INITIALIZER == 0
|
||||
# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME;
|
||||
# else
|
||||
# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
|
||||
#define _LIBC_LOCK_RECURSIVE_INITIALIZER \
|
||||
# endif
|
||||
# define _LIBC_LOCK_RECURSIVE_INITIALIZER \
|
||||
{ LLL_LOCK_INITIALIZER, 0, NULL }
|
||||
#else
|
||||
# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
|
||||
# define _LIBC_LOCK_RECURSIVE_INITIALIZER \
|
||||
{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
|
||||
#endif
|
||||
|
||||
#define __rtld_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __rtld_lock_recursive_t NAME = _RTLD_LOCK_RECURSIVE_INITIALIZER;
|
||||
#define _RTLD_LOCK_RECURSIVE_INITIALIZER \
|
||||
{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
|
||||
|
|
@ -126,7 +147,7 @@ typedef pthread_key_t __libc_key_t;
|
|||
|
||||
/* Initialize the named lock variable, leaving it in a consistent, unlocked
|
||||
state. */
|
||||
#if defined _LIBC && !defined NOT_IN_libc
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_init(NAME) (NAME) = LLL_LOCK_INITIALIZER;
|
||||
#else
|
||||
# define __libc_lock_init(NAME) \
|
||||
|
|
@ -136,23 +157,40 @@ typedef pthread_key_t __libc_key_t;
|
|||
__libc_maybe_call (__pthread_rwlock_init, (&(NAME), NULL), 0)
|
||||
|
||||
/* Same as last but this time we initialize a recursive mutex. */
|
||||
#define __libc_lock_init_recursive(NAME) \
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_init_recursive(NAME) \
|
||||
(NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER
|
||||
#else
|
||||
# define __libc_lock_init_recursive(NAME) \
|
||||
do { \
|
||||
if (__pthread_mutex_init != NULL) \
|
||||
{ \
|
||||
pthread_mutexattr_t __attr; \
|
||||
__pthread_mutexattr_init (&__attr); \
|
||||
__pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \
|
||||
__pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \
|
||||
__pthread_mutex_init (&(NAME).mutex, &__attr); \
|
||||
__pthread_mutexattr_destroy (&__attr); \
|
||||
} \
|
||||
} while (0);
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#define __rtld_lock_init_recursive(NAME) \
|
||||
do { \
|
||||
if (__pthread_mutex_init != NULL) \
|
||||
{ \
|
||||
pthread_mutexattr_t __attr; \
|
||||
__pthread_mutexattr_init (&__attr); \
|
||||
__pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \
|
||||
__pthread_mutex_init (&(NAME).mutex, &__attr); \
|
||||
__pthread_mutexattr_destroy (&__attr); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/* 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
|
||||
called on a lock variable before the containing storage is reused. */
|
||||
#if defined _LIBC && !defined NOT_IN_libc
|
||||
# define __libc_lock_fini(NAME) (0)
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_fini(NAME) ((void) 0)
|
||||
#else
|
||||
# define __libc_lock_fini(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
|
||||
|
|
@ -161,11 +199,15 @@ typedef pthread_key_t __libc_key_t;
|
|||
__libc_maybe_call (__pthread_rwlock_destroy, (&(NAME)), 0)
|
||||
|
||||
/* Finalize recursive named lock. */
|
||||
#define __libc_lock_fini_recursive(NAME) \
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_fini_recursive(NAME) ((void) 0)
|
||||
#else
|
||||
# define __libc_lock_fini_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
|
||||
#endif
|
||||
|
||||
/* Lock the named lock variable. */
|
||||
#if defined _LIBC && !defined NOT_IN_libc
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_lock(NAME) \
|
||||
lll_lock (NAME);
|
||||
#else
|
||||
|
|
@ -178,11 +220,27 @@ typedef pthread_key_t __libc_key_t;
|
|||
__libc_maybe_call (__pthread_rwlock_wrlock, (&(NAME)), 0)
|
||||
|
||||
/* Lock the recursive named lock variable. */
|
||||
#define __libc_lock_lock_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_lock, (&(NAME)), 0)
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_lock_recursive(NAME) \
|
||||
do { \
|
||||
void *self = THREAD_SELF; \
|
||||
if ((NAME).owner != self) \
|
||||
{ \
|
||||
lll_lock ((NAME).lock); \
|
||||
(NAME).owner = self; \
|
||||
} \
|
||||
++(NAME).cnt; \
|
||||
} while (0)
|
||||
#else
|
||||
# define __libc_lock_lock_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
|
||||
#endif
|
||||
|
||||
#define __rtld_lock_lock_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
|
||||
|
||||
/* Try to lock the named lock variable. */
|
||||
#if defined _LIBC && !defined NOT_IN_libc
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_trylock(NAME) \
|
||||
lll_trylock (NAME)
|
||||
#else
|
||||
|
|
@ -195,11 +253,34 @@ typedef pthread_key_t __libc_key_t;
|
|||
__libc_maybe_call (__pthread_rwlock_trywrlock, (&(NAME)), 0)
|
||||
|
||||
/* Try to lock the recursive named lock variable. */
|
||||
#define __libc_lock_trylock_recursive(NAME) \
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_trylock_recursive(NAME) \
|
||||
do { \
|
||||
int result = 0; \
|
||||
void *self = THREAD_SELF; \
|
||||
if ((NAME).owner != self) \
|
||||
{ \
|
||||
if (lll_trylock ((NAME).lock) == 0) \
|
||||
{ \
|
||||
(NAME).owner = self; \
|
||||
(NAME).cnt = 1; \
|
||||
} \
|
||||
else \
|
||||
result = EBUSY; \
|
||||
} \
|
||||
else \
|
||||
++(NAME).cnt; \
|
||||
} while (0)
|
||||
#else
|
||||
# define __libc_lock_trylock_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
|
||||
#endif
|
||||
|
||||
#define __rtld_lock_trylock_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_trylock, (&(NAME).mutex), 0)
|
||||
|
||||
/* Unlock the named lock variable. */
|
||||
#if defined _LIBC && !defined NOT_IN_libc
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
# define __libc_lock_unlock(NAME) \
|
||||
lll_unlock (NAME);
|
||||
#else
|
||||
|
|
@ -210,9 +291,23 @@ typedef pthread_key_t __libc_key_t;
|
|||
__libc_maybe_call (__pthread_rwlock_unlock, (&(NAME)), 0)
|
||||
|
||||
/* Unlock the recursive named lock variable. */
|
||||
#define __libc_lock_unlock_recursive(NAME) \
|
||||
#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
|
||||
/* We do no error checking here. */
|
||||
# define __libc_lock_unlock_recursive(NAME) \
|
||||
do { \
|
||||
if (--(NAME).cnt == 0) \
|
||||
{ \
|
||||
(NAME).owner = NULL; \
|
||||
lll_unlock ((NAME).lock); \
|
||||
} \
|
||||
} while (0)
|
||||
#else
|
||||
# define __libc_lock_unlock_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
|
||||
#endif
|
||||
|
||||
#define __rtld_lock_unlock_recursive(NAME) \
|
||||
__libc_maybe_call (__pthread_mutex_unlock, (&(NAME).mutex), 0)
|
||||
|
||||
/* Define once control variable. */
|
||||
#if PTHREAD_ONCE_INIT == 0
|
||||
|
|
@ -394,8 +489,4 @@ weak_extern (BP_SYM (_pthread_cleanup_pop_restore))
|
|||
# endif
|
||||
#endif
|
||||
|
||||
/* We need portable names for some functions. E.g., when they are
|
||||
used as argument to __libc_cleanup_region_start. */
|
||||
#define __libc_mutex_unlock __pthread_mutex_unlock
|
||||
|
||||
#endif /* bits/libc-lock.h */
|
||||
|
|
|
|||
|
|
@ -22,3 +22,7 @@ sysdep_routines += register-atfork unregister-atfork fork-gen
|
|||
|
||||
libpthread-sysdep_routines += pt-fork
|
||||
endif
|
||||
|
||||
ifeq ($(subdir),posix)
|
||||
CFLAGS-fork.c = -D_IO_MTSAFE_IO
|
||||
endif
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@
|
|||
#include <libio/libioP.h>
|
||||
#include <tls.h>
|
||||
#include "fork.h"
|
||||
#include <bits/stdio-lock.h>
|
||||
|
||||
|
||||
unsigned long int *__fork_generation_pointer;
|
||||
|
|
@ -41,8 +42,7 @@ fresetlockfiles (void)
|
|||
_IO_ITER i;
|
||||
|
||||
for (i = _IO_iter_begin(); i != _IO_iter_end(); i = _IO_iter_next(i))
|
||||
*((pthread_mutex_t *) _IO_iter_file(i)->_lock)
|
||||
= (pthread_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
|
||||
_IO_lock_init (*((_IO_lock_t *) _IO_iter_file(i)->_lock));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
of libc. */
|
||||
#define __libc_lock_define(CLASS,NAME)
|
||||
#define __libc_lock_define_recursive(CLASS,NAME)
|
||||
#define __rtld_lock_define_recursive(CLASS,NAME)
|
||||
#define __libc_rwlock_define(CLASS,NAME)
|
||||
|
||||
/* Define an initialized lock variable NAME with storage class CLASS. */
|
||||
|
|
@ -47,6 +48,7 @@
|
|||
|
||||
/* Same as last but this time we initialize a recursive mutex. */
|
||||
#define __libc_lock_init_recursive(NAME)
|
||||
#define __rtld_lock_init_recursive(NAME)
|
||||
|
||||
/* 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
|
||||
|
|
@ -64,6 +66,7 @@
|
|||
|
||||
/* Lock the recursive named lock variable. */
|
||||
#define __libc_lock_lock_recursive(NAME)
|
||||
#define __rtld_lock_lock_recursive(NAME)
|
||||
|
||||
/* Try to lock the named lock variable. */
|
||||
#define __libc_lock_trylock(NAME) 0
|
||||
|
|
@ -79,6 +82,7 @@
|
|||
|
||||
/* Unlock the recursive named lock variable. */
|
||||
#define __libc_lock_unlock_recursive(NAME)
|
||||
#define __rtld_lock_unlock_recursive(NAME)
|
||||
|
||||
|
||||
/* Define once control variable. */
|
||||
|
|
|
|||
|
|
@ -250,7 +250,7 @@ struct rtld_global
|
|||
This must be a recursive lock since the initializer function of
|
||||
the loaded object might as well require a call to this function.
|
||||
At this time it is not anymore a problem to modify the tables. */
|
||||
__libc_lock_define_recursive (EXTERN, _dl_load_lock)
|
||||
__rtld_lock_define_recursive (EXTERN, _dl_load_lock)
|
||||
|
||||
/* OS version. */
|
||||
EXTERN unsigned int _dl_osversion;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/* libc-internal interface for mutex locks. Mach cthreads version.
|
||||
Copyright (C) 1996,97,98,2000,01 Free Software Foundation, Inc.
|
||||
Copyright (C) 1996,97,98,2000,01, 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
|
|
@ -134,4 +134,11 @@ void *__libc_getspecific (__libc_key_t key);
|
|||
#define __libc_lock_unlock_recursive __libc_lock_unlock
|
||||
#define __libc_lock_lock_recursive __libc_lock_lock
|
||||
|
||||
#define __rtld_lock_define_initialized_recursive __libc_lock_define_initialized
|
||||
#define __rtld_lock_init_recursive __libc_lock_init
|
||||
#define __rtld_lock_fini_recursive __libc_lock_fini
|
||||
#define __rtld_lock_trylock_recursive __libc_lock_trylock
|
||||
#define __rtld_lock_unlock_recursive __libc_lock_unlock
|
||||
#define __rtld_lock_lock_recursive __libc_lock_lock
|
||||
|
||||
#endif /* bits/libc-lock.h */
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/* libc-internal interface for mutex locks. Hurd version using Mach cthreads.
|
||||
Copyright (C) 1996,97,98,2000,01 Free Software Foundation, Inc.
|
||||
Copyright (C) 1996,97,98,2000,01, 2002 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
|
|
@ -62,6 +62,7 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
|
|||
called on a lock variable before the containing storage is reused. */
|
||||
#define __libc_lock_fini(NAME) __mutex_unlock (&(NAME))
|
||||
#define __libc_lock_fini_recursive(NAME) __mutex_unlock (&(NAME).mutex)
|
||||
#define __rtld_lock_fini_recursive(NAME) __mutex_unlock (&(NAME).mutex)
|
||||
|
||||
|
||||
/* Lock the named lock variable. */
|
||||
|
|
@ -80,6 +81,13 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
|
|||
#define __libc_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
|
||||
|
||||
#define __rtld_lock_define_recursive(CLASS,NAME) \
|
||||
__libc_lock_define_recursive (CLASS, NAME)
|
||||
#define _RTLD_LOCK_RECURSIVE_INITIALIZER \
|
||||
_LIBC_LOCK_RECURSIVE_INITIALIZER
|
||||
#define __rtld_lock_define_initialized_recursive(CLASS,NAME) \
|
||||
__libc_lock_define_initialized_recursive (CLASS, NAME)
|
||||
|
||||
#define __libc_lock_init_recursive(NAME) \
|
||||
({ __libc_lock_recursive_t *const __lock = &(NAME); \
|
||||
__lock->owner = 0; mutex_init (&__lock->mutex); })
|
||||
|
|
@ -111,6 +119,16 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
|
|||
})
|
||||
|
||||
|
||||
#define __rtld_lock_init_recursive(NAME) \
|
||||
__libc_lock_init_recursive (NAME)
|
||||
#define __rtld_lock_trylock_recursive(NAME) \
|
||||
__libc_lock_trylock_recursive (NAME)
|
||||
#define __rtld_lock_lock_recursive(NAME) \
|
||||
__libc_lock_lock_recursive(NAME)
|
||||
#define __rtld_lock_unlock_recursive(NAME) \
|
||||
__libc_lock_unlock_recursive (NAME)
|
||||
|
||||
|
||||
/* XXX for now */
|
||||
#define __libc_rwlock_define __libc_lock_define
|
||||
#define __libc_rwlock_define_initialized __libc_lock_define_initialized
|
||||
|
|
|
|||
Loading…
Reference in a new issue