diff options
Diffstat (limited to 'linuxthreads/sysdeps')
27 files changed, 1672 insertions, 0 deletions
diff --git a/linuxthreads/sysdeps/alpha/bits/semaphore.h b/linuxthreads/sysdeps/alpha/bits/semaphore.h new file mode 100644 index 0000000000..323fea159e --- /dev/null +++ b/linuxthreads/sysdeps/alpha/bits/semaphore.h @@ -0,0 +1,31 @@ +/* Copyright (C) 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _SEMAPHORE_H +# error "Never include <bits/semaphore.h> directly; use <semaphore.h> instead." +#endif + + +/* Due to the implementation of the load-locked/store-conditional + instructions, we cannot pack semaphores closer than a cache line + or risk threads deadlocking on unrelated semaphores. */ + +typedef struct { + long int sem_status; + long int sem_reserved[3]; +} sem_t; diff --git a/linuxthreads/sysdeps/alpha/pt-machine.h b/linuxthreads/sysdeps/alpha/pt-machine.h new file mode 100644 index 0000000000..a0c7cc77e2 --- /dev/null +++ b/linuxthreads/sysdeps/alpha/pt-machine.h @@ -0,0 +1,102 @@ +/* Machine-dependent pthreads configuration and inline functions. + Alpha version. + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Richard Henderson <rth@tamu.edu>. + + 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include <asm/pal.h> + + +/* Spinlock implementation; required. */ +extern inline long testandset(int *spinlock) +{ + long ret, temp; + + __asm__ __volatile__( + "/* Inline spinlock test & set */\n" + "1:\t" + "ldl_l %0,%3\n\t" + "bne %0,2f\n\t" + "or $31,1,%1\n\t" + "stl_c %1,%2\n\t" + "beq %1,1b\n" + "2:\tmb\n" + "/* End spinlock test & set */" + : "=&r"(ret), "=&r"(temp), "=m"(*spinlock) + : "m"(*spinlock) + : "memory"); + + return ret; +} + +/* Spinlock release; default is just set to zero. */ +#define RELEASE(spinlock) \ + __asm__ __volatile__("mb" : : : "memory"); \ + *spinlock = 0 + + +/* Begin allocating thread stacks at this address. Default is to allocate + them just below the initial program stack. */ +#define THREAD_STACK_START_ADDRESS 0x40000000000 + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char *stack_pointer __asm__("$30"); + + +/* Return the thread descriptor for the current thread. */ +#define THREAD_SELF \ +({ \ + register pthread_descr __self __asm__("$0"); \ + __asm__ ("call_pal %1" : "=r"(__self) : "i"(PAL_rduniq) : "$0"); \ + __self; \ +}) + +/* Initialize the thread-unique value. */ +#define INIT_THREAD_SELF(descr) \ +{ \ + register pthread_descr __self __asm__("$16") = (descr); \ + __asm__ __volatile__ ("call_pal %1" : : "r"(__self), "i"(PAL_wruniq)); \ +} + + +/* Compare-and-swap for semaphores. */ + +#define HAS_COMPARE_AND_SWAP +extern inline int __compare_and_swap(long * p, long oldval, long newval) +{ + long ret; + + __asm__ __volatile__ ( + "/* Inline compare & swap */\n" + "1:\t" + "ldq_l %0,%4\n\t" + "cmpeq %0,%2,%0\n\t" + "beq %0,2f\n\t" + "mov %3,%0\n\t" + "stq_c %0,%1\n\t" + "beq %0,1b\n\t" + "2:\tmb\n" + "/* End compare & swap */" + : "=&r"(ret), "=m"(*p) + : "r"(oldval), "r"(newval), "m"(*p)); + + return ret; +} diff --git a/linuxthreads/sysdeps/arm/Implies b/linuxthreads/sysdeps/arm/Implies new file mode 100644 index 0000000000..7edcd7e757 --- /dev/null +++ b/linuxthreads/sysdeps/arm/Implies @@ -0,0 +1 @@ +pthread/no-cmpxchg diff --git a/linuxthreads/sysdeps/arm/pt-machine.h b/linuxthreads/sysdeps/arm/pt-machine.h new file mode 100644 index 0000000000..0b9bc01fc1 --- /dev/null +++ b/linuxthreads/sysdeps/arm/pt-machine.h @@ -0,0 +1,44 @@ +/* Machine-dependent pthreads configuration and inline functions. + ARM version. + Copyright (C) 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Philip Blundell <philb@gnu.org>. + + 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + + +/* This will not work on ARM1 or ARM2 because SWP is lacking on those + machines. Unfortunately we have no way to detect this at compile + time; let's hope nobody tries to use one. */ + +/* Spinlock implementation; required. */ +extern inline int +testandset (int *spinlock) +{ + register unsigned int ret; + + __asm__ __volatile__("swp %0, %1, [%2]" + : "=r"(ret) + : "0"(1), "r"(spinlock)); + + return ret; +} + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char * stack_pointer __asm__ ("sp"); diff --git a/linuxthreads/sysdeps/i386/Implies b/linuxthreads/sysdeps/i386/Implies new file mode 100644 index 0000000000..7edcd7e757 --- /dev/null +++ b/linuxthreads/sysdeps/i386/Implies @@ -0,0 +1 @@ +pthread/no-cmpxchg diff --git a/linuxthreads/sysdeps/i386/pt-machine.h b/linuxthreads/sysdeps/i386/pt-machine.h new file mode 100644 index 0000000000..ef4df2a1a3 --- /dev/null +++ b/linuxthreads/sysdeps/i386/pt-machine.h @@ -0,0 +1,93 @@ +/* Machine-dependent pthreads configuration and inline functions. + i386 version. + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Richard Henderson <rth@tamu.edu>. + + 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + + +/* Spinlock implementation; required. */ +extern inline int +testandset (int *spinlock) +{ + int ret; + + __asm__ __volatile__("xchgl %0, %1" + : "=r"(ret), "=m"(*spinlock) + : "0"(1), "m"(*spinlock)); + + return ret; +} + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char * stack_pointer __asm__ ("%esp"); + + +/* Compare-and-swap for semaphores. + Available on the 486 and above, but not on the 386. + We test dynamically whether it's available or not. */ + +#define HAS_COMPARE_AND_SWAP +#define TEST_FOR_COMPARE_AND_SWAP + +extern inline int +__compare_and_swap (long int *p, long int oldval, long int newval) +{ + char ret; + long int readval; + + __asm__ __volatile__ ("lock; cmpxchgl %3, %1; sete %0" + : "=q" (ret), "=m" (*p), "=a" (readval) + : "r" (newval), "m" (*p), "a" (oldval)); + return ret; +} + + +extern inline int +get_eflags (void) +{ + int res; + __asm__ __volatile__ ("pushfl; popl %0" : "=r" (res) : ); + return res; +} + + +extern inline void +set_eflags (int newflags) +{ + __asm__ __volatile__ ("pushl %0; popfl" : : "r" (newflags) : "cc"); +} + + +extern inline int +compare_and_swap_is_available (void) +{ + int oldflags = get_eflags (); + int changed; + /* Flip AC bit in EFLAGS. */ + set_eflags (oldflags ^ 0x40000); + /* See if bit changed. */ + changed = (get_eflags () ^ oldflags) & 0x40000; + /* Restore EFLAGS. */ + set_eflags (oldflags); + /* If the AC flag did not change, it's a 386 and it lacks cmpxchg. + Otherwise, it's a 486 or above and it has cmpxchg. */ + return changed != 0; +} diff --git a/linuxthreads/sysdeps/m68k/Implies b/linuxthreads/sysdeps/m68k/Implies new file mode 100644 index 0000000000..81e93666c4 --- /dev/null +++ b/linuxthreads/sysdeps/m68k/Implies @@ -0,0 +1 @@ +pthread/cmpxchg diff --git a/linuxthreads/sysdeps/m68k/pt-machine.h b/linuxthreads/sysdeps/m68k/pt-machine.h new file mode 100644 index 0000000000..c5c6cabe35 --- /dev/null +++ b/linuxthreads/sysdeps/m68k/pt-machine.h @@ -0,0 +1,58 @@ +/* Machine-dependent pthreads configuration and inline functions. + m68k version. + Copyright (C) 1996 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Richard Henderson <rth@tamu.edu>. + + 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, write to the Free Software Foundation, Inc., + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + + +/* Spinlock implementation; required. */ +extern inline int +testandset (int *spinlock) +{ + char ret; + + __asm__ __volatile__("tas %1; sne %0" + : "=dm"(ret), "=m"(*spinlock) + : "m"(*spinlock) + : "cc"); + + return ret; +} + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char * stack_pointer __asm__ ("%sp"); + + +/* Compare-and-swap for semaphores. */ + +#define HAS_COMPARE_AND_SWAP +extern inline int +__compare_and_swap (long int *p, long int oldval, long int newval) +{ + char ret; + long int readval; + + __asm__ __volatile__ ("casl %2, %3, %1; seq %0" + : "=dm" (ret), "=m" (*p), "=d" (readval) + : "d" (newval), "m" (*p), "2" (oldval)); + + return ret; +} diff --git a/linuxthreads/sysdeps/mips/Implies b/linuxthreads/sysdeps/mips/Implies new file mode 100644 index 0000000000..81e93666c4 --- /dev/null +++ b/linuxthreads/sysdeps/mips/Implies @@ -0,0 +1 @@ +pthread/cmpxchg diff --git a/linuxthreads/sysdeps/mips/pt-machine.h b/linuxthreads/sysdeps/mips/pt-machine.h new file mode 100644 index 0000000000..d15da7535b --- /dev/null +++ b/linuxthreads/sysdeps/mips/pt-machine.h @@ -0,0 +1,84 @@ +/* Machine-dependent pthreads configuration and inline functions. + + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>. + Based on the Alpha version by Richard Henderson <rth@tamu.edu>. + + 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, write to the Free Software Foundation, Inc., + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + TODO: This version makes use of MIPS ISA 2 features. It won't + work on ISA 1. These machines will have to take the overhead of + a sysmips(MIPS_ATOMIC_SET, ...) syscall which isn't implemented + yet correctly. There is however a better solution for R3000 + uniprocessor machines possible. */ + + +/* Spinlock implementation; required. */ +extern inline long testandset(int *spinlock) +{ + long ret, temp; + + __asm__ __volatile__( + "# Inline spinlock test & set\n\t" + ".set\tmips2\n" + "1:\tll\t%0,%3\n\t" + "bnez\t%0,2f\n\t" + ".set\tnoreorder\n\t" + "li\t%1,1\n\t" + ".set\treorder\n\t" + "sc\t%1,%2\n\t" + "beqz\t%1,1b\n" + "2:\t.set\tmips0\n\t" + "/* End spinlock test & set */" + : "=&r"(ret), "=&r" (temp), "=m"(*spinlock) + : "m"(*spinlock) + : "memory"); + + return ret; +} + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char * stack_pointer __asm__ ("$29"); + + +/* Compare-and-swap for semaphores. */ + +#define HAS_COMPARE_AND_SWAP +extern inline int __compare_and_swap(long * p, long oldval, long newval) +{ + long ret; + + __asm__ __volatile__ ( + "/* Inline compare & swap */\n\t" + ".set\tmips2\n" + "1:\tll\t%0,%4\n\t" + ".set\tnoreorder\n\t" + "bne\t%0,%2,2f\n\t" + "move\t%0,%3\n\t" + ".set\treorder\n\t" + "sc\t%0,%1\n\t" + "beqz\t%0,1b\n" + "2:\t.set\tmips0\n\t" + "/* End compare & swap */" + : "=&r"(ret), "=m"(*p) + : "r"(oldval), "r"(newval), "m"(*p)); + + return ret; +} diff --git a/linuxthreads/sysdeps/powerpc/Implies b/linuxthreads/sysdeps/powerpc/Implies new file mode 100644 index 0000000000..81e93666c4 --- /dev/null +++ b/linuxthreads/sysdeps/powerpc/Implies @@ -0,0 +1 @@ +pthread/cmpxchg diff --git a/linuxthreads/sysdeps/powerpc/bits/semaphore.h b/linuxthreads/sysdeps/powerpc/bits/semaphore.h new file mode 100644 index 0000000000..3770eedf15 --- /dev/null +++ b/linuxthreads/sysdeps/powerpc/bits/semaphore.h @@ -0,0 +1,32 @@ +/* Copyright (C) 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _SEMAPHORE_H +# error "Never include <bits/semaphore.h> directly; use <semaphore.h> instead." +#endif + + +/* Due to the implementation of the load-locked/store-conditional + instructions, we cannot pack semaphores closer than a cache line + or risk threads deadlocking on unrelated semaphores. */ + +typedef struct + { + int sem_status; + int sem_reserved[7]; + } sem_t; diff --git a/linuxthreads/sysdeps/powerpc/pt-machine.h b/linuxthreads/sysdeps/powerpc/pt-machine.h new file mode 100644 index 0000000000..a08828b322 --- /dev/null +++ b/linuxthreads/sysdeps/powerpc/pt-machine.h @@ -0,0 +1,84 @@ +/* Machine-dependent pthreads configuration and inline functions. + powerpc version. + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Richard Henderson <rth@tamu.edu>. + + 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, write to the Free Software Foundation, Inc., + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* These routines are from Appendix G of the 'PowerPC 601 RISC Microprocessor + User's Manual', by IBM and Motorola. */ + +/* For multiprocessor systems, we want to ensure all memory accesses + are completed before we reset a lock. */ +#if 0 +/* on non multiprocessor systems, you can just: */ +#define sync() /* nothing */ +#else +#define sync() __asm__ __volatile__ ("sync") +#endif + +/* Spinlock implementation; required. */ +extern inline int +testandset (int *spinlock) +{ + int ret; + + sync(); + __asm__ __volatile__( + "0: lwarx %0,0,%1 ;" + " cmpwi %0,0;" + " bne 1f;" + " stwcx. %2,0,%1;" + " bne- 0b;" + "1: " + : "=&r"(ret) + : "r"(spinlock), "r"(1) + : "cr0", "memory"); + sync(); + + return ret != 0; +} + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char * stack_pointer __asm__ ("r1"); + +/* Compare-and-swap for semaphores. */ +/* note that test-and-set(x) is the same as compare-and-swap(x, 0, 1) */ + +#define HAS_COMPARE_AND_SWAP +extern inline int +__compare_and_swap (int *p, int oldval, int newval) +{ + int ret; + + sync(); + __asm__ __volatile__( + "0: lwarx %0,0,%1 ;" + " xor. %0,%3,%0;" + " bne 1f;" + " stwcx. %2,0,%1;" + " bne- 0b;" + "1: " + : "=&r"(ret) + : "r"(p), "r"(newval), "r"(oldval) + : "cr0", "memory"); + sync(); + return ret == 0; +} diff --git a/linuxthreads/sysdeps/pthread/Makefile b/linuxthreads/sysdeps/pthread/Makefile new file mode 100644 index 0000000000..419650c6a6 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/Makefile @@ -0,0 +1,3 @@ +ifeq ($(subdir),libio) +sysdep_headers += bits/stdio-lock.h +endif diff --git a/linuxthreads/sysdeps/pthread/bits/libc-lock.h b/linuxthreads/sysdeps/pthread/bits/libc-lock.h new file mode 100644 index 0000000000..530d48c6da --- /dev/null +++ b/linuxthreads/sysdeps/pthread/bits/libc-lock.h @@ -0,0 +1,208 @@ +/* libc-internal interface for mutex locks. LinuxThreads version. + Copyright (C) 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _BITS_LIBC_LOCK_H +#define _BITS_LIBC_LOCK_H 1 + +#include <pthread.h> + +/* Mutex type. */ +#ifdef _LIBC +typedef pthread_mutex_t __libc_lock_t; +#else +typedef struct __libc_lock_opaque__ __libc_lock_t; +#endif + +/* Type for key to thread-specific data. */ +typedef pthread_key_t __libc_key_t; + +/* Define a lock variable NAME with storage class CLASS. The lock must be + initialized with __libc_lock_init before it can be used (or define it + with __libc_lock_define_initialized, below). Use `extern' for CLASS to + declare a lock defined in another module. In public structure + definitions you must use a pointer to the lock structure (i.e., NAME + begins with a `*'), because its storage size will not be known outside + of libc. */ +#define __libc_lock_define(CLASS,NAME) \ + CLASS __libc_lock_t NAME; + +/* Define an initialized lock variable NAME with storage class CLASS. */ +#define __libc_lock_define_initialized(CLASS,NAME) \ + CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER; + +/* Define an initialized recursive lock variable NAME with storage + class CLASS. */ +#define __libc_lock_define_initialized_recursive(CLASS,NAME) \ + CLASS __libc_lock_t NAME = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; + +/* Initialize the named lock variable, leaving it in a consistent, unlocked + state. */ +#define __libc_lock_init(NAME) \ + (__pthread_mutex_init != NULL ? __pthread_mutex_init (&(NAME), NULL) : 0); + +/* Same as last but this time we initialize a recursive mutex. */ +#define __libc_lock_init_recursive(NAME) \ + do { \ + if (__pthread_mutex_init != NULL) \ + { \ + pthread_mutexattr_t __attr; \ + __pthread_mutexattr_init (&__attr); \ + __pthread_mutexattr_setkind_np (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \ + __pthread_mutex_init (&(NAME), &__attr); \ + __pthread_mutexattr_destroy (&__attr); \ + } \ + } while (0); + +/* Finalize the named lock variable, which must be locked. It cannot be + used again until __libc_lock_init is called again on it. This must be + called on a lock variable before the containing storage is reused. */ +#define __libc_lock_fini(NAME) \ + (__pthread_mutex_destroy != NULL ? __pthread_mutex_destroy (&(NAME)) : 0); + +/* Finalize recursive named lock. */ +#define __libc_lock_fini_recursive(NAME) __libc_lock_fini (NAME) + +/* Lock the named lock variable. */ +#define __libc_lock_lock(NAME) \ + (__pthread_mutex_lock != NULL ? __pthread_mutex_lock (&(NAME)) : 0); + +/* Lock the recursive named lock variable. */ +#define __libc_lock_lock_recursive(NAME) __libc_lock_lock (NAME) + +/* Try to lock the named lock variable. */ +#define __libc_lock_trylock(NAME) \ + (__pthread_mutex_trylock != NULL ? __pthread_mutex_trylock (&(NAME)) : 0) + +/* Try to lock the recursive named lock variable. */ +#define __libc_lock_trylock_recursive(NAME) __libc_lock_trylock (NAME) + +/* Unlock the named lock variable. */ +#define __libc_lock_unlock(NAME) \ + (__pthread_mutex_unlock != NULL ? __pthread_mutex_unlock (&(NAME)) : 0); + +/* Unlock the recursive named lock variable. */ +#define __libc_lock_unlock_recursive(NAME) __libc_lock_unlock (NAME) + + +/* Define once control variable. */ +#define __libc_once_define(CLASS, NAME) \ + CLASS pthread_once_t NAME = PTHREAD_ONCE_INIT + +/* Call handler iff the first call. */ +#define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \ + do { \ + if (__pthread_once != NULL) \ + __pthread_once (&(ONCE_CONTROL), (INIT_FUNCTION)); \ + else if ((ONCE_CONTROL) == 0) { \ + INIT_FUNCTION (); \ + (ONCE_CONTROL) = 1; \ + } \ + } while (0) + + +/* Start critical region with cleanup. */ +#define __libc_cleanup_region_start(FCT, ARG) \ + { struct _pthread_cleanup_buffer _buffer; \ + if (_pthread_cleanup_push_defer != NULL) { \ + _pthread_cleanup_push_defer (&_buffer, (FCT), (ARG)); \ + } + +/* End critical region with cleanup. */ +#define __libc_cleanup_region_end(DOIT) \ + if (_pthread_cleanup_push_defer != NULL) { \ + _pthread_cleanup_pop_restore (&_buffer, (DOIT)); \ + } \ + } + +/* Create thread-specific key. */ +#define __libc_key_create(KEY, DESTRUCTOR) \ + (__pthread_key_create != NULL ? __pthread_key_create (KEY, DESTRUCTOR) : 1) + +/* Get thread-specific data. */ +#define __libc_getspecific(KEY) \ + (__pthread_getspecific != NULL ? __pthread_getspecific (KEY) : NULL) + +/* Set thread-specific data. */ +#define __libc_setspecific(KEY, VALUE) \ + (__pthread_setspecific != NULL ? __pthread_setspecific (KEY, VALUE) : 0) + +#ifdef _LIBC + +/* Fast thread-specific data internal to libc. */ +enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0, _LIBC_TSD_KEY_N }; + +extern void *__libc_internal_tsd_get __P ((enum __libc_tsd_key_t)); +extern int __libc_internal_tsd_set __P ((enum __libc_tsd_key_t, + __const void *)); + +#endif + + +/* Register handlers to execute before and after `fork'. */ +#define __libc_atfork(PREPARE, PARENT, CHILD) \ + (__pthread_atfork != NULL ? __pthread_atfork (PREPARE, PARENT, CHILD) : 0) + + +/* Make the pthread functions weak so that we can elide them from + single-threaded processes. */ +#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_setkind_np) +weak_extern (__pthread_key_create) +weak_extern (__pthread_setspecific) +weak_extern (__pthread_getspecific) +weak_extern (__libc_internal_tsd_get) +weak_extern (__libc_internal_tsd_set) +weak_extern (__pthread_once) +weak_extern (__pthread_initialize) +weak_extern (__pthread_atfork) +weak_extern (_pthread_cleanup_push_defer) +weak_extern (_pthread_cleanup_pop_restore) +#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_setkind_np +# pragma weak __pthread_key_create +# pragma weak __pthread_setspecific +# pragma weak __pthread_getspecific +# pragma weak __libc_internal_tsd_get +# pragma weak __libc_internal_tsd_set +# pragma weak __pthread_once +# pragma weak __pthread_initialize +# pragma weak __pthread_atfork +# pragma weak _pthread_cleanup_push_defer +# pragma weak _pthread_cleanup_pop_restore +#endif + +/* We need portable names for some functions. E.g., when they are + used as argument to __libc_cleanup_region_start. */ +#define __libc_mutex_unlock __pthread_mutex_unlock + +#endif /* bits/libc-lock.h */ diff --git a/linuxthreads/sysdeps/pthread/bits/stdio-lock.h b/linuxthreads/sysdeps/pthread/bits/stdio-lock.h new file mode 100644 index 0000000000..23ebf407f9 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/bits/stdio-lock.h @@ -0,0 +1,35 @@ +/* Thread package specific definitions of stream lock type. + Copyright (C) 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include <pthread.h> + +typedef pthread_mutex_t _IO_lock_t; + +/* We need recursive (counting) mutexes. */ +#define _IO_lock_initializer PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + + +#define _IO_cleanup_region_start(_fct, _fp) \ + __libc_cleanup_region_start (_fct, _fp) +#define _IO_cleanup_region_end(_doit) \ + __libc_cleanup_region_end (_doit) +#define _IO_lock_init(_name) \ + __libc_lock_init_recursive (_name) +#define _IO_lock_fini(_name) \ + __libc_lock_fini_recursive (_name) diff --git a/linuxthreads/sysdeps/pthread/cmpxchg/bits/semaphore.h b/linuxthreads/sysdeps/pthread/cmpxchg/bits/semaphore.h new file mode 100644 index 0000000000..0cdbc05b90 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/cmpxchg/bits/semaphore.h @@ -0,0 +1,26 @@ +/* Copyright (C) 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _SEMAPHORE_H +# error "Never include <bits/semaphore.h> directly; use <semaphore.h> instead." +#endif + + +typedef struct { + long int sem_status; +} sem_t; diff --git a/linuxthreads/sysdeps/pthread/no-cmpxchg/bits/semaphore.h b/linuxthreads/sysdeps/pthread/no-cmpxchg/bits/semaphore.h new file mode 100644 index 0000000000..4d801a26a6 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/no-cmpxchg/bits/semaphore.h @@ -0,0 +1,27 @@ +/* Copyright (C) 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _SEMAPHORE_H +# error "Never include <bits/semaphore.h> directly; use <semaphore.h> instead." +#endif + + +typedef struct { + long int sem_status; + int sem_spinlock; +} sem_t; diff --git a/linuxthreads/sysdeps/pthread/pthread.h b/linuxthreads/sysdeps/pthread/pthread.h new file mode 100644 index 0000000000..b62706a811 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/pthread.h @@ -0,0 +1,578 @@ +/* Linuxthreads - a simple clone()-based implementation of Posix */ +/* threads for Linux. */ +/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */ +/* */ +/* This program 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. */ +/* */ +/* 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 Library General Public License for more details. */ + +#ifndef _PTHREAD_H +#define _PTHREAD_H 1 + +#include <features.h> + +#include <errno.h> +#include <limits.h> +#include <sched.h> +#include <unistd.h> + +#define __need_sigset_t +#include <signal.h> +#define __need_timespec +#include <time.h> + +/* Linux has no ENOTSUP error code. */ +#ifndef ENOTSUP +#define ENOTSUP EOPNOTSUPP +#endif + + +__BEGIN_DECLS + +/*** Types ***/ + +/* Thread identifiers */ +typedef unsigned long int pthread_t; + +/* Thread descriptors */ +typedef struct _pthread_descr_struct *_pthread_descr; + +/* Waiting queues (not abstract because mutexes and conditions aren't). */ +struct _pthread_queue +{ + _pthread_descr head; /* First element, or NULL if queue empty. */ + _pthread_descr tail; /* Last element, or NULL if queue empty. */ +}; + +/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER). */ +typedef struct +{ + int m_spinlock; /* Spin lock to guarantee mutual exclusion. */ + int m_count; /* 0 if free, > 0 if taken. */ + _pthread_descr m_owner; /* Owner of mutex (for recursive mutexes) */ + int m_kind; /* Kind of mutex */ + struct _pthread_queue m_waiting; /* Threads waiting on this mutex. */ +} pthread_mutex_t; + +#define PTHREAD_MUTEX_INITIALIZER \ + {0, 0, 0, PTHREAD_MUTEX_FAST_NP, {0, 0}} +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \ + {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, {0, 0}} + +/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */ +typedef struct +{ + int c_spinlock; /* Spin lock to protect the queue. */ + struct _pthread_queue c_waiting; /* Threads waiting on this condition. */ +} pthread_cond_t; + +#define PTHREAD_COND_INITIALIZER {0, {0, 0}} + +#ifdef __USE_UNIX98 +/* Read-write locks. */ +typedef struct +{ + int rw_spinlock; /* Spin lock to guarantee mutual exclusion */ + int rw_readers; /* Number of readers */ + _pthread_descr rw_writer; /* Identity of writer, or NULL if none */ + struct _pthread_queue rw_read_waiting; /* Threads waiting for reading */ + struct _pthread_queue rw_write_waiting; /* Threads waiting for writing */ + int rw_kind; /* Reader/Writer preference selection */ + int rw_pshared; /* Shared between processes or not */ +} pthread_rwlock_t; + +# define PTHREAD_RWLOCK_INITIALIZER \ + { 0, 0, 0, {0, 0}, {0, 0}, \ + PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE } +#endif + +/* Attributes */ + +enum +{ + PTHREAD_CREATE_JOINABLE, + PTHREAD_CREATE_DETACHED +}; + +enum +{ + PTHREAD_INHERIT_SCHED, + PTHREAD_EXPLICIT_SCHED +}; + +enum +{ + PTHREAD_SCOPE_SYSTEM, + PTHREAD_SCOPE_PROCESS +}; + +typedef struct +{ + int detachstate; + int schedpolicy; + struct sched_param schedparam; + int inheritsched; + int scope; +} pthread_attr_t; + +enum +{ + PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP +#ifdef __USE_UNIX98 + , + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL +#endif +}; + +typedef struct +{ + int mutexkind; +} pthread_mutexattr_t; + +typedef struct +{ + int dummy; +} pthread_condattr_t; + +#ifdef __USE_UNIX98 +enum +{ + PTHREAD_PROCESS_PRIVATE, + PTHREAD_PROCESS_SHARED +}; + +enum +{ + PTHREAD_RWLOCK_PREFER_READER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NP, + PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP +}; + +typedef struct +{ + int lockkind; + int pshared; +} pthread_rwlockattr_t; +#endif + +/* Keys for thread-specific data */ + +typedef unsigned int pthread_key_t; + +/* Once-only execution */ + +typedef int pthread_once_t; + +#define PTHREAD_ONCE_INIT 0 + +/* Cleanup buffers */ + +struct _pthread_cleanup_buffer +{ + void (*routine) __P ((void *)); /* Function to call. */ + void *arg; /* Its argument. */ + int canceltype; /* Saved cancellation type. */ + struct _pthread_cleanup_buffer *prev; /* Chaining of cleanup functions. */ +}; + +/* Cancellation */ + +enum { PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DISABLE }; +enum { PTHREAD_CANCEL_DEFERRED, PTHREAD_CANCEL_ASYNCHRONOUS }; +#define PTHREAD_CANCELED ((void *) -1) + + +/* Function for handling threads. */ + +/* Create a thread with given attributes ATTR (or default attributes + if ATTR is NULL), and call function START_ROUTINE with given + arguments ARG. */ +extern int pthread_create __P ((pthread_t *__thread, + __const pthread_attr_t *__attr, + void *(*__start_routine) (void *), + void *__arg)); + +/* Obtain the identifier of the current thread. */ +extern pthread_t pthread_self __P ((void)); + +/* Compare two thread identifiers. */ +extern int pthread_equal __P ((pthread_t __thread1, pthread_t __thread2)); + +/* Terminate calling thread. */ +extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__)); + +/* Make calling thread wait for termination of the thread TH. The + exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN + is not NULL. */ +extern int pthread_join __P ((pthread_t __th, void **__thread_return)); + +/* Indicate that the thread TH is never to be joined with PTHREAD_JOIN. + The resources of TH will therefore be freed immediately when it + terminates, instead of waiting for another thread to perform PTHREAD_JOIN + on it. */ +extern int pthread_detach __P ((pthread_t __th)); + + +/* Functions for handling attributes. */ + +/* Initialize thread attribute *ATTR with default attributes + (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER). */ +extern int pthread_attr_init __P ((pthread_attr_t *__attr)); + +/* Destroy thread attribute *ATTR. */ +extern int pthread_attr_destroy __P ((pthread_attr_t *__attr)); + +/* Set the `detachstate' attribute in *ATTR according to DETACHSTATE. */ +extern int pthread_attr_setdetachstate __P ((pthread_attr_t *__attr, + int __detachstate)); + +/* Return in *DETACHSTATE the `detachstate' attribute in *ATTR. */ +extern int pthread_attr_getdetachstate __P ((__const pthread_attr_t *__attr, + int *__detachstate)); + +/* Set scheduling parameters (priority, etc) in *ATTR according to PARAM. */ +extern int pthread_attr_setschedparam __P ((pthread_attr_t *__attr, + __const struct sched_param *__param)); + +/* Return in *PARAM the scheduling parameters of *ATTR. */ +extern int pthread_attr_getschedparam __P ((__const pthread_attr_t *__attr, + struct sched_param *__param)); + +/* Set scheduling policy in *ATTR according to POLICY. */ +extern int pthread_attr_setschedpolicy __P ((pthread_attr_t *__attr, + int __policy)); + +/* Return in *POLICY the scheduling policy of *ATTR. */ +extern int pthread_attr_getschedpolicy __P ((__const pthread_attr_t *__attr, + int *__policy)); + +/* Set scheduling inheritance mode in *ATTR according to INHERIT. */ +extern int pthread_attr_setinheritsched __P ((pthread_attr_t *__attr, + int __inherit)); + +/* Return in *INHERIT the scheduling inheritance mode of *ATTR. */ +extern int pthread_attr_getinheritsched __P ((__const pthread_attr_t *__attr, + int *__inherit)); + +/* Set scheduling contention scope in *ATTR according to SCOPE. */ +extern int pthread_attr_setscope __P ((pthread_attr_t *__attr, int __scope)); + +/* Return in *SCOPE the scheduling contention scope of *ATTR. */ +extern int pthread_attr_getscope __P ((__const pthread_attr_t *__attr, + int *__scope)); + +/* Functions for scheduling control. */ + +/* Set the scheduling parameters for TARGET_THREAD according to POLICY + and *PARAM. */ +extern int pthread_setschedparam __P ((pthread_t __target_thread, int __policy, + __const struct sched_param *__param)); + +/* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */ +extern int pthread_getschedparam __P ((pthread_t __target_thread, + int *__policy, + struct sched_param *__param)); + + +/* Functions for mutex handling. */ + +/* Initialize MUTEX using attributes in *MUTEX_ATTR, or use the + default values if later is NULL. */ +extern int __pthread_mutex_init __P ((pthread_mutex_t *__mutex, + __const pthread_mutexattr_t *__mutex_attr)); +extern int pthread_mutex_init __P ((pthread_mutex_t *__mutex, + __const pthread_mutexattr_t *__mutex_attr)); + +/* Destroy MUTEX. */ +extern int __pthread_mutex_destroy __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_destroy __P ((pthread_mutex_t *__mutex)); + +/* Try to lock MUTEX. */ +extern int __pthread_mutex_trylock __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_trylock __P ((pthread_mutex_t *__mutex)); + +/* Wait until lock for MUTEX becomes available and lock it. */ +extern int __pthread_mutex_lock __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_lock __P ((pthread_mutex_t *__mutex)); + +/* Unlock MUTEX. */ +extern int __pthread_mutex_unlock __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_unlock __P ((pthread_mutex_t *__mutex)); + + +/* Functions for handling mutex attributes. */ + +/* Initialize mutex attribute object ATTR with default attributes + (kind is PTHREAD_MUTEX_FAST_NP). */ +extern int __pthread_mutexattr_init __P ((pthread_mutexattr_t *__attr)); +extern int pthread_mutexattr_init __P ((pthread_mutexattr_t *__attr)); + +/* Destroy mutex attribute object ATTR. */ +extern int __pthread_mutexattr_destroy __P ((pthread_mutexattr_t *__attr)); +extern int pthread_mutexattr_destroy __P ((pthread_mutexattr_t *__attr)); + +/* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_FAST_NP + or PTHREAD_MUTEX_RECURSIVE_NP). */ +extern int __pthread_mutexattr_setkind_np __P ((pthread_mutexattr_t *__attr, + int __kind)); +extern int pthread_mutexattr_setkind_np __P ((pthread_mutexattr_t *__attr, + int __kind)); +/* Return in *KIND the mutex kind attribute in *ATTR. */ +extern int pthread_mutexattr_getkind_np __P ((__const pthread_mutexattr_t *__attr, + int *__kind)); + + +/* Functions for handling conditional variables. */ + +/* Initialize condition variable COND using attributes ATTR, or use + the default values if later is NULL. */ +extern int pthread_cond_init __P ((pthread_cond_t *__cond, + __const pthread_condattr_t *__cond_attr)); + +/* Destroy condition variable COND. */ +extern int pthread_cond_destroy __P ((pthread_cond_t *__cond)); + +/* Wake up one thread waiting for condition variable COND. */ +extern int pthread_cond_signal __P ((pthread_cond_t *__cond)); + +/* Wake up all threads waiting for condition variables COND. */ +extern int pthread_cond_broadcast __P ((pthread_cond_t *__cond)); + +/* Wait for condition variable COND to be signaled or broadcast. + MUTEX is assumed to be locked before. */ +extern int pthread_cond_wait __P ((pthread_cond_t *__cond, + pthread_mutex_t *__mutex)); + +/* Wait for condition variable COND to be signaled or broadcast until + ABSTIME. MUTEX is assumed to be locked before. ABSTIME is an + absolute time specification; zero is the beginning of the epoch + (00:00:00 GMT, January 1, 1970). */ +extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond, + pthread_mutex_t *__mutex, + __const struct timespec *__abstime)); + +/* Functions for handling condition variable attributes. */ + +/* Initialize condition variable attribute ATTR. */ +extern int pthread_condattr_init __P ((pthread_condattr_t *__attr)); + +/* Destroy condition variable attribute ATTR. */ +extern int pthread_condattr_destroy __P ((pthread_condattr_t *__attr)); + + +#ifdef __USE_UNIX98 +/* Functions for handling read-write locks. */ + +/* Initialize read-write lock RWLOCK using attributes ATTR, or use + the default values if later is NULL. */ +extern int pthread_rwlock_init __P ((pthread_rwlock_t *__rwlock, + __const pthread_rwlockattr_t *__attr)); + +/* Destroy read-write lock RWLOCK. */ +extern int pthread_rwlock_destroy __P ((pthread_rwlock_t *__rwlock)); + +/* Acquire read lock for RWLOCK. */ +extern int pthread_rwlock_rdlock __P ((pthread_rwlock_t *__rwlock)); + +/* Try to acquire read lock for RWLOCK. */ +extern int pthread_rwlock_tryrdlock __P ((pthread_rwlock_t *__rwlock)); + +/* Acquire write lock for RWLOCK. */ +extern int pthread_rwlock_wrlock __P ((pthread_rwlock_t *__rwlock)); + +/* Try to acquire writelock for RWLOCK. */ +extern int pthread_rwlock_trywrlock __P ((pthread_rwlock_t *__rwlock)); + +/* Unlock RWLOCK. */ +extern int pthread_rwlock_unlock __P ((pthread_rwlock_t *__rwlock)); + + +/* Functions for handling read-write lock attributes. */ + +/* Initialize attribute object ATTR with default values. */ +extern int pthread_rwlockattr_init __P ((pthread_rwlockattr_t *__attr)); + +/* Destroy attribute object ATTR. */ +extern int pthread_rwlockattr_destroy __P ((pthread_rwlockattr_t *__attr)); + +/* Return current setting of process-shared attribute of ATTR in PSHARED. */ +extern int pthread_rwlockattr_getpshared __P ((__const + pthread_rwlockattr_t *__attr, + int *__pshared)); + +/* Set process-shared attribute of ATTR to PSHARED. */ +extern int pthread_rwlockattr_setpshared __P ((pthread_rwlockattr_t *__attr, + int __pshared)); + +/* Return current setting of reader/writer preference. */ +extern int pthread_rwlockattr_getkind_np __P ((__const + pthread_rwlockattr_t *__attr, + int *__pref)); + +/* Set reader/write preference. */ +extern int pthread_rwlockattr_setkind_np __P ((pthread_rwlockattr_t *__attr, + int __pref)); +#endif + + +/* Functions for handling thread-specific data */ + +/* Create a key value identifying a location in the thread-specific data + area. Each thread maintains a distinct thread-specific data area. + DESTR_FUNCTION, if non-NULL, is called with + the value associated to that key when the key is destroyed. + DESTR_FUNCTION is not called if the value associated is NULL + when the key is destroyed. */ +extern int __pthread_key_create __P ((pthread_key_t *__key, + void (*__destr_function) (void *))); +extern int pthread_key_create __P ((pthread_key_t *__key, + void (*__destr_function) (void *))); + +/* Destroy KEY. */ +extern int pthread_key_delete __P ((pthread_key_t __key)); + +/* Store POINTER in the thread-specific data slot identified by KEY. */ +extern int __pthread_setspecific __P ((pthread_key_t __key, + __const void *__pointer)); +extern int pthread_setspecific __P ((pthread_key_t __key, + __const void *__pointer)); + +/* Return current value of the thread-specific data slot identified by KEY. */ +extern void *__pthread_getspecific __P ((pthread_key_t __key)); +extern void *pthread_getspecific __P ((pthread_key_t __key)); + + +/* Functions for handling initialization */ + +/* Guarantee that the initialization function INIT_ROUTINE will be called + only once, even if pthread_once is executed several times with the + same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or + extern variable initialized to PTHREAD_ONCE_INIT. */ +extern int __pthread_once __P ((pthread_once_t *__once_control, + void (*__init_routine) (void))); +extern int pthread_once __P ((pthread_once_t *__once_control, + void (*__init_routine) (void))); + + +/* Functions for handling cancellation. */ + +/* Set cancelability state of current thread to STATE, returning old + state in *OLDSTATE if OLDSTATE is not NULL. */ +extern int pthread_setcancelstate __P ((int __state, int *__oldstate)); + +/* Set cancellation state of current thread to TYPE, returning the old + type in *OLDTYPE if OLDTYPE is not NULL. */ +extern int __pthread_setcanceltype __P ((int __type, int *__oldtype)); +extern int pthread_setcanceltype __P ((int __type, int *__oldtype)); + +/* Cancel THREAD immediately or at the next possibility. */ +extern int pthread_cancel __P ((pthread_t __thread)); + +/* Test for pending cancellation for the current thread and terminate + the thread as per pthread_exit(PTHREAD_CANCELED) if it has been + cancelled. */ +extern void pthread_testcancel __P ((void)); + + +/* Install a cleanup handler: ROUTINE will be called with arguments ARG + when the thread is cancelled or calls pthread_exit. ROUTINE will also + be called with arguments ARG when the matching pthread_cleanup_pop + is executed with non-zero EXECUTE argument. + pthread_cleanup_push and pthread_cleanup_pop are macros and must always + be used in matching pairs at the same nesting level of braces. */ + +#define pthread_cleanup_push(routine,arg) \ + { struct _pthread_cleanup_buffer _buffer; \ + _pthread_cleanup_push (&_buffer, (routine), (arg)); + +extern void _pthread_cleanup_push __P ((struct _pthread_cleanup_buffer *__buffer, + void (*__routine) (void *), + void *__arg)); + +/* Remove a cleanup handler installed by the matching pthread_cleanup_push. + If EXECUTE is non-zero, the handler function is called. */ + +#define pthread_cleanup_pop(execute) \ + _pthread_cleanup_pop (&_buffer, (execute)); } + +extern void _pthread_cleanup_pop __P ((struct _pthread_cleanup_buffer *__buffer, + int __execute)); + +/* Install a cleanup handler as pthread_cleanup_push does, but also + saves the current cancellation type and set it to deferred cancellation. */ + +#define pthread_cleanup_push_defer_np(routine,arg) \ + { struct _pthread_cleanup_buffer _buffer; \ + _pthread_cleanup_push_defer (&_buffer, (routine), (arg)); + +extern void _pthread_cleanup_push_defer __P ((struct _pthread_cleanup_buffer *__buffer, + void (*__routine) (void *), + void *__arg)); + +/* Remove a cleanup handler as pthread_cleanup_pop does, but also + restores the cancellation type that was in effect when the matching + pthread_cleanup_push_defer was called. */ + +#define pthread_cleanup_pop_restore_np(execute) \ + _pthread_cleanup_pop_restore (&_buffer, (execute)); } + +extern void _pthread_cleanup_pop_restore __P ((struct _pthread_cleanup_buffer *__buffer, + int __execute)); + +/* Functions for handling signals. */ + +/* Modify the signal mask for the calling thread. The arguments have + the same meaning as for sigprocmask(2). */ + +extern int pthread_sigmask __P ((int __how, __const sigset_t *__newmask, + sigset_t *__oldmask)); + +/* Send signal SIGNO to the given thread. */ + +extern int pthread_kill __P ((pthread_t __thread, int __signo)); + + +/* Functions for handling process creation and process execution. */ + +/* Install handlers to be called when a new process is created with FORK. + The PREPARE handler is called in the parent process just before performing + FORK. The PARENT handler is called in the parent process just after FORK. + The CHILD handler is called in the child process. Each of the three + handlers can be NULL, meaning that no handler needs to be called at that + point. + PTHREAD_ATFORK can be called several times, in which case the PREPARE + handlers are called in LIFO order (last added with PTHREAD_ATFORK, + first called before FORK), and the PARENT and CHILD handlers are called + in FIFO (first added, first called). */ + +extern int __pthread_atfork __P ((void (*__prepare) (void), + void (*__parent) (void), + void (*__child) (void))); +extern int pthread_atfork __P ((void (*__prepare) (void), + void (*__parent) (void), + void (*__child) (void))); + +/* Terminate all threads in the program except the calling process. + Should be called just before invoking one of the exec*() functions. */ + +extern void __pthread_kill_other_threads_np __P ((void)); +extern void pthread_kill_other_threads_np __P ((void)); + + +/* This function is called to initialize the pthread library. */ +extern void __pthread_initialize __P ((void)); + +__END_DECLS + +#endif /* pthread.h */ diff --git a/linuxthreads/sysdeps/sparc/sparc32/Implies b/linuxthreads/sysdeps/sparc/sparc32/Implies new file mode 100644 index 0000000000..7edcd7e757 --- /dev/null +++ b/linuxthreads/sysdeps/sparc/sparc32/Implies @@ -0,0 +1 @@ +pthread/no-cmpxchg diff --git a/linuxthreads/sysdeps/sparc/sparc32/pt-machine.h b/linuxthreads/sysdeps/sparc/sparc32/pt-machine.h new file mode 100644 index 0000000000..13f78e319a --- /dev/null +++ b/linuxthreads/sysdeps/sparc/sparc32/pt-machine.h @@ -0,0 +1,55 @@ +/* Machine-dependent pthreads configuration and inline functions. + sparc version. + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Richard Henderson <rth@tamu.edu>. + + 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* Spinlock implementation; required. */ +static inline int testandset(int *spinlock) +{ + int ret; + + __asm__ __volatile__("ldstub %1,%0" + : "=r"(ret), "=m"(*spinlock) + : "m"(*spinlock)); + + return ret; +} + + +/* Spinlock release; default is just set to zero. */ +#define RELEASE(spinlock) \ + __asm__ __volatile__("stbar; stb %1,%0" : "=m"(*(spinlock)) : "r"(0)); + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char * stack_pointer __asm__("%sp"); + + +/* Registers %g6 and %g7 are reserved by the ABI for "system use". It + happens that Solaris uses %g6 for the thread pointer -- we do the same. */ +struct _pthread_descr_struct; +register struct _pthread_descr_struct *__thread_self __asm__("%g6"); + +/* Return the thread descriptor for the current thread. */ +#define THREAD_SELF __thread_self + +/* Initialize the thread-unique value. */ +#define INIT_THREAD_SELF(descr) (__thread_self = (descr)) diff --git a/linuxthreads/sysdeps/sparc/sparc64/Implies b/linuxthreads/sysdeps/sparc/sparc64/Implies new file mode 100644 index 0000000000..81e93666c4 --- /dev/null +++ b/linuxthreads/sysdeps/sparc/sparc64/Implies @@ -0,0 +1 @@ +pthread/cmpxchg diff --git a/linuxthreads/sysdeps/sparc/sparc64/pt-machine.h b/linuxthreads/sysdeps/sparc/sparc64/pt-machine.h new file mode 100644 index 0000000000..5424860786 --- /dev/null +++ b/linuxthreads/sysdeps/sparc/sparc64/pt-machine.h @@ -0,0 +1,67 @@ +/* Machine-dependent pthreads configuration and inline functions. + Sparc v9 version. + Copyright (C) 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Richard Henderson <rth@tamu.edu>. + + 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, write to the Free Software Foundation, Inc., + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + + +/* Spinlock implementation; required. */ +extern inline int +testandset (int *spinlock) +{ + int ret; + + __asm__ __volatile__("ldstub %1,%0" + : "=r"(ret), "=m"(*spinlock) : "m"(*spinlock)); + + return ret; +} + + +/* Get some notion of the current stack. Need not be exactly the top + of the stack, just something somewhere in the current frame. */ +#define CURRENT_STACK_FRAME stack_pointer +register char * stack_pointer __asm__ ("%sp"); + + +/* Registers %g6 and %g7 are reserved by the ABI for "system use". It + happens that Solaris uses %g6 for the thread pointer -- we do the same. */ +struct _pthread_descr_struct; +register struct _pthread_descr_struct *__thread_self __asm__("%g6"); + +/* Return the thread descriptor for the current thread. */ +#define THREAD_SELF __thread_self + +/* Initialize the thread-unique value. */ +#define INIT_THREAD_SELF(descr) (__thread_self = (descr)) + + +/* Compare-and-swap for semaphores. */ + +#define HAS_COMPARE_AND_SWAP +extern inline int +__compare_and_swap (long int *p, long int oldval, long int newval) +{ + long int readval; + + __asm__ __volatile__ ("cas %1, %2, %0" + : "=r"(readval), "=m"(*p) + : "r"(oldval), "m"(*p), "0"(newval)); + + return readval == newval; +} diff --git a/linuxthreads/sysdeps/unix/sysv/linux/Implies b/linuxthreads/sysdeps/unix/sysv/linux/Implies new file mode 100644 index 0000000000..f1b3e8939c --- /dev/null +++ b/linuxthreads/sysdeps/unix/sysv/linux/Implies @@ -0,0 +1 @@ +pthread diff --git a/linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h b/linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h new file mode 100644 index 0000000000..68635ba36f --- /dev/null +++ b/linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h @@ -0,0 +1,40 @@ +/* Minimum guaranteed maximum values for system limits. Linux version. + Copyright (C) 1993, 1994, 1995, 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* The kernel sources contain a file with all the needed information. */ +#include <linux/limits.h> + +/* The number of data keys per process. */ +#define _POSIX_THREAD_KEYS_MAX 128 +/* This is the value this implementation supports. */ +#define PTHREAD_KEYS_MAX 1024 + +/* Controlling the iterations of destructors for thread-specific data. */ +#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4 +/* Number of iterations this implementation does. */ +#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS + +/* The number of threads per process. */ +#define _POSIX_THREAD_THREADS_MAX 64 +/* This is the value this implementation supports. */ +#define PTHREAD_THREADS_MAX 1024 + +/* Maximum amount by which a process can descrease its asynchronous I/O + priority level. */ +#define AIO_PRIO_DELTA_MAX 20 diff --git a/linuxthreads/sysdeps/unix/sysv/linux/bits/posix_opt.h b/linuxthreads/sysdeps/unix/sysv/linux/bits/posix_opt.h new file mode 100644 index 0000000000..feb4e10c6e --- /dev/null +++ b/linuxthreads/sysdeps/unix/sysv/linux/bits/posix_opt.h @@ -0,0 +1,94 @@ +/* Define POSIX options for Linux. + Copyright (C) 1996, 1997 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, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _POSIX_OPT_H +#define _POSIX_OPT_H 1 + +/* Job control is supported. */ +#define _POSIX_JOB_CONTROL 1 + +/* Processes have a saved set-user-ID and a saved set-group-ID. */ +#define _POSIX_SAVED_IDS 1 + +/* Priority scheduling is supported. */ +#define _POSIX_PRIORITY_SCHEDULING 1 + +/* Synchronizing file data is supported. */ +#define _POSIX_SYNCHRONIZED_IO 1 + +/* The fsync function is present. */ +#define _POSIX_FSYNC 1 + +/* Mapping of files to memory is supported. */ +#define _POSIX_MAPPED_FILES 1 + +/* Locking of all memory is supported. */ +#define _POSIX_MEMLOCK 1 + +/* Locking of ranges of memory is supported. */ +#define _POSIX_MEMLOCK_RANGE 1 + +/* Setting of memory protections is supported. */ +#define _POSIX_MEMORY_PROTECTION 1 + +/* Implementation supports `poll' function. */ +#define _POSIX_POLL 1 + +/* Implementation supports `select' and `pselect' functions. */ +#define _POSIX_SELECT 1 + +/* Only root can change owner of file. */ +#define _POSIX_CHOWN_RESTRICTED 1 + +/* `c_cc' member of 'struct termios' structure can be disabled by + using the value _POSIX_VDISABLE. */ +#define _POSIX_VDISABLE '\0' + +/* Filenames are not silently truncated. */ +#define _POSIX_NO_TRUNC 1 + +/* X/Open realtime support is available. */ +#define _XOPEN_REALTIME 1 + +/* X/Open realtime thread support is available. */ +#define _XOPEN_REALTIME_THREADS 1 + +/* XPG4.2 shared memory is supported. */ +#define _XOPEN_SHM 1 + +/* Tell we have POSIX threads. */ +#define _POSIX_THREADS 1 + +/* We have the reentrant functions described in POSIX. */ +#define _POSIX_REENTRANT_FUNCTIONS 1 +#define _POSIX_THREAD_SAFE_FUNCTIONS 1 + +/* We provide priority scheduling for threads. */ +#define _POSIX_THREAD_PRIORITY_SCHEDULING 1 + +/* We support POSIX.1b semaphores, but only the non-shared form for now. */ +/*#define _POSIX_SEMAPHORES 1 XXX We are not quite there now. */ + +/* Real-time signals are supported. */ +#define _POSIX_REALTIME_SIGNALS 1 + +/* We support asynchronous I/O. */ +#define _POSIX_ASYNCHRONOUS_IO 1 + +#endif /* posix_opt.h */ diff --git a/linuxthreads/sysdeps/unix/sysv/linux/configure b/linuxthreads/sysdeps/unix/sysv/linux/configure new file mode 100644 index 0000000000..229414dd74 --- /dev/null +++ b/linuxthreads/sysdeps/unix/sysv/linux/configure @@ -0,0 +1,3 @@ +# Local configure fragment for sysdeps/unix/sysv/linux. + +DEFINES="$DEFINES -D_LIBC_REENTRANT" |