Initial revision
[kopensolaris-gnu/glibc.git] / nptl / pthreadP.h
1 /* Copyright (C) 2002 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #ifndef _PTHREADP_H
21 #define _PTHREADP_H     1
22
23 #include <pthread.h>
24 #include <setjmp.h>
25 #include <stdint.h>
26 #include <sys/syscall.h>
27 #include "descr.h"
28 #include <tls.h>
29 #include <lowlevellock.h>
30 #include <stackinfo.h>
31 #include <internaltypes.h>
32
33
34 /* Internal variables.  */
35
36
37 /* Default stack size.  */
38 extern size_t __default_stacksize attribute_hidden;
39
40 /* Size and alignment of static TLS block.  */
41 extern size_t __static_tls_size attribute_hidden;
42 extern size_t __static_tls_align attribute_hidden;
43
44 /* Thread descriptor handling.  */
45 extern list_t __stack_user attribute_hidden;
46
47 /* Attribute handling.  */
48 extern struct pthread_attr *__attr_list attribute_hidden;
49 extern lll_lock_t __attr_list_lock attribute_hidden;
50
51 /* First available RT signal.  */
52 extern int __current_sigrtmin attribute_hidden;
53 /* Last available RT signal.  */
54 extern int __current_sigrtmax attribute_hidden;
55
56 /* Concurrency handling.  */
57 extern int __concurrency_level attribute_hidden;
58
59 /* Thread-local data key handling.  */
60 extern struct pthread_key_struct __pthread_keys[PTHREAD_KEYS_MAX]
61      attribute_hidden;
62
63 /* The library can run in debugging mode where it performs a lot more
64    tests.  */
65 extern int __pthread_debug attribute_hidden;
66 #define DEBUGGING_P __builtin_expect (__pthread_debug, 0)
67
68
69 /* Cancellation test.  */
70 #define CANCELLATION_P(self) \
71   do {                                                                        \
72     int cancelhandling = THREAD_GETMEM (self, cancelhandling);                \
73     if (CANCEL_ENABLED_AND_CANCELED (cancelhandling))                         \
74       {                                                                       \
75         THREAD_SETMEM (self, result, PTHREAD_CANCELED);                       \
76         __do_cancel (CURRENT_STACK_FRAME);                                    \
77       }                                                                       \
78   } while (0)
79
80 /* Set cancellation mode to asynchronous.  */
81 #define CANCEL_ASYNC(oldtype) \
82   pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype)
83 /* Reset to previous cancellation mode.  */
84 #define CANCEL_RESET(oldtype) \
85   pthread_setcanceltype (oldtype, NULL)
86
87 /* Function performing the cancellation.  */
88 extern void __do_cancel (char *currentframe)
89      __attribute ((visibility ("hidden"), noreturn, regparm (1)));
90 extern void __cleanup_thread (struct pthread *self, char *currentframe)
91      __attribute ((visibility ("hidden"), regparm (2)));
92
93
94 /* Test whether stackframe is still active.  */
95 #ifdef _STACK_GROWS_DOWN
96 # define FRAME_LEFT(frame, other) ((char *) frame >= (char *) other)
97 #elif _STACK_GROWS_UP
98 # define FRAME_LEFT(frame, other) ((char *) frame <= (char *) other)
99 #else
100 # error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP"
101 #endif
102
103
104 /* Internal prototypes.  */
105
106 /* Thread list handling.  */
107 extern struct pthread *__find_in_stack_list (struct pthread *pd)
108      attribute_hidden;
109
110 /* Deallocate a thread's stack after optionally making sure the thread
111    descriptor is still valid.  */
112 extern void __free_tcb (struct pthread *pd) attribute_hidden;
113
114 /* Free allocated stack.  */
115 extern void __deallocate_stack (struct pthread *pd) attribute_hidden;
116
117 /* Mark all the stacks except for the current one as available.  This
118    function also re-initializes the lock for the stack cache.  */
119 extern void __reclaim_stacks (void) attribute_hidden;
120
121 /* longjmp handling.  */
122 extern void __pthread_cleanup_upto (__jmp_buf target, char *targetframe);
123
124
125 /* Functions with versioned interfaces.  */
126 extern int __pthread_create_2_1 (pthread_t *newthread,
127                                  const pthread_attr_t *attr,
128                                  void *(*start_routine) (void *), void *arg);
129 extern int __pthread_create_2_0 (pthread_t *newthread,
130                                  const pthread_attr_t *attr,
131                                  void *(*start_routine) (void *), void *arg);
132 extern int __pthread_attr_init_2_1 (pthread_attr_t *attr);
133 extern int __pthread_attr_init_2_0 (pthread_attr_t *attr);
134
135
136 /* Event handlers for libthread_db interface.  */
137 extern void __nptl_create_event (void) attribute_hidden;
138 extern void __nptl_death_event (void) attribute_hidden;
139
140
141 /* Namespace save aliases.  */
142 extern int __pthread_mutex_init (pthread_mutex_t *__mutex,
143                                  __const pthread_mutexattr_t *__mutexattr);
144 extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex);
145 extern int __pthread_mutex_trylock (pthread_mutex_t *_mutex);
146 extern int __pthread_mutex_lock (pthread_mutex_t *__mutex);
147 extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex);
148 extern int __pthread_mutexattr_init (pthread_mutexattr_t *attr);
149 extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *attr);
150 extern int __pthread_mutexattr_settype (pthread_mutexattr_t *attr, int kind);
151 extern int __pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
152                                         __attr, void **__restrict __stackaddr);
153 extern int __pthread_attr_setstackaddr (pthread_attr_t *__attr,
154                                         void *__stackaddr);
155 extern int __pthread_attr_getstacksize (__const pthread_attr_t *__restrict
156                                         __attr,
157                                         size_t *__restrict __stacksize);
158 extern int __pthread_attr_setstacksize (pthread_attr_t *__attr,
159                                         size_t __stacksize);
160 extern int __pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
161                                     void **__restrict __stackaddr,
162                                     size_t *__restrict __stacksize);
163 extern int __pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
164                                     size_t __stacksize);
165 extern int __pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
166                                   __const pthread_rwlockattr_t *__restrict
167                                   __attr);
168 extern int __pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);
169 extern int __pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock);
170 extern int __pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock);
171 extern int __pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock);
172 extern int __pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock);
173 extern int __pthread_rwlock_unlock (pthread_rwlock_t *__rwlock);
174 extern int __pthread_key_create (pthread_key_t *key, void (*destr) (void *));
175 extern void *__pthread_getspecific (pthread_key_t key);
176 extern int __pthread_setspecific (pthread_key_t key, const void *value);
177 extern int __pthread_once (pthread_once_t *once_control,
178                            void (*init_routine) (void));
179 extern int __pthread_atfork (void (*prepare) (void), void (*parent) (void),
180                              void (*child) (void));
181
182 #endif  /* pthreadP.h */