nptl/descr.h

   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 #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 "../nptl_db/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
  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 /* Thread descriptor data structure.  */
  96 struct pthread
  97 {
  98   union
  99   {
 100 #if !TLS_DTV_AT_TP
 101     /* This overlaps the TCB as used for TLS without threads (see tls.h).  */
 102     tcbhead_t header;
 103 #else
 104     struct
 105     {
 106       int multiple_threads;
 107     } header;
 108 #endif
 109
 110     /* This extra padding has no special purpose, and this structure layout
 111        is private and subject to change without affecting the official ABI.
 112        We just have it here in case it might be convenient for some
 113        implementation-specific instrumentation hack or suchlike.  */
 114     void *__padding[16];
 115   };
 116
 117   /* This descriptor's link on the `stack_used' or `__stack_user' list.  */
 118   list_t list;
 119
 120   /* Thread ID - which is also a 'is this thread descriptor (and
 121      therefore stack) used' flag.  */
 122   pid_t tid;
 123
 124   /* List of cleanup buffers.  */
 125   struct _pthread_cleanup_buffer *cleanup;
 126
 127   /* Unwind information.  */
 128   struct pthread_unwind_buf *cleanup_jmp_buf;
 129 #define HAVE_CLEANUP_JMP_BUF
 130
 131   /* Flags determining processing of cancellation.  */
 132   int cancelhandling;
 133   /* Bit set if cancellation is disabled.  */
 134 #define CANCELSTATE_BIT         0
 135 #define CANCELSTATE_BITMASK     0x01
 136   /* Bit set if asynchronous cancellation mode is selected.  */
 137 #define CANCELTYPE_BIT          1
 138 #define CANCELTYPE_BITMASK      0x02
 139   /* Bit set if canceling has been initiated.  */
 140 #define CANCELING_BIT           2
 141 #define CANCELING_BITMASK       0x04
 142   /* Bit set if canceled.  */
 143 #define CANCELED_BIT            3
 144 #define CANCELED_BITMASK        0x08
 145   /* Bit set if thread is exiting.  */
 146 #define EXITING_BIT             4
 147 #define EXITING_BITMASK         0x10
 148   /* Bit set if thread terminated and TCB is freed.  */
 149 #define TERMINATED_BIT          5
 150 #define TERMINATED_BITMASK      0x20
 151   /* Mask for the rest.  Helps the compiler to optimize.  */
 152 #define CANCEL_RESTMASK         0xffffffc0
 153
 154 #define CANCEL_ENABLED_AND_CANCELED(value) \
 155   (((value) & (CANCELSTATE_BITMASK | CANCELED_BITMASK | EXITING_BITMASK       \
 156                | CANCEL_RESTMASK | TERMINATED_BITMASK)) == CANCELED_BITMASK)
 157 #define CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS(value) \
 158   (((value) & (CANCELSTATE_BITMASK | CANCELTYPE_BITMASK | CANCELED_BITMASK    \
 159                | EXITING_BITMASK | CANCEL_RESTMASK | TERMINATED_BITMASK))     \
 160    == (CANCELTYPE_BITMASK | CANCELED_BITMASK))
 161
 162   /* We allocate one block of references here.  This should be enough
 163      to avoid allocating any memory dynamically for most applications.  */
 164   struct pthread_key_data
 165   {
 166     /* Sequence number.  We use uintptr_t to not require padding on
 167        32- and 64-bit machines.  On 64-bit machines it helps to avoid
 168        wrapping, too.  */
 169     uintptr_t seq;
 170
 171     /* Data pointer.  */
 172     void *data;
 173   } specific_1stblock[PTHREAD_KEY_2NDLEVEL_SIZE];
 174
 175   /* Flag which is set when specific data is set.  */
 176   bool specific_used;
 177
 178   /* Two-level array for the thread-specific data.  */
 179   struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];
 180
 181   /* Process ID - thread group ID in kernel speak.  */
 182   pid_t pid;
 183
 184   /* True if events must be reported.  */
 185   bool report_events;
 186
 187   /* True if the user provided the stack.  */
 188   bool user_stack;
 189
 190   /* Lock to synchronize access to the descriptor.  */
 191   lll_lock_t lock;
 192
 193 #if HP_TIMING_AVAIL
 194   /* Offset of the CPU clock at start thread start time.  */
 195   hp_timing_t cpuclock_offset;
 196 #endif
 197
 198   /* If the thread waits to join another one the ID of the latter is
 199      stored here.
 200
 201      In case a thread is detached this field contains a pointer of the
 202      TCB if the thread itself.  This is something which cannot happen
 203      in normal operation.  */
 204   struct pthread *joinid;
 205   /* Check whether a thread is detached.  */
 206 #define IS_DETACHED(pd) ((pd)->joinid == (pd))
 207
 208   /* Flags.  Including those copied from the thread attribute.  */
 209   int flags;
 210
 211   /* The result of the thread function.  */
 212   void *result;
 213
 214   /* Scheduling parameters for the new thread.  */
 215   struct sched_param schedparam;
 216   int schedpolicy;
 217
 218   /* Start position of the code to be executed and the argument passed
 219      to the function.  */
 220   void *(*start_routine) (void *);
 221   void *arg;
 222
 223   /* Debug state.  */
 224   td_eventbuf_t eventbuf;
 225   /* Next descriptor with a pending event.  */
 226   struct pthread *nextevent;
 227
 228 #ifdef HAVE_FORCED_UNWIND
 229   /* Machine-specific unwind info.  */
 230   struct _Unwind_Exception exc;
 231 #endif
 232
 233   /* If nonzero pointer to area allocated for the stack and its
 234      size.  */
 235   void *stackblock;
 236   size_t stackblock_size;
 237   /* Size of the included guard area.  */
 238   size_t guardsize;
 239
 240   /* Resolver state.  */
 241   struct __res_state res;
 242 } __attribute ((aligned (TCB_ALIGNMENT)));
 243
 244
 245 #endif  /* descr.h */