[hurd,commited,4/6] htl: Fix cleanup support for IO locking
Commit Message
* sysdeps/htl/stdio-lock.h: New file, registers locking cleanup to htl.
* sysdeps/htl/libc-lockP.h: Include <libc-lock.h>.
(__libc_cleanup_region_start, __libc_cleanup_end,
__libc_cleanup_region_end): Override macros from <libc-lock.h> with
versions which register cleanup to htl.
(__pthread_get_cleanup_stack): Make reference weak for skipping
registration on in the static non-libpthread case.
---
sysdeps/htl/libc-lockP.h | 33 +++++++++++++++++++++++
sysdeps/htl/stdio-lock.h | 57 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 90 insertions(+)
create mode 100644 sysdeps/htl/stdio-lock.h
@@ -19,6 +19,7 @@
#ifndef _BITS_LIBC_LOCKP_H
#define _BITS_LIBC_LOCKP_H 1
+#include <libc-lock.h>
#include <pthread.h>
#include <pthread-functions.h>
@@ -73,6 +74,36 @@ typedef pthread_key_t __libc_key_t;
__libc_ptf_call (__pthread_setspecific, (KEY, VALUE), 0)
+#undef __libc_cleanup_region_start
+#undef __libc_cleanup_region_end
+#undef __libc_cleanup_end
+
+#define __libc_cleanup_region_start(DOIT, FCT, ARG) \
+ { \
+ struct __pthread_cancelation_handler **__handlers = NULL; \
+ struct __pthread_cancelation_handler __handler; \
+ int _ditit = 0; \
+ if (DOIT && __pthread_get_cleanup_stack != NULL) \
+ { \
+ __handlers = __pthread_get_cleanup_stack (); \
+ __handler.__handler = FCT; \
+ __handler.__arg = ARG; \
+ __handler.__next = *__handlers; \
+ *__handlers = &__handler; \
+ _ditit = 1; \
+ }
+
+#define __libc_cleanup_end(DOIT) \
+ if (_ditit) { \
+ if (DOIT) \
+ __handler.__handler (__handler.__arg); \
+ *__handlers = __handler.__next; \
+ }
+
+#define __libc_cleanup_region_end(DOIT) \
+ __libc_cleanup_end(DOIT) \
+ }
+
/* Functions that are used by this file and are internal to the GNU C
library. */
@@ -154,6 +185,7 @@ weak_extern (__pthread_once)
weak_extern (__pthread_initialize)
weak_extern (__pthread_atfork)
weak_extern (__pthread_setcancelstate)
+weak_extern (__pthread_get_cleanup_stack)
# else
# pragma weak __pthread_mutex_init
# pragma weak __pthread_mutex_destroy
@@ -176,6 +208,7 @@ weak_extern (__pthread_setcancelstate)
# pragma weak __pthread_initialize
# pragma weak __pthread_atfork
# pragma weak __pthread_setcancelstate
+# pragma weak __pthread_get_cleanup_stack
# endif
#endif
new file mode 100644
@@ -0,0 +1,57 @@
+/* Thread package specific definitions of stream lock type. Hurd version.
+ Copyright (C) 2000-2020 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, see
+ <https://www.gnu.org/licenses/>. */
+
+#ifndef _STDIO_LOCK_H
+#define _STDIO_LOCK_H 1
+
+#include <libc-lock.h>
+
+__libc_lock_define_recursive (typedef, _IO_lock_t)
+#define _IO_lock_t_defined 1
+
+/* We need recursive (counting) mutexes. */
+# define _IO_lock_initializer _LIBC_LOCK_RECURSIVE_INITIALIZER
+
+#define _IO_lock_init(_name) __libc_lock_init_recursive (_name)
+#define _IO_lock_fini(_name) __libc_lock_fini_recursive (_name)
+#define _IO_lock_lock(_name) __libc_lock_lock_recursive (_name)
+#define _IO_lock_trylock(_name) __libc_lock_trylock_recursive (_name)
+#define _IO_lock_unlock(_name) __libc_lock_unlock_recursive (_name)
+
+
+#define _IO_cleanup_region_start(_fct, _fp) \
+ __libc_cleanup_region_start (((_fp)->_flags & _IO_USER_LOCK) == 0, _fct, _fp)
+#define _IO_cleanup_region_start_noarg(_fct) \
+ __libc_cleanup_region_start (1, _fct, NULL)
+#define _IO_cleanup_region_end(_doit) \
+ __libc_cleanup_region_end (_doit)
+
+#if defined _LIBC && IS_IN (libc)
+
+# define _IO_acquire_lock(_fp) \
+ do { \
+ _IO_cleanup_region_start((void (*) (void *)) &_IO_funlockfile, _fp); \
+ _IO_flockfile (_fp);
+# define _IO_release_lock(_fp) \
+ _IO_funlockfile (_fp); \
+ _IO_cleanup_region_end (0); \
+ } while (0)
+
+#endif
+
+#endif /* stdio-lock.h */