The Design and Implementation of the FreeBSD Operating System, Second Edition
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/nptl/descr.h

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    1 /* Copyright (C) 2002-2006, 2007 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 #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 /* Data structure used by the kernel to find robust futexes.  */
  107 struct robust_list_head
  108 {
  109   void *list;
  110   long int futex_offset;
  111   void *list_op_pending;
  112 };
  113 
  114 
  115 /* Data strcture used to handle thread priority protection.  */
  116 struct priority_protection_data
  117 {
  118   int priomax;
  119   unsigned int priomap[];
  120 };
  121 
  122 
  123 /* Thread descriptor data structure.  */
  124 struct pthread
  125 {
  126   union
  127   {
  128 #if !TLS_DTV_AT_TP
  129     /* This overlaps the TCB as used for TLS without threads (see tls.h).  */
  130     tcbhead_t header;
  131 #else
  132     struct
  133     {
  134       int multiple_threads;
  135       int gscope_flag;
  136 # ifndef __ASSUME_PRIVATE_FUTEX
  137       int private_futex;
  138 # endif
  139     } header;
  140 #endif
  141 
  142     /* This extra padding has no special purpose, and this structure layout
  143        is private and subject to change without affecting the official ABI.
  144        We just have it here in case it might be convenient for some
  145        implementation-specific instrumentation hack or suchlike.  */
  146     void *__padding[16];
  147   };
  148 
  149   /* This descriptor's link on the `stack_used' or `__stack_user' list.  */
  150   list_t list;
  151 
  152   /* Thread ID - which is also a 'is this thread descriptor (and
  153      therefore stack) used' flag.  */
  154   pid_t tid;
  155 
  156   /* Process ID - thread group ID in kernel speak.  */
  157   pid_t pid;
  158 
  159   /* List of robust mutexes the thread is holding.  */
  160 #ifdef __PTHREAD_MUTEX_HAVE_PREV
  161   void *robust_prev;
  162   struct robust_list_head robust_head;
  163 
  164   /* The list above is strange.  It is basically a double linked list
  165      but the pointer to the next/previous element of the list points
  166      in the middle of the object, the __next element.  Whenever
  167      casting to __pthread_list_t we need to adjust the pointer
  168      first.  */
  169 # define QUEUE_PTR_ADJUST (offsetof (__pthread_list_t, __next))
  170 
  171 # define ENQUEUE_MUTEX_BOTH(mutex, val)                                       \
  172   do {                                                                        \
  173     __pthread_list_t *next = (__pthread_list_t *)                             \
  174       ((((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_head.list)) & ~1ul)   \
  175        - QUEUE_PTR_ADJUST);                                                   \
  176     next->__prev = (void *) &mutex->__data.__list.__next;                     \
  177     mutex->__data.__list.__next = THREAD_GETMEM (THREAD_SELF,                 \
  178                                                  robust_head.list);           \
  179     mutex->__data.__list.__prev = (void *) &THREAD_SELF->robust_head;         \
  180     THREAD_SETMEM (THREAD_SELF, robust_head.list,                             \
  181                    (void *) (((uintptr_t) &mutex->__data.__list.__next)       \
  182                              | val));                                         \
  183   } while (0)
  184 # define DEQUEUE_MUTEX(mutex) \
  185   do {                                                                        \
  186     __pthread_list_t *next = (__pthread_list_t *)                             \
  187       ((char *) (((uintptr_t) mutex->__data.__list.__next) & ~1ul)            \
  188        - QUEUE_PTR_ADJUST);                                                   \
  189     next->__prev = mutex->__data.__list.__prev;                               \
  190     __pthread_list_t *prev = (__pthread_list_t *)                             \
  191       ((char *) (((uintptr_t) mutex->__data.__list.__prev) & ~1ul)            \
  192        - QUEUE_PTR_ADJUST);                                                   \
  193     prev->__next = mutex->__data.__list.__next;                               \
  194     mutex->__data.__list.__prev = NULL;                                       \
  195     mutex->__data.__list.__next = NULL;                                       \
  196   } while (0)
  197 #else
  198   union
  199   {
  200     __pthread_slist_t robust_list;
  201     struct robust_list_head robust_head;
  202   };
  203 
  204 # define ENQUEUE_MUTEX_BOTH(mutex, val)                                       \
  205   do {                                                                        \
  206     mutex->__data.__list.__next                                               \
  207       = THREAD_GETMEM (THREAD_SELF, robust_list.__next);                      \
  208     THREAD_SETMEM (THREAD_SELF, robust_list.__next,                           \
  209                    (void *) (((uintptr_t) &mutex->__data.__list) | val));     \
  210   } while (0)
  211 # define DEQUEUE_MUTEX(mutex) \
  212   do {                                                                        \
  213     __pthread_slist_t *runp = (__pthread_slist_t *)                           \
  214       (((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_list.__next)) & ~1ul); \
  215     if (runp == &mutex->__data.__list)                                        \
  216       THREAD_SETMEM (THREAD_SELF, robust_list.__next, runp->__next);          \
  217     else                                                                      \
  218       {                                                                       \
  219         __pthread_slist_t *next = (__pthread_slist_t *)               \
  220           (((uintptr_t) runp->__next) & ~1ul);                                \
  221         while (next != &mutex->__data.__list)                                 \
  222           {                                                                   \
  223             runp = next;                                                      \
  224             next = (__pthread_slist_t *) (((uintptr_t) runp->__next) & ~1ul); \
  225           }                                                                   \
  226                                                                               \
  227         runp->__next = next->__next;                                          \
  228         mutex->__data.__list.__next = NULL;                                   \
  229       }                                                                       \
  230   } while (0)
  231 #endif
  232 #define ENQUEUE_MUTEX(mutex) ENQUEUE_MUTEX_BOTH (mutex, 0)
  233 #define ENQUEUE_MUTEX_PI(mutex) ENQUEUE_MUTEX_BOTH (mutex, 1)
  234 
  235   /* List of cleanup buffers.  */
  236   struct _pthread_cleanup_buffer *cleanup;
  237 
  238   /* Unwind information.  */
  239   struct pthread_unwind_buf *cleanup_jmp_buf;
  240 #define HAVE_CLEANUP_JMP_BUF
  241 
  242   /* Flags determining processing of cancellation.  */
  243   int cancelhandling;
  244   /* Bit set if cancellation is disabled.  */
  245 #define CANCELSTATE_BIT         0
  246 #define CANCELSTATE_BITMASK     0x01
  247   /* Bit set if asynchronous cancellation mode is selected.  */
  248 #define CANCELTYPE_BIT          1
  249 #define CANCELTYPE_BITMASK      0x02
  250   /* Bit set if canceling has been initiated.  */
  251 #define CANCELING_BIT           2
  252 #define CANCELING_BITMASK       0x04
  253   /* Bit set if canceled.  */
  254 #define CANCELED_BIT            3
  255 #define CANCELED_BITMASK        0x08
  256   /* Bit set if thread is exiting.  */
  257 #define EXITING_BIT             4
  258 #define EXITING_BITMASK         0x10
  259   /* Bit set if thread terminated and TCB is freed.  */
  260 #define TERMINATED_BIT          5
  261 #define TERMINATED_BITMASK      0x20
  262   /* Bit set if thread is supposed to change XID.  */
  263 #define SETXID_BIT              6
  264 #define SETXID_BITMASK          0x40
  265   /* Mask for the rest.  Helps the compiler to optimize.  */
  266 #define CANCEL_RESTMASK         0xffffff80
  267 
  268 #define CANCEL_ENABLED_AND_CANCELED(value) \
  269   (((value) & (CANCELSTATE_BITMASK | CANCELED_BITMASK | EXITING_BITMASK       \
  270                | CANCEL_RESTMASK | TERMINATED_BITMASK)) == CANCELED_BITMASK)
  271 #define CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS(value) \
  272   (((value) & (CANCELSTATE_BITMASK | CANCELTYPE_BITMASK | CANCELED_BITMASK    \
  273                | EXITING_BITMASK | CANCEL_RESTMASK | TERMINATED_BITMASK))     \
  274    == (CANCELTYPE_BITMASK | CANCELED_BITMASK))
  275 
  276   /* Flags.  Including those copied from the thread attribute.  */
  277   int flags;
  278 
  279   /* We allocate one block of references here.  This should be enough
  280      to avoid allocating any memory dynamically for most applications.  */
  281   struct pthread_key_data
  282   {
  283     /* Sequence number.  We use uintptr_t to not require padding on
  284        32- and 64-bit machines.  On 64-bit machines it helps to avoid
  285        wrapping, too.  */
  286     uintptr_t seq;
  287 
  288     /* Data pointer.  */
  289     void *data;
  290   } specific_1stblock[PTHREAD_KEY_2NDLEVEL_SIZE];
  291 
  292   /* Two-level array for the thread-specific data.  */
  293   struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];
  294 
  295   /* Flag which is set when specific data is set.  */
  296   bool specific_used;
  297 
  298   /* True if events must be reported.  */
  299   bool report_events;
  300 
  301   /* True if the user provided the stack.  */
  302   bool user_stack;
  303 
  304   /* True if thread must stop at startup time.  */
  305   bool stopped_start;
  306 
  307   /* The parent's cancel handling at the time of the pthread_create
  308      call.  This might be needed to undo the effects of a cancellation.  */
  309   int parent_cancelhandling;
  310 
  311   /* Lock to synchronize access to the descriptor.  */
  312   int lock;
  313 
  314   /* Lock for synchronizing setxid calls.  */
  315   int setxid_futex;
  316 
  317 #if HP_TIMING_AVAIL
  318   /* Offset of the CPU clock at start thread start time.  */
  319   hp_timing_t cpuclock_offset;
  320 #endif
  321 
  322   /* If the thread waits to join another one the ID of the latter is
  323      stored here.
  324 
  325      In case a thread is detached this field contains a pointer of the
  326      TCB if the thread itself.  This is something which cannot happen
  327      in normal operation.  */
  328   struct pthread *joinid;
  329   /* Check whether a thread is detached.  */
  330 #define IS_DETACHED(pd) ((pd)->joinid == (pd))
  331 
  332   /* The result of the thread function.  */
  333   void *result;
  334 
  335   /* Scheduling parameters for the new thread.  */
  336   struct sched_param schedparam;
  337   int schedpolicy;
  338 
  339   /* Start position of the code to be executed and the argument passed
  340      to the function.  */
  341   void *(*start_routine) (void *);
  342   void *arg;
  343 
  344   /* Debug state.  */
  345   td_eventbuf_t eventbuf;
  346   /* Next descriptor with a pending event.  */
  347   struct pthread *nextevent;
  348 
  349 #ifdef HAVE_FORCED_UNWIND
  350   /* Machine-specific unwind info.  */
  351   struct _Unwind_Exception exc;
  352 #endif
  353 
  354   /* If nonzero pointer to area allocated for the stack and its
  355      size.  */
  356   void *stackblock;
  357   size_t stackblock_size;
  358   /* Size of the included guard area.  */
  359   size_t guardsize;
  360   /* This is what the user specified and what we will report.  */
  361   size_t reported_guardsize;
  362 
  363   /* Thread Priority Protection data.  */
  364   struct priority_protection_data *tpp;
  365 
  366   /* Resolver state.  */
  367   struct __res_state res;
  368 
  369   /* This member must be last.  */
  370   char end_padding[];
  371 
  372 #define PTHREAD_STRUCT_END_PADDING \
  373   (sizeof (struct pthread) - offsetof (struct pthread, end_padding))
  374 } __attribute ((aligned (TCB_ALIGNMENT)));
  375 
  376 
  377 #endif  /* descr.h */

Cache object: 7ed2fd5236aadfd023ef33a08b03d7c7


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.