+2001-08-23 Roland McGrath <roland@frob.com>
+
+ * sysdeps/mach/hurd/bits/libc-lock.h: New file, initially copied from
+ sysdeps/mach version. Implement counting ("recursive") mutexes
+ on top of cthreads mutexes.
+ * sysdeps/mach/hurd/bits/stdio-lock.h: File removed; generic now works.
+
+ * sysdeps/generic/bits/stdio-lock.h (_IO_lock_initializer): Define to
+ _LIBC_LOCK_RECURSIVE_INITIALIZER if defined, else do an #error.
+ (__libc_cleanup_region_start, __libc_cleanup_region_end,
+ __libc_clean_end): Define these to call the cleanup function after
+ normal exit when they're supposed to.
+
+ * sysdeps/mach/bits/libc-lock.h (__libc_cleanup_region_start):
+ Take new first arg DOIT, a boolean saying whether to really install
+ any cleanup handler.
+ (__libc_cleanup_region_end): Do nothing if start's DOIT arg was zero.
+ (__libc_cleanup_end): Likewise.
+ * stdio-common/vfscanf.c (LOCK_STREAM): Pass new arg.
+ * stdio-common/vfprintf.c (buffered_vfprintf, vfprintf): Likewise.
+ * sysdeps/mach/hurd/bits/stdio-lock.h (_IO_cleanup_region_start):
+ Likewise.
+ * misc/syslog.c (vsyslog, openlog, closelog): Likewise.
+ * sysdeps/generic/bits/stdio-lock.h
+ (_IO_cleanup_region_start, _IO_cleanup_region_start_noarg): Likewise.
+
2001-08-23 Jakub Jelinek <jakub@redhat.com>
* elf/ldconfig.c (search_dir): Remove stale symlinks.
--- /dev/null
+/* libc-internal interface for mutex locks. Hurd version using Mach cthreads.
+ Copyright (C) 1996,97,98,2000,01 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
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _BITS_LIBC_LOCK_H
+#define _BITS_LIBC_LOCK_H 1
+
+#if (_LIBC - 0) || (_CTHREADS_ - 0)
+#include <cthreads.h>
+#include <hurd/threadvar.h>
+
+typedef struct mutex __libc_lock_t;
+typedef struct
+{
+ struct mutex mutex;
+ void *owner;
+ int count;
+} __libc_lock_recursive_t;
+
+#define __libc_lock_owner_self() ((void *) __hurd_threadvar_location (0))
+
+#else
+typedef struct __libc_lock_opaque__ __libc_lock_t;
+typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
+#endif
+
+/* Define a lock variable NAME with storage class CLASS. The lock must be
+ initialized with __libc_lock_init before it can be used (or define it
+ with __libc_lock_define_initialized, below). Use `extern' for CLASS to
+ declare a lock defined in another module. In public structure
+ definitions you must use a pointer to the lock structure (i.e., NAME
+ begins with a `*'), because its storage size will not be known outside
+ of libc. */
+#define __libc_lock_define(CLASS,NAME) \
+ CLASS __libc_lock_t NAME;
+
+/* Define an initialized lock variable NAME with storage class CLASS. */
+#define __libc_lock_define_initialized(CLASS,NAME) \
+ CLASS __libc_lock_t NAME = MUTEX_INITIALIZER;
+
+/* Initialize the named lock variable, leaving it in a consistent, unlocked
+ state. */
+#define __libc_lock_init(NAME) __mutex_init (&(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
+ 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)
+
+
+/* Lock the named lock variable. */
+#define __libc_lock_lock(NAME) __mutex_lock (&(NAME))
+
+/* Lock the named lock variable. */
+#define __libc_lock_trylock(NAME) (!__mutex_trylock (&(NAME)))
+
+/* Unlock the named lock variable. */
+#define __libc_lock_unlock(NAME) __mutex_unlock (&(NAME))
+
+
+#define __libc_lock_define_recursive(CLASS,NAME) \
+ CLASS __libc_lock_recursive_t NAME;
+#define _LIBC_LOCK_RECURSIVE_INITIALIZER { MUTEX_INITIALIZER, 0, 0 }
+#define __libc_lock_define_initialized_recursive(CLASS,NAME) \
+ CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
+
+#define __libc_lock_init_recursive(NAME) \
+ ({ __libc_lock_recursive_t *const __lock = &(NAME); \
+ __lock->owner = 0; mutex_init (&__lock->mutex); })
+
+#define __libc_lock_trylock_recursive(NAME) \
+ ({ __libc_lock_recursive_t *const __lock = &(NAME); \
+ void *__self = __libc_lock_owner_self (); \
+ __mutex_trylock (&__lock->mutex) \
+ ? (__lock->owner = __self, __lock->count = 1, 0) \
+ : __lock->owner == __self ? (++__lock->count, 0) : 1; })
+
+#define __libc_lock_lock_recursive(NAME) \
+ ({ __libc_lock_recursive_t *const __lock = &(NAME); \
+ void *__self = __libc_lock_owner_self (); \
+ if (__mutex_trylock (&__lock->mutex) \
+ || (__lock->owner != __self \
+ && (__mutex_lock (&__lock->mutex), 1))) \
+ __lock->owner = __self, __lock->count = 1; \
+ else \
+ ++__lock->count; \
+ })
+#define __libc_lock_unlock_recursive(NAME) \
+ ({ __libc_lock_recursive_t *const __lock = &(NAME); \
+ if (--__lock->count == 0) \
+ { \
+ __lock->owner = 0; \
+ __mutex_unlock (&__lock->mutex); \
+ } \
+ })
+
+
+/* XXX for now */
+#define __libc_rwlock_define __libc_lock_define
+#define __libc_rwlock_define_initialized __libc_lock_define_initialized
+#define __libc_rwlock_init __libc_lock_init
+#define __libc_rwlock_fini __libc_lock_fini
+#define __libc_rwlock_rdlock __libc_lock_lock
+#define __libc_rwlock_wrlock __libc_lock_lock
+#define __libc_rwlock_tryrdlock __libc_lock_trylock
+#define __libc_rwlock_trywrlock __libc_lock_trylock
+#define __libc_rwlock_unlock __libc_lock_unlock
+
+
+/* Start a critical region with a cleanup function */
+#define __libc_cleanup_region_start(DOIT, FCT, ARG) \
+{ \
+ typeof (***(FCT)) *__save_FCT = (DOIT) ? (FCT) : 0; \
+ typeof (ARG) __save_ARG = ARG; \
+ /* close brace is in __libc_cleanup_region_end below. */
+
+/* End a critical region started with __libc_cleanup_region_start. */
+#define __libc_cleanup_region_end(DOIT) \
+ if ((DOIT) && __save_FCT != 0) \
+ (*__save_FCT)(__save_ARG); \
+}
+
+/* Sometimes we have to exit the block in the middle. */
+#define __libc_cleanup_end(DOIT) \
+ if ((DOIT) && __save_FCT != 0) \
+ (*__save_FCT)(__save_ARG); \
+
+
+#if (_CTHREADS_ - 0)
+
+/* Use mutexes as once control variables. */
+
+struct __libc_once
+ {
+ __libc_lock_t lock;
+ int done;
+ };
+
+#define __libc_once_define(CLASS,NAME) \
+ CLASS struct __libc_once NAME = { MUTEX_INITIALIZER, 0 }
+
+/* Call handler iff the first call. */
+#define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \
+ do { \
+ __libc_lock_lock (ONCE_CONTROL.lock); \
+ if (!ONCE_CONTROL.done) \
+ (INIT_FUNCTION) (); \
+ ONCE_CONTROL.done = 1; \
+ __libc_lock_unlock (ONCE_CONTROL.lock); \
+ } while (0)
+
+#ifdef _LIBC
+/* We need portable names for some functions. E.g., when they are
+ used as argument to __libc_cleanup_region_start. */
+#define __libc_mutex_unlock __mutex_unlock
+#endif
+
+/* Type for key of thread specific data. */
+typedef cthread_key_t __libc_key_t;
+
+#define __libc_key_create(KEY,DEST) cthread_keycreate (KEY)
+#define __libc_setspecific(KEY,VAL) cthread_setspecific (KEY, VAL)
+void *__libc_getspecific (__libc_key_t key);
+
+#endif /* _CTHREADS_ */
+
+#endif /* bits/libc-lock.h */
+++ /dev/null
-/* Thread package specific definitions of stream lock type. Hurd version.
- Copyright (C) 2000, 2001 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
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- The GNU C Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA. */
-
-#ifndef _BITS_STDIO_LOCK_H
-#define _BITS_STDIO_LOCK_H 1
-
-/* We need recursive (counting) mutexes. Since cthreads doesn't really
- have them, we implement them just for libio. The implementation is
- partially here and partially in Hurd's version of cthreads (i.e. the
- libthreads library, libthreads/lockfile.c). */
-
-#if (_LIBC - 0) || (_CTHREADS_ - 0)
-#include <cthreads.h>
-
-struct _IO_cthreads_lock
-{
- struct mutex mutex;
- cthread_t owner;
- unsigned int count;
-};
-#else
-struct _IO_cthreads_lock;
-#endif
-typedef struct _IO_cthreads_lock _IO_lock_t;
-
-#define _IO_lock_initializer { MUTEX_INITIALIZER, 0, 0 }
-
-#define _IO_lock_init(_name) ({ (_name) = (_IO_lock_t) _IO_lock_initializer; })
-#define _IO_lock_fini(_name) ((void) 0) /* nothing to do */
-
-/* These are in fact only used for `list_all_lock' (libio/genops.c),
- which does not need a recursive lock. The per-FILE locks are only
- accessed through _IO_flockfile et al, which Hurd's libthreads overrides. */
-#define _IO_lock_lock(_name) __libc_lock_lock ((_name).mutex)
-#define _IO_lock_unlock(_name) __libc_lock_unlock ((_name).mutex)
-
-#ifdef _LIBC
-#include <bits/libc-lock.h>
-
-#define _IO_cleanup_region_start(_fct, _fp) \
- __libc_cleanup_region_start (_fct, _fp)
-#define _IO_cleanup_region_start_noarg(_fct) \
- __libc_cleanup_region_start (_fct, NULL)
-#define _IO_cleanup_region_end(_doit) \
- __libc_cleanup_region_end (_doit)
-#endif
-
-
-#endif /* bits/stdio-lock.h */
projects / thirdparty / glibc.git / commitdiff
