(get_myaddress): Avoid loopback interfaces, return loopback address
[kopensolaris-gnu/glibc.git] / malloc / thread-m.h
1 /* Basic platform-independent macro definitions for mutexes and
2    thread-specific data.
3    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
4    This file is part of the GNU C Library.
5    Contributed by Wolfram Gloger <wmglo@dent.med.uni-muenchen.de>, 1996.
6
7    The GNU C Library is free software; you can redistribute it and/or
8    modify it under the terms of the GNU Library General Public License as
9    published by the Free Software Foundation; either version 2 of the
10    License, or (at your option) any later version.
11
12    The GNU C Library is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Library General Public License for more details.
16
17    You should have received a copy of the GNU Library General Public
18    License along with the GNU C Library; see the file COPYING.LIB.  If not,
19    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 /* One out of _LIBC, USE_PTHREADS, USE_THR or USE_SPROC should be
23    defined, otherwise the token NO_THREADS and dummy implementations
24    of the macros will be defined.  */
25
26 #ifndef _THREAD_M_H
27 #define _THREAD_M_H
28
29 #undef thread_atfork_static
30
31 #if defined(_LIBC) /* The GNU C library, a special case of Posix threads */
32
33 #include <bits/libc-lock.h>
34
35 #ifdef PTHREAD_MUTEX_INITIALIZER
36
37 typedef pthread_t thread_id;
38
39 /* mutex */
40 typedef pthread_mutex_t mutex_t;
41
42 /* thread specific data */
43 typedef pthread_key_t tsd_key_t;
44
45 #define MUTEX_INITIALIZER       PTHREAD_MUTEX_INITIALIZER
46
47 static Void_t *malloc_key_data;
48
49 #define tsd_key_create(key, destr) \
50   if (__pthread_key_create != NULL) {                                         \
51     __pthread_key_create(key, destr);                                         \
52   } else { *(key) = (tsd_key_t) 0; }
53 #define tsd_setspecific(key, data) \
54   if (__pthread_setspecific != NULL) {                                        \
55     __pthread_setspecific(key, data);                                         \
56   } else { malloc_key_data = (Void_t *) data; }
57 #define tsd_getspecific(key, vptr) \
58   (vptr = (__pthread_getspecific != NULL                                      \
59            ? __pthread_getspecific(key) : malloc_key_data))
60
61 #define mutex_init(m)           \
62    (__pthread_mutex_init != NULL ? __pthread_mutex_init (m, NULL) : 0)
63 #define mutex_lock(m)           \
64    (__pthread_mutex_lock != NULL ? __pthread_mutex_lock (m) : 0)
65 #define mutex_trylock(m)        \
66    (__pthread_mutex_trylock != NULL ? __pthread_mutex_trylock (m) : 0)
67 #define mutex_unlock(m)         \
68    (__pthread_mutex_unlock != NULL ? __pthread_mutex_unlock (m) : 0)
69
70 #define thread_atfork(prepare, parent, child) \
71    (__pthread_atfork != NULL ? __pthread_atfork(prepare, parent, child) : 0)
72
73 #elif defined(MUTEX_INITIALIZER)
74 /* Assume hurd, with cthreads */
75
76 /* Cthreads `mutex_t' is a pointer to a mutex, and malloc wants just the
77    mutex itself.  */
78 #undef mutex_t
79 #define mutex_t struct mutex
80
81 #undef mutex_lock
82 #define mutex_lock(m) (__mutex_lock(m), 0)
83
84 #undef mutex_unlock
85 #define mutex_unlock(m) (__mutex_unlock(m), 0)
86
87 #define mutex_trylock(m) (!__mutex_trylock(m))
88
89 #include <hurd/threadvar.h>
90
91 /* thread specific data */
92 typedef int tsd_key_t;
93
94 static int tsd_keys_alloced = 0;
95
96 #define tsd_key_create(key, destr) \
97   (assert (tsd_keys_alloced == 0), tsd_keys_alloced++)
98 #define tsd_setspecific(key, data) \
99   (*__hurd_threadvar_location (_HURD_THREADVAR_MALLOC) = (unsigned long)(data))
100 #define tsd_getspecific(key, vptr) \
101   ((vptr) = (void *)*__hurd_threadvar_location (_HURD_THREADVAR_MALLOC))
102
103 #define thread_atfork(prepare, parent, child) do {} while(0)
104 #define thread_atfork_static(prepare, parent, child) \
105  text_set_element(_hurd_fork_prepare_hook, prepare); \
106  text_set_element(_hurd_fork_parent_hook, parent); \
107  text_set_element(_hurd_fork_child_hook, child);
108
109 /* No we're *not* using pthreads.  */
110 #define __pthread_initialize ((void (*)(void))0)
111
112 #else
113
114 #define NO_THREADS
115
116 #endif /* MUTEX_INITIALIZER && PTHREAD_MUTEX_INITIALIZER */
117
118 #elif defined(USE_PTHREADS) /* Posix threads */
119
120 #include <pthread.h>
121
122 typedef pthread_t thread_id;
123
124 /* mutex */
125 typedef pthread_mutex_t mutex_t;
126
127 #define MUTEX_INITIALIZER          PTHREAD_MUTEX_INITIALIZER
128 #define mutex_init(m)              pthread_mutex_init(m, NULL)
129 #define mutex_lock(m)              pthread_mutex_lock(m)
130 #define mutex_trylock(m)           pthread_mutex_trylock(m)
131 #define mutex_unlock(m)            pthread_mutex_unlock(m)
132
133 /* thread specific data */
134 typedef pthread_key_t tsd_key_t;
135
136 #define tsd_key_create(key, destr) pthread_key_create(key, destr)
137 #define tsd_setspecific(key, data) pthread_setspecific(key, data)
138 #define tsd_getspecific(key, vptr) (vptr = pthread_getspecific(key))
139
140 /* at fork */
141 #define thread_atfork(prepare, parent, child) \
142                                    pthread_atfork(prepare, parent, child)
143
144 #elif USE_THR /* Solaris threads */
145
146 #include <thread.h>
147
148 typedef thread_t thread_id;
149
150 #define MUTEX_INITIALIZER          { 0 }
151 #define mutex_init(m)              mutex_init(m, USYNC_THREAD, NULL)
152
153 /*
154  * Hack for thread-specific data on Solaris.  We can't use thr_setspecific
155  * because that function calls malloc() itself.
156  */
157 typedef void *tsd_key_t[256];
158 #define tsd_key_create(key, destr) do { \
159   int i; \
160   for(i=0; i<256; i++) (*key)[i] = 0; \
161 } while(0)
162 #define tsd_setspecific(key, data) (key[(unsigned)thr_self() % 256] = (data))
163 #define tsd_getspecific(key, vptr) (vptr = key[(unsigned)thr_self() % 256])
164
165 #define thread_atfork(prepare, parent, child) do {} while(0)
166
167 #elif USE_SPROC /* SGI sproc() threads */
168
169 #include <sys/wait.h>
170 #include <sys/types.h>
171 #include <sys/prctl.h>
172 #include <abi_mutex.h>
173
174 typedef int thread_id;
175
176 typedef abilock_t mutex_t;
177
178 #define MUTEX_INITIALIZER          { 0 }
179 #define mutex_init(m)              init_lock(m)
180 #define mutex_lock(m)              (spin_lock(m), 0)
181 #define mutex_trylock(m)           acquire_lock(m)
182 #define mutex_unlock(m)            release_lock(m)
183
184 typedef int tsd_key_t;
185 int tsd_key_next;
186 #define tsd_key_create(key, destr) ((*key) = tsd_key_next++)
187 #define tsd_setspecific(key, data) (((void **)(&PRDA->usr_prda))[key] = data)
188 #define tsd_getspecific(key, vptr) (vptr = ((void **)(&PRDA->usr_prda))[key])
189
190 #define thread_atfork(prepare, parent, child) do {} while(0)
191
192 #else /* no _LIBC or USE_... are defined */
193
194 #define NO_THREADS
195
196 #endif /* defined(_LIBC) */
197
198 #ifdef NO_THREADS /* No threads, provide dummy macros */
199
200 typedef int thread_id;
201
202 typedef int mutex_t;
203
204 #define MUTEX_INITIALIZER          0
205 #define mutex_init(m)              (*(m) = 0)
206 #define mutex_lock(m)              (0)
207 #define mutex_trylock(m)           (0)
208 #define mutex_unlock(m)            (0)
209
210 typedef void *tsd_key_t;
211 #define tsd_key_create(key, destr) do {} while(0)
212 #define tsd_setspecific(key, data) do {} while(0)
213 #define tsd_getspecific(key, vptr) (vptr = NULL)
214
215 #define thread_atfork(prepare, parent, child) do {} while(0)
216
217 #endif /* defined(NO_THREADS) */
218
219 #endif /* !defined(_THREAD_M_H) */