(pthread_cond_timedwait@GLIBC_2.0, pthread_cond_timedwait@@GLIBC_2.3.2): New
[kopensolaris-gnu/glibc.git] / nptl / forward.c
1 /* Copyright (C) 2002, 2003 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 #include <dlfcn.h>
21 #include <pthreadP.h>
22 #include <signal.h>
23 #include <stdlib.h>
24
25 #include <shlib-compat.h>
26 #include <atomic.h>
27 #include <sysdep.h>
28
29
30 /* Pointers to the libc functions.  */
31 struct pthread_functions __libc_pthread_functions attribute_hidden;
32
33
34 #define FORWARD2(name, rettype, decl, params, defaction) \
35 rettype                                                                       \
36 name decl                                                                     \
37 {                                                                             \
38   if (__libc_pthread_functions.ptr_##name == NULL)                            \
39     defaction;                                                                \
40                                                                               \
41   return __libc_pthread_functions.ptr_##name params;                          \
42 }
43
44 #define FORWARD(name, decl, params, defretval) \
45   FORWARD2 (name, int, decl, params, return defretval)
46
47
48 FORWARD (pthread_attr_destroy, (pthread_attr_t *attr), (attr), 0)
49
50 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_1)
51 FORWARD (__pthread_attr_init_2_0, (pthread_attr_t *attr), (attr), 0)
52 compat_symbol (libc, __pthread_attr_init_2_0, pthread_attr_init, GLIBC_2_0);
53 #endif
54
55 FORWARD (__pthread_attr_init_2_1, (pthread_attr_t *attr), (attr), 0)
56 versioned_symbol (libc, __pthread_attr_init_2_1, pthread_attr_init, GLIBC_2_1);
57
58 FORWARD (pthread_attr_getdetachstate,
59          (const pthread_attr_t *attr, int *detachstate), (attr, detachstate),
60          0)
61 FORWARD (pthread_attr_setdetachstate, (pthread_attr_t *attr, int detachstate),
62          (attr, detachstate), 0)
63
64 FORWARD (pthread_attr_getinheritsched,
65          (const pthread_attr_t *attr, int *inherit), (attr, inherit), 0)
66 FORWARD (pthread_attr_setinheritsched, (pthread_attr_t *attr, int inherit),
67          (attr, inherit), 0)
68
69 FORWARD (pthread_attr_getschedparam,
70          (const pthread_attr_t *attr, struct sched_param *param),
71          (attr, param), 0)
72 FORWARD (pthread_attr_setschedparam,
73          (pthread_attr_t *attr, const struct sched_param *param),
74          (attr, param), 0)
75
76 FORWARD (pthread_attr_getschedpolicy,
77          (const pthread_attr_t *attr, int *policy), (attr, policy), 0)
78 FORWARD (pthread_attr_setschedpolicy, (pthread_attr_t *attr, int policy),
79          (attr, policy), 0)
80
81 FORWARD (pthread_attr_getscope,
82          (const pthread_attr_t *attr, int *scope), (attr, scope), 0)
83 FORWARD (pthread_attr_setscope, (pthread_attr_t *attr, int scope),
84          (attr, scope), 0)
85
86
87 FORWARD (pthread_condattr_destroy, (pthread_condattr_t *attr), (attr), 0)
88 FORWARD (pthread_condattr_init, (pthread_condattr_t *attr), (attr), 0)
89
90 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3_2)
91 FORWARD (__pthread_cond_broadcast_2_0, (pthread_cond_2_0_t *cond), (cond), 0)
92 compat_symbol (libc, __pthread_cond_broadcast_2_0, pthread_cond_broadcast,
93                GLIBC_2_0);
94 #endif
95 FORWARD (__pthread_cond_broadcast, (pthread_cond_t *cond), (cond), 0)
96 versioned_symbol (libc, __pthread_cond_broadcast, pthread_cond_broadcast,
97                   GLIBC_2_3_2);
98
99 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3_2)
100 FORWARD (__pthread_cond_destroy_2_0, (pthread_cond_2_0_t *cond), (cond), 0)
101 compat_symbol (libc, __pthread_cond_destroy_2_0, pthread_cond_destroy,
102                GLIBC_2_0);
103 #endif
104 FORWARD (__pthread_cond_destroy, (pthread_cond_t *cond), (cond), 0)
105 versioned_symbol (libc, __pthread_cond_destroy, pthread_cond_destroy,
106                   GLIBC_2_3_2);
107
108 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3_2)
109 FORWARD (__pthread_cond_init_2_0,
110          (pthread_cond_2_0_t *cond, const pthread_condattr_t *cond_attr),
111          (cond, cond_attr), 0)
112 compat_symbol (libc, __pthread_cond_init_2_0, pthread_cond_init, GLIBC_2_0);
113 #endif
114 FORWARD (__pthread_cond_init,
115          (pthread_cond_t *cond, const pthread_condattr_t *cond_attr),
116          (cond, cond_attr), 0)
117 versioned_symbol (libc, __pthread_cond_init, pthread_cond_init, GLIBC_2_3_2);
118
119 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3_2)
120 FORWARD (__pthread_cond_signal_2_0, (pthread_cond_2_0_t *cond), (cond), 0)
121 compat_symbol (libc, __pthread_cond_signal_2_0, pthread_cond_signal,
122                GLIBC_2_0);
123 #endif
124 FORWARD (__pthread_cond_signal, (pthread_cond_t *cond), (cond), 0)
125 versioned_symbol (libc, __pthread_cond_signal, pthread_cond_signal,
126                   GLIBC_2_3_2);
127
128 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3_2)
129 FORWARD (__pthread_cond_wait_2_0,
130          (pthread_cond_2_0_t *cond, pthread_mutex_t *mutex), (cond, mutex), 0)
131 compat_symbol (libc, __pthread_cond_wait_2_0, pthread_cond_wait,
132                GLIBC_2_0);
133 #endif
134 FORWARD (__pthread_cond_wait, (pthread_cond_t *cond, pthread_mutex_t *mutex),
135          (cond, mutex), 0)
136 versioned_symbol (libc, __pthread_cond_wait, pthread_cond_wait,
137                   GLIBC_2_3_2);
138
139 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3_2)
140 FORWARD (__pthread_cond_timedwait_2_0,
141          (pthread_cond_2_0_t *cond, pthread_mutex_t *mutex,
142           const struct timespec *abstime), (cond, mutex, abstime), 0)
143 compat_symbol (libc, __pthread_cond_timedwait_2_0, pthread_cond_timedwait,
144                GLIBC_2_0);
145 #endif
146 FORWARD (__pthread_cond_timedwait,
147          (pthread_cond_t *cond, pthread_mutex_t *mutex,
148           const struct timespec *abstime), (cond, mutex, abstime), 0)
149 versioned_symbol (libc, __pthread_cond_timedwait, pthread_cond_timedwait,
150                   GLIBC_2_3_2);
151
152
153 FORWARD (pthread_equal, (pthread_t thread1, pthread_t thread2),
154          (thread1, thread2), 1)
155
156
157 /* Use an alias to avoid warning, as pthread_exit is declared noreturn.  */
158 FORWARD2 (__pthread_exit, void, (void *retval), (retval), exit (EXIT_SUCCESS))
159 strong_alias (__pthread_exit, pthread_exit);
160
161
162 FORWARD (pthread_getschedparam,
163          (pthread_t target_thread, int *policy, struct sched_param *param),
164          (target_thread, policy, param), 0)
165 FORWARD (pthread_setschedparam,
166          (pthread_t target_thread, int policy,
167           const struct sched_param *param), (target_thread, policy, param), 0)
168
169
170 FORWARD (pthread_mutex_destroy, (pthread_mutex_t *mutex), (mutex), 0)
171
172 FORWARD (pthread_mutex_init,
173          (pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr),
174          (mutex, mutexattr), 0)
175
176 FORWARD (pthread_mutex_lock, (pthread_mutex_t *mutex), (mutex), 0)
177
178 FORWARD (pthread_mutex_unlock, (pthread_mutex_t *mutex), (mutex), 0)
179
180
181 FORWARD2 (pthread_self, pthread_t, (void), (), return 0)
182
183
184 FORWARD (pthread_setcancelstate, (int state, int *oldstate), (state, oldstate),
185          0)
186
187 FORWARD (pthread_setcanceltype, (int type, int *oldtype), (type, oldtype), 0)
188
189 #define return /* value is void */
190 FORWARD2(__pthread_unwind,
191          void attribute_hidden __attribute ((noreturn)) __cleanup_fct_attribute,
192          (__pthread_unwind_buf_t *buf), (buf), {
193                        /* We cannot call abort() here.  */
194                        INTERNAL_SYSCALL_DECL (err);
195                        INTERNAL_SYSCALL (kill, err, 1, SIGKILL);
196                      })
197 #undef return