Add thread_db.h
[kopensolaris-gnu/glibc.git] / nptl / descr.h
1 /* Copyright (C) 2002-2006, 2007, 2008 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 _DESCR_H
21 #define _DESCR_H        1
22
23 #include <limits.h>
24 #include <sched.h>
25 #include <setjmp.h>
26 #include <stdbool.h>
27 #include <sys/types.h>
28 #include <hp-timing.h>
29 #include <list.h>
30 #include <lowlevellock.h>
31 #include <pthreaddef.h>
32 #include <dl-sysdep.h>
33 #include <thread_db.h>
34 #include <tls.h>
35 #ifdef HAVE_FORCED_UNWIND
36 # include <unwind.h>
37 #endif
38 #define __need_res_state
39 #include <resolv.h>
40 #include <kernel-features.h>
41
42 #ifndef TCB_ALIGNMENT
43 # define TCB_ALIGNMENT  sizeof (double)
44 #endif
45
46
47 /* We keep thread specific data in a special data structure, a two-level
48    array.  The top-level array contains pointers to dynamically allocated
49    arrays of a certain number of data pointers.  So we can implement a
50    sparse array.  Each dynamic second-level array has
51         PTHREAD_KEY_2NDLEVEL_SIZE
52    entries.  This value shouldn't be too large.  */
53 #define PTHREAD_KEY_2NDLEVEL_SIZE       32
54
55 /* We need to address PTHREAD_KEYS_MAX key with PTHREAD_KEY_2NDLEVEL_SIZE
56    keys in each subarray.  */
57 #define PTHREAD_KEY_1STLEVEL_SIZE \
58   ((PTHREAD_KEYS_MAX + PTHREAD_KEY_2NDLEVEL_SIZE - 1) \
59    / PTHREAD_KEY_2NDLEVEL_SIZE)
60
61
62
63
64 /* Internal version of the buffer to store cancellation handler
65    information.  */
66 struct pthread_unwind_buf
67 {
68   struct
69   {
70     __jmp_buf jmp_buf;
71     int mask_was_saved;
72   } cancel_jmp_buf[1];
73
74   union
75   {
76     /* This is the placeholder of the public version.  */
77     void *pad[4];
78
79     struct
80     {
81       /* Pointer to the previous cleanup buffer.  */
82       struct pthread_unwind_buf *prev;
83
84       /* Backward compatibility: state of the old-style cleanup
85          handler at the time of the previous new-style cleanup handler
86          installment.  */
87       struct _pthread_cleanup_buffer *cleanup;
88
89       /* Cancellation type before the push call.  */
90       int canceltype;
91     } data;
92   } priv;
93 };
94
95
96 /* Opcodes and data types for communication with the signal handler to
97    change user/group IDs.  */
98 struct xid_command
99 {
100   int syscall_no;
101   long int id[3];
102   volatile int cntr;
103 };
104
105
106 #ifndef NO_ROBUST_LIST_SUPPORT
107 /* Data structure used by the kernel to find robust futexes.  */
108 struct robust_list_head
109 {
110   void *list;
111   long int futex_offset;
112   void *list_op_pending;
113 };
114 #endif
115
116
117 /* Data strcture used to handle thread priority protection.  */
118 struct priority_protection_data
119 {
120   int priomax;
121   unsigned int priomap[];
122 };
123
124
125 /* Thread descriptor data structure.  */
126 struct pthread
127 {
128   union
129   {
130 #if !TLS_DTV_AT_TP
131     /* This overlaps the TCB as used for TLS without threads (see tls.h).  */
132     tcbhead_t header;
133 #else
134     struct
135     {
136       int multiple_threads;
137       int gscope_flag;
138 # ifndef NO_FUTEX_SUPPORT
139 # ifndef __ASSUME_PRIVATE_FUTEX
140       int private_futex;
141 # endif
142 # endif
143     } header;
144 #endif
145
146     /* This extra padding has no special purpose, and this structure layout
147        is private and subject to change without affecting the official ABI.
148        We just have it here in case it might be convenient for some
149        implementation-specific instrumentation hack or suchlike.  */
150     void *__padding[16];
151   };
152
153   /* This descriptor's link on the `stack_used' or `__stack_user' list.  */
154   list_t list;
155
156   /* Thread ID - which is also a 'is this thread descriptor (and
157      therefore stack) used' flag.  */
158 #ifndef PTHREAD_T_IS_TID
159   pid_t tid;
160 #else
161   pthread_t tid;
162 #endif
163
164   /* Process ID - thread group ID in kernel speak.  */
165   pid_t pid;
166
167 #ifndef NO_ROBUST_LIST_SUPPORT
168   /* List of robust mutexes the thread is holding.  */
169 #ifdef __PTHREAD_MUTEX_HAVE_PREV
170   void *robust_prev;
171   struct robust_list_head robust_head;
172
173   /* The list above is strange.  It is basically a double linked list
174      but the pointer to the next/previous element of the list points
175      in the middle of the object, the __next element.  Whenever
176      casting to __pthread_list_t we need to adjust the pointer
177      first.  */
178 # define QUEUE_PTR_ADJUST (offsetof (__pthread_list_t, __next))
179
180 # define ENQUEUE_MUTEX_BOTH(mutex, val)                                       \
181   do {                                                                        \
182     __pthread_list_t *next = (__pthread_list_t *)                             \
183       ((((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_head.list)) & ~1ul)   \
184        - QUEUE_PTR_ADJUST);                                                   \
185     next->__prev = (void *) &mutex->__data.__list.__next;                     \
186     mutex->__data.__list.__next = THREAD_GETMEM (THREAD_SELF,                 \
187                                                  robust_head.list);           \
188     mutex->__data.__list.__prev = (void *) &THREAD_SELF->robust_head;         \
189     THREAD_SETMEM (THREAD_SELF, robust_head.list,                             \
190                    (void *) (((uintptr_t) &mutex->__data.__list.__next)       \
191                              | val));                                         \
192   } while (0)
193 # define DEQUEUE_MUTEX(mutex) \
194   do {                                                                        \
195     __pthread_list_t *next = (__pthread_list_t *)                             \
196       ((char *) (((uintptr_t) mutex->__data.__list.__next) & ~1ul)            \
197        - QUEUE_PTR_ADJUST);                                                   \
198     next->__prev = mutex->__data.__list.__prev;                               \
199     __pthread_list_t *prev = (__pthread_list_t *)                             \
200       ((char *) (((uintptr_t) mutex->__data.__list.__prev) & ~1ul)            \
201        - QUEUE_PTR_ADJUST);                                                   \
202     prev->__next = mutex->__data.__list.__next;                               \
203     mutex->__data.__list.__prev = NULL;                                       \
204     mutex->__data.__list.__next = NULL;                                       \
205   } while (0)
206 #else
207   union
208   {
209     __pthread_slist_t robust_list;
210     struct robust_list_head robust_head;
211   };
212
213 # define ENQUEUE_MUTEX_BOTH(mutex, val)                                       \
214   do {                                                                        \
215     mutex->__data.__list.__next                                               \
216       = THREAD_GETMEM (THREAD_SELF, robust_list.__next);                      \
217     THREAD_SETMEM (THREAD_SELF, robust_list.__next,                           \
218                    (void *) (((uintptr_t) &mutex->__data.__list) | val));     \
219   } while (0)
220 # define DEQUEUE_MUTEX(mutex) \
221   do {                                                                        \
222     __pthread_slist_t *runp = (__pthread_slist_t *)                           \
223       (((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_list.__next)) & ~1ul); \
224     if (runp == &mutex->__data.__list)                                        \
225       THREAD_SETMEM (THREAD_SELF, robust_list.__next, runp->__next);          \
226     else                                                                      \
227       {                                                                       \
228         __pthread_slist_t *next = (__pthread_slist_t *)               \
229           (((uintptr_t) runp->__next) & ~1ul);                                \
230         while (next != &mutex->__data.__list)                                 \
231           {                                                                   \
232             runp = next;                                                      \
233             next = (__pthread_slist_t *) (((uintptr_t) runp->__next) & ~1ul); \
234           }                                                                   \
235                                                                               \
236         runp->__next = next->__next;                                          \
237         mutex->__data.__list.__next = NULL;                                   \
238       }                                                                       \
239   } while (0)
240 #endif
241 #define ENQUEUE_MUTEX(mutex) ENQUEUE_MUTEX_BOTH (mutex, 0)
242 #define ENQUEUE_MUTEX_PI(mutex) ENQUEUE_MUTEX_BOTH (mutex, 1)
243 #endif /* NO_ROBUST_LIST_SUPPORT */
244
245   /* List of cleanup buffers.  */
246   struct _pthread_cleanup_buffer *cleanup;
247
248   /* Unwind information.  */
249   struct pthread_unwind_buf *cleanup_jmp_buf;
250 #define HAVE_CLEANUP_JMP_BUF
251
252   /* Flags determining processing of cancellation.  */
253   int cancelhandling;
254   /* Bit set if cancellation is disabled.  */
255 #define CANCELSTATE_BIT         0
256 #define CANCELSTATE_BITMASK     0x01
257   /* Bit set if asynchronous cancellation mode is selected.  */
258 #define CANCELTYPE_BIT          1
259 #define CANCELTYPE_BITMASK      0x02
260   /* Bit set if canceling has been initiated.  */
261 #define CANCELING_BIT           2
262 #define CANCELING_BITMASK       0x04
263   /* Bit set if canceled.  */
264 #define CANCELED_BIT            3
265 #define CANCELED_BITMASK        0x08
266   /* Bit set if thread is exiting.  */
267 #define EXITING_BIT             4
268 #define EXITING_BITMASK         0x10
269   /* Bit set if thread terminated and TCB is freed.  */
270 #define TERMINATED_BIT          5
271 #define TERMINATED_BITMASK      0x20
272 #ifndef NO_SETXID_SUPPORT
273   /* Bit set if thread is supposed to change XID.  */
274 #define SETXID_BIT              6
275 #define SETXID_BITMASK          0x40
276   /* Mask for the rest.  Helps the compiler to optimize.  */
277 #define CANCEL_RESTMASK         0xffffff80
278 #else /* NO_SETXID_SUPPORT */
279   /* Mask for the rest.  Helps the compiler to optimize.  */
280 #define CANCEL_RESTMASK         0xffffffc0
281 #endif /* NO_SETXID_SUPPORT */
282
283 #define CANCEL_ENABLED_AND_CANCELED(value) \
284   (((value) & (CANCELSTATE_BITMASK | CANCELED_BITMASK | EXITING_BITMASK       \
285                | CANCEL_RESTMASK | TERMINATED_BITMASK)) == CANCELED_BITMASK)
286 #define CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS(value) \
287   (((value) & (CANCELSTATE_BITMASK | CANCELTYPE_BITMASK | CANCELED_BITMASK    \
288                | EXITING_BITMASK | CANCEL_RESTMASK | TERMINATED_BITMASK))     \
289    == (CANCELTYPE_BITMASK | CANCELED_BITMASK))
290
291   /* Flags.  Including those copied from the thread attribute.  */
292   int flags;
293
294   /* We allocate one block of references here.  This should be enough
295      to avoid allocating any memory dynamically for most applications.  */
296   struct pthread_key_data
297   {
298     /* Sequence number.  We use uintptr_t to not require padding on
299        32- and 64-bit machines.  On 64-bit machines it helps to avoid
300        wrapping, too.  */
301     uintptr_t seq;
302
303     /* Data pointer.  */
304     void *data;
305   } specific_1stblock[PTHREAD_KEY_2NDLEVEL_SIZE];
306
307   /* Two-level array for the thread-specific data.  */
308   struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];
309
310   /* Flag which is set when specific data is set.  */
311   bool specific_used;
312
313   /* True if events must be reported.  */
314   bool report_events;
315
316   /* True if the user provided the stack.  */
317   bool user_stack;
318
319   /* True if thread must stop at startup time.  */
320   bool stopped_start;
321
322   /* The parent's cancel handling at the time of the pthread_create
323      call.  This might be needed to undo the effects of a cancellation.  */
324   int parent_cancelhandling;
325
326   /* Lock to synchronize access to the descriptor.  */
327 #ifndef lll_define
328   int lock;
329 #else
330   lll_define (, lock);
331 #endif
332
333 #ifndef NO_SETXID_SUPPORT
334   /* Lock for synchronizing setxid calls.  */
335   int setxid_futex;
336 #endif
337
338 #if HP_TIMING_AVAIL
339   /* Offset of the CPU clock at start thread start time.  */
340   hp_timing_t cpuclock_offset;
341 #endif
342
343   /* If the thread waits to join another one the ID of the latter is
344      stored here.
345
346      In case a thread is detached this field contains a pointer of the
347      TCB if the thread itself.  This is something which cannot happen
348      in normal operation.  */
349   struct pthread *joinid;
350   /* Check whether a thread is detached.  */
351 #define IS_DETACHED(pd) ((pd)->joinid == (pd))
352
353   /* The result of the thread function.  */
354   void *result;
355
356   /* Scheduling parameters for the new thread.  */
357   struct sched_param schedparam;
358   int schedpolicy;
359
360   /* Start position of the code to be executed and the argument passed
361      to the function.  */
362   void *(*start_routine) (void *);
363   void *arg;
364
365   /* Debug state.  */
366   td_eventbuf_t eventbuf;
367   /* Next descriptor with a pending event.  */
368   struct pthread *nextevent;
369
370 #ifdef HAVE_FORCED_UNWIND
371   /* Machine-specific unwind info.  */
372   struct _Unwind_Exception exc;
373 #endif
374
375   /* If nonzero pointer to area allocated for the stack and its
376      size.  */
377   void *stackblock;
378   size_t stackblock_size;
379   /* Size of the included guard area.  */
380   size_t guardsize;
381   /* This is what the user specified and what we will report.  */
382   size_t reported_guardsize;
383
384   /* Thread Priority Protection data.  */
385   struct priority_protection_data *tpp;
386
387   /* Resolver state.  */
388   struct __res_state res;
389
390 #ifdef PLATFORM_DESCR_FIELDS
391 PLATFORM_DESCR_FIELDS
392 #endif
393
394   /* This member must be last.  */
395   char end_padding[];
396
397 #define PTHREAD_STRUCT_END_PADDING \
398   (sizeof (struct pthread) - offsetof (struct pthread, end_padding))
399 } __attribute ((aligned (TCB_ALIGNMENT)));
400
401
402 #endif  /* descr.h */