mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-08 14:20:07 +00:00
hurd: Add hurd thread library
Contributed by Agustina Arzille <avarzille@riseup.net> Amos Jeffries <squid3@treenet.co.nz> David Michael <fedora.dm0@gmail.com> Marco Gerards <marco@gnu.org> Marcus Brinkmann <marcus@gnu.org> Neal H. Walfield <neal@gnu.org> Pino Toscano <toscano.pino@tiscali.it> Richard Braun <rbraun@sceen.net> Roland McGrath <roland@gnu.org> Samuel Thibault <samuel.thibault@ens-lyon.org> Thomas DiModica <ricinwich@yahoo.com> Thomas Schwinge <tschwinge@gnu.org> * htl: New directory. * sysdeps/htl: New directory. * sysdeps/hurd/htl: New directory. * sysdeps/i386/htl: New directory. * sysdeps/mach/htl: New directory. * sysdeps/mach/hurd/htl: New directory. * sysdeps/mach/hurd/i386/htl: New directory. * nscd/Depend, resolv/Depend, rt/Depend: Add htl dependency. * sysdeps/mach/hurd/i386/Implies: Add mach/hurd/i386/htl imply. * sysdeps/mach/hurd/i386/libpthread.abilist: New file.
This commit is contained in:
parent
03e2aa50fd
commit
33574c17ee
24
ChangeLog
24
ChangeLog
@ -1,3 +1,27 @@
|
||||
2018-04-02 Agustina Arzille <avarzille@riseup.net>
|
||||
Amos Jeffries <squid3@treenet.co.nz>
|
||||
David Michael <fedora.dm0@gmail.com>
|
||||
Marco Gerards <marco@gnu.org>
|
||||
Marcus Brinkmann <marcus@gnu.org>
|
||||
Neal H. Walfield <neal@gnu.org>
|
||||
Pino Toscano <toscano.pino@tiscali.it>
|
||||
Richard Braun <rbraun@sceen.net>
|
||||
Roland McGrath <roland@gnu.org>
|
||||
Samuel Thibault <samuel.thibault@ens-lyon.org>
|
||||
Thomas DiModica <ricinwich@yahoo.com>
|
||||
Thomas Schwinge <tschwinge@gnu.org>
|
||||
|
||||
* htl: New directory.
|
||||
* sysdeps/htl: New directory.
|
||||
* sysdeps/hurd/htl: New directory.
|
||||
* sysdeps/i386/htl: New directory.
|
||||
* sysdeps/mach/htl: New directory.
|
||||
* sysdeps/mach/hurd/htl: New directory.
|
||||
* sysdeps/mach/hurd/i386/htl: New directory.
|
||||
* nscd/Depend, resolv/Depend, rt/Depend: Add htl dependency.
|
||||
* sysdeps/mach/hurd/i386/Implies: Add mach/hurd/i386/htl imply.
|
||||
* sysdeps/mach/hurd/i386/libpthread.abilist: New file.
|
||||
|
||||
2018-04-02 Samuel Thibault <samuel.thibault@ens-lyon.org>
|
||||
|
||||
* sysdeps/pthread/timer_routines.c (__timer_thread_start): Block all
|
||||
|
237
htl/Makefile
Normal file
237
htl/Makefile
Normal file
@ -0,0 +1,237 @@
|
||||
#
|
||||
# Copyright (C) 1994-2018 Free Software Foundation, Inc.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License as
|
||||
# published by the Free Software Foundation; either version 2, or (at
|
||||
# your option) any later version.
|
||||
#
|
||||
# This program 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
|
||||
# General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
subdir := htl
|
||||
|
||||
srcdir = .
|
||||
|
||||
MICROKERNEL := mach
|
||||
SYSDEPS := lockfile
|
||||
|
||||
LCLHDRS :=
|
||||
|
||||
libpthread-routines := pt-attr pt-attr-destroy pt-attr-getdetachstate \
|
||||
pt-attr-getguardsize pt-attr-getinheritsched \
|
||||
pt-attr-getschedparam pt-attr-getschedpolicy pt-attr-getscope \
|
||||
pt-attr-getstack pt-attr-getstackaddr pt-attr-getstacksize \
|
||||
pt-attr-init pt-attr-setdetachstate pt-attr-setguardsize \
|
||||
pt-attr-setinheritsched pt-attr-setschedparam \
|
||||
pt-attr-setschedpolicy pt-attr-setscope pt-attr-setstack \
|
||||
pt-attr-setstackaddr pt-attr-setstacksize \
|
||||
\
|
||||
pt-barrier-destroy pt-barrier-init pt-barrier-wait \
|
||||
pt-barrier pt-barrierattr-destroy pt-barrierattr-init \
|
||||
pt-barrierattr-getpshared pt-barrierattr-setpshared \
|
||||
\
|
||||
pt-destroy-specific pt-init-specific \
|
||||
pt-key-create pt-key-delete \
|
||||
pt-getspecific pt-setspecific \
|
||||
\
|
||||
pt-once \
|
||||
\
|
||||
pt-alloc \
|
||||
pt-create \
|
||||
pt-getattr \
|
||||
pt-equal \
|
||||
pt-dealloc \
|
||||
pt-detach \
|
||||
pt-exit \
|
||||
pt-initialize \
|
||||
pt-join \
|
||||
pt-self \
|
||||
pt-sigmask \
|
||||
pt-spin-inlines \
|
||||
pt-cleanup \
|
||||
pt-setcancelstate \
|
||||
pt-setcanceltype \
|
||||
pt-testcancel \
|
||||
pt-cancel \
|
||||
\
|
||||
pt-mutexattr \
|
||||
pt-mutexattr-destroy pt-mutexattr-init \
|
||||
pt-mutexattr-getprioceiling pt-mutexattr-getprotocol \
|
||||
pt-mutexattr-getpshared pt-mutexattr-gettype \
|
||||
pt-mutexattr-setprioceiling pt-mutexattr-setprotocol \
|
||||
pt-mutexattr-setpshared pt-mutexattr-settype \
|
||||
pt-mutexattr-getrobust pt-mutexattr-setrobust \
|
||||
\
|
||||
pt-mutex-init pt-mutex-destroy \
|
||||
pt-mutex-lock pt-mutex-trylock pt-mutex-timedlock \
|
||||
pt-mutex-unlock \
|
||||
pt-mutex-transfer-np \
|
||||
pt-mutex-getprioceiling pt-mutex-setprioceiling \
|
||||
pt-mutex-consistent \
|
||||
\
|
||||
pt-rwlock-attr \
|
||||
pt-rwlockattr-init pt-rwlockattr-destroy \
|
||||
pt-rwlockattr-getpshared pt-rwlockattr-setpshared \
|
||||
\
|
||||
pt-rwlock-init pt-rwlock-destroy \
|
||||
pt-rwlock-rdlock pt-rwlock-tryrdlock \
|
||||
pt-rwlock-trywrlock pt-rwlock-wrlock \
|
||||
pt-rwlock-timedrdlock pt-rwlock-timedwrlock \
|
||||
pt-rwlock-unlock \
|
||||
\
|
||||
pt-cond \
|
||||
pt-condattr-init pt-condattr-destroy \
|
||||
pt-condattr-getclock pt-condattr-getpshared \
|
||||
pt-condattr-setclock pt-condattr-setpshared \
|
||||
\
|
||||
pt-cond-destroy pt-cond-init \
|
||||
pt-cond-brdcast \
|
||||
pt-cond-signal \
|
||||
pt-cond-wait \
|
||||
pt-cond-timedwait \
|
||||
pt-hurd-cond-wait \
|
||||
pt-hurd-cond-timedwait \
|
||||
\
|
||||
pt-stack-alloc \
|
||||
pt-thread-alloc \
|
||||
pt-thread-start \
|
||||
pt-thread-terminate \
|
||||
pt-startup \
|
||||
\
|
||||
pt-getconcurrency pt-setconcurrency \
|
||||
\
|
||||
pt-block \
|
||||
pt-timedblock \
|
||||
pt-wakeup \
|
||||
pt-docancel \
|
||||
pt-sysdep \
|
||||
pt-setup \
|
||||
pt-machdep \
|
||||
pt-spin \
|
||||
\
|
||||
pt-sigstate-init \
|
||||
pt-sigstate-destroy \
|
||||
pt-sigstate \
|
||||
\
|
||||
pt-atfork \
|
||||
old_pt-atfork \
|
||||
pt-kill \
|
||||
pt-getcpuclockid \
|
||||
\
|
||||
pt-getschedparam pt-setschedparam pt-setschedprio \
|
||||
pt-yield \
|
||||
\
|
||||
sem-close sem-destroy sem-getvalue sem-init sem-open \
|
||||
sem-post sem-timedwait sem-trywait sem-unlink \
|
||||
sem-wait \
|
||||
\
|
||||
shm-directory \
|
||||
\
|
||||
cthreads-compat \
|
||||
$(SYSDEPS)
|
||||
|
||||
libpthread-static-only-routines = pt-atfork
|
||||
|
||||
headers := \
|
||||
pthread.h \
|
||||
semaphore.h \
|
||||
\
|
||||
bits/pthread.h \
|
||||
bits/pthread-np.h \
|
||||
bits/pthreadtypes.h \
|
||||
bits/pthreadtypes-arch.h \
|
||||
bits/thread-shared-types.h \
|
||||
bits/types/struct___pthread_mutex.h \
|
||||
bits/types/struct___pthread_cond.h \
|
||||
bits/types/struct___pthread_condattr.h \
|
||||
bits/types/__pthread_spinlock_t.h \
|
||||
bits/spin-lock-inline.h \
|
||||
bits/cancelation.h \
|
||||
bits/types/struct___pthread_attr.h \
|
||||
bits/types/struct___pthread_barrierattr.h \
|
||||
bits/types/struct___pthread_barrier.h \
|
||||
bits/types/__pthread_key.h \
|
||||
bits/types/struct___pthread_once.h \
|
||||
bits/types/struct___pthread_mutexattr.h \
|
||||
bits/types/struct___pthread_rwlock.h \
|
||||
bits/types/struct___pthread_rwlockattr.h \
|
||||
bits/semaphore.h
|
||||
|
||||
distribute :=
|
||||
|
||||
routines := forward libc_pthread_init alloca_cutoff
|
||||
shared-only-routines = forward
|
||||
|
||||
extra-libs := libpthread
|
||||
extra-libs-others := $(extra-libs)
|
||||
install-lib := libpthread.so
|
||||
|
||||
include ../Makeconfig
|
||||
|
||||
CFLAGS-lockfile.c = -D_IO_MTSAFE_IO
|
||||
|
||||
all: # Make this the default target; it will be defined in Rules.
|
||||
|
||||
subdir_install: $(inst_libdir)/libpthread2.a
|
||||
|
||||
# XXX: If $(inst_libdir)/libpthread2.a is installed and
|
||||
# $(inst_libdir)/libpthread is not, we can have some issues.
|
||||
.PHONY: $(inst_libdir)/libpthread.a $(inst_libdir)/libpthread_pic.a
|
||||
|
||||
# XXX: These rules are a hack. But it is better than messing with
|
||||
# ../Makeconf at the moment. Note that the linker scripts
|
||||
# $(srcdir)/libpthread.a and $(srcdir)/libpthread_pic.a get overwritten
|
||||
# when building in $(srcdir) and not a seperate build directory.
|
||||
$(inst_libdir)/libpthread2.a: $(inst_libdir)/libpthread.a
|
||||
mv $< $@
|
||||
$(INSTALL_DATA) $(srcdir)/libpthread.a $<
|
||||
|
||||
$(inst_libdir)/libpthread2_pic.a: $(inst_libdir)/libpthread_pic.a
|
||||
mv $< $@
|
||||
$(INSTALL_DATA) $(srcdir)/libpthread_pic.a $<
|
||||
|
||||
libc-link.so = $(common-objpfx)libc.so
|
||||
|
||||
extra-B-pthread.so = -B$(common-objpfx)htl/
|
||||
|
||||
include ../Rules
|
||||
|
||||
ifeq (yes,$(build-shared))
|
||||
# What we install as libpthread.so for programs to link against is in fact a
|
||||
# link script. It contains references for the various libraries we need.
|
||||
# The libpthread.so object is not complete since some functions are only
|
||||
# defined in libpthread_nonshared.a.
|
||||
# We need to use absolute paths since otherwise local copies (if they exist)
|
||||
# of the files are taken by the linker.
|
||||
install: $(inst_libdir)/libpthread.so
|
||||
|
||||
$(inst_libdir)/libpthread.so: $(common-objpfx)format.lds \
|
||||
$(objpfx)libpthread.so$(libpthread.so-version) \
|
||||
$(inst_libdir)/$(patsubst %,$(libtype.oS),\
|
||||
$(libprefix)pthread) \
|
||||
$(+force)
|
||||
(echo '/* GNU ld script';\
|
||||
echo ' Use the shared library, but some functions are only in';\
|
||||
echo ' the static library, so try that secondarily. */';\
|
||||
cat $<; \
|
||||
echo 'GROUP ( $(slibdir)/libpthread.so$(libpthread.so-version)' \
|
||||
'$(libdir)/$(patsubst %,$(libtype.oS),$(libprefix)pthread)'\
|
||||
')' \
|
||||
) > $@.new
|
||||
mv -f $@.new $@
|
||||
|
||||
$(addprefix $(objpfx), \
|
||||
$(filter-out $(tests-static) $(xtests-static) $(tests-reverse) \
|
||||
$(tests-nolibpthread), \
|
||||
$(tests) $(xtests) $(test-srcs))): $(objpfx)libpthread.so \
|
||||
$(objpfx)libpthread_nonshared.a
|
||||
endif
|
||||
|
||||
generated += libpthread_nonshared.a
|
156
htl/Versions
Normal file
156
htl/Versions
Normal file
@ -0,0 +1,156 @@
|
||||
libc {
|
||||
GLIBC_2.21 {
|
||||
pthread_attr_destroy; pthread_attr_getdetachstate;
|
||||
pthread_attr_getinheritsched; pthread_attr_getschedparam;
|
||||
pthread_attr_getschedpolicy; pthread_attr_getscope; pthread_attr_init;
|
||||
pthread_attr_setdetachstate; pthread_attr_setinheritsched;
|
||||
pthread_attr_setschedparam; pthread_attr_setschedpolicy;
|
||||
pthread_attr_setscope;
|
||||
pthread_condattr_destroy; pthread_condattr_init;
|
||||
pthread_cond_broadcast; pthread_cond_destroy;
|
||||
pthread_cond_init; pthread_cond_signal; pthread_cond_wait;
|
||||
pthread_cond_timedwait;
|
||||
pthread_equal;
|
||||
pthread_exit; pthread_getschedparam; pthread_setschedparam;
|
||||
pthread_mutex_destroy; pthread_mutex_init;
|
||||
pthread_mutex_lock; pthread_mutex_trylock; pthread_mutex_unlock;
|
||||
pthread_self; pthread_setcancelstate; pthread_setcanceltype;
|
||||
__pthread_get_cleanup_stack;
|
||||
}
|
||||
GLIBC_2.22 {
|
||||
__register_atfork;
|
||||
}
|
||||
GLIBC_PRIVATE {
|
||||
__libc_alloca_cutoff;
|
||||
__libc_pthread_init;
|
||||
}
|
||||
}
|
||||
|
||||
libpthread {
|
||||
GLIBC_2.2.6 {
|
||||
_IO_flockfile; _IO_ftrylockfile; _IO_funlockfile;
|
||||
}
|
||||
GLIBC_2.12 {
|
||||
__pthread_errorcheck_mutexattr; __pthread_recursive_mutexattr;
|
||||
|
||||
__pthread_get_cleanup_stack;
|
||||
|
||||
__pthread_mutex_transfer_np;
|
||||
|
||||
_pthread_mutex_destroy; _pthread_mutex_init;
|
||||
_pthread_mutex_lock; _pthread_mutex_trylock; _pthread_mutex_unlock;
|
||||
_pthread_rwlock_destroy; _pthread_rwlock_init;
|
||||
|
||||
_cthread_init_routine;
|
||||
|
||||
cthread_detach;
|
||||
cthread_fork;
|
||||
cthread_keycreate;
|
||||
cthread_getspecific;
|
||||
cthread_setspecific;
|
||||
__mutex_lock_solid;
|
||||
__mutex_unlock_solid;
|
||||
_cthreads_flockfile;
|
||||
_cthreads_ftrylockfile;
|
||||
_cthreads_funlockfile;
|
||||
|
||||
flockfile; ftrylockfile; funlockfile;
|
||||
|
||||
pthread_atfork;
|
||||
|
||||
pthread_attr_destroy; pthread_attr_getdetachstate;
|
||||
pthread_attr_getguardsize; pthread_attr_getinheritsched;
|
||||
pthread_attr_getschedparam; pthread_attr_getschedpolicy;
|
||||
pthread_attr_getscope; pthread_attr_getstack; pthread_attr_getstackaddr;
|
||||
pthread_attr_getstacksize; pthread_attr_init; pthread_attr_setdetachstate;
|
||||
pthread_attr_setguardsize; pthread_attr_setinheritsched;
|
||||
pthread_attr_setschedparam; pthread_attr_setschedpolicy;
|
||||
pthread_attr_setscope; pthread_attr_setstack; pthread_attr_setstackaddr;
|
||||
pthread_attr_setstacksize;
|
||||
|
||||
pthread_barrier_destroy; pthread_barrier_init; pthread_barrier_wait;
|
||||
pthread_barrierattr_destroy; pthread_barrierattr_getpshared;
|
||||
pthread_barrierattr_init; pthread_barrierattr_setpshared;
|
||||
|
||||
pthread_cancel;
|
||||
|
||||
pthread_cond_broadcast; pthread_cond_destroy; pthread_cond_init;
|
||||
pthread_cond_signal; pthread_cond_timedwait; pthread_cond_wait;
|
||||
|
||||
pthread_condattr_destroy; pthread_condattr_getclock;
|
||||
pthread_condattr_getpshared; pthread_condattr_init;
|
||||
pthread_condattr_setclock; pthread_condattr_setpshared;
|
||||
|
||||
pthread_create; pthread_detach; pthread_equal; pthread_exit;
|
||||
|
||||
pthread_getattr_np;
|
||||
|
||||
pthread_getconcurrency; pthread_getcpuclockid;
|
||||
pthread_getschedparam; pthread_getspecific;
|
||||
|
||||
pthread_join;
|
||||
|
||||
pthread_key_create; pthread_key_delete;
|
||||
__pthread_key_create;
|
||||
|
||||
pthread_kill;
|
||||
__pthread_kill;
|
||||
|
||||
pthread_mutex_destroy; pthread_mutex_getprioceiling;
|
||||
pthread_mutex_init; pthread_mutex_lock; pthread_mutex_setprioceiling;
|
||||
pthread_mutex_timedlock; pthread_mutex_transfer_np;
|
||||
pthread_mutex_trylock; pthread_mutex_unlock;
|
||||
|
||||
pthread_mutexattr_destroy; pthread_mutexattr_getprioceiling;
|
||||
pthread_mutexattr_getprotocol; pthread_mutexattr_getpshared;
|
||||
pthread_mutexattr_gettype; pthread_mutexattr_init;
|
||||
pthread_mutexattr_setprioceiling; pthread_mutexattr_setprotocol;
|
||||
pthread_mutexattr_setpshared; pthread_mutexattr_settype;
|
||||
|
||||
pthread_once;
|
||||
|
||||
pthread_rwlock_destroy; pthread_rwlock_init; pthread_rwlock_rdlock;
|
||||
pthread_rwlock_timedrdlock; pthread_rwlock_timedwrlock;
|
||||
pthread_rwlock_tryrdlock; pthread_rwlock_trywrlock;
|
||||
pthread_rwlock_unlock; pthread_rwlock_wrlock;
|
||||
|
||||
pthread_rwlockattr_destroy; pthread_rwlockattr_getpshared;
|
||||
pthread_rwlockattr_init; pthread_rwlockattr_setpshared;
|
||||
|
||||
pthread_self;
|
||||
__pthread_self;
|
||||
|
||||
pthread_setcancelstate; pthread_setcanceltype;
|
||||
pthread_setconcurrency; pthread_setschedparam;
|
||||
pthread_setschedprio; pthread_setspecific;
|
||||
|
||||
pthread_sigmask;
|
||||
pthread_testcancel;
|
||||
pthread_yield;
|
||||
|
||||
sem_close; sem_destroy; sem_getvalue; sem_init; sem_open; sem_post;
|
||||
sem_timedwait; sem_trywait; sem_unlink; sem_wait;
|
||||
|
||||
pthread_spin_destroy; pthread_spin_init; pthread_spin_lock;
|
||||
pthread_spin_trylock; pthread_spin_unlock;
|
||||
__pthread_spin_destroy; __pthread_spin_init;
|
||||
__pthread_spin_lock; __pthread_spin_trylock; __pthread_spin_unlock;
|
||||
_pthread_spin_lock;
|
||||
}
|
||||
GLIBC_2.21 {
|
||||
pthread_hurd_cond_wait_np;
|
||||
pthread_hurd_cond_timedwait_np;
|
||||
}
|
||||
GLIBC_PRIVATE {
|
||||
__shm_directory;
|
||||
__pthread_threads;
|
||||
|
||||
__cthread_detach;
|
||||
__cthread_fork;
|
||||
__cthread_keycreate;
|
||||
__cthread_getspecific;
|
||||
__cthread_setspecific;
|
||||
__pthread_getattr_np;
|
||||
__pthread_attr_getstack;
|
||||
}
|
||||
}
|
26
htl/alloca_cutoff.c
Normal file
26
htl/alloca_cutoff.c
Normal file
@ -0,0 +1,26 @@
|
||||
/* Allocate a new thread structure.
|
||||
Copyright (C) 2015-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <alloca.h>
|
||||
|
||||
int
|
||||
__libc_alloca_cutoff (size_t size)
|
||||
{
|
||||
return size <= 65536;
|
||||
}
|
||||
libc_hidden_def (__libc_alloca_cutoff)
|
2
htl/configure
vendored
Normal file
2
htl/configure
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
libc_add_on_canonical=libpthread
|
||||
libc_add_on_subdirs=.
|
4
htl/configure.in
Normal file
4
htl/configure.in
Normal file
@ -0,0 +1,4 @@
|
||||
GLIBC_PROVIDES
|
||||
|
||||
libc_add_on_canonical=libpthread
|
||||
libc_add_on_subdirs=.
|
101
htl/cthreads-compat.c
Normal file
101
htl/cthreads-compat.c
Normal file
@ -0,0 +1,101 @@
|
||||
/* Compatibility routines for cthreads.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <assert.h>
|
||||
#include <pthreadP.h>
|
||||
|
||||
#define CTHREAD_KEY_INVALID (__cthread_key_t) -1
|
||||
|
||||
void
|
||||
__cthread_detach (__cthread_t thread)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = pthread_detach ((pthread_t) thread);
|
||||
assert_perror (err);
|
||||
}
|
||||
weak_alias (__cthread_detach, cthread_detach)
|
||||
|
||||
__cthread_t
|
||||
__cthread_fork (__cthread_fn_t func, void *arg)
|
||||
{
|
||||
pthread_t thread;
|
||||
int err;
|
||||
|
||||
err = pthread_create (&thread, NULL, func, arg);
|
||||
assert_perror (err);
|
||||
|
||||
return (__cthread_t) thread;
|
||||
}
|
||||
weak_alias (__cthread_fork, cthread_fork)
|
||||
|
||||
int
|
||||
__cthread_keycreate (__cthread_key_t *key)
|
||||
{
|
||||
error_t err;
|
||||
|
||||
err = pthread_key_create (key, 0);
|
||||
if (err)
|
||||
{
|
||||
errno = err;
|
||||
*key = CTHREAD_KEY_INVALID;
|
||||
err = -1;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
weak_alias (__cthread_keycreate, cthread_keycreate)
|
||||
|
||||
int
|
||||
__cthread_getspecific (__cthread_key_t key, void **val)
|
||||
{
|
||||
*val = pthread_getspecific (key);
|
||||
return 0;
|
||||
}
|
||||
weak_alias (__cthread_getspecific, cthread_getspecific)
|
||||
|
||||
int
|
||||
__cthread_setspecific (__cthread_key_t key, void *val)
|
||||
{
|
||||
error_t err;
|
||||
|
||||
err = pthread_setspecific (key, (const void *) val);
|
||||
if (err)
|
||||
{
|
||||
errno = err;
|
||||
err = -1;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
weak_alias (__cthread_setspecific, cthread_setspecific)
|
||||
|
||||
void
|
||||
__mutex_lock_solid (void *lock)
|
||||
{
|
||||
__pthread_mutex_lock (lock);
|
||||
}
|
||||
|
||||
void
|
||||
__mutex_unlock_solid (void *lock)
|
||||
{
|
||||
if (__pthread_spin_trylock (lock) != 0)
|
||||
/* Somebody already got the lock, that one will manage waking up others */
|
||||
return;
|
||||
__pthread_mutex_unlock (lock);
|
||||
}
|
283
htl/forward.c
Normal file
283
htl/forward.c
Normal file
@ -0,0 +1,283 @@
|
||||
/* Libc stubs for pthread functions. Hurd pthread version.
|
||||
Copyright (C) 2002-2018 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
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <errno.h>
|
||||
#include <dlfcn.h>
|
||||
#include <stdlib.h>
|
||||
#include <shlib-compat.h>
|
||||
#include <pthread-functions.h>
|
||||
#include <libc-lock.h>
|
||||
#include <fork.h>
|
||||
|
||||
/* Pointers to the libc functions. */
|
||||
struct pthread_functions __libc_pthread_functions attribute_hidden;
|
||||
int __libc_pthread_functions_init attribute_hidden;
|
||||
|
||||
|
||||
#define FORWARD2(name, rettype, decl, params, defaction) \
|
||||
rettype \
|
||||
name decl \
|
||||
{ \
|
||||
if (!__libc_pthread_functions_init) \
|
||||
defaction; \
|
||||
\
|
||||
return PTHFCT_CALL (ptr_##name, params); \
|
||||
}
|
||||
|
||||
/* Same as FORWARD2, only without return. */
|
||||
#define FORWARD_NORETURN(name, rettype, decl, params, defaction) \
|
||||
rettype \
|
||||
name decl \
|
||||
{ \
|
||||
if (!__libc_pthread_functions_init) \
|
||||
defaction; \
|
||||
\
|
||||
PTHFCT_CALL (ptr_##name, params); \
|
||||
}
|
||||
|
||||
#define FORWARD(name, decl, params, defretval) \
|
||||
FORWARD2 (name, int, decl, params, return defretval)
|
||||
|
||||
FORWARD (pthread_attr_destroy, (pthread_attr_t *attr), (attr), 0)
|
||||
|
||||
FORWARD (pthread_attr_init, (pthread_attr_t *attr), (attr), 0)
|
||||
|
||||
FORWARD (pthread_attr_getdetachstate,
|
||||
(const pthread_attr_t *attr, int *detachstate), (attr, detachstate),
|
||||
0)
|
||||
FORWARD (pthread_attr_setdetachstate, (pthread_attr_t *attr, int detachstate),
|
||||
(attr, detachstate), 0)
|
||||
|
||||
FORWARD (pthread_attr_getinheritsched,
|
||||
(const pthread_attr_t *attr, int *inherit), (attr, inherit), 0)
|
||||
FORWARD (pthread_attr_setinheritsched, (pthread_attr_t *attr, int inherit),
|
||||
(attr, inherit), 0)
|
||||
|
||||
FORWARD (pthread_attr_getschedparam,
|
||||
(const pthread_attr_t *attr, struct sched_param *param),
|
||||
(attr, param), 0)
|
||||
FORWARD (pthread_attr_setschedparam,
|
||||
(pthread_attr_t *attr, const struct sched_param *param),
|
||||
(attr, param), 0)
|
||||
|
||||
FORWARD (pthread_attr_getschedpolicy,
|
||||
(const pthread_attr_t *attr, int *policy), (attr, policy), 0)
|
||||
FORWARD (pthread_attr_setschedpolicy, (pthread_attr_t *attr, int policy),
|
||||
(attr, policy), 0)
|
||||
|
||||
FORWARD (pthread_attr_getscope,
|
||||
(const pthread_attr_t *attr, int *scope), (attr, scope), 0)
|
||||
FORWARD (pthread_attr_setscope, (pthread_attr_t *attr, int scope),
|
||||
(attr, scope), 0)
|
||||
|
||||
|
||||
FORWARD (pthread_condattr_destroy, (pthread_condattr_t *attr), (attr), 0)
|
||||
FORWARD (pthread_condattr_init, (pthread_condattr_t *attr), (attr), 0)
|
||||
|
||||
|
||||
FORWARD (pthread_cond_broadcast, (pthread_cond_t *cond), (cond), 0)
|
||||
FORWARD (pthread_cond_destroy, (pthread_cond_t *cond), (cond), 0)
|
||||
FORWARD (pthread_cond_init,
|
||||
(pthread_cond_t *cond, const pthread_condattr_t *cond_attr),
|
||||
(cond, cond_attr), 0)
|
||||
FORWARD (pthread_cond_signal, (pthread_cond_t *cond), (cond), 0)
|
||||
FORWARD (pthread_cond_wait, (pthread_cond_t *cond, pthread_mutex_t *mutex),
|
||||
(cond, mutex), 0)
|
||||
FORWARD (pthread_cond_timedwait,
|
||||
(pthread_cond_t *cond, pthread_mutex_t *mutex,
|
||||
const struct timespec *abstime), (cond, mutex, abstime), 0)
|
||||
|
||||
FORWARD (pthread_equal, (pthread_t thread1, pthread_t thread2),
|
||||
(thread1, thread2), 1)
|
||||
|
||||
|
||||
/* Use an alias to avoid warning, as pthread_exit is declared noreturn. */
|
||||
FORWARD_NORETURN (__pthread_exit, void, (void *retval), (retval),
|
||||
exit (EXIT_SUCCESS))
|
||||
strong_alias (__pthread_exit, pthread_exit);
|
||||
|
||||
|
||||
FORWARD (pthread_getschedparam,
|
||||
(pthread_t target_thread, int *policy, struct sched_param *param),
|
||||
(target_thread, policy, param), 0)
|
||||
FORWARD (pthread_setschedparam,
|
||||
(pthread_t target_thread, int policy,
|
||||
const struct sched_param *param), (target_thread, policy, param), 0)
|
||||
|
||||
|
||||
FORWARD (pthread_mutex_destroy, (pthread_mutex_t *mutex), (mutex), 0)
|
||||
|
||||
FORWARD (pthread_mutex_init,
|
||||
(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr),
|
||||
(mutex, mutexattr), 0)
|
||||
|
||||
FORWARD (pthread_mutex_lock, (pthread_mutex_t *mutex), (mutex), 0)
|
||||
|
||||
FORWARD (pthread_mutex_unlock, (pthread_mutex_t *mutex), (mutex), 0)
|
||||
|
||||
|
||||
FORWARD2 (pthread_self, pthread_t, (void), (), return 0)
|
||||
|
||||
|
||||
FORWARD (__pthread_setcancelstate, (int state, int *oldstate),
|
||||
(state, oldstate), 0)
|
||||
strong_alias (__pthread_setcancelstate, pthread_setcancelstate);
|
||||
|
||||
FORWARD (pthread_setcanceltype, (int type, int *oldtype), (type, oldtype), 0)
|
||||
|
||||
struct __pthread_cancelation_handler *dummy_list;
|
||||
FORWARD2 (__pthread_get_cleanup_stack, struct __pthread_cancelation_handler **,
|
||||
(void), (), return &dummy_list);
|
||||
|
||||
|
||||
/* Fork interaction */
|
||||
|
||||
struct atfork
|
||||
{
|
||||
void (*prepare) (void);
|
||||
void (*parent) (void);
|
||||
void (*child) (void);
|
||||
void *dso_handle;
|
||||
struct atfork *prev;
|
||||
struct atfork *next;
|
||||
};
|
||||
|
||||
/* TODO: better locking */
|
||||
__libc_lock_define_initialized (static, atfork_lock);
|
||||
static struct atfork *fork_handlers, *fork_last_handler;
|
||||
|
||||
static void
|
||||
atfork_pthread_prepare (void)
|
||||
{
|
||||
struct atfork *handlers, *last_handler;
|
||||
|
||||
__libc_lock_lock (atfork_lock);
|
||||
handlers = fork_handlers;
|
||||
last_handler = fork_last_handler;
|
||||
__libc_lock_unlock (atfork_lock);
|
||||
|
||||
if (last_handler == NULL)
|
||||
return;
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (last_handler->prepare != NULL)
|
||||
last_handler->prepare ();
|
||||
if (last_handler == handlers)
|
||||
break;
|
||||
last_handler = last_handler->prev;
|
||||
}
|
||||
}
|
||||
text_set_element (_hurd_atfork_prepare_hook, atfork_pthread_prepare);
|
||||
|
||||
static void
|
||||
atfork_pthread_parent (void)
|
||||
{
|
||||
struct atfork *handlers;
|
||||
|
||||
__libc_lock_lock (atfork_lock);
|
||||
handlers = fork_handlers;
|
||||
__libc_lock_unlock (atfork_lock);
|
||||
|
||||
while (handlers != NULL)
|
||||
{
|
||||
if (handlers->parent != NULL)
|
||||
handlers->parent ();
|
||||
handlers = handlers->next;
|
||||
}
|
||||
}
|
||||
text_set_element (_hurd_atfork_parent_hook, atfork_pthread_parent);
|
||||
|
||||
static void
|
||||
atfork_pthread_child (void)
|
||||
{
|
||||
struct atfork *handlers;
|
||||
|
||||
__libc_lock_lock (atfork_lock);
|
||||
handlers = fork_handlers;
|
||||
__libc_lock_unlock (atfork_lock);
|
||||
|
||||
while (handlers != NULL)
|
||||
{
|
||||
if (handlers->child != NULL)
|
||||
handlers->child ();
|
||||
handlers = handlers->next;
|
||||
}
|
||||
}
|
||||
text_set_element (_hurd_atfork_child_hook, atfork_pthread_child);
|
||||
|
||||
int
|
||||
__register_atfork (void (*prepare) (void),
|
||||
void (*parent) (void),
|
||||
void (*child) (void),
|
||||
void *dso_handle)
|
||||
{
|
||||
struct atfork *new = malloc (sizeof (*new));
|
||||
if (new == NULL)
|
||||
return errno;
|
||||
|
||||
new->prepare = prepare;
|
||||
new->parent = parent;
|
||||
new->child = child;
|
||||
new->dso_handle = dso_handle;
|
||||
new->prev = NULL;
|
||||
|
||||
__libc_lock_lock (atfork_lock);
|
||||
new->next = fork_handlers;
|
||||
if (fork_handlers != NULL)
|
||||
fork_handlers->prev = new;
|
||||
fork_handlers = new;
|
||||
if (fork_last_handler == NULL)
|
||||
fork_last_handler = new;
|
||||
__libc_lock_unlock (atfork_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
libc_hidden_def (__register_atfork)
|
||||
|
||||
void
|
||||
__unregister_atfork (void *dso_handle)
|
||||
{
|
||||
struct atfork **handlers, *prev = NULL, *next;
|
||||
__libc_lock_lock (atfork_lock);
|
||||
handlers = &fork_handlers;
|
||||
while (*handlers != NULL)
|
||||
{
|
||||
if ((*handlers)->dso_handle == dso_handle)
|
||||
{
|
||||
/* Drop this handler from the list. */
|
||||
if (*handlers == fork_last_handler)
|
||||
{
|
||||
/* Was last, new last is prev, if any. */
|
||||
fork_last_handler = prev;
|
||||
}
|
||||
|
||||
next = (*handlers)->next;
|
||||
if (next != NULL)
|
||||
next->prev = prev;
|
||||
*handlers = next;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Just proceed to next handler. */
|
||||
prev = *handlers;
|
||||
handlers = &prev->next;
|
||||
}
|
||||
}
|
||||
__libc_lock_unlock (atfork_lock);
|
||||
}
|
33
htl/libc_pthread_init.c
Normal file
33
htl/libc_pthread_init.c
Normal file
@ -0,0 +1,33 @@
|
||||
/* libc initialization for libpthread. Hurd pthread version.
|
||||
Copyright (C) 2002-2018 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
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <string.h>
|
||||
#include <pthread-functions.h>
|
||||
|
||||
void
|
||||
__libc_pthread_init (const struct pthread_functions *functions)
|
||||
{
|
||||
#ifdef SHARED
|
||||
/* We copy the content of the variable pointed to by the FUNCTIONS
|
||||
parameter to one in libc.so since this means access to the array
|
||||
can be done with one memory access instead of two. */
|
||||
memcpy (&__libc_pthread_functions, functions,
|
||||
sizeof (__libc_pthread_functions));
|
||||
__libc_pthread_functions_init = 1;
|
||||
#endif
|
||||
}
|
22
htl/libpthread.a
Normal file
22
htl/libpthread.a
Normal file
@ -0,0 +1,22 @@
|
||||
/* pthread initializer is weak in glibc. It must be included if glibc
|
||||
is to start threading. */
|
||||
EXTERN(_cthread_init_routine)
|
||||
|
||||
/* Weak references in glibc that must be filled if glibc is to be
|
||||
thread safe. */
|
||||
EXTERN(cthread_detach)
|
||||
EXTERN(cthread_fork)
|
||||
EXTERN(cthread_keycreate)
|
||||
EXTERN(cthread_getspecific)
|
||||
EXTERN(cthread_setspecific)
|
||||
EXTERN(__mutex_lock_solid)
|
||||
EXTERN(__mutex_unlock_solid)
|
||||
/* For libio stream locking. */
|
||||
EXTERN(_cthreads_flockfile)
|
||||
EXTERN(_cthreads_funlockfile)
|
||||
EXTERN(_cthreads_ftrylockfile)
|
||||
/* To get the sigthread stack layout on fork */
|
||||
EXTERN(pthread_getattr_np)
|
||||
EXTERN(pthread_attr_getstack)
|
||||
|
||||
GROUP(-lpthread2 -lrt)
|
22
htl/libpthread_pic.a
Normal file
22
htl/libpthread_pic.a
Normal file
@ -0,0 +1,22 @@
|
||||
/* pthread initializer is weak in glibc. It must be included if glibc
|
||||
is to start threading. */
|
||||
EXTERN(_cthread_init_routine)
|
||||
|
||||
/* Weak references in glibc that must be filled if glibc is to be
|
||||
thread safe. */
|
||||
EXTERN(cthread_detach)
|
||||
EXTERN(cthread_fork)
|
||||
EXTERN(cthread_keycreate)
|
||||
EXTERN(cthread_getspecific)
|
||||
EXTERN(cthread_setspecific)
|
||||
EXTERN(__mutex_lock_solid)
|
||||
EXTERN(__mutex_unlock_solid)
|
||||
/* For libio stream locking. */
|
||||
EXTERN(_cthreads_flockfile)
|
||||
EXTERN(_cthreads_funlockfile)
|
||||
EXTERN(_cthreads_ftrylockfile)
|
||||
/* To get the sigthread stack layout on fork */
|
||||
EXTERN(pthread_getattr_np)
|
||||
EXTERN(pthread_attr_getstack)
|
||||
|
||||
GROUP(-lpthread2_pic)
|
60
htl/lockfile.c
Normal file
60
htl/lockfile.c
Normal file
@ -0,0 +1,60 @@
|
||||
/* lockfile - Handle locking and unlocking of streams. Hurd pthread version.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <cthreads.h>
|
||||
#include <pthread.h> /* Must come before <stdio.h>! */
|
||||
#include <stdio.h>
|
||||
|
||||
void
|
||||
_cthreads_flockfile (FILE *fp)
|
||||
{
|
||||
_IO_lock_lock (*fp->_lock);
|
||||
}
|
||||
|
||||
void
|
||||
_cthreads_funlockfile (FILE *fp)
|
||||
{
|
||||
_IO_lock_unlock (*fp->_lock);
|
||||
}
|
||||
|
||||
int
|
||||
_cthreads_ftrylockfile (FILE *fp)
|
||||
{
|
||||
return __libc_lock_trylock_recursive (*fp->_lock);
|
||||
}
|
||||
|
||||
#undef _IO_flockfile
|
||||
#undef _IO_funlockfile
|
||||
#undef _IO_ftrylockfile
|
||||
#undef flockfile
|
||||
#undef funlockfile
|
||||
#undef ftrylockfile
|
||||
|
||||
void _IO_flockfile (FILE *)
|
||||
__attribute__ ((alias ("_cthreads_flockfile")));
|
||||
void _IO_funlockfile (FILE *)
|
||||
__attribute__ ((alias ("_cthreads_funlockfile")));
|
||||
int _IO_ftrylockfile (FILE *)
|
||||
__attribute__ ((alias ("_cthreads_ftrylockfile")));
|
||||
|
||||
void flockfile (FILE *)
|
||||
__attribute__ ((alias ("_cthreads_flockfile")));
|
||||
void funlockfile (FILE *)
|
||||
__attribute__ ((alias ("_cthreads_funlockfile")));
|
||||
int ftrylockfile (FILE *)
|
||||
__attribute__ ((alias ("_cthreads_ftrylockfile")));
|
214
htl/pt-alloc.c
Normal file
214
htl/pt-alloc.c
Normal file
@ -0,0 +1,214 @@
|
||||
/* Allocate a new thread structure.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
/* This braindamage is necessary because the standard says that some
|
||||
of the threads functions "shall fail" if "No thread could be found
|
||||
corresponding to that specified by the given thread ID." */
|
||||
|
||||
/* Thread ID lookup table. */
|
||||
struct __pthread **__pthread_threads;
|
||||
|
||||
/* The size of the thread ID lookup table. */
|
||||
int __pthread_max_threads;
|
||||
|
||||
/* The total number of thread IDs currently in use, or on the list of
|
||||
available thread IDs. */
|
||||
int __pthread_num_threads;
|
||||
|
||||
/* A lock for the table, and the other variables above. */
|
||||
pthread_rwlock_t __pthread_threads_lock;
|
||||
|
||||
/* List of thread structures corresponding to free thread IDs. */
|
||||
struct __pthread *__pthread_free_threads;
|
||||
pthread_mutex_t __pthread_free_threads_lock;
|
||||
|
||||
static inline error_t
|
||||
initialize_pthread (struct __pthread *new)
|
||||
{
|
||||
error_t err;
|
||||
|
||||
err = __pthread_init_specific (new);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
new->nr_refs = 1;
|
||||
new->cancel_lock = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
|
||||
new->cancel_hook = NULL;
|
||||
new->cancel_hook_arg = NULL;
|
||||
new->cancel_state = PTHREAD_CANCEL_ENABLE;
|
||||
new->cancel_type = PTHREAD_CANCEL_DEFERRED;
|
||||
new->cancel_pending = 0;
|
||||
|
||||
new->state_lock = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
|
||||
new->state_cond = (pthread_cond_t) PTHREAD_COND_INITIALIZER;
|
||||
|
||||
new->cancelation_handlers = 0;
|
||||
|
||||
memset (&new->res_state, '\0', sizeof (new->res_state));
|
||||
|
||||
new->tcb = NULL;
|
||||
|
||||
new->next = 0;
|
||||
new->prevp = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Allocate a new thread structure and its pthread thread ID (but not
|
||||
a kernel thread). */
|
||||
int
|
||||
__pthread_alloc (struct __pthread **pthread)
|
||||
{
|
||||
error_t err;
|
||||
|
||||
struct __pthread *new;
|
||||
struct __pthread **threads;
|
||||
struct __pthread **old_threads;
|
||||
int max_threads;
|
||||
int new_max_threads;
|
||||
|
||||
pthread_mutex_lock (&__pthread_free_threads_lock);
|
||||
for (new = __pthread_free_threads; new; new = new->next)
|
||||
{
|
||||
/* There is no need to take NEW->STATE_LOCK: if NEW is on this
|
||||
list, then it is protected by __PTHREAD_FREE_THREADS_LOCK
|
||||
except in __pthread_dealloc where after it is added to the
|
||||
list (with the lock held), it drops the lock and then sets
|
||||
NEW->STATE and immediately stops using NEW. */
|
||||
if (new->state == PTHREAD_TERMINATED)
|
||||
{
|
||||
__pthread_dequeue (new);
|
||||
break;
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock (&__pthread_free_threads_lock);
|
||||
|
||||
if (new)
|
||||
{
|
||||
if (new->tcb)
|
||||
{
|
||||
/* Drop old values */
|
||||
_dl_deallocate_tls (new->tcb, 1);
|
||||
}
|
||||
|
||||
err = initialize_pthread (new);
|
||||
if (!err)
|
||||
*pthread = new;
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Allocate a new thread structure. */
|
||||
new = malloc (sizeof (struct __pthread));
|
||||
if (new == NULL)
|
||||
return ENOMEM;
|
||||
|
||||
err = initialize_pthread (new);
|
||||
if (err)
|
||||
{
|
||||
free (new);
|
||||
return err;
|
||||
}
|
||||
|
||||
retry:
|
||||
__pthread_rwlock_wrlock (&__pthread_threads_lock);
|
||||
|
||||
if (__pthread_num_threads < __pthread_max_threads)
|
||||
{
|
||||
/* We have a free slot. Use the slot number plus one as the
|
||||
thread ID for the new thread. */
|
||||
new->thread = 1 + __pthread_num_threads++;
|
||||
__pthread_threads[new->thread - 1] = NULL;
|
||||
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock);
|
||||
|
||||
*pthread = new;
|
||||
return 0;
|
||||
}
|
||||
#ifdef PTHREAD_THREADS_MAX
|
||||
else if (__pthread_num_threads >= PTHREAD_THREADS_MAX)
|
||||
{
|
||||
/* We have reached the limit on the number of threads per process. */
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock);
|
||||
|
||||
free (new);
|
||||
return EAGAIN;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* We are going to enlarge the threads table. Save its current
|
||||
size. We're going to release the lock before doing the necessary
|
||||
memory allocation, since that's a potentially blocking operation. */
|
||||
max_threads = __pthread_max_threads;
|
||||
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock);
|
||||
|
||||
/* Allocate a new lookup table that's twice as large. */
|
||||
new_max_threads
|
||||
= max_threads > 0 ? max_threads * 2 : _POSIX_THREAD_THREADS_MAX;
|
||||
threads = malloc (new_max_threads * sizeof (struct __pthread *));
|
||||
if (threads == NULL)
|
||||
{
|
||||
free (new);
|
||||
return ENOMEM;
|
||||
}
|
||||
|
||||
__pthread_rwlock_wrlock (&__pthread_threads_lock);
|
||||
|
||||
/* Check if nobody else has already enlarged the table. */
|
||||
if (max_threads != __pthread_max_threads)
|
||||
{
|
||||
/* Yep, they did. */
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock);
|
||||
|
||||
/* Free the newly allocated table and try again to allocate a slot. */
|
||||
free (threads);
|
||||
goto retry;
|
||||
}
|
||||
|
||||
/* Copy over the contents of the old table. */
|
||||
memcpy (threads, __pthread_threads,
|
||||
__pthread_max_threads * sizeof (struct __pthread *));
|
||||
|
||||
/* Save the location of the old table. We want to deallocate its
|
||||
storage after we released the lock. */
|
||||
old_threads = __pthread_threads;
|
||||
|
||||
/* Replace the table with the new one. */
|
||||
__pthread_max_threads = new_max_threads;
|
||||
__pthread_threads = threads;
|
||||
|
||||
/* And allocate ourselves one of the newly created slots. */
|
||||
new->thread = 1 + __pthread_num_threads++;
|
||||
__pthread_threads[new->thread - 1] = NULL;
|
||||
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock);
|
||||
|
||||
free (old_threads);
|
||||
|
||||
*pthread = new;
|
||||
return 0;
|
||||
}
|
62
htl/pt-cancel.c
Normal file
62
htl/pt-cancel.c
Normal file
@ -0,0 +1,62 @@
|
||||
/* Cancel a thread.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
pthread_cancel (pthread_t t)
|
||||
{
|
||||
int err = 0;
|
||||
struct __pthread *p;
|
||||
|
||||
p = __pthread_getid (t);
|
||||
if (p == NULL)
|
||||
return ESRCH;
|
||||
|
||||
__pthread_mutex_lock (&p->cancel_lock);
|
||||
if (p->cancel_pending)
|
||||
{
|
||||
__pthread_mutex_unlock (&p->cancel_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
p->cancel_pending = 1;
|
||||
|
||||
if (p->cancel_state != PTHREAD_CANCEL_ENABLE)
|
||||
{
|
||||
__pthread_mutex_unlock (&p->cancel_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (p->cancel_type == PTHREAD_CANCEL_ASYNCHRONOUS)
|
||||
/* CANCEL_LOCK is unlocked by this call. */
|
||||
err = __pthread_do_cancel (p);
|
||||
else
|
||||
{
|
||||
if (p->cancel_hook != NULL)
|
||||
/* Thread blocking on a cancellation point. Invoke hook to unblock.
|
||||
See __pthread_cond_timedwait_internal. */
|
||||
p->cancel_hook (p->cancel_hook_arg);
|
||||
|
||||
__pthread_mutex_unlock (&p->cancel_lock);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
27
htl/pt-cleanup.c
Normal file
27
htl/pt-cleanup.c
Normal file
@ -0,0 +1,27 @@
|
||||
/* Add a cancelation handler to the stack.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
struct __pthread_cancelation_handler **
|
||||
__pthread_get_cleanup_stack (void)
|
||||
{
|
||||
return &_pthread_self ()->cancelation_handlers;
|
||||
}
|
246
htl/pt-create.c
Normal file
246
htl/pt-create.c
Normal file
@ -0,0 +1,246 @@
|
||||
/* Thread creation.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <resolv.h>
|
||||
|
||||
#include <atomic.h>
|
||||
#include <hurd/resource.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
#if IS_IN (libpthread)
|
||||
# include <ctype.h>
|
||||
#endif
|
||||
#ifdef HAVE_USELOCALE
|
||||
# include <locale.h>
|
||||
#endif
|
||||
|
||||
/* The total number of pthreads currently active. This is defined
|
||||
here since it would be really stupid to have a threads-using
|
||||
program that doesn't call `pthread_create'. */
|
||||
unsigned int __pthread_total;
|
||||
|
||||
|
||||
/* The entry-point for new threads. */
|
||||
static void
|
||||
entry_point (struct __pthread *self, void *(*start_routine) (void *), void *arg)
|
||||
{
|
||||
___pthread_self = self;
|
||||
__resp = &self->res_state;
|
||||
|
||||
#if IS_IN (libpthread)
|
||||
/* Initialize pointers to locale data. */
|
||||
__ctype_init ();
|
||||
#endif
|
||||
#ifdef HAVE_USELOCALE
|
||||
/* A fresh thread needs to be bound to the global locale. */
|
||||
uselocale (LC_GLOBAL_LOCALE);
|
||||
#endif
|
||||
|
||||
__pthread_startup ();
|
||||
|
||||
pthread_exit (start_routine (arg));
|
||||
}
|
||||
|
||||
/* Create a thread with attributes given by ATTR, executing
|
||||
START_ROUTINE with argument ARG. */
|
||||
int
|
||||
pthread_create (pthread_t * thread, const pthread_attr_t * attr,
|
||||
void *(*start_routine) (void *), void *arg)
|
||||
{
|
||||
int err;
|
||||
struct __pthread *pthread;
|
||||
|
||||
err = __pthread_create_internal (&pthread, attr, start_routine, arg);
|
||||
if (!err)
|
||||
*thread = pthread->thread;
|
||||
else if (err == ENOMEM)
|
||||
err = EAGAIN;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Internal version of pthread_create. See comment in
|
||||
pt-internal.h. */
|
||||
int
|
||||
__pthread_create_internal (struct __pthread **thread,
|
||||
const pthread_attr_t * attr,
|
||||
void *(*start_routine) (void *), void *arg)
|
||||
{
|
||||
int err;
|
||||
struct __pthread *pthread;
|
||||
const struct __pthread_attr *setup;
|
||||
sigset_t sigset;
|
||||
size_t stacksize;
|
||||
|
||||
/* Allocate a new thread structure. */
|
||||
err = __pthread_alloc (&pthread);
|
||||
if (err)
|
||||
goto failed;
|
||||
|
||||
/* Use the default attributes if ATTR is NULL. */
|
||||
setup = attr ? attr : &__pthread_default_attr;
|
||||
|
||||
stacksize = setup->__stacksize;
|
||||
if (stacksize == 0)
|
||||
{
|
||||
struct rlimit rlim;
|
||||
__getrlimit (RLIMIT_STACK, &rlim);
|
||||
if (rlim.rlim_cur != RLIM_INFINITY)
|
||||
stacksize = rlim.rlim_cur;
|
||||
if (stacksize == 0)
|
||||
stacksize = PTHREAD_STACK_DEFAULT;
|
||||
}
|
||||
|
||||
/* Initialize the thread state. */
|
||||
pthread->state = (setup->__detachstate == PTHREAD_CREATE_DETACHED
|
||||
? PTHREAD_DETACHED : PTHREAD_JOINABLE);
|
||||
|
||||
if (setup->__stackaddr)
|
||||
{
|
||||
pthread->stackaddr = setup->__stackaddr;
|
||||
|
||||
/* If the user supplied a stack, it is not our responsibility to
|
||||
setup a stack guard. */
|
||||
pthread->guardsize = 0;
|
||||
pthread->stack = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Allocate a stack. */
|
||||
err = __pthread_stack_alloc (&pthread->stackaddr,
|
||||
((setup->__guardsize + __vm_page_size - 1)
|
||||
/ __vm_page_size) * __vm_page_size
|
||||
+ stacksize);
|
||||
if (err)
|
||||
goto failed_stack_alloc;
|
||||
|
||||
pthread->guardsize = setup->__guardsize;
|
||||
pthread->stack = 1;
|
||||
}
|
||||
|
||||
pthread->stacksize = stacksize;
|
||||
|
||||
/* Allocate the kernel thread and other required resources. */
|
||||
err = __pthread_thread_alloc (pthread);
|
||||
if (err)
|
||||
goto failed_thread_alloc;
|
||||
|
||||
pthread->tcb = _dl_allocate_tls (NULL);
|
||||
if (pthread->tcb == NULL)
|
||||
{
|
||||
err = ENOMEM;
|
||||
goto failed_thread_tls_alloc;
|
||||
}
|
||||
pthread->tcb->tcb = pthread->tcb;
|
||||
|
||||
/* And initialize the rest of the machine context. This may include
|
||||
additional machine- and system-specific initializations that
|
||||
prove convenient. */
|
||||
err = __pthread_setup (pthread, entry_point, start_routine, arg);
|
||||
if (err)
|
||||
goto failed_setup;
|
||||
|
||||
/* Initialize the system-specific signal state for the new
|
||||
thread. */
|
||||
err = __pthread_sigstate_init (pthread);
|
||||
if (err)
|
||||
goto failed_sigstate;
|
||||
|
||||
/* If the new thread is joinable, add a reference for the caller. */
|
||||
if (pthread->state == PTHREAD_JOINABLE)
|
||||
pthread->nr_refs++;
|
||||
|
||||
/* Set the new thread's signal mask and set the pending signals to
|
||||
empty. POSIX says: "The signal mask shall be inherited from the
|
||||
creating thread. The set of signals pending for the new thread
|
||||
shall be empty." If the currnet thread is not a pthread then we
|
||||
just inherit the process' sigmask. */
|
||||
if (__pthread_num_threads == 1)
|
||||
err = sigprocmask (0, 0, &sigset);
|
||||
else
|
||||
err = __pthread_sigstate (_pthread_self (), 0, 0, &sigset, 0);
|
||||
assert_perror (err);
|
||||
|
||||
err = __pthread_sigstate (pthread, SIG_SETMASK, &sigset, 0, 1);
|
||||
assert_perror (err);
|
||||
|
||||
/* Increase the total number of threads. We do this before actually
|
||||
starting the new thread, since the new thread might immediately
|
||||
call `pthread_exit' which decreases the number of threads and
|
||||
calls `exit' if the number of threads reaches zero. Increasing
|
||||
the number of threads from within the new thread isn't an option
|
||||
since this thread might return and call `pthread_exit' before the
|
||||
new thread runs. */
|
||||
atomic_increment (&__pthread_total);
|
||||
|
||||
/* Store a pointer to this thread in the thread ID lookup table. We
|
||||
could use __thread_setid, however, we only lock for reading as no
|
||||
other thread should be using this entry (we also assume that the
|
||||
store is atomic). */
|
||||
__pthread_rwlock_rdlock (&__pthread_threads_lock);
|
||||
__pthread_threads[pthread->thread - 1] = pthread;
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock);
|
||||
|
||||
/* At this point it is possible to guess our pthread ID. We have to
|
||||
make sure that all functions taking a pthread_t argument can
|
||||
handle the fact that this thread isn't really running yet. Since
|
||||
the new thread might be passed its ID through pthread_create (to
|
||||
avoid calling pthread_self), read it before starting the thread. */
|
||||
*thread = pthread;
|
||||
|
||||
/* Schedule the new thread. */
|
||||
err = __pthread_thread_start (pthread);
|
||||
if (err)
|
||||
goto failed_starting;
|
||||
|
||||
|
||||
return 0;
|
||||
|
||||
failed_starting:
|
||||
/* If joinable, a reference was added for the caller. */
|
||||
if (pthread->state == PTHREAD_JOINABLE)
|
||||
__pthread_dealloc (pthread);
|
||||
|
||||
__pthread_setid (pthread->thread, NULL);
|
||||
atomic_decrement (&__pthread_total);
|
||||
failed_sigstate:
|
||||
__pthread_sigstate_destroy (pthread);
|
||||
failed_setup:
|
||||
_dl_deallocate_tls (pthread->tcb, 1);
|
||||
pthread->tcb = NULL;
|
||||
failed_thread_tls_alloc:
|
||||
__pthread_thread_terminate (pthread);
|
||||
|
||||
/* __pthread_thread_terminate has taken care of deallocating the stack and
|
||||
the thread structure. */
|
||||
goto failed;
|
||||
failed_thread_alloc:
|
||||
if (pthread->stack)
|
||||
__pthread_stack_dealloc (pthread->stackaddr,
|
||||
((setup->__guardsize + __vm_page_size - 1)
|
||||
/ __vm_page_size) * __vm_page_size + stacksize);
|
||||
failed_stack_alloc:
|
||||
__pthread_dealloc (pthread);
|
||||
failed:
|
||||
return err;
|
||||
}
|
68
htl/pt-dealloc.c
Normal file
68
htl/pt-dealloc.c
Normal file
@ -0,0 +1,68 @@
|
||||
/* Deallocate a thread structure.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <assert.h>
|
||||
#include <pthread.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
#include <atomic.h>
|
||||
|
||||
/* List of thread structures corresponding to free thread IDs. */
|
||||
extern struct __pthread *__pthread_free_threads;
|
||||
extern pthread_mutex_t __pthread_free_threads_lock;
|
||||
|
||||
|
||||
/* Deallocate the thread structure for PTHREAD. */
|
||||
void
|
||||
__pthread_dealloc (struct __pthread *pthread)
|
||||
{
|
||||
assert (pthread->state != PTHREAD_TERMINATED);
|
||||
|
||||
if (!atomic_decrement_and_test (&pthread->nr_refs))
|
||||
return;
|
||||
|
||||
/* Withdraw this thread from the thread ID lookup table. */
|
||||
__pthread_setid (pthread->thread, NULL);
|
||||
|
||||
/* Mark the thread as terminated. We broadcast the condition
|
||||
here to prevent pthread_join from waiting for this thread to
|
||||
exit where it was never really started. Such a call to
|
||||
pthread_join is completely bogus, but unfortunately allowed
|
||||
by the standards. */
|
||||
__pthread_mutex_lock (&pthread->state_lock);
|
||||
if (pthread->state != PTHREAD_EXITED)
|
||||
__pthread_cond_broadcast (&pthread->state_cond);
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
|
||||
/* We do not actually deallocate the thread structure, but add it to
|
||||
a list of re-usable thread structures. */
|
||||
__pthread_mutex_lock (&__pthread_free_threads_lock);
|
||||
__pthread_enqueue (&__pthread_free_threads, pthread);
|
||||
__pthread_mutex_unlock (&__pthread_free_threads_lock);
|
||||
|
||||
/* Setting PTHREAD->STATE to PTHREAD_TERMINATED makes this TCB
|
||||
available for reuse. After that point, we can no longer assume
|
||||
that PTHREAD is valid.
|
||||
|
||||
Note that it is safe to not lock this update to PTHREAD->STATE:
|
||||
the only way that it can now be accessed is in __pthread_alloc,
|
||||
which reads this variable. */
|
||||
pthread->state = PTHREAD_TERMINATED;
|
||||
}
|
79
htl/pt-detach.c
Normal file
79
htl/pt-detach.c
Normal file
@ -0,0 +1,79 @@
|
||||
/* Detach a thread.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
/* Indicate that the storage for THREAD can be reclaimed when it
|
||||
terminates. */
|
||||
int
|
||||
pthread_detach (pthread_t thread)
|
||||
{
|
||||
struct __pthread *pthread;
|
||||
int err = 0;
|
||||
|
||||
/* Lookup the thread structure for THREAD. */
|
||||
pthread = __pthread_getid (thread);
|
||||
if (pthread == NULL)
|
||||
return ESRCH;
|
||||
|
||||
__pthread_mutex_lock (&pthread->state_lock);
|
||||
|
||||
switch (pthread->state)
|
||||
{
|
||||
case PTHREAD_JOINABLE:
|
||||
/* THREAD still running. Mark it as detached such that its
|
||||
resources can be reclaimed as soon as the thread exits. */
|
||||
pthread->state = PTHREAD_DETACHED;
|
||||
|
||||
/* Broadcast the condition. This will make threads that are
|
||||
waiting to join THREAD continue with hopefully disastrous
|
||||
consequences instead of blocking indefinitely. */
|
||||
pthread_cond_broadcast (&pthread->state_cond);
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
|
||||
__pthread_dealloc (pthread);
|
||||
break;
|
||||
|
||||
case PTHREAD_EXITED:
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
|
||||
/* THREAD has already exited. PTHREAD remained after the thread
|
||||
exited in order to provide the exit status, but it turns out
|
||||
it won't be needed. */
|
||||
__pthread_dealloc (pthread);
|
||||
break;
|
||||
|
||||
case PTHREAD_TERMINATED:
|
||||
/* Pretend THREAD wasn't there in the first place. */
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
err = ESRCH;
|
||||
break;
|
||||
|
||||
default:
|
||||
/* Thou shalt not detach non-joinable threads! */
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
err = EINVAL;
|
||||
break;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
111
htl/pt-exit.c
Normal file
111
htl/pt-exit.c
Normal file
@ -0,0 +1,111 @@
|
||||
/* Thread termination.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
#include <atomic.h>
|
||||
|
||||
|
||||
/* Terminate the current thread and make STATUS available to any
|
||||
thread that might join it. */
|
||||
void
|
||||
__pthread_exit (void *status)
|
||||
{
|
||||
struct __pthread *self = _pthread_self ();
|
||||
struct __pthread_cancelation_handler **handlers;
|
||||
int oldstate;
|
||||
|
||||
/* Run any cancelation handlers. According to POSIX, the
|
||||
cancellation cleanup handlers should be called with cancellation
|
||||
disabled. */
|
||||
pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate);
|
||||
|
||||
for (handlers = __pthread_get_cleanup_stack ();
|
||||
*handlers != NULL;
|
||||
*handlers = (*handlers)->__next)
|
||||
(*handlers)->__handler ((*handlers)->__arg);
|
||||
|
||||
pthread_setcancelstate (oldstate, &oldstate);
|
||||
|
||||
/* Decrease the number of threads. We use an atomic operation to
|
||||
make sure that only the last thread calls `exit'. */
|
||||
if (atomic_decrement_and_test (&__pthread_total))
|
||||
/* We are the last thread. */
|
||||
exit (0);
|
||||
|
||||
/* Note that after this point the process can be terminated at any
|
||||
point if another thread calls `pthread_exit' and happens to be
|
||||
the last thread. */
|
||||
|
||||
__pthread_mutex_lock (&self->state_lock);
|
||||
|
||||
if (self->cancel_state == PTHREAD_CANCEL_ENABLE && self->cancel_pending)
|
||||
status = PTHREAD_CANCELED;
|
||||
|
||||
switch (self->state)
|
||||
{
|
||||
default:
|
||||
assert (!"Consistency error: unexpected self->state");
|
||||
abort ();
|
||||
break;
|
||||
|
||||
case PTHREAD_DETACHED:
|
||||
__pthread_mutex_unlock (&self->state_lock);
|
||||
|
||||
break;
|
||||
|
||||
case PTHREAD_JOINABLE:
|
||||
/* We need to stay around for a while since another thread
|
||||
might want to join us. */
|
||||
self->state = PTHREAD_EXITED;
|
||||
|
||||
/* We need to remember the exit status. A thread joining us
|
||||
might ask for it. */
|
||||
self->status = status;
|
||||
|
||||
/* Broadcast the condition. This will wake up threads that are
|
||||
waiting to join us. */
|
||||
__pthread_cond_broadcast (&self->state_cond);
|
||||
__pthread_mutex_unlock (&self->state_lock);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
/* Destroy any thread specific data. */
|
||||
__pthread_destroy_specific (self);
|
||||
|
||||
/* Destroy any signal state. */
|
||||
__pthread_sigstate_destroy (self);
|
||||
|
||||
/* Self terminating requires TLS, so defer the release of the TCB until
|
||||
the thread structure is reused. */
|
||||
|
||||
/* Release kernel resources, including the kernel thread and the stack,
|
||||
and drop the self reference. */
|
||||
__pthread_thread_terminate (self);
|
||||
|
||||
/* NOTREACHED */
|
||||
abort ();
|
||||
}
|
||||
|
||||
strong_alias (__pthread_exit, pthread_exit);
|
51
htl/pt-getattr.c
Normal file
51
htl/pt-getattr.c
Normal file
@ -0,0 +1,51 @@
|
||||
/* Thread attributes retrieval.
|
||||
Copyright (C) 2008-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
/* Initialize thread attribute *ATTR with attributes corresponding to the
|
||||
already running thread THREAD. It shall be called on an uninitialized ATTR
|
||||
and destroyed with pthread_attr_destroy when no longer needed. */
|
||||
int
|
||||
__pthread_getattr_np (pthread_t thread, pthread_attr_t *attr)
|
||||
{
|
||||
struct __pthread *pthread;
|
||||
|
||||
pthread = __pthread_getid (thread);
|
||||
if (pthread == NULL)
|
||||
return ESRCH;
|
||||
|
||||
/* Some attributes (schedparam, inheritsched, contentionscope and schedpolicy)
|
||||
are not supported yet, so fill them with our default values. */
|
||||
*attr = __pthread_default_attr;
|
||||
|
||||
attr->__stackaddr = pthread->stackaddr +
|
||||
((pthread->guardsize + __vm_page_size - 1)
|
||||
/ __vm_page_size * __vm_page_size);
|
||||
attr->__stacksize = pthread->stacksize;
|
||||
attr->__guardsize = pthread->guardsize;
|
||||
attr->__detachstate = (pthread->state == PTHREAD_DETACHED
|
||||
? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
weak_alias (__pthread_getattr_np, pthread_getattr_np)
|
83
htl/pt-initialize.c
Normal file
83
htl/pt-initialize.c
Normal file
@ -0,0 +1,83 @@
|
||||
/* Initialize pthreads library.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
#include <set-hooks.h>
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pthread-functions.h>
|
||||
|
||||
#if IS_IN (libpthread)
|
||||
static const struct pthread_functions pthread_functions = {
|
||||
.ptr_pthread_attr_destroy = __pthread_attr_destroy,
|
||||
.ptr_pthread_attr_init = __pthread_attr_init,
|
||||
.ptr_pthread_attr_getdetachstate = __pthread_attr_getdetachstate,
|
||||
.ptr_pthread_attr_setdetachstate = __pthread_attr_setdetachstate,
|
||||
.ptr_pthread_attr_getinheritsched = __pthread_attr_getinheritsched,
|
||||
.ptr_pthread_attr_setinheritsched = __pthread_attr_setinheritsched,
|
||||
.ptr_pthread_attr_getschedparam = __pthread_attr_getschedparam,
|
||||
.ptr_pthread_attr_setschedparam = __pthread_attr_setschedparam,
|
||||
.ptr_pthread_attr_getschedpolicy = __pthread_attr_getschedpolicy,
|
||||
.ptr_pthread_attr_setschedpolicy = __pthread_attr_setschedpolicy,
|
||||
.ptr_pthread_attr_getscope = __pthread_attr_getscope,
|
||||
.ptr_pthread_attr_setscope = __pthread_attr_setscope,
|
||||
.ptr_pthread_condattr_destroy = __pthread_condattr_destroy,
|
||||
.ptr_pthread_condattr_init = __pthread_condattr_init,
|
||||
.ptr_pthread_cond_broadcast = __pthread_cond_broadcast,
|
||||
.ptr_pthread_cond_destroy = __pthread_cond_destroy,
|
||||
.ptr_pthread_cond_init = __pthread_cond_init,
|
||||
.ptr_pthread_cond_signal = __pthread_cond_signal,
|
||||
.ptr_pthread_cond_wait = __pthread_cond_wait,
|
||||
.ptr_pthread_cond_timedwait = __pthread_cond_timedwait,
|
||||
.ptr_pthread_equal = __pthread_equal,
|
||||
.ptr___pthread_exit = __pthread_exit,
|
||||
.ptr_pthread_getschedparam = __pthread_getschedparam,
|
||||
.ptr_pthread_setschedparam = __pthread_setschedparam,
|
||||
.ptr_pthread_mutex_destroy = _pthread_mutex_destroy,
|
||||
.ptr_pthread_mutex_init = _pthread_mutex_init,
|
||||
.ptr_pthread_mutex_lock = __pthread_mutex_lock,
|
||||
.ptr_pthread_mutex_trylock = __pthread_mutex_trylock,
|
||||
.ptr_pthread_mutex_unlock = __pthread_mutex_unlock,
|
||||
.ptr_pthread_self = __pthread_self,
|
||||
.ptr___pthread_setcancelstate = __pthread_setcancelstate,
|
||||
.ptr_pthread_setcanceltype = __pthread_setcanceltype,
|
||||
.ptr___pthread_get_cleanup_stack = __pthread_get_cleanup_stack,
|
||||
.ptr_pthread_once = __pthread_once,
|
||||
.ptr_pthread_rwlock_rdlock = __pthread_rwlock_rdlock,
|
||||
.ptr_pthread_rwlock_wrlock = __pthread_rwlock_wrlock,
|
||||
.ptr_pthread_rwlock_unlock = __pthread_rwlock_unlock,
|
||||
.ptr___pthread_key_create = __pthread_key_create,
|
||||
.ptr___pthread_getspecific = __pthread_getspecific,
|
||||
.ptr___pthread_setspecific = __pthread_setspecific,
|
||||
.ptr__IO_flockfile = _cthreads_flockfile,
|
||||
.ptr__IO_funlockfile = _cthreads_funlockfile,
|
||||
.ptr__IO_ftrylockfile = _cthreads_ftrylockfile,
|
||||
};
|
||||
#endif /* IS_IN (libpthread) */
|
||||
|
||||
/* Initialize the pthreads library. */
|
||||
void
|
||||
___pthread_init (void)
|
||||
{
|
||||
#if IS_IN (libpthread)
|
||||
__libc_pthread_init (&pthread_functions);
|
||||
#endif
|
||||
}
|
324
htl/pt-internal.h
Normal file
324
htl/pt-internal.h
Normal file
@ -0,0 +1,324 @@
|
||||
/* Internal defenitions for pthreads library.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _PT_INTERNAL_H
|
||||
#define _PT_INTERNAL_H 1
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stddef.h>
|
||||
#include <sched.h>
|
||||
#include <signal.h>
|
||||
#include <assert.h>
|
||||
#include <bits/types/res_state.h>
|
||||
|
||||
#include <atomic.h>
|
||||
|
||||
#include <pt-key.h>
|
||||
|
||||
#include <pt-sysdep.h>
|
||||
#include <pt-machdep.h>
|
||||
|
||||
#if IS_IN (libpthread)
|
||||
# include <ldsodefs.h>
|
||||
#endif
|
||||
|
||||
/* Thread state. */
|
||||
enum pthread_state
|
||||
{
|
||||
/* The thread is running and joinable. */
|
||||
PTHREAD_JOINABLE = 0,
|
||||
/* The thread is running and detached. */
|
||||
PTHREAD_DETACHED,
|
||||
/* A joinable thread exited and its return code is available. */
|
||||
PTHREAD_EXITED,
|
||||
/* The thread structure is unallocated and available for reuse. */
|
||||
PTHREAD_TERMINATED
|
||||
};
|
||||
|
||||
#ifndef PTHREAD_KEY_MEMBERS
|
||||
# define PTHREAD_KEY_MEMBERS
|
||||
#endif
|
||||
|
||||
#ifndef PTHREAD_SYSDEP_MEMBERS
|
||||
# define PTHREAD_SYSDEP_MEMBERS
|
||||
#endif
|
||||
|
||||
#if !(IS_IN (libpthread))
|
||||
/* Type of the TCB. */
|
||||
typedef struct
|
||||
{
|
||||
void *tcb; /* Points to this structure. */
|
||||
void *dtv; /* Vector of pointers to TLS data. */
|
||||
thread_t self; /* This thread's control port. */
|
||||
} tcbhead_t;
|
||||
#endif /* ! IS_IN (libpthread) */
|
||||
|
||||
/* This structure describes a POSIX thread. */
|
||||
struct __pthread
|
||||
{
|
||||
/* Thread ID. */
|
||||
pthread_t thread;
|
||||
|
||||
unsigned int nr_refs; /* Detached threads have a self reference only,
|
||||
while joinable threads have two references.
|
||||
These are used to keep the structure valid at
|
||||
thread destruction. Detaching/joining a thread
|
||||
drops a reference. */
|
||||
|
||||
/* Cancellation. */
|
||||
pthread_mutex_t cancel_lock; /* Protect cancel_xxx members. */
|
||||
void (*cancel_hook) (void *); /* Called to unblock a thread blocking
|
||||
in a cancellation point (namely,
|
||||
__pthread_cond_timedwait_internal). */
|
||||
void *cancel_hook_arg;
|
||||
int cancel_state;
|
||||
int cancel_type;
|
||||
int cancel_pending;
|
||||
struct __pthread_cancelation_handler *cancelation_handlers;
|
||||
|
||||
/* Thread stack. */
|
||||
void *stackaddr;
|
||||
size_t stacksize;
|
||||
size_t guardsize;
|
||||
int stack; /* Nonzero if the stack was allocated. */
|
||||
|
||||
/* Exit status. */
|
||||
void *status;
|
||||
|
||||
/* Thread state. */
|
||||
enum pthread_state state;
|
||||
pthread_mutex_t state_lock; /* Locks the state. */
|
||||
pthread_cond_t state_cond; /* Signalled when the state changes. */
|
||||
|
||||
/* Resolver state. */
|
||||
struct __res_state res_state;
|
||||
|
||||
/* Thread context. */
|
||||
struct pthread_mcontext mcontext;
|
||||
|
||||
PTHREAD_KEY_MEMBERS
|
||||
|
||||
PTHREAD_SYSDEP_MEMBERS
|
||||
|
||||
tcbhead_t *tcb;
|
||||
|
||||
/* Queue links. Since PREVP is used to determine if a thread has been
|
||||
awaken, it must be protected by the queue lock. */
|
||||
struct __pthread *next, **prevp;
|
||||
};
|
||||
|
||||
/* Enqueue an element THREAD on the queue *HEAD. */
|
||||
static inline void
|
||||
__pthread_enqueue (struct __pthread **head, struct __pthread *thread)
|
||||
{
|
||||
assert (thread->prevp == 0);
|
||||
|
||||
thread->next = *head;
|
||||
thread->prevp = head;
|
||||
if (*head)
|
||||
(*head)->prevp = &thread->next;
|
||||
*head = thread;
|
||||
}
|
||||
|
||||
/* Dequeue the element THREAD from the queue it is connected to. */
|
||||
static inline void
|
||||
__pthread_dequeue (struct __pthread *thread)
|
||||
{
|
||||
assert (thread);
|
||||
assert (thread->prevp);
|
||||
|
||||
if (thread->next)
|
||||
thread->next->prevp = thread->prevp;
|
||||
*thread->prevp = thread->next;
|
||||
thread->prevp = 0;
|
||||
}
|
||||
|
||||
/* Iterate over QUEUE storing each element in ELEMENT. */
|
||||
#define __pthread_queue_iterate(queue, element) \
|
||||
for (struct __pthread *__pdi_next = (queue); \
|
||||
((element) = __pdi_next) \
|
||||
&& ((__pdi_next = __pdi_next->next), \
|
||||
1); \
|
||||
)
|
||||
|
||||
/* Iterate over QUEUE dequeuing each element, storing it in
|
||||
ELEMENT. */
|
||||
#define __pthread_dequeuing_iterate(queue, element) \
|
||||
for (struct __pthread *__pdi_next = (queue); \
|
||||
((element) = __pdi_next) \
|
||||
&& ((__pdi_next = __pdi_next->next), \
|
||||
((element)->prevp = 0), \
|
||||
1); \
|
||||
)
|
||||
|
||||
/* The total number of threads currently active. */
|
||||
extern unsigned int __pthread_total;
|
||||
|
||||
/* The total number of thread IDs currently in use, or on the list of
|
||||
available thread IDs. */
|
||||
extern int __pthread_num_threads;
|
||||
|
||||
/* Concurrency hint. */
|
||||
extern int __pthread_concurrency;
|
||||
|
||||
/* Array of __pthread structures and its lock. Indexed by the pthread
|
||||
id minus one. (Why not just use the pthread id? Because some
|
||||
brain-dead users of the pthread interface incorrectly assume that 0
|
||||
is an invalid pthread id.) */
|
||||
extern struct __pthread **__pthread_threads;
|
||||
extern pthread_rwlock_t __pthread_threads_lock;
|
||||
|
||||
#define __pthread_getid(thread) \
|
||||
({ struct __pthread *__t; \
|
||||
__pthread_rwlock_rdlock (&__pthread_threads_lock); \
|
||||
__t = __pthread_threads[thread - 1]; \
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock); \
|
||||
__t; })
|
||||
|
||||
#define __pthread_setid(thread, pthread) \
|
||||
__pthread_rwlock_wrlock (&__pthread_threads_lock); \
|
||||
__pthread_threads[thread - 1] = pthread; \
|
||||
__pthread_rwlock_unlock (&__pthread_threads_lock);
|
||||
|
||||
/* Similar to pthread_self, but returns the thread descriptor instead
|
||||
of the thread ID. */
|
||||
#ifndef _pthread_self
|
||||
extern struct __pthread *_pthread_self (void);
|
||||
#endif
|
||||
|
||||
|
||||
/* Initialize the pthreads library. */
|
||||
extern void ___pthread_init (void);
|
||||
|
||||
/* Internal version of pthread_create. Rather than return the new
|
||||
tid, we return the whole __pthread structure in *PTHREAD. */
|
||||
extern int __pthread_create_internal (struct __pthread **__restrict pthread,
|
||||
const pthread_attr_t *__restrict attr,
|
||||
void *(*start_routine) (void *),
|
||||
void *__restrict arg);
|
||||
|
||||
/* Allocate a new thread structure and a pthread thread ID (but not a
|
||||
kernel thread or a stack). THREAD has one reference. */
|
||||
extern int __pthread_alloc (struct __pthread **thread);
|
||||
|
||||
/* Deallocate the thread structure. This is the dual of
|
||||
__pthread_alloc (N.B. it does not call __pthread_stack_dealloc nor
|
||||
__pthread_thread_terminate). THREAD loses one reference and is
|
||||
released if the reference counter drops to 0. */
|
||||
extern void __pthread_dealloc (struct __pthread *thread);
|
||||
|
||||
|
||||
/* Allocate a stack of size STACKSIZE. The stack base shall be
|
||||
returned in *STACKADDR. */
|
||||
extern int __pthread_stack_alloc (void **stackaddr, size_t stacksize);
|
||||
|
||||
/* Deallocate the stack STACKADDR of size STACKSIZE. */
|
||||
extern void __pthread_stack_dealloc (void *stackaddr, size_t stacksize);
|
||||
|
||||
|
||||
/* Setup thread THREAD's context. */
|
||||
extern int __pthread_setup (struct __pthread *__restrict thread,
|
||||
void (*entry_point) (struct __pthread *,
|
||||
void *(*)(void *),
|
||||
void *),
|
||||
void *(*start_routine) (void *),
|
||||
void *__restrict arg);
|
||||
|
||||
|
||||
/* Allocate a kernel thread (and any miscellaneous system dependent
|
||||
resources) for THREAD; it must not be placed on the run queue. */
|
||||
extern int __pthread_thread_alloc (struct __pthread *thread);
|
||||
|
||||
/* Start THREAD making it eligible to run. */
|
||||
extern int __pthread_thread_start (struct __pthread *thread);
|
||||
|
||||
/* Terminate the kernel thread associated with THREAD, and deallocate its
|
||||
stack as well as any other kernel resource associated with it.
|
||||
In addition, THREAD looses one reference.
|
||||
|
||||
This function can be called by any thread, including the target thread.
|
||||
Since some resources that are destroyed along the kernel thread are
|
||||
stored in thread-local variables, the conditions required for this
|
||||
function to behave correctly are a bit unusual : as long as the target
|
||||
thread hasn't been started, any thread can terminate it, but once it
|
||||
has started, no other thread can terminate it, so that thread-local
|
||||
variables created by that thread are correctly released. */
|
||||
extern void __pthread_thread_terminate (struct __pthread *thread);
|
||||
|
||||
|
||||
/* Called by a thread just before it calls the provided start
|
||||
routine. */
|
||||
extern void __pthread_startup (void);
|
||||
|
||||
/* Block THREAD. */
|
||||
extern void __pthread_block (struct __pthread *thread);
|
||||
|
||||
/* Block THREAD until *ABSTIME is reached. */
|
||||
extern error_t __pthread_timedblock (struct __pthread *__restrict thread,
|
||||
const struct timespec *__restrict abstime,
|
||||
clockid_t clock_id);
|
||||
|
||||
/* Wakeup THREAD. */
|
||||
extern void __pthread_wakeup (struct __pthread *thread);
|
||||
|
||||
|
||||
/* Perform a cancelation. The CANCEL_LOCK member of the given thread must
|
||||
be locked before calling this function, which must unlock it. */
|
||||
extern int __pthread_do_cancel (struct __pthread *thread);
|
||||
|
||||
|
||||
/* Initialize the thread specific data structures. THREAD must be the
|
||||
calling thread. */
|
||||
extern error_t __pthread_init_specific (struct __pthread *thread);
|
||||
|
||||
/* Call the destructors on all of the thread specific data in THREAD.
|
||||
THREAD must be the calling thread. */
|
||||
extern void __pthread_destroy_specific (struct __pthread *thread);
|
||||
|
||||
|
||||
/* Initialize newly create thread *THREAD's signal state data
|
||||
structures. */
|
||||
extern error_t __pthread_sigstate_init (struct __pthread *thread);
|
||||
|
||||
/* Destroy the signal state data structures associcated with thread
|
||||
*THREAD. */
|
||||
extern void __pthread_sigstate_destroy (struct __pthread *thread);
|
||||
|
||||
/* Modify thread *THREAD's signal state. */
|
||||
extern error_t __pthread_sigstate (struct __pthread *__restrict thread, int how,
|
||||
const sigset_t *__restrict set,
|
||||
sigset_t *__restrict oset,
|
||||
int clear_pending);
|
||||
|
||||
|
||||
/* Default thread attributes. */
|
||||
extern const struct __pthread_attr __pthread_default_attr;
|
||||
|
||||
/* Default barrier attributes. */
|
||||
extern const struct __pthread_barrierattr __pthread_default_barrierattr;
|
||||
|
||||
/* Default mutex attributes. */
|
||||
extern const struct __pthread_mutexattr __pthread_default_mutexattr;
|
||||
|
||||
/* Default rdlock attributes. */
|
||||
extern const struct __pthread_rwlockattr __pthread_default_rwlockattr;
|
||||
|
||||
/* Default condition attributes. */
|
||||
extern const struct __pthread_condattr __pthread_default_condattr;
|
||||
|
||||
#endif /* pt-internal.h */
|
75
htl/pt-join.c
Normal file
75
htl/pt-join.c
Normal file
@ -0,0 +1,75 @@
|
||||
/* Wait for thread termination.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
/* Make calling thread wait for termination of thread THREAD. Return
|
||||
the exit status of the thread in *STATUS. */
|
||||
int
|
||||
pthread_join (pthread_t thread, void **status)
|
||||
{
|
||||
struct __pthread *pthread;
|
||||
int err = 0;
|
||||
|
||||
/* Lookup the thread structure for THREAD. */
|
||||
pthread = __pthread_getid (thread);
|
||||
if (pthread == NULL)
|
||||
return ESRCH;
|
||||
|
||||
__pthread_mutex_lock (&pthread->state_lock);
|
||||
pthread_cleanup_push ((void (*)(void *)) __pthread_mutex_unlock,
|
||||
&pthread->state_lock);
|
||||
|
||||
/* Rely on pthread_cond_wait being a cancellation point to make
|
||||
pthread_join one too. */
|
||||
while (pthread->state == PTHREAD_JOINABLE)
|
||||
__pthread_cond_wait (&pthread->state_cond, &pthread->state_lock);
|
||||
|
||||
pthread_cleanup_pop (0);
|
||||
|
||||
switch (pthread->state)
|
||||
{
|
||||
case PTHREAD_EXITED:
|
||||
/* THREAD has already exited. Salvage its exit status. */
|
||||
if (status != NULL)
|
||||
*status = pthread->status;
|
||||
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
|
||||
__pthread_dealloc (pthread);
|
||||
break;
|
||||
|
||||
case PTHREAD_TERMINATED:
|
||||
/* Pretend THREAD wasn't there in the first place. */
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
err = ESRCH;
|
||||
break;
|
||||
|
||||
default:
|
||||
/* Thou shalt not join non-joinable threads! */
|
||||
__pthread_mutex_unlock (&pthread->state_lock);
|
||||
err = EINVAL;
|
||||
break;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
33
htl/pt-self.c
Normal file
33
htl/pt-self.c
Normal file
@ -0,0 +1,33 @@
|
||||
/* Get calling thread's ID.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
/* Return the thread ID of the calling thread. */
|
||||
pthread_t
|
||||
__pthread_self (void)
|
||||
{
|
||||
struct __pthread *self = _pthread_self ();
|
||||
assert (self != NULL);
|
||||
|
||||
return self->thread;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_self, pthread_self);
|
46
htl/pt-setcancelstate.c
Normal file
46
htl/pt-setcancelstate.c
Normal file
@ -0,0 +1,46 @@
|
||||
/* Set the cancel state for the calling thread.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_setcancelstate (int state, int *oldstate)
|
||||
{
|
||||
struct __pthread *p = _pthread_self ();
|
||||
|
||||
switch (state)
|
||||
{
|
||||
default:
|
||||
return EINVAL;
|
||||
case PTHREAD_CANCEL_ENABLE:
|
||||
case PTHREAD_CANCEL_DISABLE:
|
||||
break;
|
||||
}
|
||||
|
||||
__pthread_mutex_lock (&p->cancel_lock);
|
||||
if (oldstate != NULL)
|
||||
*oldstate = p->cancel_state;
|
||||
p->cancel_state = state;
|
||||
__pthread_mutex_unlock (&p->cancel_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_setcancelstate, pthread_setcancelstate);
|
46
htl/pt-setcanceltype.c
Normal file
46
htl/pt-setcanceltype.c
Normal file
@ -0,0 +1,46 @@
|
||||
/* Set the cancel type for the calling thread.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_setcanceltype (int type, int *oldtype)
|
||||
{
|
||||
struct __pthread *p = _pthread_self ();
|
||||
|
||||
switch (type)
|
||||
{
|
||||
default:
|
||||
return EINVAL;
|
||||
case PTHREAD_CANCEL_DEFERRED:
|
||||
case PTHREAD_CANCEL_ASYNCHRONOUS:
|
||||
break;
|
||||
}
|
||||
|
||||
__pthread_mutex_lock (&p->cancel_lock);
|
||||
if (oldtype != NULL)
|
||||
*oldtype = p->cancel_type;
|
||||
p->cancel_type = type;
|
||||
__pthread_mutex_unlock (&p->cancel_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_setcanceltype, pthread_setcanceltype);
|
31
htl/pt-sigmask.c
Normal file
31
htl/pt-sigmask.c
Normal file
@ -0,0 +1,31 @@
|
||||
/* Get or set a thread's signal mask.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
pthread_sigmask (int how, const sigset_t *set, sigset_t *oset)
|
||||
{
|
||||
struct __pthread *self = _pthread_self ();
|
||||
|
||||
/* Do not clear SELF's pending signals. */
|
||||
return __pthread_sigstate (self, how, set, oset, 0);
|
||||
}
|
33
htl/pt-spin-inlines.c
Normal file
33
htl/pt-spin-inlines.c
Normal file
@ -0,0 +1,33 @@
|
||||
/* Spin locks non-inline functions.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
/* <bits/types/__pthread_spinlock_t.h> declares some extern inline functions. These
|
||||
functions are declared additionally here for use when inlining is
|
||||
not possible. */
|
||||
|
||||
#define _FORCE_INLINES
|
||||
#define __PT_SPIN_INLINE /* empty */
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
/* Weak aliases for the spin lock functions. */
|
||||
weak_alias (__pthread_spin_destroy, pthread_spin_destroy);
|
||||
weak_alias (__pthread_spin_init, pthread_spin_init);
|
||||
weak_alias (__pthread_spin_trylock, pthread_spin_trylock);
|
||||
weak_alias (__pthread_spin_lock, pthread_spin_lock);
|
||||
weak_alias (__pthread_spin_unlock, pthread_spin_unlock);
|
35
htl/pt-testcancel.c
Normal file
35
htl/pt-testcancel.c
Normal file
@ -0,0 +1,35 @@
|
||||
/* Add an explicit cancelation point.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
void
|
||||
pthread_testcancel (void)
|
||||
{
|
||||
struct __pthread *p = _pthread_self ();
|
||||
int cancelled;
|
||||
|
||||
__pthread_mutex_lock (&p->cancel_lock);
|
||||
cancelled = (p->cancel_state == PTHREAD_CANCEL_ENABLE) && p->cancel_pending;
|
||||
__pthread_mutex_unlock (&p->cancel_lock);
|
||||
|
||||
if (cancelled)
|
||||
pthread_exit (PTHREAD_CANCELED);
|
||||
}
|
26
htl/pt-yield.c
Normal file
26
htl/pt-yield.c
Normal file
@ -0,0 +1,26 @@
|
||||
/* Yield the processor to another thread or process.
|
||||
Copyright (C) 2010-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
|
||||
int
|
||||
pthread_yield (void)
|
||||
{
|
||||
return sched_yield ();
|
||||
}
|
1
htl/shlib-versions
Normal file
1
htl/shlib-versions
Normal file
@ -0,0 +1 @@
|
||||
libpthread=0.3
|
40
htl/tests/Makefile
Normal file
40
htl/tests/Makefile
Normal file
@ -0,0 +1,40 @@
|
||||
ifdef INSTALL_ROOT
|
||||
INSTALL_ROOT_CPPFLAGS = -isystem $(INSTALL_ROOT)/include
|
||||
INSTALL_ROOT_LDFLAGS = -L$(INSTALL_ROOT)/lib -Wl,-rpath,$(INSTALL_ROOT)/lib
|
||||
endif
|
||||
|
||||
CFLAGS=-Wall -g
|
||||
|
||||
LDLIBS = -lpthread
|
||||
|
||||
CHECK_SRC := test-1.c test-2.c test-3.c test-6.c test-7.c test-8.c \
|
||||
test-9.c test-10.c test-11.c test-12.c test-13.c test-14.c \
|
||||
test-15.c test-16.c test-17.c test-__pthread_destroy_specific-skip.c
|
||||
|
||||
CHECK_OBJS := $(addsuffix .o,$(basename $(notdir $(CHECK_SRC))))
|
||||
CHECK_PROGS := $(basename $(notdir $(CHECK_SRC))) \
|
||||
$(addsuffix -static, $(basename $(CHECK_SRC)))
|
||||
|
||||
%.o: %.c
|
||||
$(CC) $(INSTALL_ROOT_CPPFLAGS) $(CPPFLAGS) $(CFLAGS) $< -c -o $@
|
||||
|
||||
%: %.o
|
||||
$(CC) $(INSTALL_ROOT_LDFLAGS) $(LDFLAGS) $< -o $@ $(LDLIBS)
|
||||
|
||||
%-static: %.o
|
||||
$(CC) -static $(INSTALL_ROOT_LDFLAGS) $(LDFLAGS) $< -o $@ $(LDLIBS)
|
||||
|
||||
check: $(CHECK_OBJS) $(CHECK_PROGS)
|
||||
for i in $(CHECK_PROGS); do \
|
||||
echo -n Running $$i...\ ; \
|
||||
if ./$$i 2>&1 > $$i.out; \
|
||||
then \
|
||||
echo Success.; \
|
||||
else \
|
||||
echo Failure.; \
|
||||
fi \
|
||||
done
|
||||
|
||||
clean:
|
||||
rm -f $(CHECK_OBJS) $(CHECK_PROGS) \
|
||||
$(addsuffix .out,$(basename $(notdir $(CHECK_PROGS))))
|
6
htl/tests/README
Normal file
6
htl/tests/README
Normal file
@ -0,0 +1,6 @@
|
||||
Testing of installed package:
|
||||
|
||||
$ [libpthread]/configure --prefix=[install_root]
|
||||
$ make
|
||||
$ make install
|
||||
$ make -C [libpthread]/tests/ INSTALL_ROOT=[install_root] clean check
|
68
htl/tests/test-1.c
Normal file
68
htl/tests/test-1.c
Normal file
@ -0,0 +1,68 @@
|
||||
/* Test mutexes.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <unistd.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define THREADS 500
|
||||
|
||||
void *
|
||||
foo (void *arg)
|
||||
{
|
||||
pthread_mutex_t *mutex = arg;
|
||||
pthread_mutex_lock (mutex);
|
||||
pthread_mutex_unlock (mutex);
|
||||
return mutex;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
int i;
|
||||
error_t err;
|
||||
pthread_t tid[THREADS];
|
||||
pthread_mutex_t mutex[THREADS];
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
pthread_mutex_init (&mutex[i], 0);
|
||||
pthread_mutex_lock (&mutex[i]);
|
||||
err = pthread_create (&tid[i], 0, foo, &mutex[i]);
|
||||
if (err)
|
||||
error (1, err, "pthread_create");
|
||||
sched_yield ();
|
||||
}
|
||||
|
||||
for (i = THREADS - 1; i >= 0; i--)
|
||||
{
|
||||
void *ret;
|
||||
pthread_mutex_unlock (&mutex[i]);
|
||||
err = pthread_join (tid[i], &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
assert (ret == &mutex[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
62
htl/tests/test-10.c
Normal file
62
htl/tests/test-10.c
Normal file
@ -0,0 +1,62 @@
|
||||
/* Test error checking mutexes.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
pthread_mutexattr_t mattr;
|
||||
pthread_mutex_t mutex;
|
||||
|
||||
err = pthread_mutexattr_init (&mattr);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutexattr_init");
|
||||
|
||||
err = pthread_mutexattr_settype (&mattr, PTHREAD_MUTEX_ERRORCHECK);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutexattr_settype");
|
||||
|
||||
err = pthread_mutex_init (&mutex, &mattr);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutex_init");
|
||||
|
||||
err = pthread_mutexattr_destroy (&mattr);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutexattr_destroy");
|
||||
|
||||
err = pthread_mutex_lock (&mutex);
|
||||
assert (err == 0);
|
||||
|
||||
err = pthread_mutex_lock (&mutex);
|
||||
assert (err == EDEADLK);
|
||||
|
||||
err = pthread_mutex_unlock (&mutex);
|
||||
assert (err == 0);
|
||||
|
||||
err = pthread_mutex_unlock (&mutex);
|
||||
assert (err == EPERM);
|
||||
|
||||
return 0;
|
||||
}
|
159
htl/tests/test-11.c
Normal file
159
htl/tests/test-11.c
Normal file
@ -0,0 +1,159 @@
|
||||
/* Test rwlocks.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define THREADS 1
|
||||
|
||||
int a;
|
||||
int b;
|
||||
|
||||
/* Get a read lock and assert that a == b. */
|
||||
void *
|
||||
test1 (void *arg)
|
||||
{
|
||||
error_t err;
|
||||
pthread_rwlock_t *lock = arg;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 200; i++)
|
||||
{
|
||||
err = pthread_rwlock_rdlock (lock);
|
||||
assert (err == 0);
|
||||
|
||||
assert (a == b);
|
||||
|
||||
sched_yield ();
|
||||
|
||||
assert (a == b);
|
||||
|
||||
err = pthread_rwlock_unlock (lock);
|
||||
assert (err == 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
pthread_rwlockattr_t attr;
|
||||
pthread_rwlock_t lock;
|
||||
int pshared;
|
||||
|
||||
int i;
|
||||
pthread_t tid[THREADS];
|
||||
void *ret;
|
||||
|
||||
err = pthread_rwlockattr_init (&attr);
|
||||
if (err)
|
||||
error (1, err, "pthread_rwlockattr_init");
|
||||
|
||||
err = pthread_rwlockattr_getpshared (&attr, &pshared);
|
||||
if (err)
|
||||
error (1, err, "pthread_rwlockattr_getpshared");
|
||||
|
||||
/* Assert the default state as mandated by POSIX. */
|
||||
assert (pshared == PTHREAD_PROCESS_PRIVATE);
|
||||
|
||||
err = pthread_rwlockattr_setpshared (&attr, pshared);
|
||||
if (err)
|
||||
error (1, err, "pthread_rwlockattr_setpshared");
|
||||
|
||||
err = pthread_rwlock_init (&lock, &attr);
|
||||
if (err)
|
||||
error (1, err, "pthread_rwlock_init");
|
||||
|
||||
err = pthread_rwlockattr_destroy (&attr);
|
||||
if (err)
|
||||
error (1, err, "pthread_rwlockattr_destroy");
|
||||
|
||||
/* Now test the lock. */
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
err = pthread_create (&tid[i], 0, test1, &lock);
|
||||
if (err)
|
||||
error (1, err, "pthread_create");
|
||||
}
|
||||
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
sched_yield ();
|
||||
|
||||
/* Get a write lock. */
|
||||
pthread_rwlock_wrlock (&lock);
|
||||
/* Increment a and b giving other threads a chance to run in
|
||||
between. */
|
||||
sched_yield ();
|
||||
a++;
|
||||
sched_yield ();
|
||||
b++;
|
||||
sched_yield ();
|
||||
/* Unlock. */
|
||||
pthread_rwlock_unlock (&lock);
|
||||
}
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
err = pthread_join (tid[i], &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
}
|
||||
|
||||
/* Read lock it. */
|
||||
err = pthread_rwlock_tryrdlock (&lock);
|
||||
assert (err == 0);
|
||||
|
||||
/* Try to write lock it. It should fail with EBUSY. */
|
||||
err = pthread_rwlock_trywrlock (&lock);
|
||||
assert (err == EBUSY);
|
||||
|
||||
/* Drop the read lock. */
|
||||
err = pthread_rwlock_unlock (&lock);
|
||||
assert (err == 0);
|
||||
|
||||
/* Get a write lock. */
|
||||
err = pthread_rwlock_trywrlock (&lock);
|
||||
assert (err == 0);
|
||||
|
||||
/* Fail trying to acquire another write lock. */
|
||||
err = pthread_rwlock_trywrlock (&lock);
|
||||
assert (err == EBUSY);
|
||||
|
||||
/* Try to get a read lock which should also fail. */
|
||||
err = pthread_rwlock_tryrdlock (&lock);
|
||||
assert (err == EBUSY);
|
||||
|
||||
/* Unlock it. */
|
||||
err = pthread_rwlock_unlock (&lock);
|
||||
assert (err == 0);
|
||||
|
||||
|
||||
err = pthread_rwlock_destroy (&lock);
|
||||
if (err)
|
||||
error (1, err, "pthread_rwlock_destroy");
|
||||
|
||||
return 0;
|
||||
}
|
45
htl/tests/test-12.c
Normal file
45
htl/tests/test-12.c
Normal file
@ -0,0 +1,45 @@
|
||||
/* Test concurrency level.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
int i;
|
||||
int err;
|
||||
|
||||
i = pthread_getconcurrency ();
|
||||
assert (i == 0);
|
||||
|
||||
err = pthread_setconcurrency (-1);
|
||||
assert (err == EINVAL);
|
||||
|
||||
err = pthread_setconcurrency (4);
|
||||
assert (err == 0);
|
||||
|
||||
i = pthread_getconcurrency ();
|
||||
assert (i == 4);
|
||||
|
||||
return 0;
|
||||
}
|
82
htl/tests/test-13.c
Normal file
82
htl/tests/test-13.c
Normal file
@ -0,0 +1,82 @@
|
||||
/* Test condition attributes and pthread_cond_timedwait.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
int i;
|
||||
pthread_condattr_t attr;
|
||||
pthread_cond_t cond;
|
||||
struct timespec ts;
|
||||
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
|
||||
struct timeval before, after;
|
||||
int diff;
|
||||
|
||||
err = pthread_condattr_init (&attr);
|
||||
if (err)
|
||||
error (1, err, "pthread_condattr_init");
|
||||
|
||||
err = pthread_condattr_getpshared (&attr, &i);
|
||||
if (err)
|
||||
error (1, err, "pthread_condattr_getpshared");
|
||||
assert (i == PTHREAD_PROCESS_PRIVATE);
|
||||
|
||||
err = pthread_condattr_setpshared (&attr, PTHREAD_PROCESS_PRIVATE);
|
||||
assert (err == 0);
|
||||
|
||||
err = pthread_cond_init (&cond, &attr);
|
||||
if (err)
|
||||
error (1, err, "pthread_cond_init");
|
||||
|
||||
err = pthread_condattr_destroy (&attr);
|
||||
if (err)
|
||||
error (1, err, "pthread_condattr_destroy");
|
||||
|
||||
gettimeofday (&before, 0);
|
||||
ts.tv_sec = before.tv_sec + 1;
|
||||
ts.tv_nsec = before.tv_usec * 1000;
|
||||
|
||||
printf ("Starting wait @ %d\n", (int) before.tv_sec);
|
||||
|
||||
pthread_mutex_lock (&m);
|
||||
err = pthread_cond_timedwait (&cond, &m, &ts);
|
||||
|
||||
gettimeofday (&after, 0);
|
||||
|
||||
printf ("End wait @ %d (err = %d)\n", (int) after.tv_sec, err);
|
||||
|
||||
assert (err == ETIMEDOUT);
|
||||
|
||||
diff = after.tv_sec * 1000000 + after.tv_usec
|
||||
- before.tv_sec * 1000000 - before.tv_usec;
|
||||
|
||||
if (diff < 900000 || diff > 1100000)
|
||||
error (1, EGRATUITOUS, "pthread_cond_timedwait waited %d us", diff);
|
||||
|
||||
return 0;
|
||||
}
|
60
htl/tests/test-14.c
Normal file
60
htl/tests/test-14.c
Normal file
@ -0,0 +1,60 @@
|
||||
/* Test pthread_mutex_timedlock.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
struct timespec ts;
|
||||
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
|
||||
struct timeval before, after;
|
||||
int diff;
|
||||
|
||||
gettimeofday (&before, 0);
|
||||
ts.tv_sec = before.tv_sec + 1;
|
||||
ts.tv_nsec = before.tv_usec * 1000;
|
||||
|
||||
printf ("Starting wait @ %d\n", (int) before.tv_sec);
|
||||
|
||||
pthread_mutex_lock (&m);
|
||||
/* A default mutex shall dead lock if locked twice. As such we do
|
||||
not need spawn a second thread. */
|
||||
err = pthread_mutex_timedlock (&m, &ts);
|
||||
assert (err == ETIMEDOUT);
|
||||
|
||||
gettimeofday (&after, 0);
|
||||
|
||||
printf ("End wait @ %d\n", (int) after.tv_sec);
|
||||
|
||||
diff = after.tv_sec * 1000000 + after.tv_usec
|
||||
- before.tv_sec * 1000000 - before.tv_usec;
|
||||
|
||||
if (diff < 900000 || diff > 1100000)
|
||||
error (1, EGRATUITOUS, "pthread_mutex_timedlock waited %d us", diff);
|
||||
|
||||
return 0;
|
||||
}
|
102
htl/tests/test-15.c
Normal file
102
htl/tests/test-15.c
Normal file
@ -0,0 +1,102 @@
|
||||
/* Test pthread_rwlock_timedrdlock and pthread_rwlock_timedwrlock.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#define THREADS 10
|
||||
|
||||
pthread_rwlock_t rwlock;
|
||||
|
||||
void *
|
||||
test (void *arg)
|
||||
{
|
||||
error_t err;
|
||||
int foo = (int) arg;
|
||||
struct timespec ts;
|
||||
struct timeval before, after;
|
||||
int diff;
|
||||
|
||||
gettimeofday (&before, 0);
|
||||
ts.tv_sec = before.tv_sec + 1;
|
||||
ts.tv_nsec = before.tv_usec * 1000;
|
||||
|
||||
printf ("Thread %d starting wait @ %d\n", pthread_self (),
|
||||
(int) before.tv_sec);
|
||||
|
||||
if (foo % 2 == 0)
|
||||
err = pthread_rwlock_timedrdlock (&rwlock, &ts);
|
||||
else
|
||||
err = pthread_rwlock_timedwrlock (&rwlock, &ts);
|
||||
|
||||
assert (err == ETIMEDOUT);
|
||||
|
||||
gettimeofday (&after, 0);
|
||||
|
||||
printf ("Thread %d ending wait @ %d\n", pthread_self (), (int) after.tv_sec);
|
||||
|
||||
diff = after.tv_sec * 1000000 + after.tv_usec
|
||||
- before.tv_sec * 1000000 - before.tv_usec;
|
||||
|
||||
if (diff < 900000 || diff > 1100000)
|
||||
error (1, EGRATUITOUS, "pthread_mutex_timedlock waited %d us", diff);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
int i;
|
||||
pthread_t tid[THREADS];
|
||||
|
||||
err = pthread_rwlock_init (&rwlock, 0);
|
||||
if (err)
|
||||
error (1, err, "pthread_rwlock_init");
|
||||
|
||||
/* Lock it so all the threads will block. */
|
||||
err = pthread_rwlock_wrlock (&rwlock);
|
||||
assert (err == 0);
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
err = pthread_create (&tid[i], 0, test, (void *) i);
|
||||
if (err)
|
||||
error (1, err, "pthread_create");
|
||||
}
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
void *ret;
|
||||
|
||||
err = pthread_join (tid[i], &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
|
||||
assert (ret == 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
87
htl/tests/test-16.c
Normal file
87
htl/tests/test-16.c
Normal file
@ -0,0 +1,87 @@
|
||||
/* Test pthread_kill.c.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
#include <hurd/signal.h>
|
||||
|
||||
pthread_t testthread;
|
||||
|
||||
int i;
|
||||
|
||||
void *
|
||||
test (void *arg)
|
||||
{
|
||||
error_t err;
|
||||
|
||||
printf ("test: %d\n", pthread_self ());
|
||||
|
||||
err = pthread_kill (pthread_self (), SIGINFO);
|
||||
if (err)
|
||||
error (1, err, "pthread_kill");
|
||||
|
||||
/* To avoid using condition variables in a signal handler. */
|
||||
while (i == 0)
|
||||
sched_yield ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
handler (int sig)
|
||||
{
|
||||
assert (pthread_equal (pthread_self (), testthread));
|
||||
printf ("handler: %d\n", pthread_self ());
|
||||
i = 1;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
struct sigaction sa;
|
||||
void *ret;
|
||||
|
||||
printf ("main: %d\n", pthread_self ());
|
||||
|
||||
sa.sa_handler = handler;
|
||||
sa.sa_mask = 0;
|
||||
sa.sa_flags = 0;
|
||||
|
||||
err = sigaction (SIGINFO, &sa, 0);
|
||||
if (err)
|
||||
error (1, err, "sigaction");
|
||||
|
||||
err = pthread_create (&testthread, 0, test, 0);
|
||||
if (err)
|
||||
error (1, err, "pthread_create");
|
||||
|
||||
err = pthread_join (testthread, &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
|
||||
assert (ret == 0);
|
||||
|
||||
return 0;
|
||||
}
|
73
htl/tests/test-17.c
Normal file
73
htl/tests/test-17.c
Normal file
@ -0,0 +1,73 @@
|
||||
/* Test that the key reuse inside libpthread does not cause thread
|
||||
specific values to persist.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE 1
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
|
||||
void
|
||||
work (int iter)
|
||||
{
|
||||
error_t err;
|
||||
pthread_key_t key1;
|
||||
pthread_key_t key2;
|
||||
void *value1;
|
||||
void *value2;
|
||||
|
||||
printf ("work/%d: start\n", iter);
|
||||
err = pthread_key_create (&key1, NULL);
|
||||
assert (err == 0);
|
||||
err = pthread_key_create (&key2, NULL);
|
||||
assert (err == 0);
|
||||
|
||||
value1 = pthread_getspecific (key1);
|
||||
value2 = pthread_getspecific (key2);
|
||||
printf ("work/%d: pre-setspecific: %p,%p\n", iter, value1, value2);
|
||||
assert (value1 == NULL);
|
||||
assert (value2 == NULL);
|
||||
err = pthread_setspecific (key1, (void *) (0x100 + iter));
|
||||
assert (err == 0);
|
||||
err = pthread_setspecific (key2, (void *) (0x200 + iter));
|
||||
assert (err == 0);
|
||||
|
||||
value1 = pthread_getspecific (key1);
|
||||
value2 = pthread_getspecific (key2);
|
||||
printf ("work/%d: post-setspecific: %p,%p\n", iter, value1, value2);
|
||||
assert (value1 == (void *) (0x100 + iter));
|
||||
assert (value2 == (void *) (0x200 + iter));
|
||||
|
||||
err = pthread_key_delete (key1);
|
||||
assert (err == 0);
|
||||
err = pthread_key_delete (key2);
|
||||
assert (err == 0);
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 8; ++i)
|
||||
work (i + 1);
|
||||
|
||||
return 0;
|
||||
}
|
56
htl/tests/test-2.c
Normal file
56
htl/tests/test-2.c
Normal file
@ -0,0 +1,56 @@
|
||||
/* Test detachability.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
|
||||
void *
|
||||
thread (void *arg)
|
||||
{
|
||||
while (1)
|
||||
sched_yield ();
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
int err;
|
||||
pthread_t tid;
|
||||
void *ret;
|
||||
|
||||
err = pthread_create (&tid, 0, thread, 0);
|
||||
if (err)
|
||||
error (1, err, "pthread_create");
|
||||
|
||||
err = pthread_detach (tid);
|
||||
if (err)
|
||||
error (1, err, "pthread_detach");
|
||||
|
||||
err = pthread_detach (tid);
|
||||
assert (err == EINVAL);
|
||||
|
||||
err = pthread_join (tid, &ret);
|
||||
assert (err == EINVAL);
|
||||
|
||||
return 0;
|
||||
}
|
71
htl/tests/test-3.c
Normal file
71
htl/tests/test-3.c
Normal file
@ -0,0 +1,71 @@
|
||||
/* Test the thread attribute get and set methods.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
error_t err;
|
||||
pthread_attr_t attr;
|
||||
|
||||
int i;
|
||||
struct sched_param sp;
|
||||
void *p;
|
||||
size_t sz;
|
||||
|
||||
err = pthread_attr_init (&attr);
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_attr_destroy (&attr);
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_attr_init (&attr);
|
||||
assert_perror (err);
|
||||
|
||||
#define TEST1(foo, rv, v) \
|
||||
err = pthread_attr_get##foo (&attr, rv); \
|
||||
assert_perror (err); \
|
||||
\
|
||||
err = pthread_attr_set##foo (&attr, v); \
|
||||
assert_perror (err);
|
||||
|
||||
#define TEST(foo, rv, v) TEST1(foo, rv, v)
|
||||
|
||||
TEST (inheritsched, &i, i);
|
||||
TEST (schedparam, &sp, &sp);
|
||||
TEST (schedpolicy, &i, i);
|
||||
TEST (scope, &i, i);
|
||||
TEST (stackaddr, &p, p);
|
||||
TEST (detachstate, &i, i);
|
||||
TEST (guardsize, &sz, sz);
|
||||
TEST (stacksize, &sz, sz);
|
||||
|
||||
err = pthread_attr_getstack (&attr, &p, &sz);
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_attr_setstack (&attr, p, sz);
|
||||
assert_perror (err);
|
||||
|
||||
return 0;
|
||||
}
|
102
htl/tests/test-4.c
Normal file
102
htl/tests/test-4.c
Normal file
@ -0,0 +1,102 @@
|
||||
/* Test the stack guard.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
size_t stacksize;
|
||||
|
||||
void *
|
||||
thr (void *arg)
|
||||
{
|
||||
int i;
|
||||
char *foo;
|
||||
|
||||
foo = alloca (3 * stacksize / 4);
|
||||
for (i = 0; i < sizeof foo; i++)
|
||||
foo[i] = -1;
|
||||
|
||||
return (void *) 1;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
error_t err;
|
||||
pid_t child;
|
||||
|
||||
child = fork ();
|
||||
switch (child)
|
||||
{
|
||||
case -1:
|
||||
error (1, errno, "fork");
|
||||
break;
|
||||
|
||||
case 0:
|
||||
{
|
||||
pthread_attr_t attr;
|
||||
pthread_t tid;
|
||||
void *ret;
|
||||
|
||||
err = pthread_attr_init (&attr);
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_attr_getstacksize (&attr, &stacksize);
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_attr_setguardsize (&attr, stacksize / 2);
|
||||
if (err == ENOTSUP)
|
||||
{
|
||||
printf ("Stack guard attribute not supported.\n");
|
||||
return 1;
|
||||
}
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_create (&tid, &attr, thr, 0);
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_attr_destroy (&attr);
|
||||
assert_perror (err);
|
||||
|
||||
err = pthread_join (tid, &ret);
|
||||
/* Should never be successful. */
|
||||
printf ("Thread did not segfault!?!\n");
|
||||
assert_perror (err);
|
||||
return 0;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
pid_t pid;
|
||||
int status;
|
||||
|
||||
pid = waitpid (child, &status, 0);
|
||||
printf ("pid = %d; child = %d; status = %d\n", pid, child, status);
|
||||
assert (pid == child);
|
||||
assert (status != 0);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
91
htl/tests/test-5.c
Normal file
91
htl/tests/test-5.c
Normal file
@ -0,0 +1,91 @@
|
||||
/* Test signals.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <error.h>
|
||||
#include <assert.h>
|
||||
#include <sys/resource.h>
|
||||
#include <sys/wait.h>
|
||||
|
||||
void *
|
||||
thr (void *arg)
|
||||
{
|
||||
*(int *) 0 = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int foobar;
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
error_t err;
|
||||
pid_t child;
|
||||
|
||||
struct rlimit limit;
|
||||
|
||||
limit.rlim_cur = 0;
|
||||
limit.rlim_max = 0;
|
||||
|
||||
err = setrlimit (RLIMIT_CORE, &limit);
|
||||
if (err)
|
||||
error (1, err, "setrlimit");
|
||||
|
||||
child = fork ();
|
||||
switch (child)
|
||||
{
|
||||
case -1:
|
||||
error (1, errno, "fork");
|
||||
break;
|
||||
|
||||
case 0:
|
||||
{
|
||||
pthread_t tid;
|
||||
void *ret;
|
||||
|
||||
err = pthread_create (&tid, 0, thr, 0);
|
||||
if (err)
|
||||
error (1, err, "pthread_create");
|
||||
|
||||
err = pthread_join (tid, &ret);
|
||||
assert_perror (err);
|
||||
|
||||
/* Should have never returned. Our parent expects us to fail
|
||||
thus we succeed and indicate the error. */
|
||||
return 0;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
pid_t pid;
|
||||
int status;
|
||||
|
||||
pid = waitpid (child, &status, 0);
|
||||
printf ("pid = %d; child = %d; status = %d\n", pid, child, status);
|
||||
assert (pid == child);
|
||||
assert (status != 0);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
114
htl/tests/test-6.c
Normal file
114
htl/tests/test-6.c
Normal file
@ -0,0 +1,114 @@
|
||||
/* Test barriers.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <error.h>
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define THREADS 500
|
||||
#define WAITS 3
|
||||
|
||||
void *
|
||||
dowait (void *arg)
|
||||
{
|
||||
pthread_barrier_t *barrier = arg;
|
||||
int ret;
|
||||
|
||||
ret = pthread_barrier_wait (barrier);
|
||||
printf ("%d ", pthread_self ());
|
||||
return (void *) ret;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
pthread_barrierattr_t attr;
|
||||
pthread_barrier_t barrier;
|
||||
|
||||
int i, j;
|
||||
error_t err;
|
||||
pthread_t tid[THREADS];
|
||||
|
||||
int havesyncs;
|
||||
|
||||
err = pthread_barrierattr_init (&attr);
|
||||
if (err)
|
||||
error (1, err, "pthread_barrierattr_init");
|
||||
|
||||
err = pthread_barrierattr_getpshared (&attr, &i);
|
||||
if (err)
|
||||
error (1, err, "pthread_barrierattr_getpshared");
|
||||
assert (i == PTHREAD_PROCESS_PRIVATE || i == PTHREAD_PROCESS_SHARED);
|
||||
|
||||
err = pthread_barrierattr_setpshared (&attr, PTHREAD_PROCESS_PRIVATE);
|
||||
if (err)
|
||||
error (1, err, "pthread_barrierattr_setpshared");
|
||||
|
||||
err = pthread_barrier_init (&barrier, &attr, THREADS + 1);
|
||||
if (err)
|
||||
error (1, err, "pthread_barrier_init");
|
||||
|
||||
for (j = 0; j < WAITS; j++)
|
||||
{
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
err = pthread_create (&tid[i], 0, dowait, &barrier);
|
||||
if (err)
|
||||
error (1, err, "pthread_create (%d)", i);
|
||||
}
|
||||
|
||||
printf ("Manager will now call pthread_barrier_wait.\n");
|
||||
|
||||
havesyncs
|
||||
= pthread_barrier_wait (&barrier) == PTHREAD_BARRIER_SERIAL_THREAD
|
||||
? 1 : 0;
|
||||
|
||||
for (i = THREADS - 1; i >= 0; i--)
|
||||
{
|
||||
void *ret;
|
||||
err = pthread_join (tid[i], &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
|
||||
switch ((int) ret)
|
||||
{
|
||||
case 0:
|
||||
break;
|
||||
|
||||
case PTHREAD_BARRIER_SERIAL_THREAD:
|
||||
havesyncs++;
|
||||
break;
|
||||
|
||||
default:
|
||||
assert (!"Unknown value returned from pthread_barrier_wait.");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
printf ("\n");
|
||||
|
||||
assert (havesyncs == 1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
89
htl/tests/test-7.c
Normal file
89
htl/tests/test-7.c
Normal file
@ -0,0 +1,89 @@
|
||||
/* Test Thread-Specific Data.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define THREADS 10
|
||||
#define KEYS 400
|
||||
|
||||
pthread_key_t key[KEYS];
|
||||
|
||||
void *
|
||||
thr (void *arg)
|
||||
{
|
||||
error_t err;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < KEYS; i++)
|
||||
{
|
||||
printf ("pthread_getspecific(%d).\n", key[i]);
|
||||
assert (pthread_getspecific (key[i]) == NULL);
|
||||
printf ("pthread_setspecific(%d, %d).\n", key[i], pthread_self ());
|
||||
err = pthread_setspecific (key[i], (void *) pthread_self ());
|
||||
printf ("pthread_setspecific(%d, %d) => %d.\n", key[i], pthread_self (),
|
||||
err);
|
||||
assert_perror (err);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
int i;
|
||||
pthread_t tid[THREADS];
|
||||
|
||||
void des (void *val)
|
||||
{
|
||||
assert ((pthread_t) val == pthread_self ());
|
||||
}
|
||||
|
||||
assert (pthread_getspecific ((pthread_key_t) 0) == NULL);
|
||||
assert (pthread_setspecific ((pthread_key_t) 0, (void *) 0x1) == EINVAL);
|
||||
|
||||
for (i = 0; i < KEYS; i++)
|
||||
err = pthread_key_create (&key[i], des);
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
err = pthread_create (&tid[i], 0, thr, 0);
|
||||
if (err)
|
||||
error (1, err, "pthread_create (%d)", i);
|
||||
}
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
void *ret;
|
||||
|
||||
err = pthread_join (tid[i], &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
|
||||
assert (ret == 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
78
htl/tests/test-8.c
Normal file
78
htl/tests/test-8.c
Normal file
@ -0,0 +1,78 @@
|
||||
/* Test pthread_once.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define THREADS 10
|
||||
|
||||
pthread_once_t inc_var_once = PTHREAD_ONCE_INIT;
|
||||
int var;
|
||||
|
||||
void
|
||||
inc_var (void)
|
||||
{
|
||||
var++;
|
||||
}
|
||||
|
||||
void *
|
||||
thr (void *arg)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 500; i++)
|
||||
pthread_once (&inc_var_once, inc_var);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
int i;
|
||||
pthread_t tid[THREADS];
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
err = pthread_create (&tid[i], 0, thr, 0);
|
||||
if (err)
|
||||
error (1, err, "pthread_create (%d)", i);
|
||||
}
|
||||
|
||||
assert (thr (0) == 0);
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
void *ret;
|
||||
|
||||
err = pthread_join (tid[i], &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
|
||||
assert (ret == 0);
|
||||
}
|
||||
|
||||
assert (var == 1);
|
||||
|
||||
return 0;
|
||||
}
|
104
htl/tests/test-9.c
Normal file
104
htl/tests/test-9.c
Normal file
@ -0,0 +1,104 @@
|
||||
/* Test recursive mutexes.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
#include <error.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define THREADS 10
|
||||
|
||||
int foo;
|
||||
|
||||
void *
|
||||
thr (void *arg)
|
||||
{
|
||||
int i;
|
||||
|
||||
pthread_mutex_lock (arg);
|
||||
|
||||
foo = pthread_self ();
|
||||
|
||||
for (i = 0; i < 500; i++)
|
||||
pthread_mutex_lock (arg);
|
||||
for (i = 0; i < 500; i++)
|
||||
pthread_mutex_unlock (arg);
|
||||
|
||||
assert (foo == pthread_self ());
|
||||
|
||||
pthread_mutex_unlock (arg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
error_t err;
|
||||
int i;
|
||||
pthread_t tid[THREADS];
|
||||
pthread_mutexattr_t mattr;
|
||||
pthread_mutex_t mutex;
|
||||
|
||||
err = pthread_mutexattr_init (&mattr);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutexattr_init");
|
||||
|
||||
err = pthread_mutexattr_settype (&mattr, PTHREAD_MUTEX_RECURSIVE);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutexattr_settype");
|
||||
|
||||
err = pthread_mutex_init (&mutex, &mattr);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutex_init");
|
||||
|
||||
err = pthread_mutexattr_destroy (&mattr);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutexattr_destroy");
|
||||
|
||||
pthread_mutex_lock (&mutex);
|
||||
pthread_mutex_lock (&mutex);
|
||||
pthread_mutex_unlock (&mutex);
|
||||
pthread_mutex_unlock (&mutex);
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
err = pthread_create (&tid[i], 0, thr, &mutex);
|
||||
if (err)
|
||||
error (1, err, "pthread_create (%d)", i);
|
||||
}
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
void *ret;
|
||||
|
||||
err = pthread_join (tid[i], &ret);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
|
||||
assert (ret == 0);
|
||||
}
|
||||
|
||||
err = pthread_mutex_destroy (&mutex);
|
||||
if (err)
|
||||
error (1, err, "pthread_mutex_destroy");
|
||||
|
||||
return 0;
|
||||
}
|
100
htl/tests/test-__pthread_destroy_specific-skip.c
Normal file
100
htl/tests/test-__pthread_destroy_specific-skip.c
Normal file
@ -0,0 +1,100 @@
|
||||
/* Check that __pthread_destroy_specific works correctly if it has to skip
|
||||
unused slots.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <error.h>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
#define N_k 42
|
||||
|
||||
static volatile int v;
|
||||
|
||||
static void
|
||||
d (void *x)
|
||||
{
|
||||
int *i = (int *) x;
|
||||
|
||||
if (v != *i)
|
||||
error (1, 0, "FAILED %d %d", v, *i);
|
||||
v += 2;
|
||||
|
||||
printf ("%s %d\n", __FUNCTION__, *i);
|
||||
fflush (stdout);
|
||||
}
|
||||
|
||||
static void *
|
||||
test (void *x)
|
||||
{
|
||||
pthread_key_t k[N_k];
|
||||
static int k_v[N_k];
|
||||
|
||||
int err, i;
|
||||
|
||||
for (i = 0; i < N_k; i += 1)
|
||||
{
|
||||
err = pthread_key_create (&k[i], &d);
|
||||
if (err != 0)
|
||||
error (1, err, "pthread_key_create %d", i);
|
||||
}
|
||||
|
||||
for (i = 0; i < N_k; i += 1)
|
||||
{
|
||||
k_v[i] = i;
|
||||
err = pthread_setspecific (k[i], &k_v[i]);
|
||||
if (err != 0)
|
||||
error (1, err, "pthread_setspecific %d", i);
|
||||
}
|
||||
|
||||
/* Delete every even key. */
|
||||
for (i = 0; i < N_k; i += 2)
|
||||
{
|
||||
err = pthread_key_delete (k[i]);
|
||||
if (err != 0)
|
||||
error (1, err, "pthread_key_delete %d", i);
|
||||
}
|
||||
|
||||
v = 1;
|
||||
pthread_exit (NULL);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
pthread_t tid;
|
||||
int err;
|
||||
|
||||
err = pthread_create (&tid, 0, test, NULL);
|
||||
if (err != 0)
|
||||
error (1, err, "pthread_create");
|
||||
|
||||
err = pthread_join (tid, NULL);
|
||||
if (err)
|
||||
error (1, err, "pthread_join");
|
||||
|
||||
if (v != N_k + 1)
|
||||
error (1, 0, "FAILED END %d %d", v, N_k + 1);
|
||||
|
||||
return 0;
|
||||
}
|
@ -1 +1,2 @@
|
||||
nptl
|
||||
htl
|
||||
|
@ -1 +1,2 @@
|
||||
nptl
|
||||
htl
|
||||
|
1
sysdeps/htl/Implies
Normal file
1
sysdeps/htl/Implies
Normal file
@ -0,0 +1 @@
|
||||
pthread
|
11
sysdeps/htl/Makeconfig
Normal file
11
sysdeps/htl/Makeconfig
Normal file
@ -0,0 +1,11 @@
|
||||
# Makeconfig fragment for Hurd libpthread add-on.
|
||||
# This gets included at the end of the main glibc Makeconfig.
|
||||
|
||||
have-thread-library = yes
|
||||
|
||||
shared-thread-library = $(common-objpfx)htl/libpthread_nonshared.a \
|
||||
$(common-objpfx)htl/libpthread.so
|
||||
static-thread-library = $(common-objpfx)htl/libpthread.a
|
||||
bounded-thread-library = $(static-thread-library)
|
||||
|
||||
rpath-dirs += htl
|
7
sysdeps/htl/Makefile
Normal file
7
sysdeps/htl/Makefile
Normal file
@ -0,0 +1,7 @@
|
||||
ifeq ($(subdir),rt)
|
||||
librt-sysdep_routines += timer_routines
|
||||
endif
|
||||
|
||||
ifeq ($(subdir),posix)
|
||||
CFLAGS-confstr.c += -DLIBPTHREAD_VERSION='"HTL $(version)"'
|
||||
endif
|
1
sysdeps/htl/Subdirs
Normal file
1
sysdeps/htl/Subdirs
Normal file
@ -0,0 +1 @@
|
||||
htl
|
15
sysdeps/htl/Versions
Normal file
15
sysdeps/htl/Versions
Normal file
@ -0,0 +1,15 @@
|
||||
libc {
|
||||
GLIBC_2.2 {
|
||||
# XXX
|
||||
__vm_deallocate; __mach_port_insert_right; __mach_reply_port;
|
||||
__mig_init; __vm_allocate; __mach_port_allocate;
|
||||
|
||||
# functions used in inline functions or macros
|
||||
__pthread_spin_destroy; __pthread_spin_init; __pthread_spin_lock;
|
||||
_pthread_spin_lock; __pthread_spin_trylock; __pthread_spin_unlock;
|
||||
|
||||
# p*
|
||||
pthread_spin_destroy; pthread_spin_init; pthread_spin_lock;
|
||||
pthread_spin_trylock; pthread_spin_unlock;
|
||||
}
|
||||
}
|
50
sysdeps/htl/bits/cancelation.h
Normal file
50
sysdeps/htl/bits/cancelation.h
Normal file
@ -0,0 +1,50 @@
|
||||
/* Cancelation. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_CANCELATION_H
|
||||
#define _BITS_CANCELATION_H 1
|
||||
|
||||
struct __pthread_cancelation_handler
|
||||
{
|
||||
void (*__handler) (void *);
|
||||
void *__arg;
|
||||
struct __pthread_cancelation_handler *__next;
|
||||
};
|
||||
|
||||
/* Returns the thread local location of the cleanup handler stack. */
|
||||
struct __pthread_cancelation_handler **__pthread_get_cleanup_stack (void);
|
||||
|
||||
#define __pthread_cleanup_push(rt, rtarg) \
|
||||
{ \
|
||||
struct __pthread_cancelation_handler **__handlers \
|
||||
= __pthread_get_cleanup_stack (); \
|
||||
struct __pthread_cancelation_handler __handler = \
|
||||
{ \
|
||||
(rt), \
|
||||
(rtarg), \
|
||||
*__handlers \
|
||||
}; \
|
||||
*__handlers = &__handler;
|
||||
|
||||
#define __pthread_cleanup_pop(execute) \
|
||||
if (execute) \
|
||||
__handler.__handler (__handler.__arg); \
|
||||
*__handlers = __handler.__next; \
|
||||
}
|
||||
|
||||
#endif /* _BITS_CANCELATION_H */
|
26
sysdeps/htl/bits/pthread-np.h
Normal file
26
sysdeps/htl/bits/pthread-np.h
Normal file
@ -0,0 +1,26 @@
|
||||
/* Non-portable functions. Generic version.
|
||||
Copyright (C) 2008-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
/*
|
||||
* Never include this file directly; use <pthread.h> or <cthreads.h> instead.
|
||||
*/
|
||||
|
||||
#ifndef _BITS_PTHREAD_NP_H
|
||||
#define _BITS_PTHREAD_NP_H 1
|
||||
|
||||
#endif /* bits/pthread-np.h */
|
36
sysdeps/htl/bits/pthread.h
Normal file
36
sysdeps/htl/bits/pthread.h
Normal file
@ -0,0 +1,36 @@
|
||||
/* Pthread data structures. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_PTHREAD_H
|
||||
#define _BITS_PTHREAD_H 1
|
||||
|
||||
typedef int __pthread_t;
|
||||
|
||||
/* Return true if __T1 and __T2 both name the same thread. Otherwise,
|
||||
false. */
|
||||
extern int __pthread_equal (__pthread_t __t1, __pthread_t __t2);
|
||||
|
||||
#ifdef __USE_EXTERN_INLINES
|
||||
__extern_inline int
|
||||
__pthread_equal (__pthread_t __t1, __pthread_t __t2)
|
||||
{
|
||||
return __t1 == __t2;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* bits/pthread.h */
|
131
sysdeps/htl/bits/pthreadtypes.h
Normal file
131
sysdeps/htl/bits/pthreadtypes.h
Normal file
@ -0,0 +1,131 @@
|
||||
/* Declaration of common pthread types for all architectures. Hurd version.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#if !defined _BITS_TYPES_H && !defined _PTHREAD_H
|
||||
# error "Never include <bits/pthreadtypes.h> directly; use <sys/types.h> instead."
|
||||
#endif
|
||||
|
||||
#ifndef _BITS_PTHREADTYPES_H
|
||||
#define _BITS_PTHREADTYPES_H 1
|
||||
|
||||
#include <bits/thread-shared-types.h>
|
||||
|
||||
#include <features.h>
|
||||
|
||||
#include <bits/types.h>
|
||||
|
||||
__BEGIN_DECLS
|
||||
#include <bits/pthread.h>
|
||||
typedef __pthread_t pthread_t;
|
||||
|
||||
/* Possible values for the process shared attribute. */
|
||||
enum __pthread_process_shared
|
||||
{
|
||||
__PTHREAD_PROCESS_PRIVATE = 0,
|
||||
__PTHREAD_PROCESS_SHARED
|
||||
};
|
||||
|
||||
/* Possible values for the inheritsched attribute. */
|
||||
enum __pthread_inheritsched
|
||||
{
|
||||
__PTHREAD_EXPLICIT_SCHED = 0,
|
||||
__PTHREAD_INHERIT_SCHED
|
||||
};
|
||||
|
||||
/* Possible values for the `contentionscope' attribute. */
|
||||
enum __pthread_contentionscope
|
||||
{
|
||||
__PTHREAD_SCOPE_SYSTEM = 0,
|
||||
__PTHREAD_SCOPE_PROCESS
|
||||
};
|
||||
|
||||
/* Possible values for the `detachstate' attribute. */
|
||||
enum __pthread_detachstate
|
||||
{
|
||||
__PTHREAD_CREATE_JOINABLE = 0,
|
||||
__PTHREAD_CREATE_DETACHED
|
||||
};
|
||||
|
||||
#include <bits/types/struct___pthread_attr.h>
|
||||
typedef struct __pthread_attr pthread_attr_t;
|
||||
|
||||
enum __pthread_mutex_protocol
|
||||
{
|
||||
__PTHREAD_PRIO_NONE = 0,
|
||||
__PTHREAD_PRIO_INHERIT,
|
||||
__PTHREAD_PRIO_PROTECT
|
||||
};
|
||||
|
||||
enum __pthread_mutex_type
|
||||
{
|
||||
__PTHREAD_MUTEX_TIMED,
|
||||
__PTHREAD_MUTEX_ERRORCHECK,
|
||||
__PTHREAD_MUTEX_RECURSIVE
|
||||
};
|
||||
|
||||
enum __pthread_mutex_robustness
|
||||
{
|
||||
__PTHREAD_MUTEX_STALLED,
|
||||
__PTHREAD_MUTEX_ROBUST = 0x100
|
||||
};
|
||||
|
||||
#include <bits/types/struct___pthread_mutexattr.h>
|
||||
typedef struct __pthread_mutexattr pthread_mutexattr_t;
|
||||
|
||||
#include <bits/types/struct___pthread_mutex.h>
|
||||
typedef struct __pthread_mutex pthread_mutex_t;
|
||||
|
||||
#include <bits/types/struct___pthread_condattr.h>
|
||||
typedef struct __pthread_condattr pthread_condattr_t;
|
||||
|
||||
#include <bits/types/struct___pthread_cond.h>
|
||||
typedef struct __pthread_cond pthread_cond_t;
|
||||
|
||||
#ifdef __USE_XOPEN2K
|
||||
# include <bits/types/__pthread_spinlock_t.h>
|
||||
typedef __pthread_spinlock_t pthread_spinlock_t;
|
||||
#endif /* XPG6. */
|
||||
|
||||
#if defined __USE_UNIX98 || defined __USE_XOPEN2K
|
||||
|
||||
# include <bits/types/struct___pthread_rwlockattr.h>
|
||||
typedef struct __pthread_rwlockattr pthread_rwlockattr_t;
|
||||
|
||||
# include <bits/types/struct___pthread_rwlock.h>
|
||||
typedef struct __pthread_rwlock pthread_rwlock_t;
|
||||
|
||||
#endif /* __USE_UNIX98 || __USE_XOPEN2K */
|
||||
|
||||
#ifdef __USE_XOPEN2K
|
||||
|
||||
# include <bits/types/struct___pthread_barrierattr.h>
|
||||
typedef struct __pthread_barrierattr pthread_barrierattr_t;
|
||||
|
||||
# include <bits/types/struct___pthread_barrier.h>
|
||||
typedef struct __pthread_barrier pthread_barrier_t;
|
||||
|
||||
#endif /* __USE_XOPEN2K */
|
||||
|
||||
#include <bits/types/__pthread_key.h>
|
||||
typedef __pthread_key pthread_key_t;
|
||||
|
||||
#include <bits/types/struct___pthread_once.h>
|
||||
typedef struct __pthread_once pthread_once_t;
|
||||
|
||||
__END_DECLS
|
||||
#endif /* bits/pthreadtypes.h */
|
47
sysdeps/htl/bits/semaphore.h
Normal file
47
sysdeps/htl/bits/semaphore.h
Normal file
@ -0,0 +1,47 @@
|
||||
/* Semaphore type. Generic version.
|
||||
Copyright (C) 2005-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_SEMAPHORE_H
|
||||
#define _BITS_SEMAPHORE_H 1
|
||||
|
||||
#ifndef _SEMAPHORE_H
|
||||
# error Never include <bits/semaphore.h> directly.
|
||||
#endif
|
||||
|
||||
#include <bits/types/__pthread_spinlock_t.h>
|
||||
#include <bits/pthread.h>
|
||||
|
||||
/* User visible part of a semaphore. */
|
||||
struct __semaphore
|
||||
{
|
||||
__pthread_spinlock_t __lock;
|
||||
struct __pthread *__queue;
|
||||
int __pshared;
|
||||
int __value;
|
||||
void *__data;
|
||||
};
|
||||
|
||||
typedef struct __semaphore sem_t;
|
||||
|
||||
#define SEM_FAILED ((void *) 0)
|
||||
|
||||
/* Initializer for a semaphore. */
|
||||
#define __SEMAPHORE_INITIALIZER(pshared, value) \
|
||||
{ __PTHREAD_SPIN_LOCK_INITIALIZER, NULL, (pshared), (value), NULL }
|
||||
|
||||
#endif /* bits/semaphore.h */
|
24
sysdeps/htl/bits/thread-shared-types.h
Normal file
24
sysdeps/htl/bits/thread-shared-types.h
Normal file
@ -0,0 +1,24 @@
|
||||
/* Common threading primitives definitions for both POSIX and C11.
|
||||
Copyright (C) 2017-2018 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
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _THREAD_SHARED_TYPES_H
|
||||
#define _THREAD_SHARED_TYPES_H 1
|
||||
|
||||
#include <bits/pthreadtypes-arch.h>
|
||||
|
||||
#endif /* _THREAD_SHARED_TYPES_H */
|
24
sysdeps/htl/bits/types/__pthread_key.h
Normal file
24
sysdeps/htl/bits/types/__pthread_key.h
Normal file
@ -0,0 +1,24 @@
|
||||
/* Thread specific data. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES___PTHREAD_KEY_H
|
||||
#define _BITS_TYPES___PTHREAD_KEY_H 1
|
||||
|
||||
typedef int __pthread_key;
|
||||
|
||||
#endif /* bits/types/__pthread_key.h */
|
45
sysdeps/htl/bits/types/struct___pthread_attr.h
Normal file
45
sysdeps/htl/bits/types/struct___pthread_attr.h
Normal file
@ -0,0 +1,45 @@
|
||||
/* Thread attribute type. Generic version.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_ATTR
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_ATTR 1
|
||||
|
||||
#include <sched.h>
|
||||
|
||||
#define __need_size_t
|
||||
#include <stddef.h>
|
||||
|
||||
enum __pthread_detachstate;
|
||||
enum __pthread_inheritsched;
|
||||
enum __pthread_contentionscope;
|
||||
|
||||
/* This structure describes the attributes of a POSIX thread. Note
|
||||
that not all of them are supported on all systems. */
|
||||
struct __pthread_attr
|
||||
{
|
||||
struct sched_param __schedparam;
|
||||
void *__stackaddr;
|
||||
size_t __stacksize;
|
||||
size_t __guardsize;
|
||||
enum __pthread_detachstate __detachstate;
|
||||
enum __pthread_inheritsched __inheritsched;
|
||||
enum __pthread_contentionscope __contentionscope;
|
||||
int __schedpolicy;
|
||||
};
|
||||
|
||||
#endif /* bits/types/struct___pthread_attr.h */
|
38
sysdeps/htl/bits/types/struct___pthread_barrier.h
Normal file
38
sysdeps/htl/bits/types/struct___pthread_barrier.h
Normal file
@ -0,0 +1,38 @@
|
||||
/* Thread barrier attribute type. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_BARRIER_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_BARRIER_H 1
|
||||
|
||||
#include <bits/types/__pthread_spinlock_t.h>
|
||||
|
||||
/* This structure describes the attributes of a POSIX barrier. */
|
||||
struct __pthread_barrier
|
||||
{
|
||||
__pthread_spinlock_t __lock;
|
||||
struct __pthread *__queue; /* List of waiters. */
|
||||
unsigned __pending; /* Number of that still need to wait on
|
||||
barrier. */
|
||||
unsigned __count; /* Number of threads that must wait before
|
||||
barrier is passed. */
|
||||
struct __pthread_barrierattr *__attr;
|
||||
void *__data;
|
||||
};
|
||||
|
||||
|
||||
#endif /* bits/types/struct___pthread_barrier.h */
|
31
sysdeps/htl/bits/types/struct___pthread_barrierattr.h
Normal file
31
sysdeps/htl/bits/types/struct___pthread_barrierattr.h
Normal file
@ -0,0 +1,31 @@
|
||||
/* Thread barrier attribute type. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_BARRIERATTR_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_BARRIERATTR_H 1
|
||||
|
||||
enum __pthread_process_shared;
|
||||
|
||||
/* This structure describes the attributes of a POSIX thread barrier.
|
||||
Note that not all of them are supported on all systems. */
|
||||
struct __pthread_barrierattr
|
||||
{
|
||||
enum __pthread_process_shared __pshared;
|
||||
};
|
||||
|
||||
#endif /* bits/types/struct___pthread_barrierattr.h */
|
38
sysdeps/htl/bits/types/struct___pthread_cond.h
Normal file
38
sysdeps/htl/bits/types/struct___pthread_cond.h
Normal file
@ -0,0 +1,38 @@
|
||||
/* Condition type. Generic version.
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_COND_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_COND_H 1
|
||||
|
||||
#include <bits/types/__pthread_spinlock_t.h>
|
||||
|
||||
/* User visible part of a condition variable. */
|
||||
struct __pthread_cond
|
||||
{
|
||||
__pthread_spinlock_t __lock;
|
||||
struct __pthread *__queue;
|
||||
struct __pthread_condattr *__attr;
|
||||
struct __pthread_condimpl *__impl;
|
||||
void *__data;
|
||||
};
|
||||
|
||||
/* Initializer for a condition variable. */
|
||||
#define __PTHREAD_COND_INITIALIZER \
|
||||
{ __PTHREAD_SPIN_LOCK_INITIALIZER, NULL, NULL, NULL, NULL }
|
||||
|
||||
#endif /* bits/types/struct___pthread_cond.h */
|
33
sysdeps/htl/bits/types/struct___pthread_condattr.h
Normal file
33
sysdeps/htl/bits/types/struct___pthread_condattr.h
Normal file
@ -0,0 +1,33 @@
|
||||
/* Condition attribute type. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_CONDATTR
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_CONDATTR 1
|
||||
|
||||
#include <bits/types.h>
|
||||
|
||||
enum __pthread_process_shared;
|
||||
|
||||
/* User visible part of a condition attribute variable. */
|
||||
struct __pthread_condattr
|
||||
{
|
||||
enum __pthread_process_shared __pshared;
|
||||
__clockid_t __clock;
|
||||
};
|
||||
|
||||
#endif /* bits/types/struct___pthread_condattr.h */
|
62
sysdeps/htl/bits/types/struct___pthread_mutex.h
Normal file
62
sysdeps/htl/bits/types/struct___pthread_mutex.h
Normal file
@ -0,0 +1,62 @@
|
||||
/* Mutex type. Generic version.
|
||||
|
||||
Copyright (C) 2000-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_MUTEX_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_MUTEX_H 1
|
||||
|
||||
#include <bits/types/__pthread_spinlock_t.h>
|
||||
#include <bits/types/struct___pthread_mutexattr.h>
|
||||
|
||||
/* User visible part of a mutex. */
|
||||
struct __pthread_mutex
|
||||
{
|
||||
__pthread_spinlock_t __held;
|
||||
__pthread_spinlock_t __lock;
|
||||
/* In cthreads, mutex_init does not initialized thre third
|
||||
pointer, as such, we cannot rely on its value for anything. */
|
||||
char *__cthreadscompat1;
|
||||
struct __pthread *__queue;
|
||||
struct __pthread_mutexattr *__attr;
|
||||
void *__data;
|
||||
/* Up to this point, we are completely compatible with cthreads
|
||||
and what libc expects. */
|
||||
void *__owner;
|
||||
unsigned __locks;
|
||||
/* If NULL then the default attributes apply. */
|
||||
};
|
||||
|
||||
/* Initializer for a mutex. N.B. this also happens to be compatible
|
||||
with the cthread mutex initializer. */
|
||||
#define __PTHREAD_MUTEX_INITIALIZER \
|
||||
{ __PTHREAD_SPIN_LOCK_INITIALIZER, __PTHREAD_SPIN_LOCK_INITIALIZER, 0, 0, 0, 0, 0, 0 }
|
||||
|
||||
#define __PTHREAD_ERRORCHECK_MUTEXATTR ((struct __pthread_mutexattr *) ((unsigned long) __PTHREAD_MUTEX_ERRORCHECK + 1))
|
||||
|
||||
#define __PTHREAD_ERRORCHECK_MUTEX_INITIALIZER \
|
||||
{ __PTHREAD_SPIN_LOCK_INITIALIZER, __PTHREAD_SPIN_LOCK_INITIALIZER, 0, 0, \
|
||||
__PTHREAD_ERRORCHECK_MUTEXATTR, 0, 0, 0 }
|
||||
|
||||
#define __PTHREAD_RECURSIVE_MUTEXATTR ((struct __pthread_mutexattr *) ((unsigned long) __PTHREAD_MUTEX_RECURSIVE + 1))
|
||||
|
||||
#define __PTHREAD_RECURSIVE_MUTEX_INITIALIZER \
|
||||
{ __PTHREAD_SPIN_LOCK_INITIALIZER, __PTHREAD_SPIN_LOCK_INITIALIZER, 0, 0, \
|
||||
__PTHREAD_RECURSIVE_MUTEXATTR, 0, 0, 0 }
|
||||
|
||||
#endif /* bits/types/struct___pthread_mutex.h */
|
40
sysdeps/htl/bits/types/struct___pthread_mutexattr.h
Normal file
40
sysdeps/htl/bits/types/struct___pthread_mutexattr.h
Normal file
@ -0,0 +1,40 @@
|
||||
/* Mutex attribute type. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_MUTEXATTR_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_MUTEXATTR_H 1
|
||||
|
||||
enum __pthread_mutex_protocol;
|
||||
enum __pthread_process_shared;
|
||||
enum __pthread_mutex_type;
|
||||
|
||||
/* This structure describes the attributes of a POSIX mutex
|
||||
attribute. */
|
||||
struct __pthread_mutexattr
|
||||
{
|
||||
int __prioceiling;
|
||||
enum __pthread_mutex_protocol __protocol;
|
||||
enum __pthread_process_shared __pshared;
|
||||
enum __pthread_mutex_type __mutex_type;
|
||||
};
|
||||
|
||||
/* Attributes for a recursive mutex. */
|
||||
extern const struct __pthread_mutexattr __pthread_errorcheck_mutexattr;
|
||||
extern const struct __pthread_mutexattr __pthread_recursive_mutexattr;
|
||||
|
||||
#endif /* bits/types/struct___pthread_mutexattr.h */
|
33
sysdeps/htl/bits/types/struct___pthread_once.h
Normal file
33
sysdeps/htl/bits/types/struct___pthread_once.h
Normal file
@ -0,0 +1,33 @@
|
||||
/* Dynamic package initialization data structures. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_ONCE_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_ONCE_H 1
|
||||
|
||||
#include <bits/types/__pthread_spinlock_t.h>
|
||||
|
||||
struct __pthread_once
|
||||
{
|
||||
int __run;
|
||||
__pthread_spinlock_t __lock;
|
||||
};
|
||||
|
||||
#define __PTHREAD_ONCE_INIT \
|
||||
(struct __pthread_once) { 0, __PTHREAD_SPIN_LOCK_INITIALIZER }
|
||||
|
||||
#endif /* bits/types/struct___pthread_once.h */
|
45
sysdeps/htl/bits/types/struct___pthread_rwlock.h
Normal file
45
sysdeps/htl/bits/types/struct___pthread_rwlock.h
Normal file
@ -0,0 +1,45 @@
|
||||
/* rwlock type. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_RWLOCK_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_RWLOCK_H
|
||||
|
||||
#include <bits/types/__pthread_spinlock_t.h>
|
||||
|
||||
/* User visible part of a rwlock. If __held is not held and readers
|
||||
is 0, then the lock is unlocked. If __held is held and readers is
|
||||
0, then the lock is held by a writer. If __held is held and
|
||||
readers is greater than 0, then the lock is held by READERS
|
||||
readers. */
|
||||
struct __pthread_rwlock
|
||||
{
|
||||
__pthread_spinlock_t __held;
|
||||
__pthread_spinlock_t __lock;
|
||||
int __readers;
|
||||
struct __pthread *__readerqueue;
|
||||
struct __pthread *__writerqueue;
|
||||
struct __pthread_rwlockattr *__attr;
|
||||
void *__data;
|
||||
};
|
||||
|
||||
/* Initializer for a rwlock. */
|
||||
#define __PTHREAD_RWLOCK_INITIALIZER \
|
||||
{ __PTHREAD_SPIN_LOCK_INITIALIZER, __PTHREAD_SPIN_LOCK_INITIALIZER, 0, 0, 0, 0, 0 }
|
||||
|
||||
|
||||
#endif /* bits/types/struct___pthread_rwlock.h */
|
31
sysdeps/htl/bits/types/struct___pthread_rwlockattr.h
Normal file
31
sysdeps/htl/bits/types/struct___pthread_rwlockattr.h
Normal file
@ -0,0 +1,31 @@
|
||||
/* Thread rwlock attribute type. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_TYPES_STRUCT___PTHREAD_RWLOCKATTR_H
|
||||
#define _BITS_TYPES_STRUCT___PTHREAD_RWLOCKATTR_H 1
|
||||
|
||||
enum __pthread_process_shared;
|
||||
|
||||
/* This structure describes the attributes of a POSIX thread rwlock.
|
||||
Note that not all of them are supported on all systems. */
|
||||
struct __pthread_rwlockattr
|
||||
{
|
||||
enum __pthread_process_shared __pshared;
|
||||
};
|
||||
|
||||
#endif /* bits/types/struct___pthread_rwlockattr.h */
|
31
sysdeps/htl/flockfile.c
Normal file
31
sysdeps/htl/flockfile.c
Normal file
@ -0,0 +1,31 @@
|
||||
/* Lock I/O stream. Hurd version.
|
||||
Copyright (C) 2002-2018 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
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <libc-lock.h>
|
||||
|
||||
|
||||
void
|
||||
__flockfile (FILE *stream)
|
||||
{
|
||||
#ifdef SHARED
|
||||
__libc_ptf_call (_IO_flockfile, (stream), 0);
|
||||
#endif
|
||||
}
|
||||
weak_alias (__flockfile, _IO_flockfile)
|
||||
weak_alias (__flockfile, flockfile)
|
29
sysdeps/htl/fork.h
Normal file
29
sysdeps/htl/fork.h
Normal file
@ -0,0 +1,29 @@
|
||||
/* Register fork handlers. Generic version.
|
||||
Copyright (C) 2002-2018 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
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
/* Function to call to unregister fork handlers. */
|
||||
extern void __unregister_atfork (void *dso_handle) attribute_hidden;
|
||||
#define UNREGISTER_ATFORK(dso_handle) __unregister_atfork (dso_handle)
|
||||
|
||||
|
||||
/* C library side function to register new fork handlers. */
|
||||
extern int __register_atfork (void (*__prepare) (void),
|
||||
void (*__parent) (void),
|
||||
void (*__child) (void),
|
||||
void *dso_handle);
|
||||
libc_hidden_proto (__register_atfork)
|
35
sysdeps/htl/ftrylockfile.c
Normal file
35
sysdeps/htl/ftrylockfile.c
Normal file
@ -0,0 +1,35 @@
|
||||
/* Try locking I/O stream. Hurd version
|
||||
Copyright (C) 2002-2018 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
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <stdio-lock.h>
|
||||
|
||||
|
||||
int
|
||||
__ftrylockfile (FILE *stream)
|
||||
{
|
||||
#ifdef SHARED
|
||||
return __libc_ptf_call (_IO_ftrylockfile, (stream), 0);
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
weak_alias (__ftrylockfile, _IO_ftrylockfile)
|
||||
weak_alias (__ftrylockfile, ftrylockfile)
|
32
sysdeps/htl/funlockfile.c
Normal file
32
sysdeps/htl/funlockfile.c
Normal file
@ -0,0 +1,32 @@
|
||||
/* Unlock I/O stream. Hurd version.
|
||||
Copyright (C) 2002-2018 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
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <stdio-lock.h>
|
||||
|
||||
|
||||
void
|
||||
__funlockfile (FILE *stream)
|
||||
{
|
||||
#ifdef SHARED
|
||||
__libc_ptf_call (_IO_funlockfile, (stream), 0);
|
||||
#endif
|
||||
}
|
||||
weak_alias (__funlockfile, _IO_funlockfile)
|
||||
weak_alias (__funlockfile, funlockfile)
|
180
sysdeps/htl/libc-lockP.h
Normal file
180
sysdeps/htl/libc-lockP.h
Normal file
@ -0,0 +1,180 @@
|
||||
/* Private libc-internal interface for mutex locks.
|
||||
Copyright (C) 2015-2018 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; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#ifndef _BITS_LIBC_LOCKP_H
|
||||
#define _BITS_LIBC_LOCKP_H 1
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pthread-functions.h>
|
||||
|
||||
/* Type for key to thread-specific data. */
|
||||
typedef pthread_key_t __libc_key_t;
|
||||
|
||||
/* 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
|
||||
|
||||
/* Call thread functions through the function pointer table. */
|
||||
#if defined SHARED && IS_IN (libc)
|
||||
# define PTFAVAIL(NAME) __libc_pthread_functions_init
|
||||
# define __libc_ptf_call(FUNC, ARGS, ELSE) \
|
||||
(__libc_pthread_functions_init ? PTHFCT_CALL (ptr_##FUNC, ARGS) : ELSE)
|
||||
# define __libc_ptf_call_always(FUNC, ARGS) \
|
||||
PTHFCT_CALL (ptr_##FUNC, ARGS)
|
||||
#elif IS_IN (libpthread)
|
||||
# define PTFAVAIL(NAME) 1
|
||||
# define __libc_ptf_call(FUNC, ARGS, ELSE) \
|
||||
FUNC ARGS
|
||||
# define __libc_ptf_call_always(FUNC, ARGS) \
|
||||
FUNC ARGS
|
||||
#else
|
||||
# define PTFAVAIL(NAME) (NAME != NULL)
|
||||
# define __libc_ptf_call(FUNC, ARGS, ELSE) \
|
||||
__libc_maybe_call (FUNC, ARGS, ELSE)
|
||||
# define __libc_ptf_call_always(FUNC, ARGS) \
|
||||
FUNC ARGS
|
||||
#endif
|
||||
|
||||
/* Create thread-specific key. */
|
||||
#define __libc_key_create(KEY, DESTRUCTOR) \
|
||||
__libc_ptf_call (__pthread_key_create, (KEY, DESTRUCTOR), 1)
|
||||
|
||||
/* Get thread-specific data. */
|
||||
#define __libc_getspecific(KEY) \
|
||||
__libc_ptf_call (__pthread_getspecific, (KEY), NULL)
|
||||
|
||||
/* Set thread-specific data. */
|
||||
#define __libc_setspecific(KEY, VALUE) \
|
||||
__libc_ptf_call (__pthread_setspecific, (KEY, VALUE), 0)
|
||||
|
||||
|
||||
/* Functions that are used by this file and are internal to the GNU C
|
||||
library. */
|
||||
|
||||
extern int __pthread_mutex_init (pthread_mutex_t *__mutex,
|
||||
const pthread_mutexattr_t *__mutex_attr);
|
||||
|
||||
extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutex_trylock (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutex_lock (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex);
|
||||
|
||||
extern int __pthread_mutexattr_init (pthread_mutexattr_t *__attr);
|
||||
|
||||
extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *__attr);
|
||||
|
||||
extern int __pthread_mutexattr_settype (pthread_mutexattr_t *__attr,
|
||||
int __kind);
|
||||
|
||||
extern int __pthread_rwlock_init (pthread_rwlock_t *__rwlock,
|
||||
const pthread_rwlockattr_t *__attr);
|
||||
|
||||
extern int __pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_rwlock_unlock (pthread_rwlock_t *__rwlock);
|
||||
|
||||
extern int __pthread_key_create (pthread_key_t *__key,
|
||||
void (*__destr_function) (void *));
|
||||
|
||||
extern int __pthread_setspecific (pthread_key_t __key,
|
||||
const void *__pointer);
|
||||
|
||||
extern void *__pthread_getspecific (pthread_key_t __key);
|
||||
|
||||
extern int __pthread_once (pthread_once_t *__once_control,
|
||||
void (*__init_routine) (void));
|
||||
|
||||
extern int __pthread_atfork (void (*__prepare) (void),
|
||||
void (*__parent) (void),
|
||||
void (*__child) (void));
|
||||
|
||||
|
||||
|
||||
/* Make the pthread functions weak so that we can elide them from
|
||||
single-threaded processes. */
|
||||
#if !defined(__NO_WEAK_PTHREAD_ALIASES) && !IS_IN (libpthread)
|
||||
# ifdef weak_extern
|
||||
weak_extern (__pthread_mutex_init)
|
||||
weak_extern (__pthread_mutex_destroy)
|
||||
weak_extern (__pthread_mutex_lock)
|
||||
weak_extern (__pthread_mutex_trylock)
|
||||
weak_extern (__pthread_mutex_unlock)
|
||||
weak_extern (__pthread_mutexattr_init)
|
||||
weak_extern (__pthread_mutexattr_destroy)
|
||||
weak_extern (__pthread_mutexattr_settype)
|
||||
weak_extern (__pthread_rwlock_init)
|
||||
weak_extern (__pthread_rwlock_destroy)
|
||||
weak_extern (__pthread_rwlock_rdlock)
|
||||
weak_extern (__pthread_rwlock_tryrdlock)
|
||||
weak_extern (__pthread_rwlock_wrlock)
|
||||
weak_extern (__pthread_rwlock_trywrlock)
|
||||
weak_extern (__pthread_rwlock_unlock)
|
||||
weak_extern (__pthread_key_create)
|
||||
weak_extern (__pthread_setspecific)
|
||||
weak_extern (__pthread_getspecific)
|
||||
weak_extern (__pthread_once)
|
||||
weak_extern (__pthread_initialize)
|
||||
weak_extern (__pthread_atfork)
|
||||
weak_extern (__pthread_setcancelstate)
|
||||
# else
|
||||
# pragma weak __pthread_mutex_init
|
||||
# pragma weak __pthread_mutex_destroy
|
||||
# pragma weak __pthread_mutex_lock
|
||||
# pragma weak __pthread_mutex_trylock
|
||||
# pragma weak __pthread_mutex_unlock
|
||||
# pragma weak __pthread_mutexattr_init
|
||||
# pragma weak __pthread_mutexattr_destroy
|
||||
# pragma weak __pthread_mutexattr_settype
|
||||
# pragma weak __pthread_rwlock_destroy
|
||||
# pragma weak __pthread_rwlock_rdlock
|
||||
# pragma weak __pthread_rwlock_tryrdlock
|
||||
# pragma weak __pthread_rwlock_wrlock
|
||||
# pragma weak __pthread_rwlock_trywrlock
|
||||
# pragma weak __pthread_rwlock_unlock
|
||||
# pragma weak __pthread_key_create
|
||||
# pragma weak __pthread_setspecific
|
||||
# pragma weak __pthread_getspecific
|
||||
# pragma weak __pthread_once
|
||||
# pragma weak __pthread_initialize
|
||||
# pragma weak __pthread_atfork
|
||||
# pragma weak __pthread_setcancelstate
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif /* bits/libc-lockP.h */
|
26
sysdeps/htl/old_pt-atfork.c
Normal file
26
sysdeps/htl/old_pt-atfork.c
Normal file
@ -0,0 +1,26 @@
|
||||
/* Register fork handlers. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <shlib-compat.h>
|
||||
|
||||
#if SHLIB_COMPAT(libpthread, GLIBC_2_12, GLIBC_2_23)
|
||||
# define pthread_atfork __dyn_pthread_atfork
|
||||
# include "pt-atfork.c"
|
||||
# undef pthread_atfork
|
||||
compat_symbol (libpthread, __dyn_pthread_atfork, pthread_atfork, GLIBC_2_12);
|
||||
#endif
|
33
sysdeps/htl/pt-atfork.c
Normal file
33
sysdeps/htl/pt-atfork.c
Normal file
@ -0,0 +1,33 @@
|
||||
/* Register fork handlers. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
#include <fork.h>
|
||||
|
||||
/* This is defined by newer gcc version unique for each module. */
|
||||
extern void *__dso_handle __attribute__ ((__weak__, __visibility__ ("hidden")));
|
||||
|
||||
int
|
||||
pthread_atfork (void (*prepare) (void),
|
||||
void (*parent) (void),
|
||||
void (*child) (void))
|
||||
{
|
||||
return __register_atfork (prepare, parent, child,
|
||||
&__dso_handle == NULL ? NULL : __dso_handle);
|
||||
}
|
27
sysdeps/htl/pt-attr-destroy.c
Normal file
27
sysdeps/htl/pt-attr-destroy.c
Normal file
@ -0,0 +1,27 @@
|
||||
/* pthread_attr_destroy. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_destroy (pthread_attr_t *attr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
strong_alias (__pthread_attr_destroy, pthread_attr_destroy);
|
29
sysdeps/htl/pt-attr-getdetachstate.c
Normal file
29
sysdeps/htl/pt-attr-getdetachstate.c
Normal file
@ -0,0 +1,29 @@
|
||||
/* pthread_attr_getdetachstate. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_getdetachstate (const pthread_attr_t *attr, int *detachstate)
|
||||
{
|
||||
*detachstate = attr->__detachstate;
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_getdetachstate, pthread_attr_getdetachstate);
|
27
sysdeps/htl/pt-attr-getguardsize.c
Normal file
27
sysdeps/htl/pt-attr-getguardsize.c
Normal file
@ -0,0 +1,27 @@
|
||||
/* pthread_attr_getguardsize. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
pthread_attr_getguardsize (const pthread_attr_t *attr, size_t * guardsize)
|
||||
{
|
||||
*guardsize = attr->__guardsize;
|
||||
return 0;
|
||||
}
|
29
sysdeps/htl/pt-attr-getinheritsched.c
Normal file
29
sysdeps/htl/pt-attr-getinheritsched.c
Normal file
@ -0,0 +1,29 @@
|
||||
/* pthread_attr_getinheritsched. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_getinheritsched (const pthread_attr_t *attr, int *inheritsched)
|
||||
{
|
||||
*inheritsched = attr->__inheritsched;
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_getinheritsched, pthread_attr_getinheritsched);
|
33
sysdeps/htl/pt-attr-getschedparam.c
Normal file
33
sysdeps/htl/pt-attr-getschedparam.c
Normal file
@ -0,0 +1,33 @@
|
||||
/* pthread_attr_getschedparam. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_getschedparam (const pthread_attr_t *attr,
|
||||
struct sched_param *param)
|
||||
{
|
||||
memcpy (param, &attr->__schedparam, sizeof *param);
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_getschedparam, pthread_attr_getschedparam);
|
29
sysdeps/htl/pt-attr-getschedpolicy.c
Normal file
29
sysdeps/htl/pt-attr-getschedpolicy.c
Normal file
@ -0,0 +1,29 @@
|
||||
/* pthread_attr_getschedpolicy. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *policy)
|
||||
{
|
||||
*policy = attr->__schedpolicy;
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_getschedpolicy, pthread_attr_getschedpolicy);
|
29
sysdeps/htl/pt-attr-getscope.c
Normal file
29
sysdeps/htl/pt-attr-getscope.c
Normal file
@ -0,0 +1,29 @@
|
||||
/* pthread_attr_getscope. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_getscope (const pthread_attr_t *attr, int *contentionscope)
|
||||
{
|
||||
*contentionscope = attr->__contentionscope;
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_getscope, pthread_attr_getscope);
|
30
sysdeps/htl/pt-attr-getstack.c
Normal file
30
sysdeps/htl/pt-attr-getstack.c
Normal file
@ -0,0 +1,30 @@
|
||||
/* pthread_attr_getstack. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_getstack (const pthread_attr_t *attr,
|
||||
void **stackaddr, size_t * stacksize)
|
||||
{
|
||||
pthread_attr_getstackaddr (attr, stackaddr);
|
||||
pthread_attr_getstacksize (attr, stacksize);
|
||||
return 0;
|
||||
}
|
||||
weak_alias (__pthread_attr_getstack, pthread_attr_getstack)
|
27
sysdeps/htl/pt-attr-getstackaddr.c
Normal file
27
sysdeps/htl/pt-attr-getstackaddr.c
Normal file
@ -0,0 +1,27 @@
|
||||
/* pthread_attr_getstackaddr. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
pthread_attr_getstackaddr (const pthread_attr_t *attr, void **stackaddr)
|
||||
{
|
||||
*stackaddr = attr->__stackaddr;
|
||||
return 0;
|
||||
}
|
27
sysdeps/htl/pt-attr-getstacksize.c
Normal file
27
sysdeps/htl/pt-attr-getstacksize.c
Normal file
@ -0,0 +1,27 @@
|
||||
/* pthread_attr_getstacksize. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
pthread_attr_getstacksize (const pthread_attr_t *attr, size_t * stacksize)
|
||||
{
|
||||
*stacksize = attr->__stacksize;
|
||||
return 0;
|
||||
}
|
28
sysdeps/htl/pt-attr-init.c
Normal file
28
sysdeps/htl/pt-attr-init.c
Normal file
@ -0,0 +1,28 @@
|
||||
/* pthread_attr_init. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_init (pthread_attr_t *attr)
|
||||
{
|
||||
*attr = __pthread_default_attr;
|
||||
return 0;
|
||||
}
|
||||
strong_alias (__pthread_attr_init, pthread_attr_init);
|
38
sysdeps/htl/pt-attr-setdetachstate.c
Normal file
38
sysdeps/htl/pt-attr-setdetachstate.c
Normal file
@ -0,0 +1,38 @@
|
||||
/* pthread_attr_setdetachstate. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate)
|
||||
{
|
||||
switch (detachstate)
|
||||
{
|
||||
case PTHREAD_CREATE_DETACHED:
|
||||
case PTHREAD_CREATE_JOINABLE:
|
||||
attr->__detachstate = detachstate;
|
||||
break;
|
||||
default:
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_setdetachstate, pthread_attr_setdetachstate);
|
27
sysdeps/htl/pt-attr-setguardsize.c
Normal file
27
sysdeps/htl/pt-attr-setguardsize.c
Normal file
@ -0,0 +1,27 @@
|
||||
/* pthread_attr_setguardsize. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
pthread_attr_setguardsize (pthread_attr_t *attr, size_t guardsize)
|
||||
{
|
||||
attr->__guardsize = guardsize;
|
||||
return 0;
|
||||
}
|
38
sysdeps/htl/pt-attr-setinheritsched.c
Normal file
38
sysdeps/htl/pt-attr-setinheritsched.c
Normal file
@ -0,0 +1,38 @@
|
||||
/* pthread_attr_setinheritsched. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_setinheritsched (pthread_attr_t *attr, int inheritsched)
|
||||
{
|
||||
switch (inheritsched)
|
||||
{
|
||||
case PTHREAD_INHERIT_SCHED:
|
||||
case PTHREAD_EXPLICIT_SCHED:
|
||||
attr->__inheritsched = inheritsched;
|
||||
break;
|
||||
default:
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_setinheritsched, pthread_attr_setinheritsched);
|
38
sysdeps/htl/pt-attr-setschedparam.c
Normal file
38
sysdeps/htl/pt-attr-setschedparam.c
Normal file
@ -0,0 +1,38 @@
|
||||
/* pthread_attr_getschedparam. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_setschedparam (pthread_attr_t *attr,
|
||||
const struct sched_param *param)
|
||||
{
|
||||
if (memcmp (param, &__pthread_default_attr.__schedparam, sizeof *param) == 0)
|
||||
{
|
||||
memcpy (&attr->__schedparam, param, sizeof *param);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ENOTSUP;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_setschedparam, pthread_attr_setschedparam);
|
42
sysdeps/htl/pt-attr-setschedpolicy.c
Normal file
42
sysdeps/htl/pt-attr-setschedpolicy.c
Normal file
@ -0,0 +1,42 @@
|
||||
/* pthread_attr_getschedpolicy. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy)
|
||||
{
|
||||
switch (policy)
|
||||
{
|
||||
case SCHED_OTHER:
|
||||
attr->__schedpolicy = policy;
|
||||
break;
|
||||
|
||||
case SCHED_FIFO:
|
||||
case SCHED_RR:
|
||||
return ENOTSUP;
|
||||
|
||||
default:
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_setschedpolicy, pthread_attr_setschedpolicy);
|
41
sysdeps/htl/pt-attr-setscope.c
Normal file
41
sysdeps/htl/pt-attr-setscope.c
Normal file
@ -0,0 +1,41 @@
|
||||
/* pthread_attr_setscope. Generic version.
|
||||
Copyright (C) 2002-2018 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 Library General Public License as
|
||||
published by the Free Software Foundation; either version 2 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
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with the GNU C Library; see the file COPYING.LIB. If
|
||||
not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <pthread.h>
|
||||
#include <pt-internal.h>
|
||||
|
||||
int
|
||||
__pthread_attr_setscope (pthread_attr_t *attr, int contentionscope)
|
||||
{
|
||||
if (contentionscope == __pthread_default_attr.__contentionscope)
|
||||
{
|
||||
attr->__contentionscope = contentionscope;
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (contentionscope)
|
||||
{
|
||||
case PTHREAD_SCOPE_PROCESS:
|
||||
case PTHREAD_SCOPE_SYSTEM:
|
||||
return ENOTSUP;
|
||||
default:
|
||||
return EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
strong_alias (__pthread_attr_setscope, pthread_attr_setscope);
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user