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